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