]> git.saurik.com Git - wxWidgets.git/blame - src/gtk1/window.cpp
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
testing tweaks
[wxWidgets.git] / src / gtk1 / window.cpp
CommitLineData
c801d85f 1/////////////////////////////////////////////////////////////////////////////
f6bcfd97 2// Name: gtk/window.cpp
c801d85f
KB		 3// Purpose:
4// Author: Robert Roebling
c67d8618 5// Id: $Id$
01111366 6// Copyright: (c) 1998 Robert Roebling, Julian Smart
65571936 7// Licence: wxWindows licence
c801d85f
KB		 8/////////////////////////////////////////////////////////////////////////////
9
10
14f355c2 11#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
bfc6fde4 12 #pragma implementation "window.h"
c801d85f
KB		 13#endif
14
14f355c2
VS		 15// For compilers that support precompilation, includes "wx.h".
16#include "wx/wxprec.h"
17
d02af7bb
JJ		 18#ifdef __VMS
19#define XWarpPointer XWARPPOINTER
20#endif
21
c801d85f 22#include "wx/window.h"
33611ebb 23#include "wx/dcclient.h"
c801d85f
KB		 24#include "wx/frame.h"
25#include "wx/app.h"
26#include "wx/layout.h"
27#include "wx/utils.h"
28#include "wx/dialog.h"
29#include "wx/msgdlg.h"
0fc5dbf5 30#include "wx/module.h"
bfc6fde4 31
06cfab17 32#if wxUSE_DRAG_AND_DROP
bfc6fde4 33 #include "wx/dnd.h"
ac57418f 34#endif
bfc6fde4 35
cad880f5 36#if wxUSE_TOOLTIPS
bfc6fde4 37 #include "wx/tooltip.h"
cad880f5 38#endif
bfc6fde4 39
f6bcfd97
BP		 40#if wxUSE_CARET
41 #include "wx/caret.h"
42#endif // wxUSE_CARET
43
ab93a576 44#if wxUSE_TEXTCTRL
0fc5dbf5 45 #include "wx/textctrl.h"
ab93a576
RD		 46#endif
47
30dea054 48#include "wx/menu.h"
d4c99d6f 49#include "wx/statusbr.h"
b4071e91 50#include "wx/intl.h"
3bc755fc 51#include "wx/settings.h"
3069ac4e 52#include "wx/log.h"
48d011c8 53#include "wx/fontutil.h"
b4071e91 54
3ac8d3bc
RR		 55#ifdef __WXDEBUG__
56 #include "wx/thread.h"
57#endif
58
b4071e91 59#include <math.h>
fab591c5 60#include <ctype.h>
c801d85f 61
9e691f46 62#include "wx/gtk/private.h"
3ac8d3bc
RR		 63#include <gdk/gdkprivate.h>
64#include <gdk/gdkkeysyms.h>
3ac8d3bc 65#include <gdk/gdkx.h>
6bc8a1c8 66
8cb9f0d0
RR		 67#include <gtk/gtk.h>
68#include <gtk/gtkprivate.h>
69
70#include "wx/gtk/win_gtk.h"
71
2b5f62a0
VZ		 72#ifdef __WXGTK20__
73#include <pango/pangox.h>
74#endif
75
9e691f46
VZ		 76#ifdef __WXGTK20__
77 #define SET_CONTAINER_FOCUS(w, d) gtk_widget_child_focus((w), (d))
78#else
79 #define SET_CONTAINER_FOCUS(w, d) gtk_container_focus(GTK_CONTAINER(w), (d))
80#endif
81
4e5a4c69
RR		 82#ifdef __WXGTK20__
83 #ifdef HAVE_XIM
84 #undef HAVE_XIM
85 #endif
86#endif
87
af1d24da
RR		 88#ifdef __WXGTK20__
89extern GtkContainerClass *pizza_parent_class;
90#endif
91
868a2826
RR		 92//-----------------------------------------------------------------------------
93// documentation on internals
94//-----------------------------------------------------------------------------
95
96/*
97 I have been asked several times about writing some documentation about
77ffb593 98 the GTK port of wxWidgets, especially its internal structures. Obviously,
868a2826 99 you cannot understand wxGTK without knowing a little about the GTK, but
47d67540 100 some more information about what the wxWindow, which is the base class
868a2826 101 for all other window classes, does seems required as well.
47d67540 102
30760ce7
RR		 103 I)
104
868a2826 105 What does wxWindow do? It contains the common interface for the following
e380f72b 106 jobs of its descendants:
47d67540 107
868a2826 108 1) Define the rudimentary behaviour common to all window classes, such as
e380f72b
RR		 109 resizing, intercepting user input (so as to make it possible to use these
110 events for special purposes in a derived class), window names etc.
868a2826
RR		 111
112 2) Provide the possibility to contain and manage children, if the derived
113 class is allowed to contain children, which holds true for those window
e380f72b 114 classes which do not display a native GTK widget. To name them, these
868a2826 115 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
47d67540 116 work classes are a special case and are handled a bit differently from
e380f72b 117 the rest. The same holds true for the wxNotebook class.
47d67540 118
868a2826
RR		 119 3) Provide the possibility to draw into a client area of a window. This,
120 too, only holds true for classes that do not display a native GTK widget
121 as above.
47d67540 122
e380f72b
RR		 123 4) Provide the entire mechanism for scrolling widgets. This actual inter-
124 face for this is usually in wxScrolledWindow, but the GTK implementation
868a2826 125 is in this class.
47d67540 126
868a2826
RR		 127 5) A multitude of helper or extra methods for special purposes, such as
128 Drag'n'Drop, managing validators etc.
47d67540 129
30760ce7
RR		 130 6) Display a border (sunken, raised, simple or none).
131
77ffb593 132 Normally one might expect, that one wxWidgets window would always correspond
e380f72b 133 to one GTK widget. Under GTK, there is no such allround widget that has all
868a2826
RR		 134 the functionality. Moreover, the GTK defines a client area as a different
135 widget from the actual widget you are handling. Last but not least some
136 special classes (e.g. wxFrame) handle different categories of widgets and
137 still have the possibility to draw something in the client area.
138 It was therefore required to write a special purpose GTK widget, that would
77ffb593 139 represent a client area in the sense of wxWidgets capable to do the jobs
868a2826
RR		 140 2), 3) and 4). I have written this class and it resides in win_gtk.c of
141 this directory.
47d67540 142
868a2826 143 All windows must have a widget, with which they interact with other under-
e380f72b 144 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
868a2826 145 thw wxWindow class has a member variable called m_widget which holds a
e380f72b
RR		 146 pointer to this widget. When the window class represents a GTK native widget,
147 this is (in most cases) the only GTK widget the class manages. E.g. the
f8e045e2 148 wxStaticText class handles only a GtkLabel widget a pointer to which you
e380f72b 149 can find in m_widget (defined in wxWindow)
8bbe427f 150
e380f72b 151 When the class has a client area for drawing into and for containing children
da048e3d 152 it has to handle the client area widget (of the type GtkPizza, defined in
8bbe427f
VZ		 153 win_gtk.c), but there could be any number of widgets, handled by a class
154 The common rule for all windows is only, that the widget that interacts with
155 the rest of GTK must be referenced in m_widget and all other widgets must be
156 children of this widget on the GTK level. The top-most widget, which also
157 represents the client area, must be in the m_wxwindow field and must be of
da048e3d 158 the type GtkPizza.
47d67540 159
868a2826
RR		 160 As I said, the window classes that display a GTK native widget only have
161 one widget, so in the case of e.g. the wxButton class m_widget holds a
162 pointer to a GtkButton widget. But windows with client areas (for drawing
163 and children) have a m_widget field that is a pointer to a GtkScrolled-
da048e3d 164 Window and a m_wxwindow field that is pointer to a GtkPizza and this
868a2826 165 one is (in the GTK sense) a child of the GtkScrolledWindow.
47d67540 166
868a2826 167 If the m_wxwindow field is set, then all input to this widget is inter-
77ffb593 168 cepted and sent to the wxWidgets class. If not, all input to the widget
868a2826 169 that gets pointed to by m_widget gets intercepted and sent to the class.
148cd9b6 170
30760ce7 171 II)
148cd9b6 172
77ffb593 173 The design of scrolling in wxWidgets is markedly different from that offered
30760ce7
RR		 174 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
175 clicking on a scrollbar belonging to scrolled window will inevitably move
77ffb593 176 the window. In wxWidgets, the scrollbar will only emit an event, send this
30760ce7 177 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
da048e3d 178 which actually moves the window and its subchildren. Note that GtkPizza
77ffb593 179 memorizes how much it has been scrolled but that wxWidgets forgets this
30760ce7 180 so that the two coordinates systems have to be kept in synch. This is done
da048e3d 181 in various places using the pizza->xoffset and pizza->yoffset values.
148cd9b6
VZ		 182
183 III)
184
30760ce7
RR		 185 Singularily the most broken code in GTK is the code that is supposes to
186 inform subwindows (child windows) about new positions. Very often, duplicate
187 events are sent without changes in size or position, equally often no
188 events are sent at all (All this is due to a bug in the GtkContainer code
189 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
190 GTK's own system and it simply waits for size events for toplevel windows
191 and then iterates down the respective size events to all window. This has
192 the disadvantage, that windows might get size events before the GTK widget
193 actually has the reported size. This doesn't normally pose any problem, but
3017f78d 194 the OpenGl drawing routines rely on correct behaviour. Therefore, I have
30760ce7
RR		 195 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
196 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
197 window that is used for OpenGl output really has that size (as reported by
198 GTK).
199
200 IV)
148cd9b6 201
30760ce7
RR		 202 If someone at some point of time feels the immense desire to have a look at,
203 change or attempt to optimse the Refresh() logic, this person will need an
204 intimate understanding of what a "draw" and what an "expose" events are and
205 what there are used for, in particular when used in connection with GTK's
206 own windowless widgets. Beware.
148cd9b6 207
30760ce7 208 V)
148cd9b6 209
30760ce7
RR		 210 Cursors, too, have been a constant source of pleasure. The main difficulty
211 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
212 for the parent. To prevent this from doing too much harm, I use idle time
213 to set the cursor over and over again, starting from the toplevel windows
214 and ending with the youngest generation (speaking of parent and child windows).
215 Also don't forget that cursors (like much else) are connected to GdkWindows,
216 not GtkWidgets and that the "window" field of a GtkWidget might very well
148cd9b6 217 point to the GdkWindow of the parent widget (-> "window less widget") and
30760ce7 218 that the two obviously have very different meanings.
868a2826
RR		 219
220*/
221
f03fc89f
VZ		 222//-----------------------------------------------------------------------------
223// data
224//-----------------------------------------------------------------------------
225
226extern wxList wxPendingDelete;
227extern bool g_blockEventsOnDrag;
228extern bool g_blockEventsOnScroll;
238d735d 229extern wxCursor g_globalCursor;
f68586e5 230
4e5a4c69
RR		 231static GdkGC *g_eraseGC = NULL;
232
1e6feb95
VZ		 233// mouse capture state: the window which has it and if the mouse is currently
234// inside it
235static wxWindowGTK *g_captureWindow = (wxWindowGTK*) NULL;
236static bool g_captureWindowHasMouse = FALSE;
237
238/* extern */ wxWindowGTK *g_focusWindow = (wxWindowGTK*) NULL;
239
240// the last window which had the focus - this is normally never NULL (except
241// if we never had focus at all) as even when g_focusWindow is NULL it still
242// keeps its previous value
d7fa7eaa 243static wxWindowGTK *g_focusWindowLast = (wxWindowGTK*) NULL;
148cd9b6 244
e8c12a53
VS		 245// the frame that is currently active (i.e. its child has focus). It is
246// used to generate wxActivateEvents
d7fa7eaa 247static wxWindowGTK *g_activeFrame = (wxWindowGTK*) NULL;
e8c12a53
VS		 248static bool g_activeFrameLostFocus = FALSE;
249
d7fa7eaa
RR		 250// If a window get the focus set but has not been realized
251// yet, defer setting the focus to idle time.
252wxWindowGTK *g_delayedFocus = (wxWindowGTK*) NULL;
253
148cd9b6
VZ		 254// if we detect that the app has got/lost the focus, we set this variable to
255// either TRUE or FALSE and an activate event will be sent during the next
256// OnIdle() call and it is reset to -1: this value means that we shouldn't
257// send any activate events at all
258static int g_sendActivateEvent = -1;
f03fc89f 259
34adc954
VZ		 260// hack: we need something to pass to gtk_menu_popup, so we store the time of
261// the last click here
262static guint32 gs_timeLastClick = 0;
263
3ac8d3bc
RR		 264extern bool g_mainThreadLocked;
265
2e563988
RR		 266//-----------------------------------------------------------------------------
267// debug
268//-----------------------------------------------------------------------------
269
270#ifdef __WXDEBUG__
271
c6e62f74
KB		 272#if wxUSE_THREADS
273# define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
274#else
275# define DEBUG_MAIN_THREAD
276#endif
559d79aa
BJ		 277#else
278#define DEBUG_MAIN_THREAD
f03fc89f 279#endif // Debug
ff8bfdbb 280
6cad4f1b
VZ		 281// the trace mask used for the focus debugging messages
282#define TRACE_FOCUS _T("focus")
283
85eb36c2
RR		 284//-----------------------------------------------------------------------------
285// missing gdk functions
286//-----------------------------------------------------------------------------
287
288void
289gdk_window_warp_pointer (GdkWindow *window,
c50f1fb9
VZ		 290 gint x,
291 gint y)
85eb36c2 292{
dd00f3f6 293#ifndef __WXGTK20__
85eb36c2 294 GdkWindowPrivate *priv;
dd00f3f6 295#endif
c50f1fb9 296
85eb36c2 297 if (!window)
27df579a 298 window = GDK_ROOT_PARENT();
c50f1fb9 299
dd00f3f6
OK		 300#ifdef __WXGTK20__
301 if (!GDK_WINDOW_DESTROYED(window))
302 {
303 XWarpPointer (GDK_WINDOW_XDISPLAY(window),
304 None, /* not source window -> move from anywhere */
305 GDK_WINDOW_XID(window), /* dest window */
306 0, 0, 0, 0, /* not source window -> move from anywhere */
307 x, y );
308 }
309#else
85eb36c2 310 priv = (GdkWindowPrivate*) window;
c50f1fb9 311
85eb36c2
RR		 312 if (!priv->destroyed)
313 {
c50f1fb9 314 XWarpPointer (priv->xdisplay,
85eb36c2 315 None, /* not source window -> move from anywhere */
c50f1fb9 316 priv->xwindow, /* dest window */
85eb36c2 317 0, 0, 0, 0, /* not source window -> move from anywhere */
c50f1fb9 318 x, y );
85eb36c2 319 }
dd00f3f6 320#endif
85eb36c2
RR		 321}
322
acfd422a 323//-----------------------------------------------------------------------------
a2053b27 324// idle system
acfd422a
RR		 325//-----------------------------------------------------------------------------
326
a2053b27
RR		 327extern void wxapp_install_idle_handler();
328extern bool g_isIdle;
329
ed673c6a
RR		 330//-----------------------------------------------------------------------------
331// local code (see below)
332//-----------------------------------------------------------------------------
333
f6bcfd97 334// returns the child of win which currently has focus or NULL if not found
1e6feb95 335//
fc71ef6e 336// Note: can't be static, needed by textctrl.cpp.
3379ed37 337wxWindow *wxFindFocusedChild(wxWindowGTK *win)
f6bcfd97 338{
3379ed37 339 wxWindow *winFocus = wxWindowGTK::FindFocus();
f6bcfd97 340 if ( !winFocus )
3379ed37 341 return (wxWindow *)NULL;
f6bcfd97
BP		 342
343 if ( winFocus == win )
3379ed37 344 return (wxWindow *)win;
f6bcfd97 345
222ed1d6 346 for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
f6bcfd97
BP		 347 node;
348 node = node->GetNext() )
349 {
3379ed37 350 wxWindow *child = wxFindFocusedChild(node->GetData());
f6bcfd97
BP		 351 if ( child )
352 return child;
353 }
354
3379ed37 355 return (wxWindow *)NULL;
f6bcfd97
BP		 356}
357
1e6feb95 358static void draw_frame( GtkWidget *widget, wxWindowGTK *win )
ed673c6a 359{
1e6feb95
VZ		 360 // wxUniversal widgets draw the borders and scrollbars themselves
361#ifndef __WXUNIVERSAL__
ed673c6a
RR		 362 if (!win->m_hasVMT)
363 return;
364
365 int dw = 0;
366 int dh = 0;
367
5b8a521e 368 if (win->m_hasScrolling)
ed673c6a 369 {
beab25bd 370 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);
2daa0ce9 371
beab25bd
RR		 372 GtkRequisition vscroll_req;
373 vscroll_req.width = 2;
374 vscroll_req.height = 2;
375 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
376 (scroll_window->vscrollbar, &vscroll_req );
2daa0ce9 377
beab25bd
RR		 378 GtkRequisition hscroll_req;
379 hscroll_req.width = 2;
380 hscroll_req.height = 2;
381 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
382 (scroll_window->hscrollbar, &hscroll_req );
9000c624 383
beab25bd 384 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(widget) );
ed673c6a 385
beab25bd
RR		 386 if (scroll_window->vscrollbar_visible)
387 {
388 dw += vscroll_req.width;
389 dw += scroll_class->scrollbar_spacing;
390 }
ed673c6a 391
beab25bd
RR		 392 if (scroll_window->hscrollbar_visible)
393 {
394 dh += hscroll_req.height;
395 dh += scroll_class->scrollbar_spacing;
396 }
397}
ed673c6a
RR		 398
399 int dx = 0;
400 int dy = 0;
401 if (GTK_WIDGET_NO_WINDOW (widget))
402 {
403 dx += widget->allocation.x;
404 dy += widget->allocation.y;
405 }
406
407 if (win->HasFlag(wxRAISED_BORDER))
408 {
409 gtk_draw_shadow( widget->style,
410 widget->window,
411 GTK_STATE_NORMAL,
412 GTK_SHADOW_OUT,
413 dx, dy,
07f5b19a 414 widget->allocation.width-dw, widget->allocation.height-dh );
ed673c6a
RR		 415 return;
416 }
417
418 if (win->HasFlag(wxSUNKEN_BORDER))
419 {
420 gtk_draw_shadow( widget->style,
421 widget->window,
422 GTK_STATE_NORMAL,
423 GTK_SHADOW_IN,
424 dx, dy,
07f5b19a 425 widget->allocation.width-dw, widget->allocation.height-dh );
ed673c6a
RR		 426 return;
427 }
148cd9b6 428
ed673c6a
RR		 429 if (win->HasFlag(wxSIMPLE_BORDER))
430 {
431 GdkGC *gc;
b02da6b1 432 gc = gdk_gc_new( widget->window );
ed673c6a 433 gdk_gc_set_foreground( gc, &widget->style->black );
148cd9b6 434 gdk_draw_rectangle( widget->window, gc, FALSE,
ed673c6a 435 dx, dy,
07f5b19a 436 widget->allocation.width-dw-1, widget->allocation.height-dh-1 );
ed673c6a
RR		 437 gdk_gc_unref( gc );
438 return;
439 }
1e6feb95 440#endif // __WXUNIVERSAL__
ed673c6a
RR		 441}
442
443//-----------------------------------------------------------------------------
444// "expose_event" of m_widget
445//-----------------------------------------------------------------------------
446
1e6feb95 447gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindowGTK *win )
ed673c6a 448{
b6fa52db 449 if (gdk_event->count > 0) return FALSE;
1e6feb95 450
ed673c6a 451 draw_frame( widget, win );
1e6feb95 452
af1d24da
RR		 453#ifdef __WXGTK20__
454
455 (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event);
0fc5dbf5
VZ		 456
457#endif
b6fa52db 458 return TRUE;
ed673c6a
RR		 459}
460
461//-----------------------------------------------------------------------------
147bc491 462// "draw" of m_widget
ed673c6a
RR		 463//-----------------------------------------------------------------------------
464
67d78217
RR		 465#ifndef __WXGTK20__
466
1e6feb95 467static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindowGTK *win )
ed673c6a
RR		 468{
469 draw_frame( widget, win );
470}
471
1c6896d7 472#endif // GTK+ < 2.0
c5b42c87 473
47c93b63
RR		 474//-----------------------------------------------------------------------------
475// "size_request" of m_widget
476//-----------------------------------------------------------------------------
477
e1f448ee
VZ		 478// make it extern because wxStatitText needs to disconnect this one
479extern "C"
480void wxgtk_window_size_request_callback(GtkWidget *widget,
481 GtkRequisition *requisition,
482 wxWindow *win)
47c93b63 483{
e1f448ee 484 int w, h;
47c93b63 485 win->GetSize( &w, &h );
e1f448ee
VZ		 486 if (w < 2)
487 w = 2;
488 if (h < 2)
489 h = 2;
1e6feb95 490
47c93b63
RR		 491 requisition->height = h;
492 requisition->width = w;
493}
494
c801d85f 495//-----------------------------------------------------------------------------
034be888 496// "expose_event" of m_wxwindow
c801d85f
KB		 497//-----------------------------------------------------------------------------
498
1e6feb95
VZ		 499static int gtk_window_expose_callback( GtkWidget *widget,
500 GdkEventExpose *gdk_event,
501 wxWindow *win )
47d67540 502{
3ac8d3bc
RR		 503 DEBUG_MAIN_THREAD
504
b6fa52db
RR		 505 if (g_isIdle)
506 wxapp_install_idle_handler();
1e6feb95 507
3fc6e5fa
RR		 508#ifdef __WXGTK20__
509 // This callback gets called in drawing-idle time under
510 // GTK 2.0, so we don't need to defer anything to idle
511 // time anymore.
2b5f62a0 512
3fc6e5fa
RR		 513 GtkPizza *pizza = GTK_PIZZA( widget );
514 if (gdk_event->window != pizza->bin_window) return FALSE;
2b5f62a0 515
9abbd4a0 516#if 0
d7fa7eaa 517 if (win->GetName())
3d2d8da1
RR		 518 {
519 wxPrintf( wxT("OnExpose from ") );
520 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
521 wxPrintf( win->GetClassInfo()->GetClassName() );
522 wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event->area.x,
523 (int)gdk_event->area.y,
524 (int)gdk_event->area.width,
525 (int)gdk_event->area.height );
526 }
a1696b86
RR		 527
528 gtk_paint_box
529 (
530 win->m_wxwindow->style,
531 pizza->bin_window,
532 GTK_STATE_NORMAL,
533 GTK_SHADOW_OUT,
534 (GdkRectangle*) NULL,
535 win->m_wxwindow,
536 (char *)"button", // const_cast
537 20,20,24,24
538 );
d7fa7eaa 539#endif
1e6feb95 540
b15ed747
RR		 541 win->GetUpdateRegion() = wxRegion( gdk_event->region );
542
543 win->GtkSendPaintEvents();
544
2b5f62a0 545
3fc6e5fa 546 // Let parent window draw window less widgets
b15ed747
RR		 547 (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event);
548#else
549 // This gets called immediately after an expose event
550 // under GTK 1.2 so we collect the calls and wait for
551 // the idle handler to pick things up.
2b5f62a0 552
2bc6945a
RR		 553 win->GetUpdateRegion().Union( gdk_event->area.x,
554 gdk_event->area.y,
555 gdk_event->area.width,
556 gdk_event->area.height );
d665f50b
JS		 557 win->m_clearRegion.Union( gdk_event->area.x,
558 gdk_event->area.y,
559 gdk_event->area.width,
560 gdk_event->area.height );
0e09f76e 561
8f3e7ecc 562 // Actual redrawing takes place in idle time.
62cb3cd8 563 // win->GtkUpdate();
0fc5dbf5 564#endif
f7a11f8c 565
3fc6e5fa 566 return FALSE;
b6fa52db
RR		 567}
568
569//-----------------------------------------------------------------------------
570// "event" of m_wxwindow
571//-----------------------------------------------------------------------------
572
beab25bd
RR		 573// GTK thinks it is clever and filters out a certain amount of "unneeded"
574// expose events. We need them, of course, so we override the main event
575// procedure in GtkWidget by giving our own handler for all system events.
576// There, we look for expose events ourselves whereas all other events are
577// handled normally.
b6fa52db 578
1e6feb95
VZ		 579gint gtk_window_event_event_callback( GtkWidget *widget,
580 GdkEventExpose *event,
581 wxWindow *win )
b6fa52db
RR		 582{
583 if (event->type == GDK_EXPOSE)
584 {
585 gint ret = gtk_window_expose_callback( widget, event, win );
586 return ret;
587 }
588
b6fa52db 589 return FALSE;
362c6693 590}
c801d85f
KB		 591
592//-----------------------------------------------------------------------------
034be888 593// "draw" of m_wxwindow
2f2aa628 594//-----------------------------------------------------------------------------
c801d85f 595
67d78217
RR		 596#ifndef __WXGTK20__
597
beab25bd 598// This callback is a complete replacement of the gtk_pizza_draw() function,
67d78217 599// which is disabled.
b6fa52db 600
1e6feb95
VZ		 601static void gtk_window_draw_callback( GtkWidget *widget,
602 GdkRectangle *rect,
603 wxWindow *win )
47d67540 604{
3ac8d3bc
RR		 605 DEBUG_MAIN_THREAD
606
c50f1fb9 607 if (g_isIdle)
a2053b27 608 wxapp_install_idle_handler();
2d19ad25 609
e441e1f4
VZ		 610 // if there are any children we must refresh everything
611 //
612 // VZ: why?
613 if ( !win->HasFlag(wxFULL_REPAINT_ON_RESIZE) &&
614 win->GetChildren().IsEmpty() )
e22454be
RR		 615 {
616 return;
617 }
2d19ad25 618
d7fa7eaa
RR		 619#if 0
620 if (win->GetName())
3d2d8da1
RR		 621 {
622 wxPrintf( wxT("OnDraw from ") );
623 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
624 wxPrintf( win->GetClassInfo()->GetClassName() );
625 wxPrintf( wxT(" %d %d %d %d\n"), (int)rect->x,
626 (int)rect->y,
627 (int)rect->width,
628 (int)rect->height );
629 }
d7fa7eaa 630#endif
1e6feb95 631
2e09dc2d 632#ifndef __WXUNIVERSAL__
b420fb6a 633 GtkPizza *pizza = GTK_PIZZA (widget);
2bc6945a 634
9cc7121f 635 if (win->GetThemeEnabled())
789dbcd4 636 {
9cc7121f
RR		 637 wxWindow *parent = win->GetParent();
638 while (parent && !parent->IsTopLevel())
789dbcd4 639 parent = parent->GetParent();
9cc7121f
RR		 640 if (!parent)
641 parent = win;
642
90350682
VZ		 643 gtk_paint_flat_box (parent->m_widget->style,
644 pizza->bin_window,
645 GTK_STATE_NORMAL,
646 GTK_SHADOW_NONE,
647 rect,
648 parent->m_widget,
649 (char *)"base",
650 0, 0, -1, -1);
789dbcd4 651 }
2e09dc2d 652#endif
1e6feb95 653
62cb3cd8 654 win->m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
9cc7121f 655 win->GetUpdateRegion().Union( rect->x, rect->y, rect->width, rect->height );
148cd9b6 656
62cb3cd8 657 // Update immediately, not in idle time.
010afced 658 win->GtkUpdate();
1e6feb95 659
8f3e7ecc 660#ifndef __WXUNIVERSAL__
beab25bd 661 // Redraw child widgets
e22454be
RR		 662 GList *children = pizza->children;
663 while (children)
664 {
beab25bd
RR		 665 GtkPizzaChild *child = (GtkPizzaChild*) children->data;
666 children = children->next;
b420fb6a 667
beab25bd
RR		 668 GdkRectangle child_area;
669 if (gtk_widget_intersect (child->widget, rect, &child_area))
670 {
671 gtk_widget_draw (child->widget, &child_area /* (GdkRectangle*) NULL*/ );
672 }
e22454be 673 }
8f3e7ecc 674#endif
362c6693 675}
c801d85f 676
67d78217
RR		 677#endif
678
c801d85f 679//-----------------------------------------------------------------------------
b292e2f5 680// "key_press_event" from any window
c801d85f 681//-----------------------------------------------------------------------------
c801d85f 682
74710601
VZ		 683// set WXTRACE to this to see the key event codes on the console
684#define TRACE_KEYS _T("keyevent")
f17393f1 685
1c6896d7
VZ		 686// translates an X key symbol to WXK_XXX value
687//
688// if isChar is true it means that the value returned will be used for EVT_CHAR
689// event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
690// for example, while if it is false it means that the value is going to be
691// used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
692// WXK_NUMPAD_DIVIDE
693static long wxTranslateKeySymToWXKey(KeySym keysym, bool isChar)
694{
695 long key_code;
696
697 switch ( keysym )
698 {
699 // Shift, Control and Alt don't generate the CHAR events at all
700 case GDK_Shift_L:
701 case GDK_Shift_R:
702 key_code = isChar ? 0 : WXK_SHIFT;
703 break;
704 case GDK_Control_L:
705 case GDK_Control_R:
706 key_code = isChar ? 0 : WXK_CONTROL;
707 break;
708 case GDK_Meta_L:
709 case GDK_Meta_R:
710 case GDK_Alt_L:
711 case GDK_Alt_R:
712 case GDK_Super_L:
713 case GDK_Super_R:
714 key_code = isChar ? 0 : WXK_ALT;
715 break;
716
717 // neither do the toggle modifies
718 case GDK_Scroll_Lock:
719 key_code = isChar ? 0 : WXK_SCROLL;
720 break;
721
722 case GDK_Caps_Lock:
723 key_code = isChar ? 0 : WXK_CAPITAL;
724 break;
725
726 case GDK_Num_Lock:
727 key_code = isChar ? 0 : WXK_NUMLOCK;
728 break;
729
730
731 // various other special keys
732 case GDK_Menu:
733 key_code = WXK_MENU;
734 break;
735
736 case GDK_Help:
737 key_code = WXK_HELP;
738 break;
739
740 case GDK_BackSpace:
741 key_code = WXK_BACK;
742 break;
743
744 case GDK_ISO_Left_Tab:
745 case GDK_Tab:
746 key_code = WXK_TAB;
747 break;
748
749 case GDK_Linefeed:
750 case GDK_Return:
751 key_code = WXK_RETURN;
752 break;
753
754 case GDK_Clear:
755 key_code = WXK_CLEAR;
756 break;
757
758 case GDK_Pause:
759 key_code = WXK_PAUSE;
760 break;
761
762 case GDK_Select:
763 key_code = WXK_SELECT;
764 break;
765
766 case GDK_Print:
767 key_code = WXK_PRINT;
768 break;
769
770 case GDK_Execute:
771 key_code = WXK_EXECUTE;
772 break;
773
774 case GDK_Escape:
775 key_code = WXK_ESCAPE;
776 break;
777
778 // cursor and other extended keyboard keys
779 case GDK_Delete:
780 key_code = WXK_DELETE;
781 break;
782
783 case GDK_Home:
784 key_code = WXK_HOME;
785 break;
786
787 case GDK_Left:
788 key_code = WXK_LEFT;
789 break;
790
791 case GDK_Up:
792 key_code = WXK_UP;
793 break;
794
795 case GDK_Right:
796 key_code = WXK_RIGHT;
797 break;
798
799 case GDK_Down:
800 key_code = WXK_DOWN;
801 break;
802
803 case GDK_Prior: // == GDK_Page_Up
804 key_code = WXK_PRIOR;
805 break;
806
807 case GDK_Next: // == GDK_Page_Down
808 key_code = WXK_NEXT;
809 break;
810
811 case GDK_End:
812 key_code = WXK_END;
813 break;
814
815 case GDK_Begin:
816 key_code = WXK_HOME;
817 break;
818
819 case GDK_Insert:
820 key_code = WXK_INSERT;
821 break;
822
823
824 // numpad keys
825 case GDK_KP_0:
826 case GDK_KP_1:
827 case GDK_KP_2:
828 case GDK_KP_3:
829 case GDK_KP_4:
830 case GDK_KP_5:
831 case GDK_KP_6:
832 case GDK_KP_7:
833 case GDK_KP_8:
834 case GDK_KP_9:
835 key_code = (isChar ? '0' : WXK_NUMPAD0) + keysym - GDK_KP_0;
836 break;
837
838 case GDK_KP_Space:
839 key_code = isChar ? ' ' : WXK_NUMPAD_SPACE;
840 break;
841
842 case GDK_KP_Tab:
843 key_code = isChar ? WXK_TAB : WXK_NUMPAD_TAB;
844 break;
845
846 case GDK_KP_Enter:
847 key_code = isChar ? WXK_RETURN : WXK_NUMPAD_ENTER;
848 break;
849
850 case GDK_KP_F1:
851 key_code = isChar ? WXK_F1 : WXK_NUMPAD_F1;
852 break;
853
854 case GDK_KP_F2:
855 key_code = isChar ? WXK_F2 : WXK_NUMPAD_F2;
856 break;
857
858 case GDK_KP_F3:
859 key_code = isChar ? WXK_F3 : WXK_NUMPAD_F3;
860 break;
861
862 case GDK_KP_F4:
863 key_code = isChar ? WXK_F4 : WXK_NUMPAD_F4;
864 break;
865
866 case GDK_KP_Home:
867 key_code = isChar ? WXK_HOME : WXK_NUMPAD_HOME;
868 break;
869
870 case GDK_KP_Left:
871 key_code = isChar ? WXK_LEFT : WXK_NUMPAD_LEFT;
872 break;
873
874 case GDK_KP_Up:
875 key_code = isChar ? WXK_UP : WXK_NUMPAD_UP;
876 break;
877
878 case GDK_KP_Right:
879 key_code = isChar ? WXK_RIGHT : WXK_NUMPAD_RIGHT;
880 break;
881
882 case GDK_KP_Down:
883 key_code = isChar ? WXK_DOWN : WXK_NUMPAD_DOWN;
884 break;
885
886 case GDK_KP_Prior: // == GDK_KP_Page_Up
887 key_code = isChar ? WXK_PRIOR : WXK_NUMPAD_PRIOR;
888 break;
889
890 case GDK_KP_Next: // == GDK_KP_Page_Down
891 key_code = isChar ? WXK_NEXT : WXK_NUMPAD_NEXT;
892 break;
893
894 case GDK_KP_End:
895 key_code = isChar ? WXK_END : WXK_NUMPAD_END;
896 break;
897
898 case GDK_KP_Begin:
899 key_code = isChar ? WXK_HOME : WXK_NUMPAD_BEGIN;
900 break;
901
902 case GDK_KP_Insert:
903 key_code = isChar ? WXK_INSERT : WXK_NUMPAD_INSERT;
904 break;
905
906 case GDK_KP_Delete:
907 key_code = isChar ? WXK_DELETE : WXK_NUMPAD_DELETE;
908 break;
909
910 case GDK_KP_Equal:
911 key_code = isChar ? '=' : WXK_NUMPAD_EQUAL;
912 break;
913
914 case GDK_KP_Multiply:
915 key_code = isChar ? '*' : WXK_NUMPAD_MULTIPLY;
916 break;
917
918 case GDK_KP_Add:
919 key_code = isChar ? '+' : WXK_NUMPAD_ADD;
920 break;
921
922 case GDK_KP_Separator:
923 // FIXME: what is this?
924 key_code = isChar ? '.' : WXK_NUMPAD_SEPARATOR;
925 break;
926
927 case GDK_KP_Subtract:
928 key_code = isChar ? '-' : WXK_NUMPAD_SUBTRACT;
929 break;
930
931 case GDK_KP_Decimal:
932 key_code = isChar ? '.' : WXK_NUMPAD_DECIMAL;
933 break;
934
935 case GDK_KP_Divide:
936 key_code = isChar ? '/' : WXK_NUMPAD_DIVIDE;
937 break;
938
939
940 // function keys
941 case GDK_F1:
942 case GDK_F2:
943 case GDK_F3:
944 case GDK_F4:
945 case GDK_F5:
946 case GDK_F6:
947 case GDK_F7:
948 case GDK_F8:
949 case GDK_F9:
950 case GDK_F10:
951 case GDK_F11:
952 case GDK_F12:
953 key_code = WXK_F1 + keysym - GDK_F1;
954 break;
955
956 default:
957 key_code = 0;
958 }
959
960 return key_code;
961}
962
963static inline bool wxIsAsciiKeysym(KeySym ks)
964{
965 return ks < 256;
966}
967
74710601
VZ		 968static bool
969wxTranslateGTKKeyEventToWx(wxKeyEvent& event,
970 wxWindowGTK *win,
971 GdkEventKey *gdk_event)
47d67540 972{
1c6896d7
VZ		 973 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
974 // but only event->keyval which is quite useless to us, so remember
975 // the last character from GDK_KEY_PRESS and reuse it as last resort
976 //
977 // NB: should be MT-safe as we're always called from the main thread only
978 static struct
979 {
980 KeySym keysym;
981 long keycode;
982 } s_lastKeyPress = { 0, 0 };
983
984 KeySym keysym = gdk_event->keyval;
0a62b197 985
ada7d2c0 986 wxLogTrace(TRACE_KEYS, _T("Key %s event: keysym = %ld"),
0a62b197
VZ		 987 event.GetEventType() == wxEVT_KEY_UP ? _T("release")
988 : _T("press"),
989 keysym);
990
1c6896d7
VZ		 991 long key_code = wxTranslateKeySymToWXKey(keysym, FALSE /* !isChar */);
992
993 if ( !key_code )
994 {
995 // do we have the translation or is it a plain ASCII character?
996 if ( (gdk_event->length == 1) || wxIsAsciiKeysym(keysym) )
997 {
998 // we should use keysym if it is ASCII as X does some translations
999 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
1000 // which we don't want here (but which we do use for OnChar())
1001 if ( !wxIsAsciiKeysym(keysym) )
1002 {
1003 keysym = (KeySym)gdk_event->string[0];
1004 }
a2053b27 1005
1c6896d7
VZ		 1006 // we want to always get the same key code when the same key is
1007 // pressed regardless of the state of the modifies, i.e. on a
1008 // standard US keyboard pressing '5' or '%' ('5' key with
1009 // Shift) should result in the same key code in OnKeyDown():
1010 // '5' (although OnChar() will get either '5' or '%').
1011 //
1012 // to do it we first translate keysym to keycode (== scan code)
1013 // and then back but always using the lower register
1014 Display *dpy = (Display *)wxGetDisplay();
1015 KeyCode keycode = XKeysymToKeycode(dpy, keysym);
0a62b197
VZ		 1016
1017 wxLogTrace(TRACE_KEYS, _T("\t-> keycode %d"), keycode);
1018
1c6896d7
VZ		 1019 KeySym keysymNormalized = XKeycodeToKeysym(dpy, keycode, 0);
1020
1021 // use the normalized, i.e. lower register, keysym if we've
1022 // got one
1023 key_code = keysymNormalized ? keysymNormalized : keysym;
1024
1025 // as explained above, we want to have lower register key codes
1026 // normally but for the letter keys we want to have the upper ones
1027 //
1028 // NB: don't use XConvertCase() here, we want to do it for letters
1029 // only
1030 key_code = toupper(key_code);
1031 }
1032 else // non ASCII key, what to do?
1033 {
1034 // by default, ignore it
1035 key_code = 0;
1036
1037 // but if we have cached information from the last KEY_PRESS
1038 if ( gdk_event->type == GDK_KEY_RELEASE )
1039 {
1040 // then reuse it
1041 if ( keysym == s_lastKeyPress.keysym )
1042 {
1043 key_code = s_lastKeyPress.keycode;
1044 }
1045 }
1046 }
1047
1048 if ( gdk_event->type == GDK_KEY_PRESS )
1049 {
1050 // remember it to be reused for KEY_UP event later
1051 s_lastKeyPress.keysym = keysym;
1052 s_lastKeyPress.keycode = key_code;
1053 }
1054 }
1055
ada7d2c0 1056 wxLogTrace(TRACE_KEYS, _T("\t-> wxKeyCode %ld"), key_code);
c801d85f 1057
74710601 1058 // sending unknown key events doesn't really make sense
1c6896d7 1059 if ( !key_code )
74710601 1060 return FALSE;
3d6f7261 1061
1c6896d7 1062 // now fill all the other fields
b0e813a0
RR		 1063 int x = 0;
1064 int y = 0;
1065 GdkModifierType state;
f17393f1
VZ		 1066 if (gdk_event->window)
1067 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
47d67540 1068
d1367c3d 1069 event.SetTimestamp( gdk_event->time );
74710601
VZ		 1070 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0;
1071 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
1072 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
1073 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK) != 0;
f5e27805 1074 event.m_keyCode = key_code;
b0e813a0 1075 event.m_scanCode = gdk_event->keyval;
9c7df356
VZ		 1076 event.m_rawCode = (wxUint32) gdk_event->keyval;
1077 event.m_rawFlags = 0;
b0e813a0
RR		 1078 event.m_x = x;
1079 event.m_y = y;
f5e27805 1080 event.SetEventObject( win );
74710601
VZ		 1081
1082 return TRUE;
1083}
1084
7c5e6fc6 1085
74710601
VZ		 1086static gint gtk_window_key_press_callback( GtkWidget *widget,
1087 GdkEventKey *gdk_event,
1088 wxWindow *win )
1089{
1090 DEBUG_MAIN_THREAD
1091
1092 if (g_isIdle)
1093 wxapp_install_idle_handler();
1094
1c6896d7
VZ		 1095 if (!win->m_hasVMT)
1096 return FALSE;
1097 if (g_blockEventsOnDrag)
1098 return FALSE;
74710601 1099
1ec3a984
RR		 1100
1101 wxKeyEvent event( wxEVT_KEY_DOWN );
74710601
VZ		 1102 if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
1103 {
1c6896d7 1104 // unknown key pressed, ignore (the event would be useless anyhow)
74710601
VZ		 1105 return FALSE;
1106 }
1107
1ec3a984
RR		 1108 // Emit KEY_DOWN event
1109 bool ret = win->GetEventHandler()->ProcessEvent( event );
c50f1fb9 1110
88ac883a 1111#if wxUSE_ACCEL
f5e27805 1112 if (!ret)
47d67540 1113 {
1e6feb95 1114 wxWindowGTK *ancestor = win;
f5e27805
RR		 1115 while (ancestor)
1116 {
1117 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
1118 if (command != -1)
1119 {
1120 wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
1121 ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
1122 break;
1123 }
f6bcfd97 1124 if (ancestor->IsTopLevel())
b02da6b1 1125 break;
f5e27805
RR		 1126 ancestor = ancestor->GetParent();
1127 }
bcf1fa6b 1128 }
88ac883a 1129#endif // wxUSE_ACCEL
3017f78d 1130
1ec3a984
RR		 1131 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1132 // will only be sent if it is not in an accelerator table.
2dde25b9 1133 if (!ret)
d728dd40 1134 {
7c5e6fc6 1135 long key_code;
1c6896d7 1136 KeySym keysym = gdk_event->keyval;
7c5e6fc6
RD		 1137#ifdef __WXGTK20__
1138 // In GTK 2.0, we need to hand over the key event to an input method
1139 // and the IM will emit a "commit" event containing the actual utf8
1140 // character. In that case the EVT_CHAR events will be sent from
1141 // there. But only do it this way for non-KeySym keys.
1142 key_code = wxTranslateKeySymToWXKey(gdk_event->keyval, FALSE /* isChar */);
1143 if ( !key_code && win->m_imContext )
1c6896d7 1144 {
da210120 1145 gtk_im_context_filter_keypress(win->m_imContext, gdk_event );
7c5e6fc6 1146 ret = TRUE;
1c6896d7 1147 }
7c5e6fc6
RD		 1148 else
1149#endif
f17393f1 1150 {
7c5e6fc6
RD		 1151 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1152 key_code = wxTranslateKeySymToWXKey(keysym, TRUE /* isChar */);
1153 if ( !key_code )
1ec3a984 1154 {
7c5e6fc6
RD		 1155 if ( gdk_event->length == 1 )
1156 {
1157 key_code = (unsigned char)gdk_event->string[0];
1158 }
1159 else if ( wxIsAsciiKeysym(keysym) )
1160 {
1161 // ASCII key
1162 key_code = (unsigned char)keysym;
1163 }
1ec3a984 1164 }
f17393f1 1165
7c5e6fc6 1166 if ( key_code )
1ec3a984 1167 {
7c5e6fc6
RD		 1168 wxLogTrace(TRACE_KEYS, _T("Char event: %ld"), key_code);
1169
1170 event.m_keyCode = key_code;
1171
1172 // Implement OnCharHook by checking ancesteror top level windows
1173 wxWindow *parent = win;
1174 while (parent && !parent->IsTopLevel())
1175 parent = parent->GetParent();
1176 if (parent)
1177 {
1178 event.SetEventType( wxEVT_CHAR_HOOK );
1179 ret = parent->GetEventHandler()->ProcessEvent( event );
1180 }
1181
1182 if (!ret)
1183 {
1184 event.SetEventType(wxEVT_CHAR);
1185 ret = win->GetEventHandler()->ProcessEvent( event );
1186 }
1ec3a984 1187 }
f17393f1 1188 }
d728dd40
KB		 1189 }
1190
1ec3a984 1191 // win is a control: tab can be propagated up
f17393f1 1192 if ( !ret &&
5664fc32 1193 ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
f6bcfd97
BP		 1194// VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may
1195// have this style, yet choose not to process this particular TAB in which
1196// case TAB must still work as a navigational character
f5f3247d
JS		 1197// JS: enabling again to make consistent with other platforms
1198// (with wxTE_PROCESS_TAB you have to call Navigate to get default
1199// navigation behaviour)
eedc82f4 1200#if wxUSE_TEXTCTRL
8700aedc 1201 (! (win->HasFlag(wxTE_PROCESS_TAB) && win->IsKindOf(CLASSINFO(wxTextCtrl)) )) &&
f5f3247d 1202#endif
f17393f1 1203 win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
b292e2f5
RR		 1204 {
1205 wxNavigationKeyEvent new_event;
8253c7fd 1206 new_event.SetEventObject( win->GetParent() );
1ec3a984 1207 // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
5664fc32 1208 new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
1ec3a984 1209 // CTRL-TAB changes the (parent) window, i.e. switch notebook page
b98d804b 1210 new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
b292e2f5 1211 new_event.SetCurrentFocus( win );
8253c7fd 1212 ret = win->GetParent()->GetEventHandler()->ProcessEvent( new_event );
b292e2f5 1213 }
ff8bfdbb 1214
1ec3a984 1215 // generate wxID_CANCEL if <esc> has been pressed (typically in dialogs)
f17393f1 1216 if ( !ret &&
b98d804b
RR		 1217 (gdk_event->keyval == GDK_Escape) )
1218 {
6ce16bdb
VZ		 1219 // however only do it if we have a Cancel button in the dialog,
1220 // otherwise the user code may get confused by the events from a
1221 // non-existing button and, worse, a wxButton might get button event
1222 // from another button which is not really expected
1223 wxWindow *winForCancel = win,
1224 *btnCancel = NULL;
1225 while ( winForCancel )
1226 {
1227 btnCancel = winForCancel->FindWindow(wxID_CANCEL);
1228 if ( btnCancel )
1229 {
1230 // found a cancel button
1231 break;
1232 }
1233
1234 if ( winForCancel->IsTopLevel() )
1235 {
1236 // no need to look further
1237 break;
1238 }
1239
1240 // maybe our parent has a cancel button?
1241 winForCancel = winForCancel->GetParent();
1242 }
1243
1244 if ( btnCancel )
1245 {
1246 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
1247 event.SetEventObject(btnCancel);
1248 ret = btnCancel->GetEventHandler()->ProcessEvent(event);
1249 }
b98d804b 1250 }
c50f1fb9 1251
2b5f62a0 1252 if (ret)
801aa178 1253 {
2b5f62a0
VZ		 1254 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
1255 return TRUE;
1256 }
1257
1258 return FALSE;
1259}
2b5f62a0
VZ		 1260
1261#ifdef __WXGTK20__
2b5f62a0 1262static void gtk_wxwindow_commit_cb (GtkIMContext *context,
9abbd4a0
RR		 1263 const gchar *str,
1264 wxWindow *window)
2b5f62a0
VZ		 1265{
1266 bool ret = FALSE;
1267
1268 wxKeyEvent event( wxEVT_KEY_DOWN );
1269
1270#if wxUSE_UNICODE
1271 event.m_uniChar = g_utf8_get_char( str );
1272
1273 // Backward compatible for ISO-8859
1274 if (event.m_uniChar < 256)
1275 event.m_keyCode = event.m_uniChar;
1276#else
cf82b73a
VS		 1277 wchar_t unistr[2];
1278 unistr[0] = g_utf8_get_char(str);
1279 unistr[1] = 0;
1280 wxCharBuffer ansistr(wxConvLocal.cWC2MB(unistr));
1281 // We cannot handle characters that cannot be represented in
1282 // current locale's charset in non-Unicode mode:
1283 if (ansistr.data() == NULL) return;
1284
1285 event.m_keyCode = ansistr[0u];
2b5f62a0
VZ		 1286#endif
1287
7c5e6fc6
RD		 1288
1289 // TODO: We still need to set all the extra attributes of the
1290 // event, modifiers and such...
1291
1292
1293 // Implement OnCharHook by checking ancestor top level windows
1294 wxWindow *parent = window;
1295 while (parent && !parent->IsTopLevel())
2b5f62a0 1296 parent = parent->GetParent();
7c5e6fc6
RD		 1297 if (parent)
1298 {
1299 event.SetEventType( wxEVT_CHAR_HOOK );
1300 ret = parent->GetEventHandler()->ProcessEvent( event );
1301 }
2b5f62a0 1302
7c5e6fc6
RD		 1303 if (!ret)
1304 {
1305 event.SetEventType(wxEVT_CHAR);
1306 ret = window->GetEventHandler()->ProcessEvent( event );
2b5f62a0
VZ		 1307 }
1308}
1309#endif
1310
1311
b666df2c
RR		 1312//-----------------------------------------------------------------------------
1313// "key_release_event" from any window
1314//-----------------------------------------------------------------------------
1315
74710601
VZ		 1316static gint gtk_window_key_release_callback( GtkWidget *widget,
1317 GdkEventKey *gdk_event,
1318 wxWindowGTK *win )
b666df2c 1319{
3ac8d3bc
RR		 1320 DEBUG_MAIN_THREAD
1321
c50f1fb9 1322 if (g_isIdle)
a2053b27
RR		 1323 wxapp_install_idle_handler();
1324
74710601
VZ		 1325 if (!win->m_hasVMT)
1326 return FALSE;
b666df2c 1327
74710601
VZ		 1328 if (g_blockEventsOnDrag)
1329 return FALSE;
b666df2c
RR		 1330
1331 wxKeyEvent event( wxEVT_KEY_UP );
74710601 1332 if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
b666df2c 1333 {
74710601
VZ		 1334 // unknown key pressed, ignore (the event would be useless anyhow
1335 return FALSE;
b666df2c
RR		 1336 }
1337
74710601
VZ		 1338 if ( !win->GetEventHandler()->ProcessEvent( event ) )
1339 return FALSE;
1340
1341 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" );
1342 return TRUE;
b666df2c
RR		 1343}
1344
c5f9d156
VS		 1345// ============================================================================
1346// the mouse events
1347// ============================================================================
1348
d1f2ac45
VZ		 1349// ----------------------------------------------------------------------------
1350// mouse event processing helpers
1351// ----------------------------------------------------------------------------
1352
50f00d0c
VS		 1353// init wxMouseEvent with the info from GdkEventXXX struct
1354template<typename T> void InitMouseEvent(wxWindowGTK *win,
1355 wxMouseEvent& event,
1356 T *gdk_event)
1357{
1358 event.SetTimestamp( gdk_event->time );
1359 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
1360 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
1361 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
1362 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
1363 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
1364 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
1365 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
1366 if (event.GetEventType() == wxEVT_MOUSEWHEEL)
1367 {
1368 event.m_linesPerAction = 3;
1369 if (((GdkEventButton*)gdk_event)->button == 4)
1370 event.m_wheelRotation = 120;
1371 else if (((GdkEventButton*)gdk_event)->button == 5)
1372 event.m_wheelRotation = -120;
1373 }
1374
1375 wxPoint pt = win->GetClientAreaOrigin();
1376 event.m_x = (wxCoord)gdk_event->x - pt.x;
1377 event.m_y = (wxCoord)gdk_event->y - pt.y;
1378
1379 event.SetEventObject( win );
1380 event.SetId( win->GetId() );
1381 event.SetTimestamp( gdk_event->time );
1382}
c5f9d156 1383
2daa0ce9
VZ		 1384static void AdjustEventButtonState(wxMouseEvent& event)
1385{
1386 // GDK reports the old state of the button for a button press event, but
1387 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1388 // for a LEFT_DOWN event, not FALSE, so we will invert
1389 // left/right/middleDown for the corresponding click events
1e6feb95 1390
1a8caf94
RR		 1391 if ((event.GetEventType() == wxEVT_LEFT_DOWN) ||
1392 (event.GetEventType() == wxEVT_LEFT_DCLICK) ||
1393 (event.GetEventType() == wxEVT_LEFT_UP))
1394 {
1395 event.m_leftDown = !event.m_leftDown;
1396 return;
1397 }
1398
1399 if ((event.GetEventType() == wxEVT_MIDDLE_DOWN) ||
1400 (event.GetEventType() == wxEVT_MIDDLE_DCLICK) ||
1401 (event.GetEventType() == wxEVT_MIDDLE_UP))
2daa0ce9 1402 {
1a8caf94
RR		 1403 event.m_middleDown = !event.m_middleDown;
1404 return;
1405 }
1406
1407 if ((event.GetEventType() == wxEVT_RIGHT_DOWN) ||
1408 (event.GetEventType() == wxEVT_RIGHT_DCLICK) ||
1409 (event.GetEventType() == wxEVT_RIGHT_UP))
1410 {
1411 event.m_rightDown = !event.m_rightDown;
1412 return;
2daa0ce9
VZ		 1413 }
1414}
1415
d1f2ac45
VZ		 1416// find the window to send the mouse event too
1417static
1418wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
1419{
7d4909b2
RR		 1420 wxCoord xx = x;
1421 wxCoord yy = y;
1422
d1f2ac45
VZ		 1423 if (win->m_wxwindow)
1424 {
1425 GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
7d4909b2
RR		 1426 xx += pizza->xoffset;
1427 yy += pizza->yoffset;
d1f2ac45
VZ		 1428 }
1429
222ed1d6 1430 wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
d1f2ac45
VZ		 1431 while (node)
1432 {
b1d4dd7a 1433 wxWindowGTK *child = node->GetData();
d1f2ac45 1434
b1d4dd7a 1435 node = node->GetNext();
d1f2ac45
VZ		 1436 if (!child->IsShown())
1437 continue;
1438
1439 if (child->IsTransparentForMouse())
1440 {
1441 // wxStaticBox is transparent in the box itself
1442 int xx1 = child->m_x;
1443 int yy1 = child->m_y;
1444 int xx2 = child->m_x + child->m_width;
7408cf7f 1445 int yy2 = child->m_y + child->m_height;
d1f2ac45
VZ		 1446
1447 // left
7d4909b2 1448 if (((xx >= xx1) && (xx <= xx1+10) && (yy >= yy1) && (yy <= yy2)) ||
d1f2ac45 1449 // right
7d4909b2 1450 ((xx >= xx2-10) && (xx <= xx2) && (yy >= yy1) && (yy <= yy2)) ||
d1f2ac45 1451 // top
7d4909b2 1452 ((xx >= xx1) && (xx <= xx2) && (yy >= yy1) && (yy <= yy1+10)) ||
d1f2ac45 1453 // bottom
7d4909b2 1454 ((xx >= xx1) && (xx <= xx2) && (yy >= yy2-1) && (yy <= yy2)))
d1f2ac45
VZ		 1455 {
1456 win = child;
1457 x -= child->m_x;
1458 y -= child->m_y;
1459 break;
1460 }
1461
1462 }
1463 else
1464 {
1465 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
7d4909b2
RR		 1466 (child->m_x <= xx) &&
1467 (child->m_y <= yy) &&
af3653dd
RR		 1468 (child->m_x+child->m_width >= xx) &&
1469 (child->m_y+child->m_height >= yy))
d1f2ac45
VZ		 1470 {
1471 win = child;
1472 x -= child->m_x;
1473 y -= child->m_y;
1474 break;
1475 }
1476 }
1477 }
1478
1479 return win;
1480}
1481
c801d85f 1482//-----------------------------------------------------------------------------
2f2aa628
RR		 1483// "button_press_event"
1484//-----------------------------------------------------------------------------
c801d85f 1485
d1f2ac45
VZ		 1486static gint gtk_window_button_press_callback( GtkWidget *widget,
1487 GdkEventButton *gdk_event,
1488 wxWindowGTK *win )
903f689b 1489{
3ac8d3bc
RR		 1490 DEBUG_MAIN_THREAD
1491
c50f1fb9 1492 if (g_isIdle)
a2053b27
RR		 1493 wxapp_install_idle_handler();
1494
1495/*
223d09f6 1496 wxPrintf( wxT("1) OnButtonPress from ") );
a2053b27
RR		 1497 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1498 wxPrintf( win->GetClassInfo()->GetClassName() );
223d09f6 1499 wxPrintf( wxT(".\n") );
a2053b27 1500*/
a2053b27 1501 if (!win->m_hasVMT) return FALSE;
f5e27805 1502 if (g_blockEventsOnDrag) return TRUE;
76ed8f8d 1503 if (g_blockEventsOnScroll) return TRUE;
c801d85f 1504
034be888
RR		 1505 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1506
afbe906a 1507 if (win->m_wxwindow && (g_focusWindow != win) && win->AcceptsFocus())
c801d85f 1508 {
afbe906a 1509 gtk_widget_grab_focus( win->m_wxwindow );
c801d85f 1510/*
afbe906a
RR		 1511 wxPrintf( wxT("GrabFocus from ") );
1512 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1513 wxPrintf( win->GetClassInfo()->GetClassName() );
1514 wxPrintf( wxT(".\n") );
c801d85f 1515*/
362c6693 1516 }
47d67540 1517
2b5f62a0
VZ		 1518 // GDK sends surplus button down event
1519 // before a double click event. We
1520 // need to filter these out.
1521 if (gdk_event->type == GDK_BUTTON_PRESS)
1522 {
1523 GdkEvent *peek_event = gdk_event_peek();
1524 if (peek_event)
1525 {
8b8a8e0e
RR		 1526 if ((peek_event->type == GDK_2BUTTON_PRESS) ||
1527 (peek_event->type == GDK_3BUTTON_PRESS))
2b5f62a0
VZ		 1528 {
1529 gdk_event_free( peek_event );
1530 return TRUE;
1531 }
1532 else
1533 {
1534 gdk_event_free( peek_event );
1535 }
1536 }
1537 }
1538
2daa0ce9 1539 wxEventType event_type = wxEVT_NULL;
47d67540 1540
127304e9
VS		 1541 // GdkDisplay is a GTK+ 2.2.0 thing
1542#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0)
15475ced
VZ		 1543 if ( gdk_event->type == GDK_2BUTTON_PRESS &&
1544 gdk_event->button >= 1 && gdk_event->button <= 3 )
1545 {
1546 // Reset GDK internal timestamp variables in order to disable GDK
1547 // triple click events. GDK will then next time believe no button has
1548 // been clicked just before, and send a normal button click event.
1549 GdkDisplay* display = gtk_widget_get_display (widget);
1550 display->button_click_time[1] = 0;
1551 display->button_click_time[0] = 0;
1552 }
1553#endif // GTK 2+
1554
f5e27805 1555 if (gdk_event->button == 1)
c801d85f 1556 {
f3f0d961 1557 // note that GDK generates triple click events which are not supported
77ffb593 1558 // by wxWidgets but still have to be passed to the app as otherwise
f3f0d961 1559 // clicks would simply go missing
f5e27805
RR		 1560 switch (gdk_event->type)
1561 {
15475ced
VZ		 1562 // we shouldn't get triple clicks at all for GTK2 because we
1563 // suppress them artificially using the code above but we still
1564 // should map them to something for GTK1 and not just ignore them
1565 // as this would lose clicks
f3f0d961
VZ		 1566 case GDK_3BUTTON_PRESS: // we could also map this to DCLICK...
1567 case GDK_BUTTON_PRESS:
1568 event_type = wxEVT_LEFT_DOWN;
1569 break;
1570
1571 case GDK_2BUTTON_PRESS:
1572 event_type = wxEVT_LEFT_DCLICK;
1573 break;
b1f50e65
VZ		 1574
1575 default:
1576 // just to silence gcc warnings
1577 ;
f5e27805 1578 }
362c6693 1579 }
f5e27805 1580 else if (gdk_event->button == 2)
c801d85f 1581 {
f5e27805
RR		 1582 switch (gdk_event->type)
1583 {
15475ced 1584 case GDK_3BUTTON_PRESS:
f3f0d961
VZ		 1585 case GDK_BUTTON_PRESS:
1586 event_type = wxEVT_MIDDLE_DOWN;
1587 break;
1588
1589 case GDK_2BUTTON_PRESS:
1590 event_type = wxEVT_MIDDLE_DCLICK;
1591 break;
b1f50e65
VZ		 1592
1593 default:
1594 ;
f5e27805 1595 }
362c6693 1596 }
f5e27805 1597 else if (gdk_event->button == 3)
c801d85f 1598 {
f5e27805
RR		 1599 switch (gdk_event->type)
1600 {
15475ced 1601 case GDK_3BUTTON_PRESS:
f3f0d961
VZ		 1602 case GDK_BUTTON_PRESS:
1603 event_type = wxEVT_RIGHT_DOWN;
1604 break;
1605
1606 case GDK_2BUTTON_PRESS:
1607 event_type = wxEVT_RIGHT_DCLICK;
1608 break;
b1f50e65
VZ		 1609
1610 default:
1611 ;
2b5f62a0
VZ		 1612 }
1613 }
f3f0d961 1614 else if (gdk_event->button == 4 || gdk_event->button == 5)
2b5f62a0 1615 {
f3f0d961 1616 if (gdk_event->type == GDK_BUTTON_PRESS )
2b5f62a0 1617 {
f3f0d961 1618 event_type = wxEVT_MOUSEWHEEL;
2b5f62a0
VZ		 1619 }
1620 }
47d67540 1621
2daa0ce9
VZ		 1622 if ( event_type == wxEVT_NULL )
1623 {
1624 // unknown mouse button or click type
1625 return FALSE;
1626 }
1627
f5e27805 1628 wxMouseEvent event( event_type );
c5f9d156 1629 InitMouseEvent( win, event, gdk_event );
47d67540 1630
2daa0ce9 1631 AdjustEventButtonState(event);
94633ad9 1632
3ae4c570
VZ		 1633 // wxListBox actually get mouse events from the item, so we need to give it
1634 // a chance to correct this
1635 win->FixUpMouseEvent(widget, event.m_x, event.m_y);
2daa0ce9 1636
d1f2ac45
VZ		 1637 // find the correct window to send the event too: it may be a different one
1638 // from the one which got it at GTK+ level because some control don't have
1639 // their own X window and thus cannot get any events.
1640 if ( !g_captureWindow )
1641 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
ff8bfdbb 1642
34adc954
VZ		 1643 gs_timeLastClick = gdk_event->time;
1644
2f073eb2
RR		 1645/*
1646 wxPrintf( wxT("2) OnButtonPress from ") );
1647 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1648 wxPrintf( win->GetClassInfo()->GetClassName() );
1649 wxPrintf( wxT(".\n") );
1650*/
1651
df135f2b
RR		 1652#ifndef __WXGTK20__
1653 if (event_type == wxEVT_LEFT_DCLICK)
1654 {
1655 // GTK 1.2 crashes when intercepting double
1656 // click events from both wxSpinButton and
1657 // wxSpinCtrl
1658 if (GTK_IS_SPIN_BUTTON(win->m_widget))
1659 {
1660 // Just disable this event for now.
1661 return FALSE;
1662 }
1663 }
1664#endif
1665
f5e27805 1666 if (win->GetEventHandler()->ProcessEvent( event ))
034be888 1667 {
f5e27805 1668 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
f03fc89f 1669 return TRUE;
034be888 1670 }
47d67540 1671
034be888 1672 return FALSE;
362c6693 1673}
c801d85f
KB		 1674
1675//-----------------------------------------------------------------------------
97b3455a 1676// "button_release_event"
2f2aa628 1677//-----------------------------------------------------------------------------
c801d85f 1678
2b5f62a0
VZ		 1679static gint gtk_window_button_release_callback( GtkWidget *widget,
1680 GdkEventButton *gdk_event,
1681 wxWindowGTK *win )
47d67540 1682{
3ac8d3bc
RR		 1683 DEBUG_MAIN_THREAD
1684
c50f1fb9 1685 if (g_isIdle)
a2053b27
RR		 1686 wxapp_install_idle_handler();
1687
1688 if (!win->m_hasVMT) return FALSE;
034be888
RR		 1689 if (g_blockEventsOnDrag) return FALSE;
1690 if (g_blockEventsOnScroll) return FALSE;
c801d85f 1691
034be888 1692 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
47d67540 1693
f5e27805 1694 wxEventType event_type = wxEVT_NULL;
47d67540 1695
f5e27805
RR		 1696 switch (gdk_event->button)
1697 {
2b5f62a0
VZ		 1698 case 1:
1699 event_type = wxEVT_LEFT_UP;
1700 break;
1701
1702 case 2:
1703 event_type = wxEVT_MIDDLE_UP;
1704 break;
1705
1706 case 3:
1707 event_type = wxEVT_RIGHT_UP;
1708 break;
1709
1710 default:
1711 // unknwon button, don't process
1712 return FALSE;
f5e27805 1713 }
47d67540 1714
f5e27805 1715 wxMouseEvent event( event_type );
c5f9d156 1716 InitMouseEvent( win, event, gdk_event );
f5e27805 1717
2daa0ce9
VZ		 1718 AdjustEventButtonState(event);
1719
3ae4c570
VZ		 1720 // same wxListBox hack as above
1721 win->FixUpMouseEvent(widget, event.m_x, event.m_y);
e2762ff0 1722
2b5f62a0
VZ		 1723 if ( event_type == wxEVT_RIGHT_UP )
1724 {
1725 // generate a "context menu" event: this is similar to wxEVT_RIGHT_UP
1726 // except that:
1727 //
1728 // (a) it's a command event and so is propagated to the parent
1729 // (b) under MSW it can be generated from kbd too
1730 // (c) it uses screen coords (because of (a))
1731 wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU,
1732 win->GetId(),
1733 win->ClientToScreen(event.GetPosition()));
1734 (void)win->GetEventHandler()->ProcessEvent(evtCtx);
1735 }
1736
d1f2ac45
VZ		 1737 if ( !g_captureWindow )
1738 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
47d67540 1739
f5e27805 1740 if (win->GetEventHandler()->ProcessEvent( event ))
034be888 1741 {
f5e27805 1742 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
f03fc89f 1743 return TRUE;
034be888 1744 }
47d67540 1745
034be888 1746 return FALSE;
362c6693 1747}
c801d85f
KB		 1748
1749//-----------------------------------------------------------------------------
2f2aa628
RR		 1750// "motion_notify_event"
1751//-----------------------------------------------------------------------------
c801d85f 1752
1e6feb95
VZ		 1753static gint gtk_window_motion_notify_callback( GtkWidget *widget,
1754 GdkEventMotion *gdk_event,
1755 wxWindowGTK *win )
47d67540 1756{
3ac8d3bc
RR		 1757 DEBUG_MAIN_THREAD
1758
c50f1fb9 1759 if (g_isIdle)
a2053b27
RR		 1760 wxapp_install_idle_handler();
1761
1762 if (!win->m_hasVMT) return FALSE;
034be888
RR		 1763 if (g_blockEventsOnDrag) return FALSE;
1764 if (g_blockEventsOnScroll) return FALSE;
148cd9b6 1765
034be888
RR		 1766 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1767
ff8bfdbb 1768 if (gdk_event->is_hint)
aae24d21 1769 {
f7a11f8c
RR		 1770 int x = 0;
1771 int y = 0;
1772 GdkModifierType state;
1773 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1774 gdk_event->x = x;
1775 gdk_event->y = y;
aae24d21 1776 }
ff8bfdbb 1777
c801d85f 1778/*
e380f72b
RR		 1779 printf( "OnMotion from " );
1780 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1781 printf( win->GetClassInfo()->GetClassName() );
1782 printf( ".\n" );
aae24d21 1783*/
47d67540 1784
e380f72b 1785 wxMouseEvent event( wxEVT_MOTION );
c5f9d156 1786 InitMouseEvent(win, event, gdk_event);
e380f72b 1787
50382578 1788 if ( g_captureWindow )
2f2aa628 1789 {
1e6feb95
VZ		 1790 // synthetize a mouse enter or leave event if needed
1791 GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
7c5e6fc6 1792 // This seems to be necessary and actually been added to
50382578
RR		 1793 // GDK itself in version 2.0.X
1794 gdk_flush();
7c5e6fc6 1795
1e6feb95
VZ		 1796 bool hasMouse = winUnderMouse == gdk_event->window;
1797 if ( hasMouse != g_captureWindowHasMouse )
1798 {
1799 // the mouse changed window
1800 g_captureWindowHasMouse = hasMouse;
1801
1802 wxMouseEvent event(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1803 : wxEVT_LEAVE_WINDOW);
c5f9d156 1804 InitMouseEvent(win, event, gdk_event);
1e6feb95
VZ		 1805 event.SetEventObject(win);
1806 win->GetEventHandler()->ProcessEvent(event);
1807 }
1808 }
1809 else // no capture
1810 {
d1f2ac45 1811 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
2f2aa628 1812 }
47d67540 1813
e380f72b 1814 if (win->GetEventHandler()->ProcessEvent( event ))
034be888 1815 {
e380f72b 1816 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
f03fc89f 1817 return TRUE;
034be888 1818 }
47d67540 1819
034be888 1820 return FALSE;
362c6693 1821}
c801d85f 1822
557c9f5b
JS		 1823#ifdef __WXGTK20__
1824//-----------------------------------------------------------------------------
1825// "mouse_wheel_event"
1826//-----------------------------------------------------------------------------
1827
1828static gint gtk_window_wheel_callback (GtkWidget * widget,
1829 GdkEventScroll * gdk_event,
1830 wxWindowGTK * win)
1831{
1832 DEBUG_MAIN_THREAD
1833
1834 if (g_isIdle)
1835 wxapp_install_idle_handler();
1836
1837 wxEventType event_type = wxEVT_NULL;
1838 if (gdk_event->direction == GDK_SCROLL_UP)
1839 event_type = wxEVT_MOUSEWHEEL;
1840 else if (gdk_event->direction == GDK_SCROLL_DOWN)
1841 event_type = wxEVT_MOUSEWHEEL;
1842 else
1843 return FALSE;
1844
1845 wxMouseEvent event( event_type );
1846 // Can't use InitMouse macro because scroll events don't have button
1847 event.SetTimestamp( gdk_event->time );
1848 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
1849 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
1850 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
1851 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
1852 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
1853 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
1854 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
58d185f7 1855 event.m_linesPerAction = 3;
557c9f5b
JS		 1856 if (gdk_event->direction == GDK_SCROLL_UP)
1857 event.m_wheelRotation = 120;
1858 else
1859 event.m_wheelRotation = -120;
1860
1861 wxPoint pt = win->GetClientAreaOrigin();
1862 event.m_x = (wxCoord)gdk_event->x - pt.x;
1863 event.m_y = (wxCoord)gdk_event->y - pt.y;
1864
1865 event.SetEventObject( win );
1866 event.SetId( win->GetId() );
1867 event.SetTimestamp( gdk_event->time );
1868
1869 if (win->GetEventHandler()->ProcessEvent( event ))
1870 {
1871 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "scroll_event" );
1872 return TRUE;
1873 }
1874
1875 return FALSE;
1876}
1877#endif
1878
c801d85f 1879//-----------------------------------------------------------------------------
2f2aa628
RR		 1880// "focus_in_event"
1881//-----------------------------------------------------------------------------
c801d85f 1882
6aeb6f2a
VZ		 1883// send the wxChildFocusEvent and wxFocusEvent, common code of
1884// gtk_window_focus_in_callback() and SetFocus()
1885static bool DoSendFocusEvents(wxWindow *win)
1886{
1887 // Notify the parent keeping track of focus for the kbd navigation
1888 // purposes that we got it.
1889 wxChildFocusEvent eventChildFocus(win);
1890 (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
1891
1892 wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
1893 eventFocus.SetEventObject(win);
1894
1895 return win->GetEventHandler()->ProcessEvent(eventFocus);
1896}
1897
1e6feb95
VZ		 1898static gint gtk_window_focus_in_callback( GtkWidget *widget,
1899 GdkEvent *WXUNUSED(event),
1900 wxWindow *win )
c801d85f 1901{
3ac8d3bc
RR		 1902 DEBUG_MAIN_THREAD
1903
c50f1fb9 1904 if (g_isIdle)
a2053b27
RR		 1905 wxapp_install_idle_handler();
1906
1907 if (!win->m_hasVMT) return FALSE;
034be888 1908 if (g_blockEventsOnDrag) return FALSE;
ff8bfdbb 1909
148cd9b6
VZ		 1910 switch ( g_sendActivateEvent )
1911 {
1912 case -1:
76fcf0f2 1913 // we've got focus from outside, synthetize wxActivateEvent
148cd9b6
VZ		 1914 g_sendActivateEvent = 1;
1915 break;
1916
1917 case 0:
1918 // another our window just lost focus, it was already ours before
1919 // - don't send any wxActivateEvent
1920 g_sendActivateEvent = -1;
1921 break;
1922 }
1923
1e6feb95 1924 g_focusWindowLast =
b292e2f5 1925 g_focusWindow = win;
ff8bfdbb 1926
6cad4f1b
VZ		 1927 wxLogTrace(TRACE_FOCUS,
1928 _T("%s: focus in"), win->GetName().c_str());
7de59551 1929
b79395c5
RR		 1930#ifdef HAVE_XIM
1931 if (win->m_ic)
1932 gdk_im_begin(win->m_ic, win->m_wxwindow->window);
1933#endif
1934
1e6feb95 1935#if wxUSE_CARET
f6bcfd97
BP		 1936 // caret needs to be informed about focus change
1937 wxCaret *caret = win->GetCaret();
1938 if ( caret )
1939 {
1940 caret->OnSetFocus();
1941 }
1942#endif // wxUSE_CARET
1943
d7fa7eaa 1944 g_activeFrameLostFocus = FALSE;
2b5f62a0 1945
e8c12a53
VS		 1946 wxWindowGTK *active = wxGetTopLevelParent(win);
1947 if ( active != g_activeFrame )
942bef71 1948 {
e8c12a53
VS		 1949 if ( g_activeFrame )
1950 {
45eb5249 1951 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from focus_in)"), g_activeFrame);
e8c12a53
VS		 1952 wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
1953 event.SetEventObject(g_activeFrame);
1954 g_activeFrame->GetEventHandler()->ProcessEvent(event);
1955 }
47d67540 1956
45eb5249 1957 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), active);
e8c12a53
VS		 1958 g_activeFrame = active;
1959 wxActivateEvent event(wxEVT_ACTIVATE, TRUE, g_activeFrame->GetId());
1960 event.SetEventObject(g_activeFrame);
1961 g_activeFrame->GetEventHandler()->ProcessEvent(event);
2b5f62a0 1962
d7fa7eaa
RR		 1963 // Don't send focus events in addition to activate
1964 // if (win == g_activeFrame)
1965 // return TRUE;
942bef71 1966 }
e8c12a53 1967
6cad4f1b
VZ		 1968 // does the window itself think that it has the focus?
1969 if ( !win->m_hasFocus )
5cd09f0b 1970 {
6cad4f1b
VZ		 1971 // not yet, notify it
1972 win->m_hasFocus = TRUE;
1973
1974 if ( DoSendFocusEvents(win) )
1975 {
1976 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
1977 return TRUE;
1978 }
034be888 1979 }
ca298c88 1980
034be888 1981 return FALSE;
362c6693 1982}
c801d85f
KB		 1983
1984//-----------------------------------------------------------------------------
2f2aa628
RR		 1985// "focus_out_event"
1986//-----------------------------------------------------------------------------
c801d85f 1987
afbe906a 1988static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk_event, wxWindowGTK *win )
c801d85f 1989{
3ac8d3bc
RR		 1990 DEBUG_MAIN_THREAD
1991
c50f1fb9 1992 if (g_isIdle)
a2053b27
RR		 1993 wxapp_install_idle_handler();
1994
1995 if (!win->m_hasVMT) return FALSE;
034be888 1996 if (g_blockEventsOnDrag) return FALSE;
ca298c88 1997
6cad4f1b
VZ		 1998 wxLogTrace( TRACE_FOCUS,
1999 _T("%s: focus out"), win->GetName().c_str() );
b231914f 2000
45eb5249
VS		 2001 if ( !g_activeFrameLostFocus && g_activeFrame )
2002 {
c0ad3d42
VZ		 2003 // VZ: commenting this out because it does happen (although not easy
2004 // to reproduce, I only see it when using wxMiniFrame and not
2005 // always) and makes using Mahogany quite annoying
2006#if 0
2007 wxASSERT_MSG( wxGetTopLevelParent(win) == g_activeFrame,
63fd5f0b 2008 wxT("unfocusing window that hasn't gained focus properly") );
c0ad3d42
VZ		 2009#endif // 0
2010
45eb5249
VS		 2011 g_activeFrameLostFocus = TRUE;
2012 }
2013
148cd9b6
VZ		 2014 // if the focus goes out of our app alltogether, OnIdle() will send
2015 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
2016 // g_sendActivateEvent to -1
2017 g_sendActivateEvent = 0;
2018
3379ed37 2019 wxWindowGTK *winFocus = wxFindFocusedChild(win);
f6bcfd97
BP		 2020 if ( winFocus )
2021 win = winFocus;
2022
1e6feb95 2023 g_focusWindow = (wxWindowGTK *)NULL;
148cd9b6 2024
b79395c5
RR		 2025#ifdef HAVE_XIM
2026 if (win->m_ic)
2027 gdk_im_end();
2028#endif
2029
1e6feb95 2030#if wxUSE_CARET
f6bcfd97
BP		 2031 // caret needs to be informed about focus change
2032 wxCaret *caret = win->GetCaret();
2033 if ( caret )
2034 {
2035 caret->OnKillFocus();
2036 }
2037#endif // wxUSE_CARET
2038
6cad4f1b
VZ		 2039 // don't send the window a kill focus event if it thinks that it doesn't
2040 // have focus already
2041 if ( win->m_hasFocus )
5cd09f0b 2042 {
6cad4f1b
VZ		 2043 win->m_hasFocus = FALSE;
2044
2045 wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
2046 event.SetEventObject( win );
2047
2048 if (win->GetEventHandler()->ProcessEvent( event ))
2049 {
2050 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
2051 return TRUE;
2052 }
034be888 2053 }
ca298c88 2054
034be888 2055 return FALSE;
362c6693 2056}
c801d85f 2057
b4071e91
RR		 2058//-----------------------------------------------------------------------------
2059// "enter_notify_event"
2060//-----------------------------------------------------------------------------
2061
edc1d330
VZ		 2062static
2063gint gtk_window_enter_callback( GtkWidget *widget,
2064 GdkEventCrossing *gdk_event,
2065 wxWindowGTK *win )
b4071e91 2066{
3ac8d3bc
RR		 2067 DEBUG_MAIN_THREAD
2068
c50f1fb9 2069 if (g_isIdle)
a2053b27 2070 wxapp_install_idle_handler();
ca298c88 2071
a2053b27
RR		 2072 if (!win->m_hasVMT) return FALSE;
2073 if (g_blockEventsOnDrag) return FALSE;
47d67540 2074
7f5f144a
RR		 2075 // Event was emitted after a grab
2076 if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
7c5e6fc6 2077
a2053b27 2078 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
b292e2f5 2079
4a33eba6
RR		 2080 int x = 0;
2081 int y = 0;
2082 GdkModifierType state = (GdkModifierType)0;
ff8bfdbb 2083
a2053b27 2084 gdk_window_get_pointer( widget->window, &x, &y, &state );
ff8bfdbb 2085
edc1d330 2086 wxMouseEvent event( wxEVT_ENTER_WINDOW );
c5f9d156
VS		 2087 InitMouseEvent(win, event, gdk_event);
2088 wxPoint pt = win->GetClientAreaOrigin();
2089 event.m_x = x + pt.x;
2090 event.m_y = y + pt.y;
ff8bfdbb 2091
e380f72b 2092 if (win->GetEventHandler()->ProcessEvent( event ))
034be888 2093 {
e380f72b 2094 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
034be888
RR		 2095 return TRUE;
2096 }
ca298c88 2097
034be888 2098 return FALSE;
b4071e91 2099}
47d67540 2100
b4071e91
RR		 2101//-----------------------------------------------------------------------------
2102// "leave_notify_event"
2103//-----------------------------------------------------------------------------
2104
1e6feb95 2105static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )
b4071e91 2106{
3ac8d3bc
RR		 2107 DEBUG_MAIN_THREAD
2108
c50f1fb9 2109 if (g_isIdle)
a2053b27 2110 wxapp_install_idle_handler();
acfd422a 2111
a2053b27
RR		 2112 if (!win->m_hasVMT) return FALSE;
2113 if (g_blockEventsOnDrag) return FALSE;
b292e2f5 2114
7f5f144a
RR		 2115 // Event was emitted after an ungrab
2116 if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
7c5e6fc6 2117
a2053b27 2118 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
c50f1fb9 2119
e380f72b 2120 wxMouseEvent event( wxEVT_LEAVE_WINDOW );
d1367c3d 2121 event.SetTimestamp( gdk_event->time );
e380f72b 2122 event.SetEventObject( win );
47d67540 2123
4a33eba6
RR		 2124 int x = 0;
2125 int y = 0;
2126 GdkModifierType state = (GdkModifierType)0;
ff8bfdbb 2127
4a33eba6 2128 gdk_window_get_pointer( widget->window, &x, &y, &state );
ff8bfdbb 2129
74710601
VZ		 2130 event.m_shiftDown = (state & GDK_SHIFT_MASK) != 0;
2131 event.m_controlDown = (state & GDK_CONTROL_MASK) != 0;
2132 event.m_altDown = (state & GDK_MOD1_MASK) != 0;
2133 event.m_metaDown = (state & GDK_MOD2_MASK) != 0;
2134 event.m_leftDown = (state & GDK_BUTTON1_MASK) != 0;
2135 event.m_middleDown = (state & GDK_BUTTON2_MASK) != 0;
2136 event.m_rightDown = (state & GDK_BUTTON3_MASK) != 0;
4a33eba6 2137
c5f9d156
VS		 2138 wxPoint pt = win->GetClientAreaOrigin();
2139 event.m_x = x + pt.x;
2140 event.m_y = y + pt.y;
ff8bfdbb 2141
e380f72b 2142 if (win->GetEventHandler()->ProcessEvent( event ))
034be888 2143 {
e380f72b 2144 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
034be888
RR		 2145 return TRUE;
2146 }
ca298c88 2147
034be888 2148 return FALSE;
b4071e91 2149}
47d67540 2150
c801d85f 2151//-----------------------------------------------------------------------------
2f2aa628
RR		 2152// "value_changed" from m_vAdjust
2153//-----------------------------------------------------------------------------
c801d85f 2154
9e691f46
VZ		 2155static void gtk_window_vscroll_callback( GtkAdjustment *adjust,
2156 SCROLLBAR_CBACK_ARG
2157 wxWindowGTK *win )
c801d85f 2158{
3ac8d3bc
RR		 2159 DEBUG_MAIN_THREAD
2160
c50f1fb9 2161 if (g_isIdle)
a2053b27 2162 wxapp_install_idle_handler();
c801d85f 2163
a2053b27 2164 if (g_blockEventsOnDrag) return;
47d67540 2165
a2053b27 2166 if (!win->m_hasVMT) return;
148cd9b6 2167
5e014a0c 2168 float diff = adjust->value - win->m_oldVerticalPos;
e380f72b 2169 if (fabs(diff) < 0.2) return;
148cd9b6 2170
5e014a0c 2171 win->m_oldVerticalPos = adjust->value;
47d67540 2172
a8bf1826 2173#ifndef __WXGTK20__
6728fb61 2174 GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(win->m_widget);
a8bf1826 2175#endif
6728fb61 2176 wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->vscrollbar));
148cd9b6 2177
5e014a0c 2178 int value = (int)(adjust->value+0.5);
c801d85f 2179
c5b42c87 2180 wxScrollWinEvent event( command, value, wxVERTICAL );
e380f72b
RR		 2181 event.SetEventObject( win );
2182 win->GetEventHandler()->ProcessEvent( event );
362c6693 2183}
c801d85f
KB		 2184
2185//-----------------------------------------------------------------------------
2f2aa628
RR		 2186// "value_changed" from m_hAdjust
2187//-----------------------------------------------------------------------------
c801d85f 2188
9e691f46
VZ		 2189static void gtk_window_hscroll_callback( GtkAdjustment *adjust,
2190 SCROLLBAR_CBACK_ARG
2191 wxWindowGTK *win )
47d67540 2192{
3ac8d3bc
RR		 2193 DEBUG_MAIN_THREAD
2194
c50f1fb9 2195 if (g_isIdle)
a2053b27 2196 wxapp_install_idle_handler();
47d67540 2197
a2053b27
RR		 2198 if (g_blockEventsOnDrag) return;
2199 if (!win->m_hasVMT) return;
47d67540 2200
5e014a0c 2201 float diff = adjust->value - win->m_oldHorizontalPos;
e380f72b 2202 if (fabs(diff) < 0.2) return;
148cd9b6 2203
a8bf1826 2204#ifndef __WXGTK20__
6728fb61 2205 GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(win->m_widget);
a8bf1826 2206#endif
6728fb61 2207 wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->hscrollbar));
148cd9b6 2208
9e691f46 2209 win->m_oldHorizontalPos = adjust->value;
148cd9b6 2210
5e014a0c 2211 int value = (int)(adjust->value+0.5);
47d67540 2212
c5b42c87 2213 wxScrollWinEvent event( command, value, wxHORIZONTAL );
e380f72b
RR		 2214 event.SetEventObject( win );
2215 win->GetEventHandler()->ProcessEvent( event );
362c6693 2216}
c801d85f 2217
cb43b372
RR		 2218//-----------------------------------------------------------------------------
2219// "button_press_event" from scrollbar
2220//-----------------------------------------------------------------------------
2221
2a23d363
RR		 2222static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
2223 GdkEventButton *gdk_event,
1e6feb95 2224 wxWindowGTK *win)
cb43b372 2225{
3ac8d3bc
RR		 2226 DEBUG_MAIN_THREAD
2227
c50f1fb9 2228 if (g_isIdle)
a2053b27
RR		 2229 wxapp_install_idle_handler();
2230
d6d26e04 2231
5b8a521e 2232 g_blockEventsOnScroll = TRUE;
9e691f46
VZ		 2233
2234 // FIXME: there is no 'slider' field in GTK+ 2.0 any more
2235#ifndef __WXGTK20__
2a23d363 2236 win->m_isScrolling = (gdk_event->window == widget->slider);
9e691f46 2237#endif
47d67540 2238
e380f72b 2239 return FALSE;
cb43b372
RR		 2240}
2241
2242//-----------------------------------------------------------------------------
2243// "button_release_event" from scrollbar
2244//-----------------------------------------------------------------------------
2245
88413fec 2246static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
8bbe427f 2247 GdkEventButton *WXUNUSED(gdk_event),
1e6feb95 2248 wxWindowGTK *win)
cb43b372 2249{
3ac8d3bc
RR		 2250 DEBUG_MAIN_THREAD
2251
1ecc4d80 2252// don't test here as we can release the mouse while being over
5e014a0c 2253// a different window than the slider
76ed8f8d
RR		 2254//
2255// if (gdk_event->window != widget->slider) return FALSE;
cb43b372 2256
5b8a521e 2257 g_blockEventsOnScroll = FALSE;
47d67540 2258
2a23d363 2259 if (win->m_isScrolling)
88413fec 2260 {
d6d26e04 2261 wxEventType command = wxEVT_SCROLLWIN_THUMBRELEASE;
2a23d363
RR		 2262 int value = -1;
2263 int dir = -1;
2daa0ce9 2264
2a23d363
RR		 2265 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
2266 if (widget == GTK_RANGE(scrolledWindow->hscrollbar))
2267 {
2268 value = (int)(win->m_hAdjust->value+0.5);
2269 dir = wxHORIZONTAL;
2270 }
2271 if (widget == GTK_RANGE(scrolledWindow->vscrollbar))
2272 {
2273 value = (int)(win->m_vAdjust->value+0.5);
2274 dir = wxVERTICAL;
2275 }
2daa0ce9 2276
2a23d363 2277 wxScrollWinEvent event( command, value, dir );
2a23d363
RR		 2278 event.SetEventObject( win );
2279 win->GetEventHandler()->ProcessEvent( event );
88413fec
RR		 2280 }
2281
2a23d363 2282 win->m_isScrolling = FALSE;
2daa0ce9 2283
e380f72b 2284 return FALSE;
cb43b372
RR		 2285}
2286
f03fc89f
VZ		 2287// ----------------------------------------------------------------------------
2288// this wxWindowBase function is implemented here (in platform-specific file)
2289// because it is static and so couldn't be made virtual
2290// ----------------------------------------------------------------------------
2b07d713 2291
f03fc89f 2292wxWindow *wxWindowBase::FindFocus()
2b07d713 2293{
1e6feb95
VZ		 2294 // the cast is necessary when we compile in wxUniversal mode
2295 return (wxWindow *)g_focusWindow;
2b07d713 2296}
ca298c88 2297
1a685a59 2298
a2053b27
RR		 2299//-----------------------------------------------------------------------------
2300// "realize" from m_widget
2301//-----------------------------------------------------------------------------
2302
b79395c5
RR		 2303/* We cannot set colours and fonts before the widget has
2304 been realized, so we do this directly after realization. */
a2053b27
RR		 2305
2306static gint
2b5f62a0 2307gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
a2053b27 2308{
3ac8d3bc
RR		 2309 DEBUG_MAIN_THREAD
2310
c50f1fb9 2311 if (g_isIdle)
a2053b27 2312 wxapp_install_idle_handler();
2b904684 2313
2b5f62a0
VZ		 2314#ifdef __WXGTK20__
2315 if (win->m_imContext)
2316 {
2317 GtkPizza *pizza = GTK_PIZZA( m_widget );
da210120 2318 gtk_im_context_set_client_window( win->m_imContext, pizza->bin_window );
2b5f62a0
VZ		 2319 }
2320#endif
2321
3c679789
RR		 2322 wxWindowCreateEvent event( win );
2323 event.SetEventObject( win );
2324 win->GetEventHandler()->ProcessEvent( event );
1e6feb95 2325
a2053b27
RR		 2326 return FALSE;
2327}
2328
b79395c5
RR		 2329//-----------------------------------------------------------------------------
2330// "size_allocate"
2331//-----------------------------------------------------------------------------
2332
8f75cb6c 2333static
adc1999b
RR		 2334void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
2335 GtkAllocation *WXUNUSED(alloc),
8f75cb6c
RR		 2336 wxWindow *win )
2337{
2338 if (g_isIdle)
2339 wxapp_install_idle_handler();
2daa0ce9 2340
5b8a521e 2341 if (!win->m_hasScrolling) return;
2daa0ce9 2342
5b8a521e
RR		 2343 int client_width = 0;
2344 int client_height = 0;
2345 win->GetClientSize( &client_width, &client_height );
2346 if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight))
2347 return;
2daa0ce9 2348
5b8a521e
RR		 2349 win->m_oldClientWidth = client_width;
2350 win->m_oldClientHeight = client_height;
2daa0ce9 2351
5b8a521e
RR		 2352 if (!win->m_nativeSizeEvent)
2353 {
2354 wxSizeEvent event( win->GetSize(), win->GetId() );
2355 event.SetEventObject( win );
2356 win->GetEventHandler()->ProcessEvent( event );
2357 }
8f75cb6c
RR		 2358}
2359
2360
3ed2e7ce
VZ		 2361#ifdef HAVE_XIM
2362 #define WXUNUSED_UNLESS_XIM(param) param
2363#else
2364 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2365#endif
2366
b79395c5
RR		 2367/* Resize XIM window */
2368
3ed2e7ce 2369static
8f75cb6c
RR		 2370void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
2371 GtkAllocation* WXUNUSED_UNLESS_XIM(alloc),
1e6feb95 2372 wxWindowGTK* WXUNUSED_UNLESS_XIM(win) )
b79395c5
RR		 2373{
2374 if (g_isIdle)
2375 wxapp_install_idle_handler();
2daa0ce9 2376
9a8c7620 2377#ifdef HAVE_XIM
b79395c5
RR		 2378 if (!win->m_ic)
2379 return;
2380
b79395c5
RR		 2381 if (gdk_ic_get_style (win->m_ic) & GDK_IM_PREEDIT_POSITION)
2382 {
2383 gint width, height;
2384
3ed2e7ce 2385 gdk_window_get_size (widget->window, &width, &height);
b79395c5
RR		 2386 win->m_icattr->preedit_area.width = width;
2387 win->m_icattr->preedit_area.height = height;
2388 gdk_ic_set_attr (win->m_ic, win->m_icattr, GDK_IC_PREEDIT_AREA);
2389 }
9a8c7620 2390#endif // HAVE_XIM
b79395c5
RR		 2391}
2392
63081513
RR		 2393//-----------------------------------------------------------------------------
2394// "realize" from m_wxwindow
2395//-----------------------------------------------------------------------------
2396
2397/* Initialize XIM support */
2398
2399static gint
3ed2e7ce 2400gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
1e6feb95 2401 wxWindowGTK * WXUNUSED_UNLESS_XIM(win) )
63081513
RR		 2402{
2403 if (g_isIdle)
2404 wxapp_install_idle_handler();
2405
d06800f1 2406#ifdef HAVE_XIM
63081513
RR		 2407 if (win->m_ic) return FALSE;
2408 if (!widget) return FALSE;
2409 if (!gdk_im_ready()) return FALSE;
2410
2411 win->m_icattr = gdk_ic_attr_new();
2412 if (!win->m_icattr) return FALSE;
2daa0ce9 2413
63081513
RR		 2414 gint width, height;
2415 GdkEventMask mask;
2416 GdkColormap *colormap;
2417 GdkICAttr *attr = win->m_icattr;
b58b1dfc 2418 unsigned attrmask = GDK_IC_ALL_REQ;
63081513 2419 GdkIMStyle style;
b79395c5
RR		 2420 GdkIMStyle supported_style = (GdkIMStyle)
2421 (GDK_IM_PREEDIT_NONE |
1e6feb95
VZ		 2422 GDK_IM_PREEDIT_NOTHING |
2423 GDK_IM_PREEDIT_POSITION |
2424 GDK_IM_STATUS_NONE |
2425 GDK_IM_STATUS_NOTHING);
63081513
RR		 2426
2427 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
1e6feb95 2428 supported_style = (GdkIMStyle)(supported_style & ~GDK_IM_PREEDIT_POSITION);
63081513
RR		 2429
2430 attr->style = style = gdk_im_decide_style (supported_style);
2431 attr->client_window = widget->window;
2432
2433 if ((colormap = gtk_widget_get_colormap (widget)) !=
1e6feb95 2434 gtk_widget_get_default_colormap ())
63081513 2435 {
5cd09f0b
RR		 2436 attrmask |= GDK_IC_PREEDIT_COLORMAP;
2437 attr->preedit_colormap = colormap;
63081513 2438 }
2daa0ce9 2439
63081513
RR		 2440 attrmask |= GDK_IC_PREEDIT_FOREGROUND;
2441 attrmask |= GDK_IC_PREEDIT_BACKGROUND;
2442 attr->preedit_foreground = widget->style->fg[GTK_STATE_NORMAL];
2443 attr->preedit_background = widget->style->base[GTK_STATE_NORMAL];
2444
2445 switch (style & GDK_IM_PREEDIT_MASK)
2446 {
1e6feb95
VZ		 2447 case GDK_IM_PREEDIT_POSITION:
2448 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2449 {
2450 g_warning ("over-the-spot style requires fontset");
2451 break;
2452 }
63081513 2453
1e6feb95 2454 gdk_window_get_size (widget->window, &width, &height);
63081513 2455
1e6feb95
VZ		 2456 attrmask |= GDK_IC_PREEDIT_POSITION_REQ;
2457 attr->spot_location.x = 0;
2458 attr->spot_location.y = height;
2459 attr->preedit_area.x = 0;
2460 attr->preedit_area.y = 0;
2461 attr->preedit_area.width = width;
2462 attr->preedit_area.height = height;
2463 attr->preedit_fontset = widget->style->font;
63081513 2464
1e6feb95 2465 break;
b79395c5 2466 }
2daa0ce9 2467
b58b1dfc 2468 win->m_ic = gdk_ic_new (attr, (GdkICAttributesType)attrmask);
2daa0ce9 2469
63081513 2470 if (win->m_ic == NULL)
1e6feb95 2471 g_warning ("Can't create input context.");
63081513 2472 else
1e6feb95
VZ		 2473 {
2474 mask = gdk_window_get_events (widget->window);
2475 mask = (GdkEventMask)(mask | gdk_ic_get_events (win->m_ic));
2476 gdk_window_set_events (widget->window, mask);
2477
2478 if (GTK_WIDGET_HAS_FOCUS(widget))
2479 gdk_im_begin (win->m_ic, widget->window);
2480 }
2481#endif // HAVE_XIM
63081513
RR		 2482
2483 return FALSE;
2484}
2485
6ca41e57 2486//-----------------------------------------------------------------------------
1e6feb95 2487// InsertChild for wxWindowGTK.
6ca41e57
RR		 2488//-----------------------------------------------------------------------------
2489
1e6feb95 2490/* Callback for wxWindowGTK. This very strange beast has to be used because
b1170810
RR		 2491 * C++ has no virtual methods in a constructor. We have to emulate a
2492 * virtual function here as wxNotebook requires a different way to insert
2493 * a child in it. I had opted for creating a wxNotebookPage window class
2494 * which would have made this superfluous (such in the MDI window system),
2495 * but no-one was listening to me... */
6ca41e57 2496
1e6feb95 2497static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
6ca41e57 2498{
bf0c00c6
RR		 2499 /* the window might have been scrolled already, do we
2500 have to adapt the position */
da048e3d
RR		 2501 GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
2502 child->m_x += pizza->xoffset;
2503 child->m_y += pizza->yoffset;
148cd9b6 2504
da048e3d 2505 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
a2053b27
RR		 2506 GTK_WIDGET(child->m_widget),
2507 child->m_x,
2508 child->m_y,
2509 child->m_width,
2510 child->m_height );
6ca41e57
RR		 2511}
2512
bbe0af5b
RR		 2513//-----------------------------------------------------------------------------
2514// global functions
2515//-----------------------------------------------------------------------------
2516
1e6feb95 2517wxWindow *wxGetActiveWindow()
bbe0af5b 2518{
6cad4f1b 2519 return wxWindow::FindFocus();
bbe0af5b
RR		 2520}
2521
c801d85f 2522//-----------------------------------------------------------------------------
1e6feb95 2523// wxWindowGTK
c801d85f
KB		 2524//-----------------------------------------------------------------------------
2525
6522713c
VZ		 2526// in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2527// method
1e6feb95 2528#ifdef __WXUNIVERSAL__
6522713c
VZ		 2529 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
2530#else // __WXGTK__
1e6feb95 2531 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
6522713c 2532#endif // __WXUNIVERSAL__/__WXGTK__
c801d85f 2533
1e6feb95 2534void wxWindowGTK::Init()
c801d85f 2535{
f03fc89f 2536 // GTK specific
a2053b27 2537 m_widget = (GtkWidget *) NULL;
e380f72b 2538 m_wxwindow = (GtkWidget *) NULL;
76fcf0f2 2539 m_focusWidget = (GtkWidget *) NULL;
8bbe427f 2540
f03fc89f 2541 // position/size
a2053b27
RR		 2542 m_x = 0;
2543 m_y = 0;
2544 m_width = 0;
e380f72b 2545 m_height = 0;
8bbe427f 2546
e380f72b
RR		 2547 m_sizeSet = FALSE;
2548 m_hasVMT = FALSE;
2549 m_needParent = TRUE;
31c6b4fc 2550 m_isBeingDeleted = FALSE;
148cd9b6 2551
147bc491 2552 m_noExpose = FALSE;
30760ce7 2553 m_nativeSizeEvent = FALSE;
94633ad9 2554
a2053b27 2555 m_hasScrolling = FALSE;
846e1424 2556 m_isScrolling = FALSE;
f03fc89f 2557
a2053b27 2558 m_hAdjust = (GtkAdjustment*) NULL;
e380f72b 2559 m_vAdjust = (GtkAdjustment*) NULL;
815ac4a7 2560 m_oldHorizontalPos =
e380f72b 2561 m_oldVerticalPos = 0.0;
815ac4a7
VZ		 2562 m_oldClientWidth =
2563 m_oldClientHeight = 0;
8bbe427f 2564
e380f72b 2565 m_resizing = FALSE;
8bbe427f 2566
ddb6bc71 2567 m_insertCallback = (wxInsertChildFunction) NULL;
8bbe427f 2568
b292e2f5 2569 m_acceptsFocus = FALSE;
6cad4f1b 2570 m_hasFocus = FALSE;
148cd9b6 2571
b6fa52db 2572 m_clipPaintRegion = FALSE;
b6fa52db 2573
5e014a0c 2574 m_cursor = *wxSTANDARD_CURSOR;
2daa0ce9 2575
2b5f62a0
VZ		 2576#ifdef __WXGTK20__
2577 m_imContext = NULL;
2578 m_x11Context = NULL;
2579#else
63081513
RR		 2580#ifdef HAVE_XIM
2581 m_ic = (GdkIC*) NULL;
2582 m_icattr = (GdkICAttr*) NULL;
2583#endif
2b5f62a0 2584#endif
362c6693 2585}
c801d85f 2586
1e6feb95 2587wxWindowGTK::wxWindowGTK()
68995f26
VZ		 2588{
2589 Init();
2590}
2591
1e6feb95
VZ		 2592wxWindowGTK::wxWindowGTK( wxWindow *parent,
2593 wxWindowID id,
2594 const wxPoint &pos,
2595 const wxSize &size,
2596 long style,
2597 const wxString &name )
6ca41e57 2598{
68995f26
VZ		 2599 Init();
2600
e380f72b 2601 Create( parent, id, pos, size, style, name );
6ca41e57 2602}
8bbe427f 2603
1e6feb95
VZ		 2604bool wxWindowGTK::Create( wxWindow *parent,
2605 wxWindowID id,
2606 const wxPoint &pos,
2607 const wxSize &size,
2608 long style,
2609 const wxString &name )
c801d85f 2610{
4dcaf11a
RR		 2611 if (!PreCreation( parent, pos, size ) ||
2612 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2613 {
1e6feb95 2614 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
b02da6b1 2615 return FALSE;
4dcaf11a 2616 }
47d67540 2617
ddb6bc71 2618 m_insertCallback = wxInsertChildInWindow;
2b5f62a0 2619
e380f72b 2620 m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
38c7b3d3 2621 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
ff8bfdbb 2622
f03fc89f 2623 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
47d67540 2624
dd00f3f6 2625 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
e380f72b 2626 scroll_class->scrollbar_spacing = 0;
47d67540 2627
f03fc89f 2628 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
47d67540 2629
f03fc89f
VZ		 2630 m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
2631 m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
47d67540 2632
da048e3d 2633 m_wxwindow = gtk_pizza_new();
0fc5dbf5 2634
1e6feb95 2635#ifndef __WXUNIVERSAL__
da048e3d 2636 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
b292e2f5 2637
f03fc89f 2638 if (HasFlag(wxRAISED_BORDER))
034be888 2639 {
da048e3d 2640 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
034be888 2641 }
f03fc89f 2642 else if (HasFlag(wxSUNKEN_BORDER))
034be888 2643 {
da048e3d 2644 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
5e014a0c
RR		 2645 }
2646 else if (HasFlag(wxSIMPLE_BORDER))
2647 {
da048e3d 2648 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN );
034be888
RR		 2649 }
2650 else
2651 {
da048e3d 2652 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
034be888 2653 }
1e6feb95 2654#endif // __WXUNIVERSAL__
47d67540 2655
4e5a4c69
RR		 2656 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
2657
3da17724
RR		 2658 GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
2659 m_acceptsFocus = TRUE;
ca298c88 2660
e380f72b 2661 // I _really_ don't want scrollbars in the beginning
a2053b27
RR		 2662 m_vAdjust->lower = 0.0;
2663 m_vAdjust->upper = 1.0;
2664 m_vAdjust->value = 0.0;
2665 m_vAdjust->step_increment = 1.0;
2666 m_vAdjust->page_increment = 1.0;
2667 m_vAdjust->page_size = 5.0;
2668 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
2669 m_hAdjust->lower = 0.0;
2670 m_hAdjust->upper = 1.0;
2671 m_hAdjust->value = 0.0;
2672 m_hAdjust->step_increment = 1.0;
2673 m_hAdjust->page_increment = 1.0;
2674 m_hAdjust->page_size = 5.0;
2675 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
f03fc89f
VZ		 2676
2677 // these handlers block mouse events to any window during scrolling such as
77ffb593 2678 // motion events and prevent GTK and wxWidgets from fighting over where the
f03fc89f
VZ		 2679 // slider should be
2680
2681 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
76ed8f8d
RR		 2682 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2683
f03fc89f 2684 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
76ed8f8d
RR		 2685 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2686
f03fc89f 2687 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
76ed8f8d
RR		 2688 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2689
f03fc89f 2690 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
76ed8f8d 2691 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
8bbe427f 2692
034be888 2693 // these handlers get notified when screen updates are required either when
76ed8f8d
RR		 2694 // scrolling or when the window size (and therefore scrollbar configuration)
2695 // has changed
2696
2697 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
2698 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
2699 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
2700 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
2701
f03fc89f 2702 gtk_widget_show( m_wxwindow );
47d67540 2703
f03fc89f
VZ		 2704 if (m_parent)
2705 m_parent->DoAddChild( this );
94633ad9 2706
76fcf0f2 2707 m_focusWidget = m_wxwindow;
8bbe427f 2708
e380f72b 2709 PostCreation();
8bbe427f 2710
e380f72b 2711 return TRUE;
362c6693 2712}
c801d85f 2713
1e6feb95 2714wxWindowGTK::~wxWindowGTK()
c801d85f 2715{
7de59551
RD		 2716 SendDestroyEvent();
2717
44cd54c2
JS		 2718 if (g_focusWindow == this)
2719 g_focusWindow = NULL;
2720
e8c12a53
VS		 2721 if (g_activeFrame == this)
2722 g_activeFrame = NULL;
2723
3e679f01
VZ		 2724 if ( g_delayedFocus == this )
2725 g_delayedFocus = NULL;
2726
31c6b4fc 2727 m_isBeingDeleted = TRUE;
43a18898 2728 m_hasVMT = FALSE;
47d67540 2729
f03fc89f
VZ		 2730 if (m_widget)
2731 Show( FALSE );
8bbe427f 2732
a2053b27
RR		 2733 DestroyChildren();
2734
63081513
RR		 2735#ifdef HAVE_XIM
2736 if (m_ic)
2737 gdk_ic_destroy (m_ic);
2738 if (m_icattr)
2739 gdk_ic_attr_destroy (m_icattr);
2740#endif
2741
f03fc89f 2742 if (m_wxwindow)
a2053b27 2743 {
f03fc89f 2744 gtk_widget_destroy( m_wxwindow );
c50f1fb9 2745 m_wxwindow = (GtkWidget*) NULL;
a2053b27 2746 }
8bbe427f 2747
f03fc89f 2748 if (m_widget)
a2053b27 2749 {
f03fc89f 2750 gtk_widget_destroy( m_widget );
c50f1fb9 2751 m_widget = (GtkWidget*) NULL;
a2053b27 2752 }
362c6693 2753}
c801d85f 2754
1e6feb95 2755bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
c801d85f 2756{
223d09f6 2757 wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );
8bbe427f 2758
a7c26d10
RD		 2759 // Use either the given size, or the default if -1 is given.
2760 // See wxWindowBase for these functions.
3013a903 2761 m_width = WidthDefault(size.x) ;
f03fc89f 2762 m_height = HeightDefault(size.y);
8bbe427f 2763
43a18898
RR		 2764 m_x = (int)pos.x;
2765 m_y = (int)pos.y;
8bbe427f 2766
4dcaf11a 2767 return TRUE;
c801d85f
KB		 2768}
2769
1e6feb95 2770void wxWindowGTK::PostCreation()
c801d85f 2771{
82b978d7
RD		 2772 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2773
43a18898
RR		 2774 if (m_wxwindow)
2775 {
147bc491 2776 if (!m_noExpose)
b02da6b1 2777 {
77ffb593 2778 // these get reported to wxWidgets -> wxPaintEvent
1e6feb95 2779
b420fb6a
RR		 2780 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE );
2781
147bc491
RR		 2782 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
2783 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
2784
4e5a4c69 2785#ifndef __WXGTK20__
147bc491
RR		 2786 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
2787 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
0fc5dbf5 2788
e441e1f4 2789 if (!HasFlag(wxFULL_REPAINT_ON_RESIZE))
e22454be
RR		 2790 {
2791 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
2792 GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
2793 }
4e5a4c69 2794#else
e441e1f4 2795 // gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), !HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
2b5f62a0 2796#endif
93d23d8f 2797 }
2b5f62a0
VZ		 2798
2799#ifdef __WXGTK20__
2800 // Create input method handler
da210120 2801 m_imContext = gtk_im_multicontext_new();
2b5f62a0
VZ		 2802
2803 // Cannot handle drawing preedited text yet
da210120 2804 gtk_im_context_set_use_preedit( m_imContext, FALSE );
2b5f62a0
VZ		 2805
2806 g_signal_connect (G_OBJECT (m_imContext), "commit",
da210120 2807 G_CALLBACK (gtk_wxwindow_commit_cb), this);
4e5a4c69 2808#endif
148cd9b6 2809
67d78217 2810 // these are called when the "sunken" or "raised" borders are drawn
034be888
RR		 2811 gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
2812 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
2813
4e5a4c69 2814#ifndef __WXGTK20__
034be888
RR		 2815 gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
2816 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
4e5a4c69 2817#endif
43a18898 2818 }
47d67540 2819
76fcf0f2 2820 // focus handling
63081513 2821
76fcf0f2
RR		 2822 if (m_focusWidget == NULL)
2823 m_focusWidget = m_widget;
2daa0ce9 2824
76fcf0f2
RR		 2825 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event",
2826 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
2827
2828 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_out_event",
2829 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
2830
2831 // connect to the various key and mouse handlers
63081513 2832
a2053b27 2833 GtkWidget *connect_widget = GetConnectWidget();
f03fc89f 2834
a2053b27 2835 ConnectWidget( connect_widget );
47d67540 2836
63081513 2837 /* We cannot set colours, fonts and cursors before the widget has
a2053b27
RR		 2838 been realized, so we do this directly after realization */
2839 gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
c50f1fb9 2840 GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
2daa0ce9 2841
63081513
RR		 2842 if (m_wxwindow)
2843 {
47c93b63 2844 // Catch native resize events
8f75cb6c
RR		 2845 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2846 GTK_SIGNAL_FUNC(gtk_window_size_callback), (gpointer)this );
2daa0ce9 2847
47c93b63 2848 // Initialize XIM support
63081513
RR		 2849 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
2850 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback), (gpointer) this );
8f75cb6c 2851
47c93b63 2852 // And resize XIM window
b79395c5
RR		 2853 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2854 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this );
63081513 2855 }
2daa0ce9 2856
e1f448ee 2857 if ( !GTK_IS_COMBO(m_widget))
47c93b63
RR		 2858 {
2859 // This is needed if we want to add our windows into native
2860 // GTK control, such as the toolbar. With this callback, the
2861 // toolbar gets to know the correct size (the one set by the
2862 // programmer). Sadly, it misbehaves for wxComboBox. FIXME
2863 // when moving to GTK 2.0.
2864 gtk_signal_connect( GTK_OBJECT(m_widget), "size_request",
e1f448ee
VZ		 2865 GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback),
2866 (gpointer) this );
47c93b63 2867 }
1e6feb95 2868
43a18898 2869 m_hasVMT = TRUE;
a433fbd5
VZ		 2870
2871 // unless the window was created initially hidden (i.e. Hide() had been
2872 // called before Create()), we should show it at GTK+ level as well
2873 if ( IsShown() )
2874 gtk_widget_show( m_widget );
b4071e91
RR		 2875}
2876
1e6feb95 2877void wxWindowGTK::ConnectWidget( GtkWidget *widget )
b4071e91 2878{
43a18898
RR		 2879 gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
2880 GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
c801d85f 2881
b666df2c
RR		 2882 gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
2883 GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
2884
43a18898
RR		 2885 gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
2886 GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
47d67540 2887
43a18898
RR		 2888 gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
2889 GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
47d67540 2890
43a18898
RR		 2891 gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
2892 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
47d67540 2893
557c9f5b
JS		 2894#ifdef __WXGTK20__
2895 gtk_signal_connect( GTK_OBJECT(widget), "scroll_event",
2896 GTK_SIGNAL_FUNC(gtk_window_wheel_callback), (gpointer)this );
2897#endif
2898
43a18898
RR		 2899 gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
2900 GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
47d67540 2901
43a18898
RR		 2902 gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
2903 GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
362c6693 2904}
c801d85f 2905
1e6feb95 2906bool wxWindowGTK::Destroy()
c801d85f 2907{
82b978d7 2908 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
47d67540 2909
43a18898 2910 m_hasVMT = FALSE;
c801d85f 2911
f03fc89f 2912 return wxWindowBase::Destroy();
362c6693 2913}
c801d85f 2914
1e6feb95 2915void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
23efdd02
RR		 2916{
2917 gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
2918}
2daa0ce9 2919
1e6feb95 2920void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
c801d85f 2921{
82b978d7 2922 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
1e6feb95 2923 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
8bbe427f 2924
33611ebb 2925/*
f94fca1b 2926 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
33611ebb
RR		 2927*/
2928
e27ce4e9 2929 if (m_resizing) return; /* I don't like recursions */
fb1585ae 2930 m_resizing = TRUE;
1e6feb95 2931
b9f29261
VS		 2932 int currentX, currentY;
2933 GetPosition(&currentX, &currentY);
443c834d 2934 if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
b9f29261 2935 x = currentX;
443c834d 2936 if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
b9f29261 2937 y = currentY;
a200c35e
VS		 2938 AdjustForParentClientOrigin(x, y, sizeFlags);
2939
a2053b27 2940 if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
fb1585ae 2941 {
e27ce4e9 2942 /* don't set the size for children of wxNotebook, just take the values. */
fb1585ae
RR		 2943 m_x = x;
2944 m_y = y;
2945 m_width = width;
ba4e3652 2946 m_height = height;
fb1585ae 2947 }
ba4e3652 2948 else
fb1585ae 2949 {
da048e3d 2950 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
85ad5eb5 2951 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
ba4e3652 2952 {
da048e3d
RR		 2953 if (x != -1) m_x = x + pizza->xoffset;
2954 if (y != -1) m_y = y + pizza->yoffset;
ba4e3652
RR		 2955 }
2956 else
2957 {
da048e3d
RR		 2958 m_x = x + pizza->xoffset;
2959 m_y = y + pizza->yoffset;
ba4e3652 2960 }
47d67540 2961
a63d48fa 2962 // calculate the best size if we should auto size the window
c7e111cd
VZ		 2963 if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
2964 ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
ba4e3652 2965 {
a63d48fa 2966 const wxSize sizeBest = GetBestSize();
c7e111cd 2967 if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
a63d48fa 2968 width = sizeBest.x;
c7e111cd 2969 if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
a63d48fa 2970 height = sizeBest.y;
ba4e3652
RR		 2971 }
2972
a63d48fa
VZ		 2973 if (width != -1)
2974 m_width = width;
2975 if (height != -1)
2976 m_height = height;
8bbe427f 2977
e7dda1ff
VS		 2978 int minWidth = GetMinWidth(),
2979 minHeight = GetMinHeight(),
2980 maxWidth = GetMaxWidth(),
2981 maxHeight = GetMaxHeight();
2982
2983 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
2984 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
2985 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
2986 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
47d67540 2987
a2053b27 2988 int border = 0;
c50f1fb9 2989 int bottom_border = 0;
f03fc89f 2990
eb9e6a00 2991#ifndef __WXGTK20__
29f538ce 2992 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
c50f1fb9
VZ		 2993 {
2994 /* the default button has a border around it */
2995 border = 6;
2996 bottom_border = 5;
2997 }
67d78217 2998#endif
c50f1fb9 2999
23efdd02
RR		 3000 DoMoveWindow( m_x-border,
3001 m_y-border,
3002 m_width+2*border,
3003 m_height+border+bottom_border );
54517652 3004 }
148cd9b6 3005
5b8a521e
RR		 3006 if (m_hasScrolling)
3007 {
1e6feb95 3008 /* Sometimes the client area changes size without the
b6fa52db
RR		 3009 whole windows's size changing, but if the whole
3010 windows's size doesn't change, no wxSizeEvent will
3011 normally be sent. Here we add an extra test if
3012 the client test has been changed and this will
3013 be used then. */
5b8a521e
RR		 3014 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
3015 }
3016
54517652 3017/*
6d693bb4
RR		 3018 wxPrintf( "OnSize sent from " );
3019 if (GetClassInfo() && GetClassInfo()->GetClassName())
3020 wxPrintf( GetClassInfo()->GetClassName() );
3021 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
3022*/
3023
30760ce7
RR		 3024 if (!m_nativeSizeEvent)
3025 {
3026 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
3027 event.SetEventObject( this );
3028 GetEventHandler()->ProcessEvent( event );
3029 }
6d693bb4 3030
fb1585ae 3031 m_resizing = FALSE;
362c6693 3032}
c801d85f 3033
1e6feb95 3034void wxWindowGTK::OnInternalIdle()
9390a202 3035{
beab25bd 3036 // Update invalidated regions.
010afced 3037 GtkUpdate();
0fc5dbf5 3038
beab25bd 3039 // Synthetize activate events.
148cd9b6
VZ		 3040 if ( g_sendActivateEvent != -1 )
3041 {
3042 bool activate = g_sendActivateEvent != 0;
3043
3044 // do it only once
3045 g_sendActivateEvent = -1;
3046
1e6feb95 3047 wxTheApp->SetActive(activate, (wxWindow *)g_focusWindowLast);
148cd9b6
VZ		 3048 }
3049
e8c12a53
VS		 3050 if ( g_activeFrameLostFocus )
3051 {
3052 if ( g_activeFrame )
3053 {
45eb5249 3054 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame);
e8c12a53
VS		 3055 wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
3056 event.SetEventObject(g_activeFrame);
3057 g_activeFrame->GetEventHandler()->ProcessEvent(event);
3058 g_activeFrame = NULL;
3059 }
3060 g_activeFrameLostFocus = FALSE;
3061 }
2b5f62a0 3062
9146082c
RR		 3063 wxCursor cursor = m_cursor;
3064 if (g_globalCursor.Ok()) cursor = g_globalCursor;
c50f1fb9 3065
f7a11f8c 3066 if (cursor.Ok())
9146082c 3067 {
3017f78d 3068 /* I now set the cursor anew in every OnInternalIdle call
b02da6b1
VZ		 3069 as setting the cursor in a parent window also effects the
3070 windows above so that checking for the current cursor is
3071 not possible. */
148cd9b6 3072
9146082c 3073 if (m_wxwindow)
6a008b33 3074 {
da048e3d 3075 GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
6a008b33 3076 if (window)
c50f1fb9 3077 gdk_window_set_cursor( window, cursor.GetCursor() );
6a008b33
VZ		 3078
3079 if (!g_globalCursor.Ok())
3080 cursor = *wxSTANDARD_CURSOR;
3081
3082 window = m_widget->window;
5e014a0c 3083 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
9146082c 3084 gdk_window_set_cursor( window, cursor.GetCursor() );
5e014a0c 3085
6a008b33
VZ		 3086 }
3087 else
3088 {
5e014a0c 3089
9146082c 3090 GdkWindow *window = m_widget->window;
5e014a0c 3091 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
9146082c 3092 gdk_window_set_cursor( window, cursor.GetCursor() );
5e014a0c 3093
6a008b33 3094 }
9146082c 3095 }
6a008b33 3096
e39af974
JS		 3097 if (wxUpdateUIEvent::CanUpdate(this))
3098 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
9390a202
RR		 3099}
3100
1e6feb95 3101void wxWindowGTK::DoGetSize( int *width, int *height ) const
c801d85f 3102{
82b978d7 3103 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3104
fb1585ae
RR		 3105 if (width) (*width) = m_width;
3106 if (height) (*height) = m_height;
362c6693 3107}
c801d85f 3108
1e6feb95 3109void wxWindowGTK::DoSetClientSize( int width, int height )
c801d85f 3110{
82b978d7
RD		 3111 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3112
1ecc4d80 3113 if (!m_wxwindow)
c801d85f 3114 {
1ecc4d80 3115 SetSize( width, height );
c801d85f
KB		 3116 }
3117 else
3118 {
1ecc4d80
RR		 3119 int dw = 0;
3120 int dh = 0;
3121
1e6feb95 3122#ifndef __WXUNIVERSAL__
98d3fdbe
RR		 3123 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
3124 {
5e014a0c 3125 /* when using GTK 1.2 we set the shadow border size to 2 */
6a008b33 3126 dw += 2 * 2;
98d3fdbe
RR		 3127 dh += 2 * 2;
3128 }
5e014a0c
RR		 3129 if (HasFlag(wxSIMPLE_BORDER))
3130 {
3131 /* when using GTK 1.2 we set the simple border size to 1 */
3132 dw += 1 * 2;
3133 dh += 1 * 2;
3134 }
1e6feb95 3135#endif // __WXUNIVERSAL__
034be888 3136
5b8a521e 3137 if (m_hasScrolling)
98d3fdbe 3138 {
324dbfec 3139 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2daa0ce9 3140
9000c624
RR		 3141 GtkRequisition vscroll_req;
3142 vscroll_req.width = 2;
3143 vscroll_req.height = 2;
dd00f3f6 3144 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
9000c624 3145 (scroll_window->vscrollbar, &vscroll_req );
2daa0ce9 3146
9000c624
RR		 3147 GtkRequisition hscroll_req;
3148 hscroll_req.width = 2;
3149 hscroll_req.height = 2;
dd00f3f6 3150 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
9000c624
RR		 3151 (scroll_window->hscrollbar, &hscroll_req );
3152
dd00f3f6 3153 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
324dbfec 3154
1ecc4d80
RR		 3155 if (scroll_window->vscrollbar_visible)
3156 {
9000c624 3157 dw += vscroll_req.width;
1ecc4d80
RR		 3158 dw += scroll_class->scrollbar_spacing;
3159 }
3160
3161 if (scroll_window->hscrollbar_visible)
3162 {
9000c624 3163 dh += hscroll_req.height;
63cc5d9d 3164 dh += scroll_class->scrollbar_spacing;
1ecc4d80 3165 }
9000c624 3166 }
1ecc4d80 3167
034be888 3168 SetSize( width+dw, height+dh );
1ecc4d80 3169 }
362c6693 3170}
c801d85f 3171
1e6feb95 3172void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
c801d85f 3173{
82b978d7 3174 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3175
1ecc4d80
RR		 3176 if (!m_wxwindow)
3177 {
3178 if (width) (*width) = m_width;
3179 if (height) (*height) = m_height;
c801d85f
KB		 3180 }
3181 else
3182 {
1ecc4d80
RR		 3183 int dw = 0;
3184 int dh = 0;
3185
1e6feb95 3186#ifndef __WXUNIVERSAL__
98d3fdbe
RR		 3187 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
3188 {
5e014a0c 3189 /* when using GTK 1.2 we set the shadow border size to 2 */
6a008b33 3190 dw += 2 * 2;
98d3fdbe
RR		 3191 dh += 2 * 2;
3192 }
5e014a0c
RR		 3193 if (HasFlag(wxSIMPLE_BORDER))
3194 {
3195 /* when using GTK 1.2 we set the simple border size to 1 */
3196 dw += 1 * 2;
3197 dh += 1 * 2;
3198 }
1e6feb95 3199#endif // __WXUNIVERSAL__
9000c624 3200
5b8a521e 3201 if (m_hasScrolling)
98d3fdbe 3202 {
6a008b33 3203 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2daa0ce9 3204
9000c624
RR		 3205 GtkRequisition vscroll_req;
3206 vscroll_req.width = 2;
3207 vscroll_req.height = 2;
dd00f3f6 3208 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
9000c624 3209 (scroll_window->vscrollbar, &vscroll_req );
2daa0ce9 3210
9000c624
RR		 3211 GtkRequisition hscroll_req;
3212 hscroll_req.width = 2;
3213 hscroll_req.height = 2;
dd00f3f6 3214 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
9000c624
RR		 3215 (scroll_window->hscrollbar, &hscroll_req );
3216
dd00f3f6 3217 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
6a008b33 3218
1ecc4d80
RR		 3219 if (scroll_window->vscrollbar_visible)
3220 {
9000c624 3221 dw += vscroll_req.width;
1ecc4d80
RR		 3222 dw += scroll_class->scrollbar_spacing;
3223 }
3224
3225 if (scroll_window->hscrollbar_visible)
3226 {
9000c624 3227 dh += hscroll_req.height;
1ecc4d80
RR		 3228 dh += scroll_class->scrollbar_spacing;
3229 }
6a008b33 3230 }
47d67540 3231
1ecc4d80
RR		 3232 if (width) (*width) = m_width - dw;
3233 if (height) (*height) = m_height - dh;
3234 }
1e6feb95 3235
f94fca1b
RR		 3236/*
3237 printf( "GetClientSize, name %s ", GetName().c_str() );
3238 if (width) printf( " width = %d", (*width) );
3239 if (height) printf( " height = %d", (*height) );
3240 printf( "\n" );
3241*/
362c6693 3242}
c801d85f 3243
1e6feb95 3244void wxWindowGTK::DoGetPosition( int *x, int *y ) const
c801d85f 3245{
82b978d7 3246 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3247
bf0c00c6
RR		 3248 int dx = 0;
3249 int dy = 0;
3250 if (m_parent && m_parent->m_wxwindow)
3251 {
da048e3d 3252 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
b02da6b1
VZ		 3253 dx = pizza->xoffset;
3254 dy = pizza->yoffset;
bf0c00c6 3255 }
94633ad9 3256
496beb3f
VS		 3257 if (x) (*x) = m_x - dx;
3258 if (y) (*y) = m_y - dy;
362c6693 3259}
c801d85f 3260
1e6feb95 3261void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
c801d85f 3262{
82b978d7 3263 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3264
a2053b27
RR		 3265 if (!m_widget->window) return;
3266
43a18898
RR		 3267 GdkWindow *source = (GdkWindow *) NULL;
3268 if (m_wxwindow)
da048e3d 3269 source = GTK_PIZZA(m_wxwindow)->bin_window;
43a18898
RR		 3270 else
3271 source = m_widget->window;
47d67540 3272
43a18898
RR		 3273 int org_x = 0;
3274 int org_y = 0;
3275 gdk_window_get_origin( source, &org_x, &org_y );
c801d85f 3276
43a18898 3277 if (!m_wxwindow)
c801d85f 3278 {
43a18898
RR		 3279 if (GTK_WIDGET_NO_WINDOW (m_widget))
3280 {
3281 org_x += m_widget->allocation.x;
3282 org_y += m_widget->allocation.y;
3283 }
362c6693 3284 }
47d67540 3285
43a18898
RR		 3286 if (x) *x += org_x;
3287 if (y) *y += org_y;
362c6693 3288}
c801d85f 3289
1e6feb95 3290void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
c801d85f 3291{
82b978d7 3292 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3293
a2053b27
RR		 3294 if (!m_widget->window) return;
3295
1ecc4d80
RR		 3296 GdkWindow *source = (GdkWindow *) NULL;
3297 if (m_wxwindow)
da048e3d 3298 source = GTK_PIZZA(m_wxwindow)->bin_window;
1ecc4d80
RR		 3299 else
3300 source = m_widget->window;
47d67540 3301
1ecc4d80
RR		 3302 int org_x = 0;
3303 int org_y = 0;
3304 gdk_window_get_origin( source, &org_x, &org_y );
c801d85f 3305
1ecc4d80 3306 if (!m_wxwindow)
c801d85f 3307 {
1ecc4d80
RR		 3308 if (GTK_WIDGET_NO_WINDOW (m_widget))
3309 {
3310 org_x += m_widget->allocation.x;
3311 org_y += m_widget->allocation.y;
3312 }
362c6693 3313 }
47d67540 3314
1ecc4d80
RR		 3315 if (x) *x -= org_x;
3316 if (y) *y -= org_y;
362c6693 3317}
c801d85f 3318
1e6feb95 3319bool wxWindowGTK::Show( bool show )
c801d85f 3320{
82b978d7 3321 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
47d67540 3322
739730ca
RR		 3323 if (!wxWindowBase::Show(show))
3324 {
3325 // nothing to do
f03fc89f 3326 return FALSE;
739730ca 3327 }
8bbe427f 3328
f03fc89f
VZ		 3329 if (show)
3330 gtk_widget_show( m_widget );
1ecc4d80 3331 else
f03fc89f 3332 gtk_widget_hide( m_widget );
8bbe427f 3333
2b5f62a0
VZ		 3334 wxShowEvent eventShow(GetId(), show);
3335 eventShow.m_eventObject = this;
3336
3337 GetEventHandler()->ProcessEvent(eventShow);
3338
f03fc89f 3339 return TRUE;
362c6693 3340}
c801d85f 3341
3379ed37 3342static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable)
fdca68a6
JS		 3343{
3344 win->OnParentEnable(enable);
3345
3346 // Recurse, so that children have the opportunity to Do The Right Thing
3347 // and reset colours that have been messed up by a parent's (really ancestor's)
3348 // Enable call
222ed1d6 3349 for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
fdca68a6
JS		 3350 node;
3351 node = node->GetNext() )
3352 {
3353 wxWindow *child = node->GetData();
3354 if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame)))
3355 wxWindowNotifyEnable(child, enable);
3356 }
3357}
3358
3379ed37 3359bool wxWindowGTK::Enable( bool enable )
c801d85f 3360{
82b978d7
RD		 3361 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3362
739730ca
RR		 3363 if (!wxWindowBase::Enable(enable))
3364 {
3365 // nothing to do
f03fc89f 3366 return FALSE;
739730ca 3367 }
1ecc4d80 3368
f03fc89f
VZ		 3369 gtk_widget_set_sensitive( m_widget, enable );
3370 if ( m_wxwindow )
3371 gtk_widget_set_sensitive( m_wxwindow, enable );
ff8bfdbb 3372
fdca68a6 3373 wxWindowNotifyEnable(this, enable);
513903c4 3374
f03fc89f 3375 return TRUE;
362c6693 3376}
c801d85f 3377
1e6feb95 3378int wxWindowGTK::GetCharHeight() const
2f2aa628 3379{
82b978d7 3380 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
47d67540 3381
cc402e64
VZ		 3382 wxFont font = GetFont();
3383 wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
2f2aa628 3384
bbd006c0
RR		 3385#ifdef __WXGTK20__
3386 PangoContext *context = NULL;
3387 if (m_widget)
3388 context = gtk_widget_get_pango_context( m_widget );
3389
3390 if (!context)
3391 return 0;
3392
cc402e64 3393 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
bbd006c0
RR		 3394 PangoLayout *layout = pango_layout_new(context);
3395 pango_layout_set_font_description(layout, desc);
3396 pango_layout_set_text(layout, "H", 1);
3397 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3398
3399 PangoRectangle rect;
3400 pango_layout_line_get_extents(line, NULL, &rect);
3401
3402 g_object_unref( G_OBJECT( layout ) );
7de59551 3403
bbd006c0
RR		 3404 return (int) (rect.height / PANGO_SCALE);
3405#else
cc402e64 3406 GdkFont *gfont = font.GetInternalFont( 1.0 );
f03fc89f 3407
cc402e64 3408 return gfont->ascent + gfont->descent;
bbd006c0 3409#endif
362c6693 3410}
c801d85f 3411
1e6feb95 3412int wxWindowGTK::GetCharWidth() const
c33c4050 3413{
82b978d7 3414 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
47d67540 3415
cc402e64
VZ		 3416 wxFont font = GetFont();
3417 wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
47d67540 3418
bbd006c0
RR		 3419#ifdef __WXGTK20__
3420 PangoContext *context = NULL;
3421 if (m_widget)
3422 context = gtk_widget_get_pango_context( m_widget );
3423
3424 if (!context)
3425 return 0;
3426
cc402e64 3427 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
bbd006c0
RR		 3428 PangoLayout *layout = pango_layout_new(context);
3429 pango_layout_set_font_description(layout, desc);
95c430aa 3430 pango_layout_set_text(layout, "g", 1);
bbd006c0
RR		 3431 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3432
3433 PangoRectangle rect;
3434 pango_layout_line_get_extents(line, NULL, &rect);
3435
3436 g_object_unref( G_OBJECT( layout ) );
7de59551 3437
bbd006c0
RR		 3438 return (int) (rect.width / PANGO_SCALE);
3439#else
cc402e64 3440 GdkFont *gfont = font.GetInternalFont( 1.0 );
ff8bfdbb 3441
cc402e64 3442 return gdk_string_width( gfont, "g" );
bbd006c0 3443#endif
c33c4050
RR		 3444}
3445
1e6feb95 3446void wxWindowGTK::GetTextExtent( const wxString& string,
f03fc89f
VZ		 3447 int *x,
3448 int *y,
3449 int *descent,
3450 int *externalLeading,
3451 const wxFont *theFont ) const
c33c4050 3452{
cc402e64 3453 wxFont fontToUse = theFont ? *theFont : GetFont();
47d67540 3454
223d09f6 3455 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
2b5f62a0 3456
48d011c8
RR		 3457 if (string.IsEmpty())
3458 {
b15ed747
RR		 3459 if (x) (*x) = 0;
3460 if (y) (*y) = 0;
48d011c8
RR		 3461 return;
3462 }
47d67540 3463
2b5f62a0 3464#ifdef __WXGTK20__
48d011c8
RR		 3465 PangoContext *context = NULL;
3466 if (m_widget)
2b5f62a0
VZ		 3467 context = gtk_widget_get_pango_context( m_widget );
3468
48d011c8
RR		 3469 if (!context)
3470 {
b15ed747
RR		 3471 if (x) (*x) = 0;
3472 if (y) (*y) = 0;
48d011c8
RR		 3473 return;
3474 }
2b5f62a0 3475
48d011c8
RR		 3476 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
3477 PangoLayout *layout = pango_layout_new(context);
3478 pango_layout_set_font_description(layout, desc);
3479 {
fb3ed106 3480#if wxUSE_UNICODE
48d011c8
RR		 3481 const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
3482 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
fb3ed106
RR		 3483#else
3484 const wxWCharBuffer wdata = wxConvLocal.cMB2WC( string );
3485 const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
3486 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
3487#endif
48d011c8
RR		 3488 }
3489 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2b5f62a0 3490
48d011c8
RR		 3491 PangoRectangle rect;
3492 pango_layout_line_get_extents(line, NULL, &rect);
2b5f62a0 3493
b15ed747
RR		 3494 if (x) (*x) = (wxCoord) (rect.width / PANGO_SCALE);
3495 if (y) (*y) = (wxCoord) (rect.height / PANGO_SCALE);
48d011c8
RR		 3496 if (descent)
3497 {
3498 // Do something about metrics here
3499 (*descent) = 0;
3500 }
3501 if (externalLeading) (*externalLeading) = 0; // ??
2b5f62a0 3502
48d011c8
RR		 3503 g_object_unref( G_OBJECT( layout ) );
3504#else
463c1fa1 3505 GdkFont *font = fontToUse.GetInternalFont( 1.0 );
fab591c5 3506 if (x) (*x) = gdk_string_width( font, wxGTK_CONV( string ) );
463c1fa1
RR		 3507 if (y) (*y) = font->ascent + font->descent;
3508 if (descent) (*descent) = font->descent;
3509 if (externalLeading) (*externalLeading) = 0; // ??
48d011c8 3510#endif
c33c4050
RR		 3511}
3512
1e6feb95 3513void wxWindowGTK::SetFocus()
c801d85f 3514{
82b978d7 3515 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
6cad4f1b
VZ		 3516
3517 if ( m_hasFocus )
3518 {
3519 // don't do anything if we already have focus
3520 return;
3521 }
2daa0ce9 3522
354aa1e3
RR		 3523 if (m_wxwindow)
3524 {
173348db 3525 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
b231914f 3526 {
173348db 3527 gtk_widget_grab_focus (m_wxwindow);
b231914f 3528 }
354aa1e3 3529 }
b231914f 3530 else if (m_widget)
c801d85f 3531 {
173348db 3532 if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
463c1fa1 3533 {
d7fa7eaa 3534 if (!GTK_WIDGET_REALIZED(m_widget))
6aeb6f2a 3535 {
6cad4f1b
VZ		 3536 // we can't set the focus to the widget now so we remember that
3537 // it should be focused and will do it later, during the idle
3538 // time, as soon as we can
3539 wxLogTrace(TRACE_FOCUS,
3540 _T("Delaying setting focus to %s(%s)"),
6aeb6f2a
VZ		 3541 GetClassInfo()->GetClassName(), GetLabel().c_str());
3542
d7fa7eaa 3543 g_delayedFocus = this;
6aeb6f2a 3544 }
d7fa7eaa 3545 else
6aeb6f2a 3546 {
6cad4f1b
VZ		 3547 wxLogTrace(TRACE_FOCUS,
3548 _T("Setting focus to %s(%s)"),
6aeb6f2a
VZ		 3549 GetClassInfo()->GetClassName(), GetLabel().c_str());
3550
d7fa7eaa 3551 gtk_widget_grab_focus (m_widget);
6aeb6f2a 3552 }
463c1fa1 3553 }
354aa1e3 3554 else if (GTK_IS_CONTAINER(m_widget))
ff8bfdbb 3555 {
9e691f46 3556 SET_CONTAINER_FOCUS( m_widget, GTK_DIR_TAB_FORWARD );
ff8bfdbb
VZ		 3557 }
3558 else
3559 {
6cad4f1b
VZ		 3560 wxLogTrace(TRACE_FOCUS,
3561 _T("Can't set focus to %s(%s)"),
3562 GetClassInfo()->GetClassName(), GetLabel().c_str());
ff8bfdbb 3563 }
362c6693 3564 }
362c6693 3565}
c801d85f 3566
1e6feb95 3567bool wxWindowGTK::AcceptsFocus() const
b292e2f5 3568{
f03fc89f 3569 return m_acceptsFocus && wxWindowBase::AcceptsFocus();
b292e2f5
RR		 3570}
3571
1e6feb95 3572bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
463c1fa1 3573{
82b978d7 3574 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
c50f1fb9 3575
1e6feb95
VZ		 3576 wxWindowGTK *oldParent = m_parent,
3577 *newParent = (wxWindowGTK *)newParentBase;
a2053b27 3578
5fd11f09
RR		 3579 wxASSERT( GTK_IS_WIDGET(m_widget) );
3580
f03fc89f
VZ		 3581 if ( !wxWindowBase::Reparent(newParent) )
3582 return FALSE;
8bbe427f 3583
5fd11f09
RR		 3584 wxASSERT( GTK_IS_WIDGET(m_widget) );
3585
3586 /* prevent GTK from deleting the widget arbitrarily */
3587 gtk_widget_ref( m_widget );
3588
8ce63e9d
RR		 3589 if (oldParent)
3590 {
3017f78d 3591 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
8ce63e9d 3592 }
c50f1fb9 3593
5fd11f09
RR		 3594 wxASSERT( GTK_IS_WIDGET(m_widget) );
3595
8ce63e9d
RR		 3596 if (newParent)
3597 {
3598 /* insert GTK representation */
3599 (*(newParent->m_insertCallback))(newParent, this);
3600 }
c50f1fb9 3601
5fd11f09
RR		 3602 /* reverse: prevent GTK from deleting the widget arbitrarily */
3603 gtk_widget_unref( m_widget );
148cd9b6 3604
f03fc89f 3605 return TRUE;
362c6693 3606}
c801d85f 3607
1e6feb95 3608void wxWindowGTK::DoAddChild(wxWindowGTK *child)
ddb6bc71 3609{
223d09f6 3610 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
ddb6bc71 3611
223d09f6 3612 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
ddb6bc71 3613
223d09f6 3614 wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
c50f1fb9 3615
ddb6bc71
RR		 3616 /* add to list */
3617 AddChild( child );
c50f1fb9 3618
ddb6bc71
RR		 3619 /* insert GTK representation */
3620 (*m_insertCallback)(this, child);
3621}
3622
1e6feb95 3623void wxWindowGTK::Raise()
362c6693 3624{
82b978d7
RD		 3625 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3626
a2053b27
RR		 3627 if (!m_widget->window) return;
3628
f03fc89f 3629 gdk_window_raise( m_widget->window );
362c6693
RR		 3630}
3631
1e6feb95 3632void wxWindowGTK::Lower()
362c6693 3633{
82b978d7
RD		 3634 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3635
a2053b27
RR		 3636 if (!m_widget->window) return;
3637
f03fc89f 3638 gdk_window_lower( m_widget->window );
362c6693 3639}
c801d85f 3640
1e6feb95 3641bool wxWindowGTK::SetCursor( const wxCursor &cursor )
86b29a61 3642{
82b978d7 3643 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
86b29a61 3644
f6bcfd97
BP		 3645 if (cursor == m_cursor)
3646 return FALSE;
3647
3648 if (g_isIdle)
3649 wxapp_install_idle_handler();
1e6feb95 3650
f6bcfd97
BP		 3651 if (cursor == wxNullCursor)
3652 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR );
3653 else
3654 return wxWindowBase::SetCursor( cursor );
362c6693 3655}
c801d85f 3656
1e6feb95 3657void wxWindowGTK::WarpPointer( int x, int y )
4f22cf8d 3658{
82b978d7
RD		 3659 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3660
3bcc8d15
RR		 3661 // We provide this function ourselves as it is
3662 // missing in GDK (top of this file).
148cd9b6 3663
ed673c6a
RR		 3664 GdkWindow *window = (GdkWindow*) NULL;
3665 if (m_wxwindow)
da048e3d 3666 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a
RR		 3667 else
3668 window = GetConnectWidget()->window;
148cd9b6 3669
ed673c6a
RR		 3670 if (window)
3671 gdk_window_warp_pointer( window, x, y );
4f22cf8d
RR		 3672}
3673
3013a903 3674
1e6feb95 3675void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
c801d85f 3676{
f2593d0d 3677 if (!m_widget) return;
a2053b27 3678 if (!m_widget->window) return;
2b5f62a0 3679
4e5a4c69 3680#ifndef __WXGTK20__
ea323db3
RR		 3681 if (g_isIdle)
3682 wxapp_install_idle_handler();
2b5f62a0 3683
75625d79
SN		 3684 wxRect myRect(0,0,0,0);
3685 if (m_wxwindow && rect)
3686 {
3687 myRect.SetSize(wxSize( m_wxwindow->allocation.width,
3688 m_wxwindow->allocation.height));
3689 myRect.Intersect(*rect);
3690 if (!myRect.width || !myRect.height)
3691 // nothing to do, rectangle is empty
3692 return;
3693 rect = &myRect;
3694 }
3695
139adb6a 3696 if (eraseBackground && m_wxwindow && m_wxwindow->window)
c801d85f 3697 {
139adb6a
RR		 3698 if (rect)
3699 {
3bcc8d15
RR		 3700 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3701 m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
139adb6a
RR		 3702 }
3703 else
3704 {
3bcc8d15
RR		 3705 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3706 m_clearRegion.Clear();
3707 m_clearRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
139adb6a
RR		 3708 }
3709 }
ff8bfdbb 3710
3bcc8d15 3711 if (rect)
139adb6a
RR		 3712 {
3713 if (m_wxwindow)
b02da6b1 3714 {
23716407 3715 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3bcc8d15 3716 m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
b02da6b1 3717 }
ff8bfdbb 3718 else
b6fa52db 3719 {
3bcc8d15
RR		 3720 GdkRectangle gdk_rect;
3721 gdk_rect.x = rect->x;
3722 gdk_rect.y = rect->y;
3723 gdk_rect.width = rect->width;
3724 gdk_rect.height = rect->height;
3725 gtk_widget_draw( m_widget, &gdk_rect );
b6fa52db 3726 }
362c6693 3727 }
c801d85f 3728 else
139adb6a 3729 {
139adb6a 3730 if (m_wxwindow)
b02da6b1 3731 {
23716407 3732 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3bcc8d15
RR		 3733 m_updateRegion.Clear();
3734 m_updateRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
b02da6b1 3735 }
139adb6a 3736 else
b6fa52db 3737 {
3bcc8d15 3738 gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
b6fa52db 3739 }
139adb6a 3740 }
4e5a4c69
RR		 3741#else
3742 if (m_wxwindow)
3743 {
3744 if (rect)
3745 {
3746 GdkRectangle gdk_rect;
3747 gdk_rect.x = rect->x;
3748 gdk_rect.y = rect->y;
3749 gdk_rect.width = rect->width;
3750 gdk_rect.height = rect->height;
3751 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, &gdk_rect, TRUE );
3752 }
3753 else
3754 {
3755 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, NULL, TRUE );
3756 }
3757 }
3758#endif
362c6693 3759}
c801d85f 3760
beab25bd 3761void wxWindowGTK::Update()
010afced
RR		 3762{
3763 GtkUpdate();
3764}
3765
3766void wxWindowGTK::GtkUpdate()
beab25bd 3767{
4e5a4c69
RR		 3768#ifdef __WXGTK20__
3769 if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
3770 gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );
b15ed747 3771#else
beab25bd 3772 if (!m_updateRegion.IsEmpty())
23716407 3773 GtkSendPaintEvents();
b15ed747 3774#endif
beab25bd
RR		 3775}
3776
3777void wxWindowGTK::GtkSendPaintEvents()
3778{
3bcc8d15
RR		 3779 if (!m_wxwindow)
3780 {
2b5f62a0 3781#ifndef __WXGTK20__
3bcc8d15 3782 m_clearRegion.Clear();
b15ed747 3783#endif
3bcc8d15
RR		 3784 m_updateRegion.Clear();
3785 return;
3786 }
beab25bd 3787
f90566f5 3788 // Clip to paint region in wxClientDC
3bcc8d15 3789 m_clipPaintRegion = TRUE;
fab591c5 3790
b15ed747
RR		 3791 // widget to draw on
3792 GtkPizza *pizza = GTK_PIZZA (m_wxwindow);
2b5f62a0 3793
f90566f5
RR		 3794 if (GetThemeEnabled())
3795 {
3796 // find ancestor from which to steal background
3797 wxWindow *parent = GetParent();
3798 while (parent && !parent->IsTopLevel())
3799 parent = parent->GetParent();
3800 if (!parent)
cc06fe74 3801 parent = (wxWindow*)this;
2b5f62a0 3802
f90566f5
RR		 3803 wxRegionIterator upd( m_updateRegion );
3804 while (upd)
3805 {
3806 GdkRectangle rect;
3807 rect.x = upd.GetX();
3808 rect.y = upd.GetY();
3809 rect.width = upd.GetWidth();
3810 rect.height = upd.GetHeight();
2b5f62a0 3811
f90566f5
RR		 3812 gtk_paint_flat_box( parent->m_widget->style,
3813 pizza->bin_window,
90b85bfc 3814 (GtkStateType)GTK_WIDGET_STATE(m_wxwindow),
f90566f5
RR		 3815 GTK_SHADOW_NONE,
3816 &rect,
3817 parent->m_widget,
3818 (char *)"base",
3819 0, 0, -1, -1 );
2b5f62a0 3820
f90566f5
RR		 3821 upd ++;
3822 }
3823 }
3824 else
b15ed747
RR		 3825
3826#ifdef __WXGTK20__
3827 {
3828 wxWindowDC dc( (wxWindow*)this );
3829 dc.SetClippingRegion( m_updateRegion );
3830
3831 wxEraseEvent erase_event( GetId(), &dc );
3832 erase_event.SetEventObject( this );
3833
3834 GetEventHandler()->ProcessEvent(erase_event);
3835 }
3836#else
3837 // if (!m_clearRegion.IsEmpty()) // Always send an erase event under GTK 1.2
beab25bd 3838 {
3bcc8d15 3839 wxWindowDC dc( (wxWindow*)this );
62cb3cd8
RR		 3840 if (m_clearRegion.IsEmpty())
3841 dc.SetClippingRegion( m_updateRegion );
3842 else
3843 dc.SetClippingRegion( m_clearRegion );
0fc5dbf5 3844
3bcc8d15
RR		 3845 wxEraseEvent erase_event( GetId(), &dc );
3846 erase_event.SetEventObject( this );
0fc5dbf5 3847
beab25bd
RR		 3848 if (!GetEventHandler()->ProcessEvent(erase_event))
3849 {
994bc575
RR		 3850 if (!g_eraseGC)
3851 {
f90566f5 3852 g_eraseGC = gdk_gc_new( pizza->bin_window );
994bc575
RR		 3853 gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
3854 }
1cd3409d 3855 gdk_gc_set_foreground( g_eraseGC, GetBackgroundColour().GetColor() );
0fc5dbf5 3856
3bcc8d15 3857 wxRegionIterator upd( m_clearRegion );
beab25bd
RR		 3858 while (upd)
3859 {
f90566f5
RR		 3860 gdk_draw_rectangle( pizza->bin_window, g_eraseGC, 1,
3861 upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
beab25bd
RR		 3862 upd ++;
3863 }
3864 }
3bcc8d15 3865 m_clearRegion.Clear();
beab25bd 3866 }
b15ed747 3867#endif
beab25bd
RR		 3868
3869 wxNcPaintEvent nc_paint_event( GetId() );
3870 nc_paint_event.SetEventObject( this );
3871 GetEventHandler()->ProcessEvent( nc_paint_event );
3872
3873 wxPaintEvent paint_event( GetId() );
3874 paint_event.SetEventObject( this );
3875 GetEventHandler()->ProcessEvent( paint_event );
3876
beab25bd 3877 m_clipPaintRegion = FALSE;
c89f5c02 3878
8f3e7ecc 3879#ifndef __WXUNIVERSAL__
4e5a4c69 3880#ifndef __WXGTK20__
8f3e7ecc 3881 // The following code will result in all window-less widgets
77ffb593 3882 // being redrawn because the wxWidgets class is allowed to
8f3e7ecc 3883 // paint over the window-less widgets.
0fc5dbf5 3884
8f3e7ecc
RR		 3885 GList *children = pizza->children;
3886 while (children)
c89f5c02 3887 {
8f3e7ecc
RR		 3888 GtkPizzaChild *child = (GtkPizzaChild*) children->data;
3889 children = children->next;
2b5f62a0 3890
8f3e7ecc
RR		 3891 if (GTK_WIDGET_NO_WINDOW (child->widget) &&
3892 GTK_WIDGET_DRAWABLE (child->widget))
3893 {
3894 // Get intersection of widget area and update region
3895 wxRegion region( m_updateRegion );
0fc5dbf5 3896
8f3e7ecc
RR		 3897 GdkEventExpose gdk_event;
3898 gdk_event.type = GDK_EXPOSE;
3899 gdk_event.window = pizza->bin_window;
3900 gdk_event.count = 0;
0fc5dbf5 3901
8f3e7ecc
RR		 3902 wxRegionIterator upd( m_updateRegion );
3903 while (upd)
c89f5c02 3904 {
8f3e7ecc
RR		 3905 GdkRectangle rect;
3906 rect.x = upd.GetX();
3907 rect.y = upd.GetY();
3908 rect.width = upd.GetWidth();
3909 rect.height = upd.GetHeight();
0fc5dbf5 3910
8f3e7ecc
RR		 3911 if (gtk_widget_intersect (child->widget, &rect, &gdk_event.area))
3912 {
3913 gtk_widget_event (child->widget, (GdkEvent*) &gdk_event);
3914 }
0fc5dbf5 3915
8f3e7ecc 3916 upd ++;
c89f5c02
RR		 3917 }
3918 }
3919 }
4e5a4c69 3920#endif
8f3e7ecc 3921#endif
c89f5c02
RR		 3922
3923 m_updateRegion.Clear();
beab25bd
RR		 3924}
3925
596f1d11 3926void wxWindowGTK::ClearBackground()
c801d85f 3927{
82b978d7
RD		 3928 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3929
b15ed747 3930#ifndef __WXGTK20__
f234c60c
RR		 3931 if (m_wxwindow && m_wxwindow->window)
3932 {
d7fa7eaa
RR		 3933 m_clearRegion.Clear();
3934 wxSize size( GetClientSize() );
3935 m_clearRegion.Union( 0,0,size.x,size.y );
2b5f62a0 3936
d7fa7eaa 3937 // Better do this in idle?
010afced 3938 GtkUpdate();
f234c60c 3939 }
b15ed747 3940#endif
362c6693 3941}
c801d85f 3942
ff8bfdbb 3943#if wxUSE_TOOLTIPS
1e6feb95 3944void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
b1170810 3945{
f03fc89f 3946 wxWindowBase::DoSetToolTip(tip);
ff8bfdbb 3947
f03fc89f 3948 if (m_tooltip)
3379ed37 3949 m_tooltip->Apply( (wxWindow *)this );
b1170810
RR		 3950}
3951
1e6feb95 3952void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
b1170810 3953{
aa154cb1
RR		 3954 wxString tmp( tip );
3955 gtk_tooltips_set_tip( tips, GetConnectWidget(), wxGTK_CONV(tmp), (gchar*) NULL );
301cd871 3956}
ff8bfdbb 3957#endif // wxUSE_TOOLTIPS
b1170810 3958
1e6feb95 3959bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
c801d85f 3960{
5edef14e 3961 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
8bbe427f 3962
739730ca 3963 if (!wxWindowBase::SetBackgroundColour(colour))
44dfb5ce 3964 return false;
c50f1fb9 3965
5edef14e 3966 if (colour.Ok())
994bc575 3967 {
5edef14e
VS		 3968 // We need the pixel value e.g. for background clearing.
3969 m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
994bc575 3970 }
ca298c88 3971
5edef14e
VS		 3972 // apply style change (forceStyle=true so that new style is applied
3973 // even if the bg colour changed from valid to wxNullColour):
3974 ApplyWidgetStyle(true);
ea323db3 3975
5edef14e 3976 return true;
6de97a3b
RR		 3977}
3978
1e6feb95 3979bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
6de97a3b 3980{
82b978d7 3981 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
8bbe427f 3982
739730ca
RR		 3983 if (!wxWindowBase::SetForegroundColour(colour))
3984 {
5edef14e 3985 return false;
739730ca 3986 }
5edef14e
VS		 3987
3988 if (colour.Ok())
ea323db3 3989 {
5edef14e
VS		 3990 // We need the pixel value e.g. for background clearing.
3991 m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
ea323db3 3992 }
f03fc89f 3993
5edef14e
VS		 3994 // apply style change (forceStyle=true so that new style is applied
3995 // even if the bg colour changed from valid to wxNullColour):
3996 ApplyWidgetStyle(true);
3997
44dfb5ce 3998 return true;
58614078
RR		 3999}
4000
2b5f62a0
VZ		 4001#ifdef __WXGTK20__
4002PangoContext *wxWindowGTK::GtkGetPangoDefaultContext()
4003{
4004 return gtk_widget_get_pango_context( m_widget );
4005}
4006
4007PangoContext *wxWindowGTK::GtkGetPangoX11Context()
4008{
4009 if (!m_x11Context)
4010 m_x11Context = pango_x_get_context( gdk_display );
4011
4012 return m_x11Context;
4013}
4014#endif
f40fdaa3 4015
5edef14e 4016GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle)
58614078 4017{
f40fdaa3 4018 // do we need to apply any changes at all?
5edef14e 4019 if ( !forceStyle &&
984e8d0b
VS		 4020 !m_font.Ok() &&
4021 !m_foregroundColour.Ok() && !m_backgroundColour.Ok() )
fb65642c 4022 {
f40fdaa3 4023 return NULL;
fb65642c
RR		 4024 }
4025
f40fdaa3 4026 GtkRcStyle *style = gtk_rc_style_new();
1ecc4d80 4027
984e8d0b 4028 if ( m_font.Ok() )
db434467 4029 {
288059b2 4030#ifdef __WXGTK20__
f40fdaa3
VS		 4031 style->font_desc =
4032 pango_font_description_copy( m_font.GetNativeFontInfo()->description );
288059b2 4033#else
f40fdaa3
VS		 4034 wxString xfontname = m_font.GetNativeFontInfo()->GetXFontName();
4035 style->fontset_name = g_strdup(xfontname.c_str());
cfcc3932 4036#endif
288059b2 4037 }
1ecc4d80 4038
fe161a26 4039 if ( m_foregroundColour.Ok() )
1ecc4d80 4040 {
5edef14e 4041 GdkColor *fg = m_foregroundColour.GetColor();
f40fdaa3 4042
5edef14e 4043 style->fg[GTK_STATE_NORMAL] = *fg;
f40fdaa3
VS		 4044 style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG;
4045
5edef14e 4046 style->fg[GTK_STATE_PRELIGHT] = *fg;
f40fdaa3
VS		 4047 style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG;
4048
5edef14e 4049 style->fg[GTK_STATE_ACTIVE] = *fg;
f40fdaa3 4050 style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG;
1ecc4d80
RR		 4051 }
4052
fe161a26 4053 if ( m_backgroundColour.Ok() )
1ecc4d80 4054 {
5edef14e
VS		 4055 GdkColor *bg = m_backgroundColour.GetColor();
4056
4057 style->bg[GTK_STATE_NORMAL] = *bg;
4058 style->base[GTK_STATE_NORMAL] = *bg;
f40fdaa3
VS		 4059 style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)
4060 (style->color_flags[GTK_STATE_NORMAL] | GTK_RC_BG | GTK_RC_BASE);
4061
5edef14e
VS		 4062 style->bg[GTK_STATE_PRELIGHT] = *bg;
4063 style->base[GTK_STATE_PRELIGHT] = *bg;
f40fdaa3
VS		 4064 style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)
4065 (style->color_flags[GTK_STATE_PRELIGHT] | GTK_RC_BG | GTK_RC_BASE);
4066
5edef14e
VS		 4067 style->bg[GTK_STATE_ACTIVE] = *bg;
4068 style->base[GTK_STATE_ACTIVE] = *bg;
f40fdaa3
VS		 4069 style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)
4070 (style->color_flags[GTK_STATE_ACTIVE] | GTK_RC_BG | GTK_RC_BASE);
4071
5edef14e
VS		 4072 style->bg[GTK_STATE_INSENSITIVE] = *bg;
4073 style->base[GTK_STATE_INSENSITIVE] = *bg;
f40fdaa3
VS		 4074 style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)
4075 (style->color_flags[GTK_STATE_INSENSITIVE] | GTK_RC_BG | GTK_RC_BASE);
1ecc4d80 4076 }
f40fdaa3
VS		 4077
4078 return style;
a81258be
RR		 4079}
4080
f8e045e2 4081void wxWindowGTK::ApplyWidgetStyle(bool forceStyle)
a81258be 4082{
f8e045e2
RD		 4083 GtkRcStyle *style = CreateWidgetStyle(forceStyle);
4084 if ( style )
4085 {
7074ce35 4086 DoApplyWidgetStyle(style);
f8e045e2
RD		 4087 gtk_rc_style_unref(style);
4088 }
6de97a3b
RR		 4089}
4090
7074ce35
VS		 4091void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
4092{
4093 if (m_wxwindow)
4094 // should we also do m_widget in this case?
4095 gtk_widget_modify_style(m_wxwindow, style);
4096 else
4097 gtk_widget_modify_style(m_widget, style);
4098}
4099
4100
2259e007
RR		 4101//-----------------------------------------------------------------------------
4102// Pop-up menu stuff
4103//-----------------------------------------------------------------------------
4104
6522713c 4105#if wxUSE_MENUS_NATIVE
1e6feb95 4106
90350682
VZ		 4107extern "C"
4108void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting )
2259e007
RR		 4109{
4110 *is_waiting = FALSE;
4111}
4112
1e6feb95 4113static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win )
30dea054 4114{
1ecc4d80 4115 menu->SetInvokingWindow( win );
222ed1d6 4116 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
1ecc4d80
RR		 4117 while (node)
4118 {
1987af7e 4119 wxMenuItem *menuitem = node->GetData();
1ecc4d80
RR		 4120 if (menuitem->IsSubMenu())
4121 {
ff8bfdbb
VZ		 4122 SetInvokingWindow( menuitem->GetSubMenu(), win );
4123 }
1987af7e
VZ		 4124
4125 node = node->GetNext();
1ecc4d80 4126 }
362c6693 4127}
30dea054 4128
295272bd
VZ		 4129extern "C" void wxPopupMenuPositionCallback( GtkMenu *menu,
4130 gint *x, gint *y,
9e691f46
VZ		 4131#ifdef __WXGTK20__
4132 gboolean * WXUNUSED(whatever),
4133#endif
39b44a39 4134 gpointer user_data )
0c77152e 4135{
e3473203
VZ		 4136 // ensure that the menu appears entirely on screen
4137 GtkRequisition req;
4138 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
4139
4140 wxSize sizeScreen = wxGetDisplaySize();
39b44a39 4141 wxPoint *pos = (wxPoint*)user_data;
e3473203
VZ		 4142
4143 gint xmax = sizeScreen.x - req.width,
4144 ymax = sizeScreen.y - req.height;
4145
39b44a39
VS		 4146 *x = pos->x < xmax ? pos->x : xmax;
4147 *y = pos->y < ymax ? pos->y : ymax;
0c77152e
RR		 4148}
4149
1e6feb95 4150bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
30dea054 4151{
971562cb 4152 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
47d67540 4153
971562cb 4154 wxCHECK_MSG( menu != NULL, false, wxT("invalid popup-menu") );
8bbe427f 4155
1ecc4d80 4156 SetInvokingWindow( menu, this );
ff8bfdbb 4157
631f1bfe
JS		 4158 menu->UpdateUI();
4159
971562cb 4160 bool is_waiting = true;
148cd9b6 4161
90350682
VZ		 4162 gtk_signal_connect( GTK_OBJECT(menu->m_menu),
4163 "hide",
4164 GTK_SIGNAL_FUNC(gtk_pop_hide_callback),
4165 (gpointer)&is_waiting );
2259e007 4166
971562cb
VS		 4167 wxPoint pos;
4168 gpointer userdata;
4169 GtkMenuPositionFunc posfunc;
4170 if ( x == -1 && y == -1 )
4171 {
4172 // use GTK's default positioning algorithm
4173 userdata = NULL;
4174 posfunc = NULL;
4175 }
4176 else
4177 {
4178 pos = ClientToScreen(wxPoint(x, y));
4179 userdata = &pos;
4180 posfunc = wxPopupMenuPositionCallback;
4181 }
4182
1ecc4d80 4183 gtk_menu_popup(
47d67540 4184 GTK_MENU(menu->m_menu),
e3473203
VZ		 4185 (GtkWidget *) NULL, // parent menu shell
4186 (GtkWidget *) NULL, // parent menu item
971562cb
VS		 4187 posfunc, // function to position it
4188 userdata, // client data
4189 0, // button used to activate it
34791896
RR		 4190#ifdef __WXGTK20__
4191 gtk_get_current_event_time()
4192#else
34adc954 4193 gs_timeLastClick // the time of activation
34791896 4194#endif
47d67540 4195 );
148cd9b6 4196
956dbab1
RR		 4197 while (is_waiting)
4198 {
a03cac3f 4199 gtk_main_iteration();
956dbab1 4200 }
2259e007 4201
971562cb 4202 return true;
30dea054
RR		 4203}
4204
6522713c 4205#endif // wxUSE_MENUS_NATIVE
1e6feb95 4206
06cfab17 4207#if wxUSE_DRAG_AND_DROP
ac57418f 4208
1e6feb95 4209void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
c801d85f 4210{
82b978d7
RD		 4211 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4212
1ecc4d80 4213 GtkWidget *dnd_widget = GetConnectWidget();
47d67540 4214
1ecc4d80 4215 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
47d67540 4216
1ecc4d80
RR		 4217 if (m_dropTarget) delete m_dropTarget;
4218 m_dropTarget = dropTarget;
47d67540 4219
1ecc4d80 4220 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
362c6693 4221}
c801d85f 4222
f03fc89f 4223#endif // wxUSE_DRAG_AND_DROP
ac57418f 4224
1e6feb95 4225GtkWidget* wxWindowGTK::GetConnectWidget()
e3e65dac 4226{
1ecc4d80
RR		 4227 GtkWidget *connect_widget = m_widget;
4228 if (m_wxwindow) connect_widget = m_wxwindow;
47d67540 4229
1ecc4d80 4230 return connect_widget;
e3e65dac 4231}
47d67540 4232
1e6feb95 4233bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window )
903f689b 4234{
148cd9b6 4235 if (m_wxwindow)
da048e3d 4236 return (window == GTK_PIZZA(m_wxwindow)->bin_window);
148cd9b6 4237
1ecc4d80 4238 return (window == m_widget->window);
903f689b
RR		 4239}
4240
1e6feb95 4241bool wxWindowGTK::SetFont( const wxFont &font )
c801d85f 4242{
5edef14e 4243 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
9c288e4d 4244
5edef14e
VS		 4245 if (!wxWindowBase::SetFont(font))
4246 return false;
c801d85f 4247
5edef14e
VS		 4248 // apply style change (forceStyle=true so that new style is applied
4249 // even if the font changed from valid to wxNullFont):
4250 ApplyWidgetStyle(true);
4251
4252 return true;
362c6693 4253}
c801d85f 4254
94633ad9 4255void wxWindowGTK::DoCaptureMouse()
c801d85f 4256{
82b978d7
RD		 4257 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4258
ed673c6a 4259 GdkWindow *window = (GdkWindow*) NULL;
b231914f
VZ		 4260 if (m_wxwindow)
4261 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a 4262 else
b231914f 4263 window = GetConnectWidget()->window;
148cd9b6 4264
e4606ed9 4265 wxCHECK_RET( window, _T("CaptureMouse() failed") );
c50f1fb9 4266
b231914f 4267 wxCursor* cursor = & m_cursor;
cca602ac
JS		 4268 if (!cursor->Ok())
4269 cursor = wxSTANDARD_CURSOR;
4270
ed673c6a 4271 gdk_pointer_grab( window, FALSE,
1ecc4d80
RR		 4272 (GdkEventMask)
4273 (GDK_BUTTON_PRESS_MASK |
4274 GDK_BUTTON_RELEASE_MASK |
148cd9b6 4275 GDK_POINTER_MOTION_HINT_MASK |
1ecc4d80 4276 GDK_POINTER_MOTION_MASK),
ff8bfdbb 4277 (GdkWindow *) NULL,
cca602ac 4278 cursor->GetCursor(),
b02da6b1 4279 (guint32)GDK_CURRENT_TIME );
b231914f 4280 g_captureWindow = this;
1e6feb95 4281 g_captureWindowHasMouse = TRUE;
362c6693 4282}
c801d85f 4283
94633ad9 4284void wxWindowGTK::DoReleaseMouse()
c801d85f 4285{
82b978d7
RD		 4286 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4287
e4606ed9 4288 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
47d67540 4289
c43430bb
VS		 4290 g_captureWindow = (wxWindowGTK*) NULL;
4291
ed673c6a 4292 GdkWindow *window = (GdkWindow*) NULL;
b231914f
VZ		 4293 if (m_wxwindow)
4294 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a 4295 else
b231914f 4296 window = GetConnectWidget()->window;
148cd9b6 4297
b02da6b1
VZ		 4298 if (!window)
4299 return;
c50f1fb9 4300
b02da6b1 4301 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
362c6693 4302}
c801d85f 4303
1e6feb95
VZ		 4304/* static */
4305wxWindow *wxWindowBase::GetCapture()
4306{
4307 return (wxWindow *)g_captureWindow;
4308}
4309
4310bool wxWindowGTK::IsRetained() const
c801d85f 4311{
1ecc4d80 4312 return FALSE;
362c6693 4313}
c801d85f 4314
1e6feb95 4315void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,
cb43b372 4316 int range, bool refresh )
c801d85f 4317{
82b978d7
RD		 4318 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4319
223d09f6 4320 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
c801d85f 4321
1ecc4d80 4322 m_hasScrolling = TRUE;
47d67540 4323
1ecc4d80 4324 if (orient == wxHORIZONTAL)
cb43b372 4325 {
1ecc4d80
RR		 4326 float fpos = (float)pos;
4327 float frange = (float)range;
4328 float fthumb = (float)thumbVisible;
4329 if (fpos > frange-fthumb) fpos = frange-fthumb;
4330 if (fpos < 0.0) fpos = 0.0;
4331
4332 if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
4333 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
4334 {
4335 SetScrollPos( orient, pos, refresh );
4336 return;
4337 }
47d67540 4338
1ecc4d80 4339 m_oldHorizontalPos = fpos;
47d67540 4340
1ecc4d80
RR		 4341 m_hAdjust->lower = 0.0;
4342 m_hAdjust->upper = frange;
4343 m_hAdjust->value = fpos;
4344 m_hAdjust->step_increment = 1.0;
4345 m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
4346 m_hAdjust->page_size = fthumb;
cb43b372 4347 }
1ecc4d80
RR		 4348 else
4349 {
4350 float fpos = (float)pos;
4351 float frange = (float)range;
4352 float fthumb = (float)thumbVisible;
4353 if (fpos > frange-fthumb) fpos = frange-fthumb;
4354 if (fpos < 0.0) fpos = 0.0;
4355
4356 if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
4357 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
4358 {
4359 SetScrollPos( orient, pos, refresh );
4360 return;
4361 }
47d67540 4362
1ecc4d80 4363 m_oldVerticalPos = fpos;
47d67540 4364
1ecc4d80
RR		 4365 m_vAdjust->lower = 0.0;
4366 m_vAdjust->upper = frange;
4367 m_vAdjust->value = fpos;
4368 m_vAdjust->step_increment = 1.0;
4369 m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
4370 m_vAdjust->page_size = fthumb;
4371 }
47d67540 4372
eb082a08
RR		 4373 if (orient == wxHORIZONTAL)
4374 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
4375 else
4376 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
362c6693 4377}
c801d85f 4378
1e6feb95 4379void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
c801d85f 4380{
82b978d7 4381 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
1ecc4d80 4382
223d09f6 4383 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
1ecc4d80
RR		 4384
4385 if (orient == wxHORIZONTAL)
4386 {
4387 float fpos = (float)pos;
4388 if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
4389 if (fpos < 0.0) fpos = 0.0;
4390 m_oldHorizontalPos = fpos;
4391
4392 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
4393 m_hAdjust->value = fpos;
4394 }
4395 else
4396 {
4397 float fpos = (float)pos;
4398 if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
4399 if (fpos < 0.0) fpos = 0.0;
4400 m_oldVerticalPos = fpos;
ff8bfdbb 4401
1ecc4d80
RR		 4402 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
4403 m_vAdjust->value = fpos;
4404 }
47d67540 4405
5b8a521e 4406 if (m_wxwindow->window)
47d67540 4407 {
5b8a521e 4408 if (orient == wxHORIZONTAL)
473d087e
RR		 4409 {
4410 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust),
4411 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
2daa0ce9 4412
5b8a521e 4413 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
2daa0ce9 4414
473d087e
RR		 4415 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
4416 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
4417 }
5b8a521e 4418 else
473d087e
RR		 4419 {
4420 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust),
4421 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
2daa0ce9 4422
5b8a521e 4423 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
473d087e
RR		 4424
4425 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
4426 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
4427 }
cb43b372 4428 }
362c6693 4429}
c801d85f 4430
1e6feb95 4431int wxWindowGTK::GetScrollThumb( int orient ) const
c801d85f 4432{
82b978d7
RD		 4433 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4434
223d09f6 4435 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
47d67540 4436
1ecc4d80
RR		 4437 if (orient == wxHORIZONTAL)
4438 return (int)(m_hAdjust->page_size+0.5);
4439 else
4440 return (int)(m_vAdjust->page_size+0.5);
362c6693 4441}
c801d85f 4442
1e6feb95 4443int wxWindowGTK::GetScrollPos( int orient ) const
c801d85f 4444{
82b978d7 4445 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
47d67540 4446
223d09f6 4447 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
c801d85f 4448
1ecc4d80
RR		 4449 if (orient == wxHORIZONTAL)
4450 return (int)(m_hAdjust->value+0.5);
4451 else
4452 return (int)(m_vAdjust->value+0.5);
362c6693 4453}
c801d85f 4454
1e6feb95 4455int wxWindowGTK::GetScrollRange( int orient ) const
c801d85f 4456{
82b978d7 4457 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
47d67540 4458
223d09f6 4459 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
c801d85f 4460
1ecc4d80
RR		 4461 if (orient == wxHORIZONTAL)
4462 return (int)(m_hAdjust->upper+0.5);
4463 else
4464 return (int)(m_vAdjust->upper+0.5);
362c6693 4465}
c801d85f 4466
1e6feb95 4467void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
c801d85f 4468{
82b978d7
RD		 4469 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4470
223d09f6 4471 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
2b5f62a0 4472
f47ae6e7 4473 // No scrolling requested.
8e217128 4474 if ((dx == 0) && (dy == 0)) return;
0fc5dbf5 4475
4e5a4c69 4476#ifndef __WXGTK20__
35917d22
RR		 4477 if (!m_updateRegion.IsEmpty())
4478 {
4479 m_updateRegion.Offset( dx, dy );
0fc5dbf5 4480
35917d22
RR		 4481 int cw = 0;
4482 int ch = 0;
4483 GetClientSize( &cw, &ch );
4484 m_updateRegion.Intersect( 0, 0, cw, ch );
4485 }
0fc5dbf5 4486
3bcc8d15
RR		 4487 if (!m_clearRegion.IsEmpty())
4488 {
4489 m_clearRegion.Offset( dx, dy );
0fc5dbf5 4490
3bcc8d15
RR		 4491 int cw = 0;
4492 int ch = 0;
4493 GetClientSize( &cw, &ch );
4494 m_clearRegion.Intersect( 0, 0, cw, ch );
4495 }
3fc6e5fa
RR		 4496#endif
4497
b6fa52db 4498 m_clipPaintRegion = TRUE;
0fc5dbf5 4499
da048e3d 4500 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
0fc5dbf5 4501
b6fa52db 4502 m_clipPaintRegion = FALSE;
c801d85f 4503}
3723b7b1 4504
4e5a4c69 4505
3723b7b1
JS		 4506// Find the wxWindow at the current mouse position, also returning the mouse
4507// position.
4508wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4509{
59a12e90
JS		 4510 pt = wxGetMousePosition();
4511 wxWindow* found = wxFindWindowAtPoint(pt);
4512 return found;
3723b7b1
JS		 4513}
4514
4515// Get the current mouse position.
4516wxPoint wxGetMousePosition()
4517{
59a12e90
JS		 4518 /* This crashes when used within wxHelpContext,
4519 so we have to use the X-specific implementation below.
4520 gint x, y;
4521 GdkModifierType *mask;
4522 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4523
4524 return wxPoint(x, y);
4525 */
4526
3723b7b1
JS		 4527 int x, y;
4528 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
59a12e90 4529
37d81cc2 4530 Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
59a12e90
JS		 4531 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4532 Window rootReturn, childReturn;
4533 int rootX, rootY, winX, winY;
4534 unsigned int maskReturn;
4535
4536 XQueryPointer (display,
5cd09f0b
RR		 4537 rootWindow,
4538 &rootReturn,
59a12e90
JS		 4539 &childReturn,
4540 &rootX, &rootY, &winX, &winY, &maskReturn);
4541 return wxPoint(rootX, rootY);
4542
3723b7b1
JS		 4543}
4544
4e5a4c69
RR		 4545// ----------------------------------------------------------------------------
4546// wxDCModule
4547// ----------------------------------------------------------------------------
4548
4549class wxWinModule : public wxModule
4550{
4551public:
4552 bool OnInit();
4553 void OnExit();
4554
4555private:
4556 DECLARE_DYNAMIC_CLASS(wxWinModule)
4557};
4558
4559IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule)
4560
4561bool wxWinModule::OnInit()
4562{
994bc575
RR		 4563 // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
4564 // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
0fc5dbf5 4565
4e5a4c69
RR		 4566 return TRUE;
4567}
4568
4569void wxWinModule::OnExit()
4570{
994bc575
RR		 4571 if (g_eraseGC)
4572 gdk_gc_unref( g_eraseGC );
4e5a4c69
RR		 4573}
4574
6728fb61 4575// vi:sts=4:sw=4:et
wxWidgets (Impactor)