]> 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
header includes for mac corrected
[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
f9d5648a
JS		 1540 // GdkDisplay is a GTK+ 2.1.0 thing
1541#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 1, 0)
15475ced
VZ		 1542 if ( gdk_event->type == GDK_2BUTTON_PRESS &&
1543 gdk_event->button >= 1 && gdk_event->button <= 3 )
1544 {
1545 // Reset GDK internal timestamp variables in order to disable GDK
1546 // triple click events. GDK will then next time believe no button has
1547 // been clicked just before, and send a normal button click event.
1548 GdkDisplay* display = gtk_widget_get_display (widget);
1549 display->button_click_time[1] = 0;
1550 display->button_click_time[0] = 0;
1551 }
1552#endif // GTK 2+
1553
f5e27805 1554 if (gdk_event->button == 1)
c801d85f 1555 {
f3f0d961
VZ		 1556 // note that GDK generates triple click events which are not supported
1557 // by wxWindows but still have to be passed to the app as otherwise
1558 // clicks would simply go missing
f5e27805
RR		 1559 switch (gdk_event->type)
1560 {
15475ced
VZ		 1561 // we shouldn't get triple clicks at all for GTK2 because we
1562 // suppress them artificially using the code above but we still
1563 // should map them to something for GTK1 and not just ignore them
1564 // as this would lose clicks
f3f0d961
VZ		 1565 case GDK_3BUTTON_PRESS: // we could also map this to DCLICK...
1566 case GDK_BUTTON_PRESS:
1567 event_type = wxEVT_LEFT_DOWN;
1568 break;
1569
1570 case GDK_2BUTTON_PRESS:
1571 event_type = wxEVT_LEFT_DCLICK;
1572 break;
b1f50e65
VZ		 1573
1574 default:
1575 // just to silence gcc warnings
1576 ;
f5e27805 1577 }
362c6693 1578 }
f5e27805 1579 else if (gdk_event->button == 2)
c801d85f 1580 {
f5e27805
RR		 1581 switch (gdk_event->type)
1582 {
15475ced 1583 case GDK_3BUTTON_PRESS:
f3f0d961
VZ		 1584 case GDK_BUTTON_PRESS:
1585 event_type = wxEVT_MIDDLE_DOWN;
1586 break;
1587
1588 case GDK_2BUTTON_PRESS:
1589 event_type = wxEVT_MIDDLE_DCLICK;
1590 break;
b1f50e65
VZ		 1591
1592 default:
1593 ;
f5e27805 1594 }
362c6693 1595 }
f5e27805 1596 else if (gdk_event->button == 3)
c801d85f 1597 {
f5e27805
RR		 1598 switch (gdk_event->type)
1599 {
15475ced 1600 case GDK_3BUTTON_PRESS:
f3f0d961
VZ		 1601 case GDK_BUTTON_PRESS:
1602 event_type = wxEVT_RIGHT_DOWN;
1603 break;
1604
1605 case GDK_2BUTTON_PRESS:
1606 event_type = wxEVT_RIGHT_DCLICK;
1607 break;
b1f50e65
VZ		 1608
1609 default:
1610 ;
2b5f62a0
VZ		 1611 }
1612 }
f3f0d961 1613 else if (gdk_event->button == 4 || gdk_event->button == 5)
2b5f62a0 1614 {
f3f0d961 1615 if (gdk_event->type == GDK_BUTTON_PRESS )
2b5f62a0 1616 {
f3f0d961 1617 event_type = wxEVT_MOUSEWHEEL;
2b5f62a0
VZ		 1618 }
1619 }
47d67540 1620
2daa0ce9
VZ		 1621 if ( event_type == wxEVT_NULL )
1622 {
1623 // unknown mouse button or click type
1624 return FALSE;
1625 }
1626
f5e27805 1627 wxMouseEvent event( event_type );
c5f9d156 1628 InitMouseEvent( win, event, gdk_event );
47d67540 1629
2daa0ce9 1630 AdjustEventButtonState(event);
94633ad9 1631
3ae4c570
VZ		 1632 // wxListBox actually get mouse events from the item, so we need to give it
1633 // a chance to correct this
1634 win->FixUpMouseEvent(widget, event.m_x, event.m_y);
2daa0ce9 1635
d1f2ac45
VZ		 1636 // find the correct window to send the event too: it may be a different one
1637 // from the one which got it at GTK+ level because some control don't have
1638 // their own X window and thus cannot get any events.
1639 if ( !g_captureWindow )
1640 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
ff8bfdbb 1641
34adc954
VZ		 1642 gs_timeLastClick = gdk_event->time;
1643
2f073eb2
RR		 1644/*
1645 wxPrintf( wxT("2) OnButtonPress from ") );
1646 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1647 wxPrintf( win->GetClassInfo()->GetClassName() );
1648 wxPrintf( wxT(".\n") );
1649*/
1650
df135f2b
RR		 1651#ifndef __WXGTK20__
1652 if (event_type == wxEVT_LEFT_DCLICK)
1653 {
1654 // GTK 1.2 crashes when intercepting double
1655 // click events from both wxSpinButton and
1656 // wxSpinCtrl
1657 if (GTK_IS_SPIN_BUTTON(win->m_widget))
1658 {
1659 // Just disable this event for now.
1660 return FALSE;
1661 }
1662 }
1663#endif
1664
f5e27805 1665 if (win->GetEventHandler()->ProcessEvent( event ))
034be888 1666 {
f5e27805 1667 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
f03fc89f 1668 return TRUE;
034be888 1669 }
47d67540 1670
034be888 1671 return FALSE;
362c6693 1672}
c801d85f
KB		 1673
1674//-----------------------------------------------------------------------------
97b3455a 1675// "button_release_event"
2f2aa628 1676//-----------------------------------------------------------------------------
c801d85f 1677
2b5f62a0
VZ		 1678static gint gtk_window_button_release_callback( GtkWidget *widget,
1679 GdkEventButton *gdk_event,
1680 wxWindowGTK *win )
47d67540 1681{
3ac8d3bc
RR		 1682 DEBUG_MAIN_THREAD
1683
c50f1fb9 1684 if (g_isIdle)
a2053b27
RR		 1685 wxapp_install_idle_handler();
1686
1687 if (!win->m_hasVMT) return FALSE;
034be888
RR		 1688 if (g_blockEventsOnDrag) return FALSE;
1689 if (g_blockEventsOnScroll) return FALSE;
c801d85f 1690
034be888 1691 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
47d67540 1692
f5e27805 1693 wxEventType event_type = wxEVT_NULL;
47d67540 1694
f5e27805
RR		 1695 switch (gdk_event->button)
1696 {
2b5f62a0
VZ		 1697 case 1:
1698 event_type = wxEVT_LEFT_UP;
1699 break;
1700
1701 case 2:
1702 event_type = wxEVT_MIDDLE_UP;
1703 break;
1704
1705 case 3:
1706 event_type = wxEVT_RIGHT_UP;
1707 break;
1708
1709 default:
1710 // unknwon button, don't process
1711 return FALSE;
f5e27805 1712 }
47d67540 1713
f5e27805 1714 wxMouseEvent event( event_type );
c5f9d156 1715 InitMouseEvent( win, event, gdk_event );
f5e27805 1716
2daa0ce9
VZ		 1717 AdjustEventButtonState(event);
1718
3ae4c570
VZ		 1719 // same wxListBox hack as above
1720 win->FixUpMouseEvent(widget, event.m_x, event.m_y);
e2762ff0 1721
2b5f62a0
VZ		 1722 if ( event_type == wxEVT_RIGHT_UP )
1723 {
1724 // generate a "context menu" event: this is similar to wxEVT_RIGHT_UP
1725 // except that:
1726 //
1727 // (a) it's a command event and so is propagated to the parent
1728 // (b) under MSW it can be generated from kbd too
1729 // (c) it uses screen coords (because of (a))
1730 wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU,
1731 win->GetId(),
1732 win->ClientToScreen(event.GetPosition()));
1733 (void)win->GetEventHandler()->ProcessEvent(evtCtx);
1734 }
1735
d1f2ac45
VZ		 1736 if ( !g_captureWindow )
1737 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
47d67540 1738
f5e27805 1739 if (win->GetEventHandler()->ProcessEvent( event ))
034be888 1740 {
f5e27805 1741 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
f03fc89f 1742 return TRUE;
034be888 1743 }
47d67540 1744
034be888 1745 return FALSE;
362c6693 1746}
c801d85f
KB		 1747
1748//-----------------------------------------------------------------------------
2f2aa628
RR		 1749// "motion_notify_event"
1750//-----------------------------------------------------------------------------
c801d85f 1751
1e6feb95
VZ		 1752static gint gtk_window_motion_notify_callback( GtkWidget *widget,
1753 GdkEventMotion *gdk_event,
1754 wxWindowGTK *win )
47d67540 1755{
3ac8d3bc
RR		 1756 DEBUG_MAIN_THREAD
1757
c50f1fb9 1758 if (g_isIdle)
a2053b27
RR		 1759 wxapp_install_idle_handler();
1760
1761 if (!win->m_hasVMT) return FALSE;
034be888
RR		 1762 if (g_blockEventsOnDrag) return FALSE;
1763 if (g_blockEventsOnScroll) return FALSE;
148cd9b6 1764
034be888
RR		 1765 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1766
ff8bfdbb 1767 if (gdk_event->is_hint)
aae24d21 1768 {
f7a11f8c
RR		 1769 int x = 0;
1770 int y = 0;
1771 GdkModifierType state;
1772 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1773 gdk_event->x = x;
1774 gdk_event->y = y;
aae24d21 1775 }
ff8bfdbb 1776
c801d85f 1777/*
e380f72b
RR		 1778 printf( "OnMotion from " );
1779 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1780 printf( win->GetClassInfo()->GetClassName() );
1781 printf( ".\n" );
aae24d21 1782*/
47d67540 1783
e380f72b 1784 wxMouseEvent event( wxEVT_MOTION );
c5f9d156 1785 InitMouseEvent(win, event, gdk_event);
e380f72b 1786
50382578 1787 if ( g_captureWindow )
2f2aa628 1788 {
1e6feb95
VZ		 1789 // synthetize a mouse enter or leave event if needed
1790 GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
7c5e6fc6 1791 // This seems to be necessary and actually been added to
50382578
RR		 1792 // GDK itself in version 2.0.X
1793 gdk_flush();
7c5e6fc6 1794
1e6feb95
VZ		 1795 bool hasMouse = winUnderMouse == gdk_event->window;
1796 if ( hasMouse != g_captureWindowHasMouse )
1797 {
1798 // the mouse changed window
1799 g_captureWindowHasMouse = hasMouse;
1800
1801 wxMouseEvent event(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1802 : wxEVT_LEAVE_WINDOW);
c5f9d156 1803 InitMouseEvent(win, event, gdk_event);
1e6feb95
VZ		 1804 event.SetEventObject(win);
1805 win->GetEventHandler()->ProcessEvent(event);
1806 }
1807 }
1808 else // no capture
1809 {
d1f2ac45 1810 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
2f2aa628 1811 }
47d67540 1812
e380f72b 1813 if (win->GetEventHandler()->ProcessEvent( event ))
034be888 1814 {
e380f72b 1815 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
f03fc89f 1816 return TRUE;
034be888 1817 }
47d67540 1818
034be888 1819 return FALSE;
362c6693 1820}
c801d85f 1821
557c9f5b
JS		 1822#ifdef __WXGTK20__
1823//-----------------------------------------------------------------------------
1824// "mouse_wheel_event"
1825//-----------------------------------------------------------------------------
1826
1827static gint gtk_window_wheel_callback (GtkWidget * widget,
1828 GdkEventScroll * gdk_event,
1829 wxWindowGTK * win)
1830{
1831 DEBUG_MAIN_THREAD
1832
1833 if (g_isIdle)
1834 wxapp_install_idle_handler();
1835
1836 wxEventType event_type = wxEVT_NULL;
1837 if (gdk_event->direction == GDK_SCROLL_UP)
1838 event_type = wxEVT_MOUSEWHEEL;
1839 else if (gdk_event->direction == GDK_SCROLL_DOWN)
1840 event_type = wxEVT_MOUSEWHEEL;
1841 else
1842 return FALSE;
1843
1844 wxMouseEvent event( event_type );
1845 // Can't use InitMouse macro because scroll events don't have button
1846 event.SetTimestamp( gdk_event->time );
1847 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
1848 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
1849 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
1850 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
1851 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
1852 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
1853 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
1854 if (gdk_event->direction == GDK_SCROLL_UP)
1855 event.m_wheelRotation = 120;
1856 else
1857 event.m_wheelRotation = -120;
1858
1859 wxPoint pt = win->GetClientAreaOrigin();
1860 event.m_x = (wxCoord)gdk_event->x - pt.x;
1861 event.m_y = (wxCoord)gdk_event->y - pt.y;
1862
1863 event.SetEventObject( win );
1864 event.SetId( win->GetId() );
1865 event.SetTimestamp( gdk_event->time );
1866
1867 if (win->GetEventHandler()->ProcessEvent( event ))
1868 {
1869 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "scroll_event" );
1870 return TRUE;
1871 }
1872
1873 return FALSE;
1874}
1875#endif
1876
c801d85f 1877//-----------------------------------------------------------------------------
2f2aa628
RR		 1878// "focus_in_event"
1879//-----------------------------------------------------------------------------
c801d85f 1880
6aeb6f2a
VZ		 1881// send the wxChildFocusEvent and wxFocusEvent, common code of
1882// gtk_window_focus_in_callback() and SetFocus()
1883static bool DoSendFocusEvents(wxWindow *win)
1884{
1885 // Notify the parent keeping track of focus for the kbd navigation
1886 // purposes that we got it.
1887 wxChildFocusEvent eventChildFocus(win);
1888 (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
1889
1890 wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
1891 eventFocus.SetEventObject(win);
1892
1893 return win->GetEventHandler()->ProcessEvent(eventFocus);
1894}
1895
1e6feb95
VZ		 1896static gint gtk_window_focus_in_callback( GtkWidget *widget,
1897 GdkEvent *WXUNUSED(event),
1898 wxWindow *win )
c801d85f 1899{
3ac8d3bc
RR		 1900 DEBUG_MAIN_THREAD
1901
c50f1fb9 1902 if (g_isIdle)
a2053b27
RR		 1903 wxapp_install_idle_handler();
1904
1905 if (!win->m_hasVMT) return FALSE;
034be888 1906 if (g_blockEventsOnDrag) return FALSE;
ff8bfdbb 1907
148cd9b6
VZ		 1908 switch ( g_sendActivateEvent )
1909 {
1910 case -1:
76fcf0f2 1911 // we've got focus from outside, synthetize wxActivateEvent
148cd9b6
VZ		 1912 g_sendActivateEvent = 1;
1913 break;
1914
1915 case 0:
1916 // another our window just lost focus, it was already ours before
1917 // - don't send any wxActivateEvent
1918 g_sendActivateEvent = -1;
1919 break;
1920 }
1921
1e6feb95 1922 g_focusWindowLast =
b292e2f5 1923 g_focusWindow = win;
ff8bfdbb 1924
6cad4f1b
VZ		 1925 wxLogTrace(TRACE_FOCUS,
1926 _T("%s: focus in"), win->GetName().c_str());
7de59551 1927
b79395c5
RR		 1928#ifdef HAVE_XIM
1929 if (win->m_ic)
1930 gdk_im_begin(win->m_ic, win->m_wxwindow->window);
1931#endif
1932
1e6feb95 1933#if wxUSE_CARET
f6bcfd97
BP		 1934 // caret needs to be informed about focus change
1935 wxCaret *caret = win->GetCaret();
1936 if ( caret )
1937 {
1938 caret->OnSetFocus();
1939 }
1940#endif // wxUSE_CARET
1941
d7fa7eaa 1942 g_activeFrameLostFocus = FALSE;
2b5f62a0 1943
e8c12a53
VS		 1944 wxWindowGTK *active = wxGetTopLevelParent(win);
1945 if ( active != g_activeFrame )
942bef71 1946 {
e8c12a53
VS		 1947 if ( g_activeFrame )
1948 {
45eb5249 1949 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from focus_in)"), g_activeFrame);
e8c12a53
VS		 1950 wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
1951 event.SetEventObject(g_activeFrame);
1952 g_activeFrame->GetEventHandler()->ProcessEvent(event);
1953 }
47d67540 1954
45eb5249 1955 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), active);
e8c12a53
VS		 1956 g_activeFrame = active;
1957 wxActivateEvent event(wxEVT_ACTIVATE, TRUE, g_activeFrame->GetId());
1958 event.SetEventObject(g_activeFrame);
1959 g_activeFrame->GetEventHandler()->ProcessEvent(event);
2b5f62a0 1960
d7fa7eaa
RR		 1961 // Don't send focus events in addition to activate
1962 // if (win == g_activeFrame)
1963 // return TRUE;
942bef71 1964 }
e8c12a53 1965
6cad4f1b
VZ		 1966 // does the window itself think that it has the focus?
1967 if ( !win->m_hasFocus )
5cd09f0b 1968 {
6cad4f1b
VZ		 1969 // not yet, notify it
1970 win->m_hasFocus = TRUE;
1971
1972 if ( DoSendFocusEvents(win) )
1973 {
1974 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
1975 return TRUE;
1976 }
034be888 1977 }
ca298c88 1978
034be888 1979 return FALSE;
362c6693 1980}
c801d85f
KB		 1981
1982//-----------------------------------------------------------------------------
2f2aa628
RR		 1983// "focus_out_event"
1984//-----------------------------------------------------------------------------
c801d85f 1985
afbe906a 1986static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk_event, wxWindowGTK *win )
c801d85f 1987{
3ac8d3bc
RR		 1988 DEBUG_MAIN_THREAD
1989
c50f1fb9 1990 if (g_isIdle)
a2053b27
RR		 1991 wxapp_install_idle_handler();
1992
1993 if (!win->m_hasVMT) return FALSE;
034be888 1994 if (g_blockEventsOnDrag) return FALSE;
ca298c88 1995
6cad4f1b
VZ		 1996 wxLogTrace( TRACE_FOCUS,
1997 _T("%s: focus out"), win->GetName().c_str() );
b231914f 1998
45eb5249
VS		 1999 if ( !g_activeFrameLostFocus && g_activeFrame )
2000 {
c0ad3d42
VZ		 2001 // VZ: commenting this out because it does happen (although not easy
2002 // to reproduce, I only see it when using wxMiniFrame and not
2003 // always) and makes using Mahogany quite annoying
2004#if 0
2005 wxASSERT_MSG( wxGetTopLevelParent(win) == g_activeFrame,
63fd5f0b 2006 wxT("unfocusing window that hasn't gained focus properly") );
c0ad3d42
VZ		 2007#endif // 0
2008
45eb5249
VS		 2009 g_activeFrameLostFocus = TRUE;
2010 }
2011
148cd9b6
VZ		 2012 // if the focus goes out of our app alltogether, OnIdle() will send
2013 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
2014 // g_sendActivateEvent to -1
2015 g_sendActivateEvent = 0;
2016
3379ed37 2017 wxWindowGTK *winFocus = wxFindFocusedChild(win);
f6bcfd97
BP		 2018 if ( winFocus )
2019 win = winFocus;
2020
1e6feb95 2021 g_focusWindow = (wxWindowGTK *)NULL;
148cd9b6 2022
b79395c5
RR		 2023#ifdef HAVE_XIM
2024 if (win->m_ic)
2025 gdk_im_end();
2026#endif
2027
1e6feb95 2028#if wxUSE_CARET
f6bcfd97
BP		 2029 // caret needs to be informed about focus change
2030 wxCaret *caret = win->GetCaret();
2031 if ( caret )
2032 {
2033 caret->OnKillFocus();
2034 }
2035#endif // wxUSE_CARET
2036
6cad4f1b
VZ		 2037 // don't send the window a kill focus event if it thinks that it doesn't
2038 // have focus already
2039 if ( win->m_hasFocus )
5cd09f0b 2040 {
6cad4f1b
VZ		 2041 win->m_hasFocus = FALSE;
2042
2043 wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
2044 event.SetEventObject( win );
2045
2046 if (win->GetEventHandler()->ProcessEvent( event ))
2047 {
2048 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
2049 return TRUE;
2050 }
034be888 2051 }
ca298c88 2052
034be888 2053 return FALSE;
362c6693 2054}
c801d85f 2055
b4071e91
RR		 2056//-----------------------------------------------------------------------------
2057// "enter_notify_event"
2058//-----------------------------------------------------------------------------
2059
edc1d330
VZ		 2060static
2061gint gtk_window_enter_callback( GtkWidget *widget,
2062 GdkEventCrossing *gdk_event,
2063 wxWindowGTK *win )
b4071e91 2064{
3ac8d3bc
RR		 2065 DEBUG_MAIN_THREAD
2066
c50f1fb9 2067 if (g_isIdle)
a2053b27 2068 wxapp_install_idle_handler();
ca298c88 2069
a2053b27
RR		 2070 if (!win->m_hasVMT) return FALSE;
2071 if (g_blockEventsOnDrag) return FALSE;
47d67540 2072
7f5f144a
RR		 2073 // Event was emitted after a grab
2074 if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
7c5e6fc6 2075
a2053b27 2076 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
b292e2f5 2077
4a33eba6
RR		 2078 int x = 0;
2079 int y = 0;
2080 GdkModifierType state = (GdkModifierType)0;
ff8bfdbb 2081
a2053b27 2082 gdk_window_get_pointer( widget->window, &x, &y, &state );
ff8bfdbb 2083
edc1d330 2084 wxMouseEvent event( wxEVT_ENTER_WINDOW );
c5f9d156
VS		 2085 InitMouseEvent(win, event, gdk_event);
2086 wxPoint pt = win->GetClientAreaOrigin();
2087 event.m_x = x + pt.x;
2088 event.m_y = y + pt.y;
ff8bfdbb 2089
e380f72b 2090 if (win->GetEventHandler()->ProcessEvent( event ))
034be888 2091 {
e380f72b 2092 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
034be888
RR		 2093 return TRUE;
2094 }
ca298c88 2095
034be888 2096 return FALSE;
b4071e91 2097}
47d67540 2098
b4071e91
RR		 2099//-----------------------------------------------------------------------------
2100// "leave_notify_event"
2101//-----------------------------------------------------------------------------
2102
1e6feb95 2103static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )
b4071e91 2104{
3ac8d3bc
RR		 2105 DEBUG_MAIN_THREAD
2106
c50f1fb9 2107 if (g_isIdle)
a2053b27 2108 wxapp_install_idle_handler();
acfd422a 2109
a2053b27
RR		 2110 if (!win->m_hasVMT) return FALSE;
2111 if (g_blockEventsOnDrag) return FALSE;
b292e2f5 2112
7f5f144a
RR		 2113 // Event was emitted after an ungrab
2114 if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
7c5e6fc6 2115
a2053b27 2116 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
c50f1fb9 2117
e380f72b 2118 wxMouseEvent event( wxEVT_LEAVE_WINDOW );
d1367c3d 2119 event.SetTimestamp( gdk_event->time );
e380f72b 2120 event.SetEventObject( win );
47d67540 2121
4a33eba6
RR		 2122 int x = 0;
2123 int y = 0;
2124 GdkModifierType state = (GdkModifierType)0;
ff8bfdbb 2125
4a33eba6 2126 gdk_window_get_pointer( widget->window, &x, &y, &state );
ff8bfdbb 2127
74710601
VZ		 2128 event.m_shiftDown = (state & GDK_SHIFT_MASK) != 0;
2129 event.m_controlDown = (state & GDK_CONTROL_MASK) != 0;
2130 event.m_altDown = (state & GDK_MOD1_MASK) != 0;
2131 event.m_metaDown = (state & GDK_MOD2_MASK) != 0;
2132 event.m_leftDown = (state & GDK_BUTTON1_MASK) != 0;
2133 event.m_middleDown = (state & GDK_BUTTON2_MASK) != 0;
2134 event.m_rightDown = (state & GDK_BUTTON3_MASK) != 0;
4a33eba6 2135
c5f9d156
VS		 2136 wxPoint pt = win->GetClientAreaOrigin();
2137 event.m_x = x + pt.x;
2138 event.m_y = y + pt.y;
ff8bfdbb 2139
e380f72b 2140 if (win->GetEventHandler()->ProcessEvent( event ))
034be888 2141 {
e380f72b 2142 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
034be888
RR		 2143 return TRUE;
2144 }
ca298c88 2145
034be888 2146 return FALSE;
b4071e91 2147}
47d67540 2148
c801d85f 2149//-----------------------------------------------------------------------------
2f2aa628
RR		 2150// "value_changed" from m_vAdjust
2151//-----------------------------------------------------------------------------
c801d85f 2152
9e691f46
VZ		 2153static void gtk_window_vscroll_callback( GtkAdjustment *adjust,
2154 SCROLLBAR_CBACK_ARG
2155 wxWindowGTK *win )
c801d85f 2156{
3ac8d3bc
RR		 2157 DEBUG_MAIN_THREAD
2158
c50f1fb9 2159 if (g_isIdle)
a2053b27 2160 wxapp_install_idle_handler();
c801d85f 2161
a2053b27 2162 if (g_blockEventsOnDrag) return;
47d67540 2163
a2053b27 2164 if (!win->m_hasVMT) return;
148cd9b6 2165
5e014a0c 2166 float diff = adjust->value - win->m_oldVerticalPos;
e380f72b 2167 if (fabs(diff) < 0.2) return;
148cd9b6 2168
5e014a0c 2169 win->m_oldVerticalPos = adjust->value;
47d67540 2170
a8bf1826 2171#ifndef __WXGTK20__
6728fb61 2172 GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(win->m_widget);
a8bf1826 2173#endif
6728fb61 2174 wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->vscrollbar));
148cd9b6 2175
5e014a0c 2176 int value = (int)(adjust->value+0.5);
c801d85f 2177
c5b42c87 2178 wxScrollWinEvent event( command, value, wxVERTICAL );
e380f72b
RR		 2179 event.SetEventObject( win );
2180 win->GetEventHandler()->ProcessEvent( event );
362c6693 2181}
c801d85f
KB		 2182
2183//-----------------------------------------------------------------------------
2f2aa628
RR		 2184// "value_changed" from m_hAdjust
2185//-----------------------------------------------------------------------------
c801d85f 2186
9e691f46
VZ		 2187static void gtk_window_hscroll_callback( GtkAdjustment *adjust,
2188 SCROLLBAR_CBACK_ARG
2189 wxWindowGTK *win )
47d67540 2190{
3ac8d3bc
RR		 2191 DEBUG_MAIN_THREAD
2192
c50f1fb9 2193 if (g_isIdle)
a2053b27 2194 wxapp_install_idle_handler();
47d67540 2195
a2053b27
RR		 2196 if (g_blockEventsOnDrag) return;
2197 if (!win->m_hasVMT) return;
47d67540 2198
5e014a0c 2199 float diff = adjust->value - win->m_oldHorizontalPos;
e380f72b 2200 if (fabs(diff) < 0.2) return;
148cd9b6 2201
a8bf1826 2202#ifndef __WXGTK20__
6728fb61 2203 GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(win->m_widget);
a8bf1826 2204#endif
6728fb61 2205 wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->hscrollbar));
148cd9b6 2206
9e691f46 2207 win->m_oldHorizontalPos = adjust->value;
148cd9b6 2208
5e014a0c 2209 int value = (int)(adjust->value+0.5);
47d67540 2210
c5b42c87 2211 wxScrollWinEvent event( command, value, wxHORIZONTAL );
e380f72b
RR		 2212 event.SetEventObject( win );
2213 win->GetEventHandler()->ProcessEvent( event );
362c6693 2214}
c801d85f 2215
cb43b372
RR		 2216//-----------------------------------------------------------------------------
2217// "button_press_event" from scrollbar
2218//-----------------------------------------------------------------------------
2219
2a23d363
RR		 2220static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
2221 GdkEventButton *gdk_event,
1e6feb95 2222 wxWindowGTK *win)
cb43b372 2223{
3ac8d3bc
RR		 2224 DEBUG_MAIN_THREAD
2225
c50f1fb9 2226 if (g_isIdle)
a2053b27
RR		 2227 wxapp_install_idle_handler();
2228
d6d26e04 2229
5b8a521e 2230 g_blockEventsOnScroll = TRUE;
9e691f46
VZ		 2231
2232 // FIXME: there is no 'slider' field in GTK+ 2.0 any more
2233#ifndef __WXGTK20__
2a23d363 2234 win->m_isScrolling = (gdk_event->window == widget->slider);
9e691f46 2235#endif
47d67540 2236
e380f72b 2237 return FALSE;
cb43b372
RR		 2238}
2239
2240//-----------------------------------------------------------------------------
2241// "button_release_event" from scrollbar
2242//-----------------------------------------------------------------------------
2243
88413fec 2244static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
8bbe427f 2245 GdkEventButton *WXUNUSED(gdk_event),
1e6feb95 2246 wxWindowGTK *win)
cb43b372 2247{
3ac8d3bc
RR		 2248 DEBUG_MAIN_THREAD
2249
1ecc4d80 2250// don't test here as we can release the mouse while being over
5e014a0c 2251// a different window than the slider
76ed8f8d
RR		 2252//
2253// if (gdk_event->window != widget->slider) return FALSE;
cb43b372 2254
5b8a521e 2255 g_blockEventsOnScroll = FALSE;
47d67540 2256
2a23d363 2257 if (win->m_isScrolling)
88413fec 2258 {
d6d26e04 2259 wxEventType command = wxEVT_SCROLLWIN_THUMBRELEASE;
2a23d363
RR		 2260 int value = -1;
2261 int dir = -1;
2daa0ce9 2262
2a23d363
RR		 2263 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
2264 if (widget == GTK_RANGE(scrolledWindow->hscrollbar))
2265 {
2266 value = (int)(win->m_hAdjust->value+0.5);
2267 dir = wxHORIZONTAL;
2268 }
2269 if (widget == GTK_RANGE(scrolledWindow->vscrollbar))
2270 {
2271 value = (int)(win->m_vAdjust->value+0.5);
2272 dir = wxVERTICAL;
2273 }
2daa0ce9 2274
2a23d363 2275 wxScrollWinEvent event( command, value, dir );
2a23d363
RR		 2276 event.SetEventObject( win );
2277 win->GetEventHandler()->ProcessEvent( event );
88413fec
RR		 2278 }
2279
2a23d363 2280 win->m_isScrolling = FALSE;
2daa0ce9 2281
e380f72b 2282 return FALSE;
cb43b372
RR		 2283}
2284
f03fc89f
VZ		 2285// ----------------------------------------------------------------------------
2286// this wxWindowBase function is implemented here (in platform-specific file)
2287// because it is static and so couldn't be made virtual
2288// ----------------------------------------------------------------------------
2b07d713 2289
f03fc89f 2290wxWindow *wxWindowBase::FindFocus()
2b07d713 2291{
1e6feb95
VZ		 2292 // the cast is necessary when we compile in wxUniversal mode
2293 return (wxWindow *)g_focusWindow;
2b07d713 2294}
ca298c88 2295
1a685a59 2296
a2053b27
RR		 2297//-----------------------------------------------------------------------------
2298// "realize" from m_widget
2299//-----------------------------------------------------------------------------
2300
b79395c5
RR		 2301/* We cannot set colours and fonts before the widget has
2302 been realized, so we do this directly after realization. */
a2053b27
RR		 2303
2304static gint
2b5f62a0 2305gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
a2053b27 2306{
3ac8d3bc
RR		 2307 DEBUG_MAIN_THREAD
2308
c50f1fb9 2309 if (g_isIdle)
a2053b27 2310 wxapp_install_idle_handler();
2b904684
RR		 2311
2312 if (win->m_delayedBackgroundColour && !win->GetThemeEnabled())
ea323db3 2313 win->GtkSetBackgroundColour( win->GetBackgroundColour() );
a2053b27 2314
2b904684 2315 if (win->m_delayedForegroundColour && !win->GetThemeEnabled())
ea323db3 2316 win->GtkSetForegroundColour( win->GetForegroundColour() );
a2053b27 2317
2b5f62a0
VZ		 2318#ifdef __WXGTK20__
2319 if (win->m_imContext)
2320 {
2321 GtkPizza *pizza = GTK_PIZZA( m_widget );
2322 gtk_im_context_set_client_window( (GtkIMContext*) win->m_imContext, pizza->bin_window );
2323 }
2324#endif
2325
3c679789
RR		 2326 wxWindowCreateEvent event( win );
2327 event.SetEventObject( win );
2328 win->GetEventHandler()->ProcessEvent( event );
1e6feb95 2329
a2053b27
RR		 2330 return FALSE;
2331}
2332
b79395c5
RR		 2333//-----------------------------------------------------------------------------
2334// "size_allocate"
2335//-----------------------------------------------------------------------------
2336
8f75cb6c 2337static
adc1999b
RR		 2338void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
2339 GtkAllocation *WXUNUSED(alloc),
8f75cb6c
RR		 2340 wxWindow *win )
2341{
2342 if (g_isIdle)
2343 wxapp_install_idle_handler();
2daa0ce9 2344
5b8a521e 2345 if (!win->m_hasScrolling) return;
2daa0ce9 2346
5b8a521e
RR		 2347 int client_width = 0;
2348 int client_height = 0;
2349 win->GetClientSize( &client_width, &client_height );
2350 if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight))
2351 return;
2daa0ce9 2352
5b8a521e
RR		 2353 win->m_oldClientWidth = client_width;
2354 win->m_oldClientHeight = client_height;
2daa0ce9 2355
5b8a521e
RR		 2356 if (!win->m_nativeSizeEvent)
2357 {
2358 wxSizeEvent event( win->GetSize(), win->GetId() );
2359 event.SetEventObject( win );
2360 win->GetEventHandler()->ProcessEvent( event );
2361 }
8f75cb6c
RR		 2362}
2363
2364
3ed2e7ce
VZ		 2365#ifdef HAVE_XIM
2366 #define WXUNUSED_UNLESS_XIM(param) param
2367#else
2368 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2369#endif
2370
b79395c5
RR		 2371/* Resize XIM window */
2372
3ed2e7ce 2373static
8f75cb6c
RR		 2374void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
2375 GtkAllocation* WXUNUSED_UNLESS_XIM(alloc),
1e6feb95 2376 wxWindowGTK* WXUNUSED_UNLESS_XIM(win) )
b79395c5
RR		 2377{
2378 if (g_isIdle)
2379 wxapp_install_idle_handler();
2daa0ce9 2380
9a8c7620 2381#ifdef HAVE_XIM
b79395c5
RR		 2382 if (!win->m_ic)
2383 return;
2384
b79395c5
RR		 2385 if (gdk_ic_get_style (win->m_ic) & GDK_IM_PREEDIT_POSITION)
2386 {
2387 gint width, height;
2388
3ed2e7ce 2389 gdk_window_get_size (widget->window, &width, &height);
b79395c5
RR		 2390 win->m_icattr->preedit_area.width = width;
2391 win->m_icattr->preedit_area.height = height;
2392 gdk_ic_set_attr (win->m_ic, win->m_icattr, GDK_IC_PREEDIT_AREA);
2393 }
9a8c7620 2394#endif // HAVE_XIM
b79395c5
RR		 2395}
2396
63081513
RR		 2397//-----------------------------------------------------------------------------
2398// "realize" from m_wxwindow
2399//-----------------------------------------------------------------------------
2400
2401/* Initialize XIM support */
2402
2403static gint
3ed2e7ce 2404gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
1e6feb95 2405 wxWindowGTK * WXUNUSED_UNLESS_XIM(win) )
63081513
RR		 2406{
2407 if (g_isIdle)
2408 wxapp_install_idle_handler();
2409
d06800f1 2410#ifdef HAVE_XIM
63081513
RR		 2411 if (win->m_ic) return FALSE;
2412 if (!widget) return FALSE;
2413 if (!gdk_im_ready()) return FALSE;
2414
2415 win->m_icattr = gdk_ic_attr_new();
2416 if (!win->m_icattr) return FALSE;
2daa0ce9 2417
63081513
RR		 2418 gint width, height;
2419 GdkEventMask mask;
2420 GdkColormap *colormap;
2421 GdkICAttr *attr = win->m_icattr;
b58b1dfc 2422 unsigned attrmask = GDK_IC_ALL_REQ;
63081513 2423 GdkIMStyle style;
b79395c5
RR		 2424 GdkIMStyle supported_style = (GdkIMStyle)
2425 (GDK_IM_PREEDIT_NONE |
1e6feb95
VZ		 2426 GDK_IM_PREEDIT_NOTHING |
2427 GDK_IM_PREEDIT_POSITION |
2428 GDK_IM_STATUS_NONE |
2429 GDK_IM_STATUS_NOTHING);
63081513
RR		 2430
2431 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
1e6feb95 2432 supported_style = (GdkIMStyle)(supported_style & ~GDK_IM_PREEDIT_POSITION);
63081513
RR		 2433
2434 attr->style = style = gdk_im_decide_style (supported_style);
2435 attr->client_window = widget->window;
2436
2437 if ((colormap = gtk_widget_get_colormap (widget)) !=
1e6feb95 2438 gtk_widget_get_default_colormap ())
63081513 2439 {
5cd09f0b
RR		 2440 attrmask |= GDK_IC_PREEDIT_COLORMAP;
2441 attr->preedit_colormap = colormap;
63081513 2442 }
2daa0ce9 2443
63081513
RR		 2444 attrmask |= GDK_IC_PREEDIT_FOREGROUND;
2445 attrmask |= GDK_IC_PREEDIT_BACKGROUND;
2446 attr->preedit_foreground = widget->style->fg[GTK_STATE_NORMAL];
2447 attr->preedit_background = widget->style->base[GTK_STATE_NORMAL];
2448
2449 switch (style & GDK_IM_PREEDIT_MASK)
2450 {
1e6feb95
VZ		 2451 case GDK_IM_PREEDIT_POSITION:
2452 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2453 {
2454 g_warning ("over-the-spot style requires fontset");
2455 break;
2456 }
63081513 2457
1e6feb95 2458 gdk_window_get_size (widget->window, &width, &height);
63081513 2459
1e6feb95
VZ		 2460 attrmask |= GDK_IC_PREEDIT_POSITION_REQ;
2461 attr->spot_location.x = 0;
2462 attr->spot_location.y = height;
2463 attr->preedit_area.x = 0;
2464 attr->preedit_area.y = 0;
2465 attr->preedit_area.width = width;
2466 attr->preedit_area.height = height;
2467 attr->preedit_fontset = widget->style->font;
63081513 2468
1e6feb95 2469 break;
b79395c5 2470 }
2daa0ce9 2471
b58b1dfc 2472 win->m_ic = gdk_ic_new (attr, (GdkICAttributesType)attrmask);
2daa0ce9 2473
63081513 2474 if (win->m_ic == NULL)
1e6feb95 2475 g_warning ("Can't create input context.");
63081513 2476 else
1e6feb95
VZ		 2477 {
2478 mask = gdk_window_get_events (widget->window);
2479 mask = (GdkEventMask)(mask | gdk_ic_get_events (win->m_ic));
2480 gdk_window_set_events (widget->window, mask);
2481
2482 if (GTK_WIDGET_HAS_FOCUS(widget))
2483 gdk_im_begin (win->m_ic, widget->window);
2484 }
2485#endif // HAVE_XIM
63081513
RR		 2486
2487 return FALSE;
2488}
2489
6ca41e57 2490//-----------------------------------------------------------------------------
1e6feb95 2491// InsertChild for wxWindowGTK.
6ca41e57
RR		 2492//-----------------------------------------------------------------------------
2493
1e6feb95 2494/* Callback for wxWindowGTK. This very strange beast has to be used because
b1170810
RR		 2495 * C++ has no virtual methods in a constructor. We have to emulate a
2496 * virtual function here as wxNotebook requires a different way to insert
2497 * a child in it. I had opted for creating a wxNotebookPage window class
2498 * which would have made this superfluous (such in the MDI window system),
2499 * but no-one was listening to me... */
6ca41e57 2500
1e6feb95 2501static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
6ca41e57 2502{
bf0c00c6
RR		 2503 /* the window might have been scrolled already, do we
2504 have to adapt the position */
da048e3d
RR		 2505 GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
2506 child->m_x += pizza->xoffset;
2507 child->m_y += pizza->yoffset;
148cd9b6 2508
da048e3d 2509 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
a2053b27
RR		 2510 GTK_WIDGET(child->m_widget),
2511 child->m_x,
2512 child->m_y,
2513 child->m_width,
2514 child->m_height );
6ca41e57
RR		 2515}
2516
bbe0af5b
RR		 2517//-----------------------------------------------------------------------------
2518// global functions
2519//-----------------------------------------------------------------------------
2520
1e6feb95 2521wxWindow *wxGetActiveWindow()
bbe0af5b 2522{
6cad4f1b 2523 return wxWindow::FindFocus();
bbe0af5b
RR		 2524}
2525
c801d85f 2526//-----------------------------------------------------------------------------
1e6feb95 2527// wxWindowGTK
c801d85f
KB		 2528//-----------------------------------------------------------------------------
2529
6522713c
VZ		 2530// in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2531// method
1e6feb95 2532#ifdef __WXUNIVERSAL__
6522713c
VZ		 2533 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
2534#else // __WXGTK__
1e6feb95 2535 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
6522713c 2536#endif // __WXUNIVERSAL__/__WXGTK__
c801d85f 2537
1e6feb95 2538void wxWindowGTK::Init()
c801d85f 2539{
f03fc89f 2540 // GTK specific
a2053b27 2541 m_widget = (GtkWidget *) NULL;
e380f72b 2542 m_wxwindow = (GtkWidget *) NULL;
76fcf0f2 2543 m_focusWidget = (GtkWidget *) NULL;
8bbe427f 2544
f03fc89f 2545 // position/size
a2053b27
RR		 2546 m_x = 0;
2547 m_y = 0;
2548 m_width = 0;
e380f72b 2549 m_height = 0;
8bbe427f 2550
e380f72b
RR		 2551 m_sizeSet = FALSE;
2552 m_hasVMT = FALSE;
2553 m_needParent = TRUE;
31c6b4fc 2554 m_isBeingDeleted = FALSE;
148cd9b6 2555
147bc491 2556 m_noExpose = FALSE;
30760ce7 2557 m_nativeSizeEvent = FALSE;
94633ad9 2558
a2053b27 2559 m_hasScrolling = FALSE;
846e1424 2560 m_isScrolling = FALSE;
f03fc89f 2561
a2053b27 2562 m_hAdjust = (GtkAdjustment*) NULL;
e380f72b 2563 m_vAdjust = (GtkAdjustment*) NULL;
815ac4a7 2564 m_oldHorizontalPos =
e380f72b 2565 m_oldVerticalPos = 0.0;
815ac4a7
VZ		 2566 m_oldClientWidth =
2567 m_oldClientHeight = 0;
8bbe427f 2568
e380f72b 2569 m_resizing = FALSE;
e380f72b 2570 m_widgetStyle = (GtkStyle*) NULL;
8bbe427f 2571
ddb6bc71 2572 m_insertCallback = (wxInsertChildFunction) NULL;
8bbe427f 2573
b292e2f5 2574 m_acceptsFocus = FALSE;
6cad4f1b 2575 m_hasFocus = FALSE;
148cd9b6 2576
b6fa52db 2577 m_clipPaintRegion = FALSE;
b6fa52db 2578
5e014a0c 2579 m_cursor = *wxSTANDARD_CURSOR;
2daa0ce9 2580
f6bcfd97
BP		 2581 m_delayedForegroundColour = FALSE;
2582 m_delayedBackgroundColour = FALSE;
1e6feb95 2583
2b5f62a0
VZ		 2584#ifdef __WXGTK20__
2585 m_imContext = NULL;
2586 m_x11Context = NULL;
2587#else
63081513
RR		 2588#ifdef HAVE_XIM
2589 m_ic = (GdkIC*) NULL;
2590 m_icattr = (GdkICAttr*) NULL;
2591#endif
2b5f62a0 2592#endif
362c6693 2593}
c801d85f 2594
1e6feb95 2595wxWindowGTK::wxWindowGTK()
68995f26
VZ		 2596{
2597 Init();
2598}
2599
1e6feb95
VZ		 2600wxWindowGTK::wxWindowGTK( wxWindow *parent,
2601 wxWindowID id,
2602 const wxPoint &pos,
2603 const wxSize &size,
2604 long style,
2605 const wxString &name )
6ca41e57 2606{
68995f26
VZ		 2607 Init();
2608
e380f72b 2609 Create( parent, id, pos, size, style, name );
6ca41e57 2610}
8bbe427f 2611
1e6feb95
VZ		 2612bool wxWindowGTK::Create( wxWindow *parent,
2613 wxWindowID id,
2614 const wxPoint &pos,
2615 const wxSize &size,
2616 long style,
2617 const wxString &name )
c801d85f 2618{
4dcaf11a
RR		 2619 if (!PreCreation( parent, pos, size ) ||
2620 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2621 {
1e6feb95 2622 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
b02da6b1 2623 return FALSE;
4dcaf11a 2624 }
47d67540 2625
ddb6bc71 2626 m_insertCallback = wxInsertChildInWindow;
2b5f62a0 2627
994bc575 2628 // always needed for background clearing
2b5f62a0 2629 m_delayedBackgroundColour = TRUE;
1e6feb95 2630
e380f72b 2631 m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
38c7b3d3 2632 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
ff8bfdbb 2633
f03fc89f 2634 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
47d67540 2635
dd00f3f6 2636 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
e380f72b 2637 scroll_class->scrollbar_spacing = 0;
47d67540 2638
f03fc89f 2639 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
47d67540 2640
f03fc89f
VZ		 2641 m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
2642 m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
47d67540 2643
da048e3d 2644 m_wxwindow = gtk_pizza_new();
0fc5dbf5 2645
1e6feb95 2646#ifndef __WXUNIVERSAL__
da048e3d 2647 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
b292e2f5 2648
f03fc89f 2649 if (HasFlag(wxRAISED_BORDER))
034be888 2650 {
da048e3d 2651 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
034be888 2652 }
f03fc89f 2653 else if (HasFlag(wxSUNKEN_BORDER))
034be888 2654 {
da048e3d 2655 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
5e014a0c
RR		 2656 }
2657 else if (HasFlag(wxSIMPLE_BORDER))
2658 {
da048e3d 2659 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN );
034be888
RR		 2660 }
2661 else
2662 {
da048e3d 2663 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
034be888 2664 }
1e6feb95 2665#endif // __WXUNIVERSAL__
47d67540 2666
4e5a4c69
RR		 2667 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
2668
3da17724
RR		 2669 GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
2670 m_acceptsFocus = TRUE;
ca298c88 2671
e380f72b 2672 // I _really_ don't want scrollbars in the beginning
a2053b27
RR		 2673 m_vAdjust->lower = 0.0;
2674 m_vAdjust->upper = 1.0;
2675 m_vAdjust->value = 0.0;
2676 m_vAdjust->step_increment = 1.0;
2677 m_vAdjust->page_increment = 1.0;
2678 m_vAdjust->page_size = 5.0;
2679 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
2680 m_hAdjust->lower = 0.0;
2681 m_hAdjust->upper = 1.0;
2682 m_hAdjust->value = 0.0;
2683 m_hAdjust->step_increment = 1.0;
2684 m_hAdjust->page_increment = 1.0;
2685 m_hAdjust->page_size = 5.0;
2686 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
f03fc89f
VZ		 2687
2688 // these handlers block mouse events to any window during scrolling such as
2689 // motion events and prevent GTK and wxWindows from fighting over where the
2690 // slider should be
2691
2692 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
76ed8f8d
RR		 2693 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2694
f03fc89f 2695 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
76ed8f8d
RR		 2696 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2697
f03fc89f 2698 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
76ed8f8d
RR		 2699 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2700
f03fc89f 2701 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
76ed8f8d 2702 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
8bbe427f 2703
034be888 2704 // these handlers get notified when screen updates are required either when
76ed8f8d
RR		 2705 // scrolling or when the window size (and therefore scrollbar configuration)
2706 // has changed
2707
2708 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
2709 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
2710 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
2711 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
2712
2b5f62a0
VZ		 2713#ifdef __WXGTK20__
2714 // Create input method handler
2715 m_imContext = (GtkIMMulticontext*) gtk_im_multicontext_new ();
2716
2717 // Cannot handle drawing preedited text yet
2718 gtk_im_context_set_use_preedit( (GtkIMContext*) m_imContext, FALSE );
2719
2720 g_signal_connect (G_OBJECT (m_imContext), "commit",
2721 G_CALLBACK (gtk_wxwindow_commit_cb), this);
2722#endif
2723
f03fc89f 2724 gtk_widget_show( m_wxwindow );
47d67540 2725
f03fc89f
VZ		 2726 if (m_parent)
2727 m_parent->DoAddChild( this );
94633ad9 2728
76fcf0f2 2729 m_focusWidget = m_wxwindow;
8bbe427f 2730
e380f72b 2731 PostCreation();
8bbe427f 2732
e380f72b 2733 Show( TRUE );
c801d85f 2734
e380f72b 2735 return TRUE;
362c6693 2736}
c801d85f 2737
1e6feb95 2738wxWindowGTK::~wxWindowGTK()
c801d85f 2739{
7de59551
RD		 2740 SendDestroyEvent();
2741
44cd54c2
JS		 2742 if (g_focusWindow == this)
2743 g_focusWindow = NULL;
2744
e8c12a53
VS		 2745 if (g_activeFrame == this)
2746 g_activeFrame = NULL;
2747
3e679f01
VZ		 2748 if ( g_delayedFocus == this )
2749 g_delayedFocus = NULL;
2750
31c6b4fc 2751 m_isBeingDeleted = TRUE;
43a18898 2752 m_hasVMT = FALSE;
47d67540 2753
f03fc89f
VZ		 2754 if (m_widget)
2755 Show( FALSE );
8bbe427f 2756
a2053b27
RR		 2757 DestroyChildren();
2758
63081513
RR		 2759#ifdef HAVE_XIM
2760 if (m_ic)
2761 gdk_ic_destroy (m_ic);
2762 if (m_icattr)
2763 gdk_ic_attr_destroy (m_icattr);
2764#endif
2765
f03fc89f 2766 if (m_widgetStyle)
a2053b27 2767 {
a56fcaaf 2768#if DISABLE_STYLE_IF_BROKEN_THEME
bce1406b
RR		 2769 // don't delete if it's a pixmap theme style
2770 if (!m_widgetStyle->engine_data)
2771 gtk_style_unref( m_widgetStyle );
1e6feb95 2772#endif
c50f1fb9 2773 m_widgetStyle = (GtkStyle*) NULL;
a2053b27 2774 }
c801d85f 2775
f03fc89f 2776 if (m_wxwindow)
a2053b27 2777 {
f03fc89f 2778 gtk_widget_destroy( m_wxwindow );
c50f1fb9 2779 m_wxwindow = (GtkWidget*) NULL;
a2053b27 2780 }
8bbe427f 2781
f03fc89f 2782 if (m_widget)
a2053b27 2783 {
f03fc89f 2784 gtk_widget_destroy( m_widget );
c50f1fb9 2785 m_widget = (GtkWidget*) NULL;
a2053b27 2786 }
362c6693 2787}
c801d85f 2788
1e6feb95 2789bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
c801d85f 2790{
223d09f6 2791 wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );
8bbe427f 2792
a7c26d10
RD		 2793 // Use either the given size, or the default if -1 is given.
2794 // See wxWindowBase for these functions.
3013a903 2795 m_width = WidthDefault(size.x) ;
f03fc89f 2796 m_height = HeightDefault(size.y);
8bbe427f 2797
43a18898
RR		 2798 m_x = (int)pos.x;
2799 m_y = (int)pos.y;
8bbe427f 2800
3013a903 2801 // some reasonable defaults
148cd9b6 2802 if (!parent)
6ca41e57 2803 {
43a18898
RR		 2804 if (m_x == -1)
2805 {
2806 m_x = (gdk_screen_width () - m_width) / 2;
2807 if (m_x < 10) m_x = 10;
2808 }
2809 if (m_y == -1)
2810 {
2811 m_y = (gdk_screen_height () - m_height) / 2;
2812 if (m_y < 10) m_y = 10;
2813 }
6ca41e57 2814 }
148cd9b6 2815
4dcaf11a 2816 return TRUE;
c801d85f
KB		 2817}
2818
1e6feb95 2819void wxWindowGTK::PostCreation()
c801d85f 2820{
223d09f6 2821 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
94633ad9 2822
43a18898
RR		 2823 if (m_wxwindow)
2824 {
147bc491 2825 if (!m_noExpose)
b02da6b1 2826 {
76fcf0f2 2827 // these get reported to wxWindows -> wxPaintEvent
1e6feb95 2828
b420fb6a
RR		 2829 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE );
2830
147bc491
RR		 2831 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
2832 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
2833
4e5a4c69 2834#ifndef __WXGTK20__
147bc491
RR		 2835 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
2836 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
0fc5dbf5 2837
e441e1f4 2838 if (!HasFlag(wxFULL_REPAINT_ON_RESIZE))
e22454be
RR		 2839 {
2840 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
2841 GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
2842 }
4e5a4c69 2843#else
e441e1f4 2844 // gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), !HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
2b5f62a0
VZ		 2845#endif
2846
2847#ifdef __WXGTK20__
2848 // Create input method handler
2849 m_imContext = (GtkIMMulticontext*) gtk_im_multicontext_new ();
2850
2851 // Cannot handle drawing preedited text yet
2852 gtk_im_context_set_use_preedit( (GtkIMContext*) m_imContext, FALSE );
2853
2854 g_signal_connect (G_OBJECT (m_imContext), "commit",
2855 G_CALLBACK (gtk_wxwindow_commit_cb), this);
4e5a4c69 2856#endif
b02da6b1 2857 }
148cd9b6 2858
67d78217 2859 // these are called when the "sunken" or "raised" borders are drawn
034be888
RR		 2860 gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
2861 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
2862
4e5a4c69 2863#ifndef __WXGTK20__
034be888
RR		 2864 gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
2865 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
4e5a4c69 2866#endif
43a18898 2867 }
47d67540 2868
76fcf0f2 2869 // focus handling
63081513 2870
76fcf0f2
RR		 2871 if (m_focusWidget == NULL)
2872 m_focusWidget = m_widget;
2daa0ce9 2873
76fcf0f2
RR		 2874 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event",
2875 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
2876
2877 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_out_event",
2878 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
2879
2880 // connect to the various key and mouse handlers
63081513 2881
a2053b27 2882 GtkWidget *connect_widget = GetConnectWidget();
f03fc89f 2883
a2053b27 2884 ConnectWidget( connect_widget );
47d67540 2885
63081513 2886 /* We cannot set colours, fonts and cursors before the widget has
a2053b27
RR		 2887 been realized, so we do this directly after realization */
2888 gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
c50f1fb9 2889 GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
2daa0ce9 2890
63081513
RR		 2891 if (m_wxwindow)
2892 {
47c93b63 2893 // Catch native resize events
8f75cb6c
RR		 2894 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2895 GTK_SIGNAL_FUNC(gtk_window_size_callback), (gpointer)this );
2daa0ce9 2896
47c93b63 2897 // Initialize XIM support
63081513
RR		 2898 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
2899 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback), (gpointer) this );
8f75cb6c 2900
47c93b63 2901 // And resize XIM window
b79395c5
RR		 2902 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2903 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this );
63081513 2904 }
2daa0ce9 2905
e1f448ee 2906 if ( !GTK_IS_COMBO(m_widget))
47c93b63
RR		 2907 {
2908 // This is needed if we want to add our windows into native
2909 // GTK control, such as the toolbar. With this callback, the
2910 // toolbar gets to know the correct size (the one set by the
2911 // programmer). Sadly, it misbehaves for wxComboBox. FIXME
2912 // when moving to GTK 2.0.
2913 gtk_signal_connect( GTK_OBJECT(m_widget), "size_request",
e1f448ee
VZ		 2914 GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback),
2915 (gpointer) this );
47c93b63 2916 }
1e6feb95 2917
43a18898 2918 m_hasVMT = TRUE;
b4071e91
RR		 2919}
2920
1e6feb95 2921void wxWindowGTK::ConnectWidget( GtkWidget *widget )
b4071e91 2922{
43a18898
RR		 2923 gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
2924 GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
c801d85f 2925
b666df2c
RR		 2926 gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
2927 GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
2928
43a18898
RR		 2929 gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
2930 GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
47d67540 2931
43a18898
RR		 2932 gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
2933 GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
47d67540 2934
43a18898
RR		 2935 gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
2936 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
47d67540 2937
557c9f5b
JS		 2938#ifdef __WXGTK20__
2939 gtk_signal_connect( GTK_OBJECT(widget), "scroll_event",
2940 GTK_SIGNAL_FUNC(gtk_window_wheel_callback), (gpointer)this );
2941#endif
2942
43a18898
RR		 2943 gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
2944 GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
47d67540 2945
43a18898
RR		 2946 gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
2947 GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
362c6693 2948}
c801d85f 2949
1e6feb95 2950bool wxWindowGTK::Destroy()
c801d85f 2951{
223d09f6 2952 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
47d67540 2953
43a18898 2954 m_hasVMT = FALSE;
c801d85f 2955
f03fc89f 2956 return wxWindowBase::Destroy();
362c6693 2957}
c801d85f 2958
1e6feb95 2959void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
23efdd02
RR		 2960{
2961 gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
2962}
2daa0ce9 2963
1e6feb95 2964void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
c801d85f 2965{
223d09f6 2966 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
1e6feb95 2967 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
8bbe427f 2968
33611ebb 2969/*
f94fca1b 2970 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
33611ebb
RR		 2971*/
2972
e27ce4e9 2973 if (m_resizing) return; /* I don't like recursions */
fb1585ae 2974 m_resizing = TRUE;
1e6feb95 2975
b9f29261
VS		 2976 int currentX, currentY;
2977 GetPosition(&currentX, &currentY);
443c834d 2978 if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
b9f29261 2979 x = currentX;
443c834d 2980 if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
b9f29261 2981 y = currentY;
a200c35e
VS		 2982 AdjustForParentClientOrigin(x, y, sizeFlags);
2983
a2053b27 2984 if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
fb1585ae 2985 {
e27ce4e9 2986 /* don't set the size for children of wxNotebook, just take the values. */
fb1585ae
RR		 2987 m_x = x;
2988 m_y = y;
2989 m_width = width;
ba4e3652 2990 m_height = height;
fb1585ae 2991 }
ba4e3652 2992 else
fb1585ae 2993 {
da048e3d 2994 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
85ad5eb5 2995 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
ba4e3652 2996 {
da048e3d
RR		 2997 if (x != -1) m_x = x + pizza->xoffset;
2998 if (y != -1) m_y = y + pizza->yoffset;
ba4e3652
RR		 2999 }
3000 else
3001 {
da048e3d
RR		 3002 m_x = x + pizza->xoffset;
3003 m_y = y + pizza->yoffset;
ba4e3652 3004 }
d44c23ce
RR		 3005 if (width != -1) m_width = width;
3006 if (height != -1) m_height = height;
47d67540 3007
ba4e3652
RR		 3008 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
3009 {
3010 if (width == -1) m_width = 80;
3011 }
3012
3013 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
3014 {
3015 if (height == -1) m_height = 26;
3016 }
8bbe427f 3017
e7dda1ff
VS		 3018 int minWidth = GetMinWidth(),
3019 minHeight = GetMinHeight(),
3020 maxWidth = GetMaxWidth(),
3021 maxHeight = GetMaxHeight();
3022
3023 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
3024 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
3025 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
3026 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
47d67540 3027
a2053b27 3028 int border = 0;
c50f1fb9 3029 int bottom_border = 0;
f03fc89f 3030
eb9e6a00 3031#ifndef __WXGTK20__
29f538ce 3032 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
c50f1fb9
VZ		 3033 {
3034 /* the default button has a border around it */
3035 border = 6;
3036 bottom_border = 5;
3037 }
67d78217 3038#endif
c50f1fb9 3039
23efdd02
RR		 3040 DoMoveWindow( m_x-border,
3041 m_y-border,
3042 m_width+2*border,
3043 m_height+border+bottom_border );
54517652 3044 }
148cd9b6 3045
5b8a521e
RR		 3046 if (m_hasScrolling)
3047 {
1e6feb95 3048 /* Sometimes the client area changes size without the
b6fa52db
RR		 3049 whole windows's size changing, but if the whole
3050 windows's size doesn't change, no wxSizeEvent will
3051 normally be sent. Here we add an extra test if
3052 the client test has been changed and this will
3053 be used then. */
5b8a521e
RR		 3054 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
3055 }
3056
54517652 3057/*
6d693bb4
RR		 3058 wxPrintf( "OnSize sent from " );
3059 if (GetClassInfo() && GetClassInfo()->GetClassName())
3060 wxPrintf( GetClassInfo()->GetClassName() );
3061 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
3062*/
3063
30760ce7
RR		 3064 if (!m_nativeSizeEvent)
3065 {
3066 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
3067 event.SetEventObject( this );
3068 GetEventHandler()->ProcessEvent( event );
3069 }
6d693bb4 3070
fb1585ae 3071 m_resizing = FALSE;
362c6693 3072}
c801d85f 3073
1e6feb95 3074void wxWindowGTK::OnInternalIdle()
9390a202 3075{
beab25bd 3076 // Update invalidated regions.
010afced 3077 GtkUpdate();
0fc5dbf5 3078
beab25bd 3079 // Synthetize activate events.
148cd9b6
VZ		 3080 if ( g_sendActivateEvent != -1 )
3081 {
3082 bool activate = g_sendActivateEvent != 0;
3083
3084 // do it only once
3085 g_sendActivateEvent = -1;
3086
1e6feb95 3087 wxTheApp->SetActive(activate, (wxWindow *)g_focusWindowLast);
148cd9b6
VZ		 3088 }
3089
e8c12a53
VS		 3090 if ( g_activeFrameLostFocus )
3091 {
3092 if ( g_activeFrame )
3093 {
45eb5249 3094 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame);
e8c12a53
VS		 3095 wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
3096 event.SetEventObject(g_activeFrame);
3097 g_activeFrame->GetEventHandler()->ProcessEvent(event);
3098 g_activeFrame = NULL;
3099 }
3100 g_activeFrameLostFocus = FALSE;
3101 }
2b5f62a0 3102
9146082c
RR		 3103 wxCursor cursor = m_cursor;
3104 if (g_globalCursor.Ok()) cursor = g_globalCursor;
c50f1fb9 3105
f7a11f8c 3106 if (cursor.Ok())
9146082c 3107 {
3017f78d 3108 /* I now set the cursor anew in every OnInternalIdle call
b02da6b1
VZ		 3109 as setting the cursor in a parent window also effects the
3110 windows above so that checking for the current cursor is
3111 not possible. */
148cd9b6 3112
9146082c 3113 if (m_wxwindow)
6a008b33 3114 {
da048e3d 3115 GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
6a008b33 3116 if (window)
c50f1fb9 3117 gdk_window_set_cursor( window, cursor.GetCursor() );
6a008b33
VZ		 3118
3119 if (!g_globalCursor.Ok())
3120 cursor = *wxSTANDARD_CURSOR;
3121
3122 window = m_widget->window;
5e014a0c 3123 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
9146082c 3124 gdk_window_set_cursor( window, cursor.GetCursor() );
5e014a0c 3125
6a008b33
VZ		 3126 }
3127 else
3128 {
5e014a0c 3129
9146082c 3130 GdkWindow *window = m_widget->window;
5e014a0c 3131 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
9146082c 3132 gdk_window_set_cursor( window, cursor.GetCursor() );
5e014a0c 3133
6a008b33 3134 }
9146082c 3135 }
6a008b33 3136
e39af974
JS		 3137 if (wxUpdateUIEvent::CanUpdate(this))
3138 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
9390a202
RR		 3139}
3140
1e6feb95 3141void wxWindowGTK::DoGetSize( int *width, int *height ) const
c801d85f 3142{
223d09f6 3143 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3144
fb1585ae
RR		 3145 if (width) (*width) = m_width;
3146 if (height) (*height) = m_height;
362c6693 3147}
c801d85f 3148
1e6feb95 3149void wxWindowGTK::DoSetClientSize( int width, int height )
c801d85f 3150{
223d09f6 3151 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3152
1ecc4d80 3153 if (!m_wxwindow)
c801d85f 3154 {
1ecc4d80 3155 SetSize( width, height );
c801d85f
KB		 3156 }
3157 else
3158 {
1ecc4d80
RR		 3159 int dw = 0;
3160 int dh = 0;
3161
1e6feb95 3162#ifndef __WXUNIVERSAL__
98d3fdbe
RR		 3163 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
3164 {
5e014a0c 3165 /* when using GTK 1.2 we set the shadow border size to 2 */
6a008b33 3166 dw += 2 * 2;
98d3fdbe
RR		 3167 dh += 2 * 2;
3168 }
5e014a0c
RR		 3169 if (HasFlag(wxSIMPLE_BORDER))
3170 {
3171 /* when using GTK 1.2 we set the simple border size to 1 */
3172 dw += 1 * 2;
3173 dh += 1 * 2;
3174 }
1e6feb95 3175#endif // __WXUNIVERSAL__
034be888 3176
5b8a521e 3177 if (m_hasScrolling)
98d3fdbe 3178 {
324dbfec 3179 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2daa0ce9 3180
9000c624
RR		 3181 GtkRequisition vscroll_req;
3182 vscroll_req.width = 2;
3183 vscroll_req.height = 2;
dd00f3f6 3184 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
9000c624 3185 (scroll_window->vscrollbar, &vscroll_req );
2daa0ce9 3186
9000c624
RR		 3187 GtkRequisition hscroll_req;
3188 hscroll_req.width = 2;
3189 hscroll_req.height = 2;
dd00f3f6 3190 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
9000c624
RR		 3191 (scroll_window->hscrollbar, &hscroll_req );
3192
dd00f3f6 3193 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
324dbfec 3194
1ecc4d80
RR		 3195 if (scroll_window->vscrollbar_visible)
3196 {
9000c624 3197 dw += vscroll_req.width;
1ecc4d80
RR		 3198 dw += scroll_class->scrollbar_spacing;
3199 }
3200
3201 if (scroll_window->hscrollbar_visible)
3202 {
9000c624 3203 dh += hscroll_req.height;
63cc5d9d 3204 dh += scroll_class->scrollbar_spacing;
1ecc4d80 3205 }
9000c624 3206 }
1ecc4d80 3207
034be888 3208 SetSize( width+dw, height+dh );
1ecc4d80 3209 }
362c6693 3210}
c801d85f 3211
1e6feb95 3212void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
c801d85f 3213{
223d09f6 3214 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3215
1ecc4d80
RR		 3216 if (!m_wxwindow)
3217 {
3218 if (width) (*width) = m_width;
3219 if (height) (*height) = m_height;
c801d85f
KB		 3220 }
3221 else
3222 {
1ecc4d80
RR		 3223 int dw = 0;
3224 int dh = 0;
3225
1e6feb95 3226#ifndef __WXUNIVERSAL__
98d3fdbe
RR		 3227 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
3228 {
5e014a0c 3229 /* when using GTK 1.2 we set the shadow border size to 2 */
6a008b33 3230 dw += 2 * 2;
98d3fdbe
RR		 3231 dh += 2 * 2;
3232 }
5e014a0c
RR		 3233 if (HasFlag(wxSIMPLE_BORDER))
3234 {
3235 /* when using GTK 1.2 we set the simple border size to 1 */
3236 dw += 1 * 2;
3237 dh += 1 * 2;
3238 }
1e6feb95 3239#endif // __WXUNIVERSAL__
9000c624 3240
5b8a521e 3241 if (m_hasScrolling)
98d3fdbe 3242 {
6a008b33 3243 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2daa0ce9 3244
9000c624
RR		 3245 GtkRequisition vscroll_req;
3246 vscroll_req.width = 2;
3247 vscroll_req.height = 2;
dd00f3f6 3248 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
9000c624 3249 (scroll_window->vscrollbar, &vscroll_req );
2daa0ce9 3250
9000c624
RR		 3251 GtkRequisition hscroll_req;
3252 hscroll_req.width = 2;
3253 hscroll_req.height = 2;
dd00f3f6 3254 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
9000c624
RR		 3255 (scroll_window->hscrollbar, &hscroll_req );
3256
dd00f3f6 3257 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
6a008b33 3258
1ecc4d80
RR		 3259 if (scroll_window->vscrollbar_visible)
3260 {
9000c624 3261 dw += vscroll_req.width;
1ecc4d80
RR		 3262 dw += scroll_class->scrollbar_spacing;
3263 }
3264
3265 if (scroll_window->hscrollbar_visible)
3266 {
9000c624 3267 dh += hscroll_req.height;
1ecc4d80
RR		 3268 dh += scroll_class->scrollbar_spacing;
3269 }
6a008b33 3270 }
47d67540 3271
1ecc4d80
RR		 3272 if (width) (*width) = m_width - dw;
3273 if (height) (*height) = m_height - dh;
3274 }
1e6feb95 3275
f94fca1b
RR		 3276/*
3277 printf( "GetClientSize, name %s ", GetName().c_str() );
3278 if (width) printf( " width = %d", (*width) );
3279 if (height) printf( " height = %d", (*height) );
3280 printf( "\n" );
3281*/
362c6693 3282}
c801d85f 3283
1e6feb95 3284void wxWindowGTK::DoGetPosition( int *x, int *y ) const
c801d85f 3285{
223d09f6 3286 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3287
bf0c00c6
RR		 3288 int dx = 0;
3289 int dy = 0;
3290 if (m_parent && m_parent->m_wxwindow)
3291 {
da048e3d 3292 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
b02da6b1
VZ		 3293 dx = pizza->xoffset;
3294 dy = pizza->yoffset;
bf0c00c6 3295 }
94633ad9 3296
496beb3f
VS		 3297 if (x) (*x) = m_x - dx;
3298 if (y) (*y) = m_y - dy;
362c6693 3299}
c801d85f 3300
1e6feb95 3301void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
c801d85f 3302{
223d09f6 3303 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3304
a2053b27
RR		 3305 if (!m_widget->window) return;
3306
43a18898
RR		 3307 GdkWindow *source = (GdkWindow *) NULL;
3308 if (m_wxwindow)
da048e3d 3309 source = GTK_PIZZA(m_wxwindow)->bin_window;
43a18898
RR		 3310 else
3311 source = m_widget->window;
47d67540 3312
43a18898
RR		 3313 int org_x = 0;
3314 int org_y = 0;
3315 gdk_window_get_origin( source, &org_x, &org_y );
c801d85f 3316
43a18898 3317 if (!m_wxwindow)
c801d85f 3318 {
43a18898
RR		 3319 if (GTK_WIDGET_NO_WINDOW (m_widget))
3320 {
3321 org_x += m_widget->allocation.x;
3322 org_y += m_widget->allocation.y;
3323 }
362c6693 3324 }
47d67540 3325
43a18898
RR		 3326 if (x) *x += org_x;
3327 if (y) *y += org_y;
362c6693 3328}
c801d85f 3329
1e6feb95 3330void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
c801d85f 3331{
223d09f6 3332 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3333
a2053b27
RR		 3334 if (!m_widget->window) return;
3335
1ecc4d80
RR		 3336 GdkWindow *source = (GdkWindow *) NULL;
3337 if (m_wxwindow)
da048e3d 3338 source = GTK_PIZZA(m_wxwindow)->bin_window;
1ecc4d80
RR		 3339 else
3340 source = m_widget->window;
47d67540 3341
1ecc4d80
RR		 3342 int org_x = 0;
3343 int org_y = 0;
3344 gdk_window_get_origin( source, &org_x, &org_y );
c801d85f 3345
1ecc4d80 3346 if (!m_wxwindow)
c801d85f 3347 {
1ecc4d80
RR		 3348 if (GTK_WIDGET_NO_WINDOW (m_widget))
3349 {
3350 org_x += m_widget->allocation.x;
3351 org_y += m_widget->allocation.y;
3352 }
362c6693 3353 }
47d67540 3354
1ecc4d80
RR		 3355 if (x) *x -= org_x;
3356 if (y) *y -= org_y;
362c6693 3357}
c801d85f 3358
1e6feb95 3359bool wxWindowGTK::Show( bool show )
c801d85f 3360{
223d09f6 3361 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
47d67540 3362
739730ca
RR		 3363 if (!wxWindowBase::Show(show))
3364 {
3365 // nothing to do
f03fc89f 3366 return FALSE;
739730ca 3367 }
8bbe427f 3368
f03fc89f
VZ		 3369 if (show)
3370 gtk_widget_show( m_widget );
1ecc4d80 3371 else
f03fc89f 3372 gtk_widget_hide( m_widget );
8bbe427f 3373
2b5f62a0
VZ		 3374 wxShowEvent eventShow(GetId(), show);
3375 eventShow.m_eventObject = this;
3376
3377 GetEventHandler()->ProcessEvent(eventShow);
3378
f03fc89f 3379 return TRUE;
362c6693 3380}
c801d85f 3381
3379ed37 3382static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable)
fdca68a6
JS		 3383{
3384 win->OnParentEnable(enable);
3385
3386 // Recurse, so that children have the opportunity to Do The Right Thing
3387 // and reset colours that have been messed up by a parent's (really ancestor's)
3388 // Enable call
222ed1d6 3389 for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
fdca68a6
JS		 3390 node;
3391 node = node->GetNext() )
3392 {
3393 wxWindow *child = node->GetData();
3394 if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame)))
3395 wxWindowNotifyEnable(child, enable);
3396 }
3397}
3398
3379ed37 3399bool wxWindowGTK::Enable( bool enable )
c801d85f 3400{
223d09f6 3401 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
5e0aa05a 3402
739730ca
RR		 3403 if (!wxWindowBase::Enable(enable))
3404 {
3405 // nothing to do
f03fc89f 3406 return FALSE;
739730ca 3407 }
1ecc4d80 3408
f03fc89f
VZ		 3409 gtk_widget_set_sensitive( m_widget, enable );
3410 if ( m_wxwindow )
3411 gtk_widget_set_sensitive( m_wxwindow, enable );
ff8bfdbb 3412
fdca68a6 3413 wxWindowNotifyEnable(this, enable);
513903c4 3414
f03fc89f 3415 return TRUE;
362c6693 3416}
c801d85f 3417
1e6feb95 3418int wxWindowGTK::GetCharHeight() const
2f2aa628 3419{
223d09f6 3420 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
47d67540 3421
223d09f6 3422 wxCHECK_MSG( m_font.Ok(), 12, wxT("invalid font") );
2f2aa628 3423
bbd006c0
RR		 3424#ifdef __WXGTK20__
3425 PangoContext *context = NULL;
3426 if (m_widget)
3427 context = gtk_widget_get_pango_context( m_widget );
3428
3429 if (!context)
3430 return 0;
3431
3432 PangoFontDescription *desc = m_font.GetNativeFontInfo()->description;
3433 PangoLayout *layout = pango_layout_new(context);
3434 pango_layout_set_font_description(layout, desc);
3435 pango_layout_set_text(layout, "H", 1);
3436 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3437
3438 PangoRectangle rect;
3439 pango_layout_line_get_extents(line, NULL, &rect);
3440
3441 g_object_unref( G_OBJECT( layout ) );
7de59551 3442
bbd006c0
RR		 3443 return (int) (rect.height / PANGO_SCALE);
3444#else
f03fc89f
VZ		 3445 GdkFont *font = m_font.GetInternalFont( 1.0 );
3446
3447 return font->ascent + font->descent;
bbd006c0 3448#endif
362c6693 3449}
c801d85f 3450
1e6feb95 3451int wxWindowGTK::GetCharWidth() const
c33c4050 3452{
223d09f6 3453 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
47d67540 3454
223d09f6 3455 wxCHECK_MSG( m_font.Ok(), 8, wxT("invalid font") );
47d67540 3456
bbd006c0
RR		 3457#ifdef __WXGTK20__
3458 PangoContext *context = NULL;
3459 if (m_widget)
3460 context = gtk_widget_get_pango_context( m_widget );
3461
3462 if (!context)
3463 return 0;
3464
3465 PangoFontDescription *desc = m_font.GetNativeFontInfo()->description;
3466 PangoLayout *layout = pango_layout_new(context);
3467 pango_layout_set_font_description(layout, desc);
95c430aa 3468 pango_layout_set_text(layout, "g", 1);
bbd006c0
RR		 3469 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3470
3471 PangoRectangle rect;
3472 pango_layout_line_get_extents(line, NULL, &rect);
3473
3474 g_object_unref( G_OBJECT( layout ) );
7de59551 3475
bbd006c0
RR		 3476 return (int) (rect.width / PANGO_SCALE);
3477#else
463c1fa1 3478 GdkFont *font = m_font.GetInternalFont( 1.0 );
ff8bfdbb 3479
95c430aa 3480 return gdk_string_width( font, "g" );
bbd006c0 3481#endif
c33c4050
RR		 3482}
3483
1e6feb95 3484void wxWindowGTK::GetTextExtent( const wxString& string,
f03fc89f
VZ		 3485 int *x,
3486 int *y,
3487 int *descent,
3488 int *externalLeading,
3489 const wxFont *theFont ) const
c33c4050 3490{
463c1fa1
RR		 3491 wxFont fontToUse = m_font;
3492 if (theFont) fontToUse = *theFont;
47d67540 3493
223d09f6 3494 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
2b5f62a0 3495
48d011c8
RR		 3496 if (string.IsEmpty())
3497 {
b15ed747
RR		 3498 if (x) (*x) = 0;
3499 if (y) (*y) = 0;
48d011c8
RR		 3500 return;
3501 }
47d67540 3502
2b5f62a0 3503#ifdef __WXGTK20__
48d011c8
RR		 3504 PangoContext *context = NULL;
3505 if (m_widget)
2b5f62a0
VZ		 3506 context = gtk_widget_get_pango_context( m_widget );
3507
48d011c8
RR		 3508 if (!context)
3509 {
b15ed747
RR		 3510 if (x) (*x) = 0;
3511 if (y) (*y) = 0;
48d011c8
RR		 3512 return;
3513 }
2b5f62a0 3514
48d011c8
RR		 3515 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
3516 PangoLayout *layout = pango_layout_new(context);
3517 pango_layout_set_font_description(layout, desc);
3518 {
fb3ed106 3519#if wxUSE_UNICODE
48d011c8
RR		 3520 const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
3521 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
fb3ed106
RR		 3522#else
3523 const wxWCharBuffer wdata = wxConvLocal.cMB2WC( string );
3524 const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
3525 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
3526#endif
48d011c8
RR		 3527 }
3528 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2b5f62a0 3529
48d011c8
RR		 3530 PangoRectangle rect;
3531 pango_layout_line_get_extents(line, NULL, &rect);
2b5f62a0 3532
b15ed747
RR		 3533 if (x) (*x) = (wxCoord) (rect.width / PANGO_SCALE);
3534 if (y) (*y) = (wxCoord) (rect.height / PANGO_SCALE);
48d011c8
RR		 3535 if (descent)
3536 {
3537 // Do something about metrics here
3538 (*descent) = 0;
3539 }
3540 if (externalLeading) (*externalLeading) = 0; // ??
2b5f62a0 3541
48d011c8
RR		 3542 g_object_unref( G_OBJECT( layout ) );
3543#else
463c1fa1 3544 GdkFont *font = fontToUse.GetInternalFont( 1.0 );
fab591c5 3545 if (x) (*x) = gdk_string_width( font, wxGTK_CONV( string ) );
463c1fa1
RR		 3546 if (y) (*y) = font->ascent + font->descent;
3547 if (descent) (*descent) = font->descent;
3548 if (externalLeading) (*externalLeading) = 0; // ??
48d011c8 3549#endif
c33c4050
RR		 3550}
3551
1e6feb95 3552void wxWindowGTK::SetFocus()
c801d85f 3553{
6cad4f1b
VZ		 3554 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3555
3556 if ( m_hasFocus )
3557 {
3558 // don't do anything if we already have focus
3559 return;
3560 }
2daa0ce9 3561
354aa1e3
RR		 3562 if (m_wxwindow)
3563 {
173348db 3564 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
b231914f 3565 {
173348db 3566 gtk_widget_grab_focus (m_wxwindow);
b231914f 3567 }
354aa1e3 3568 }
b231914f 3569 else if (m_widget)
c801d85f 3570 {
173348db 3571 if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
463c1fa1 3572 {
d7fa7eaa 3573 if (!GTK_WIDGET_REALIZED(m_widget))
6aeb6f2a 3574 {
6cad4f1b
VZ		 3575 // we can't set the focus to the widget now so we remember that
3576 // it should be focused and will do it later, during the idle
3577 // time, as soon as we can
3578 wxLogTrace(TRACE_FOCUS,
3579 _T("Delaying setting focus to %s(%s)"),
6aeb6f2a
VZ		 3580 GetClassInfo()->GetClassName(), GetLabel().c_str());
3581
d7fa7eaa 3582 g_delayedFocus = this;
6aeb6f2a 3583 }
d7fa7eaa 3584 else
6aeb6f2a 3585 {
6cad4f1b
VZ		 3586 wxLogTrace(TRACE_FOCUS,
3587 _T("Setting focus to %s(%s)"),
6aeb6f2a
VZ		 3588 GetClassInfo()->GetClassName(), GetLabel().c_str());
3589
d7fa7eaa 3590 gtk_widget_grab_focus (m_widget);
6aeb6f2a 3591 }
463c1fa1 3592 }
354aa1e3 3593 else if (GTK_IS_CONTAINER(m_widget))
ff8bfdbb 3594 {
9e691f46 3595 SET_CONTAINER_FOCUS( m_widget, GTK_DIR_TAB_FORWARD );
ff8bfdbb
VZ		 3596 }
3597 else
3598 {
6cad4f1b
VZ		 3599 wxLogTrace(TRACE_FOCUS,
3600 _T("Can't set focus to %s(%s)"),
3601 GetClassInfo()->GetClassName(), GetLabel().c_str());
ff8bfdbb 3602 }
362c6693 3603 }
362c6693 3604}
c801d85f 3605
1e6feb95 3606bool wxWindowGTK::AcceptsFocus() const
b292e2f5 3607{
f03fc89f 3608 return m_acceptsFocus && wxWindowBase::AcceptsFocus();
b292e2f5
RR		 3609}
3610
1e6feb95 3611bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
463c1fa1 3612{
223d09f6 3613 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
c50f1fb9 3614
1e6feb95
VZ		 3615 wxWindowGTK *oldParent = m_parent,
3616 *newParent = (wxWindowGTK *)newParentBase;
a2053b27 3617
5fd11f09
RR		 3618 wxASSERT( GTK_IS_WIDGET(m_widget) );
3619
f03fc89f
VZ		 3620 if ( !wxWindowBase::Reparent(newParent) )
3621 return FALSE;
8bbe427f 3622
5fd11f09
RR		 3623 wxASSERT( GTK_IS_WIDGET(m_widget) );
3624
3625 /* prevent GTK from deleting the widget arbitrarily */
3626 gtk_widget_ref( m_widget );
3627
8ce63e9d
RR		 3628 if (oldParent)
3629 {
3017f78d 3630 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
8ce63e9d 3631 }
c50f1fb9 3632
5fd11f09
RR		 3633 wxASSERT( GTK_IS_WIDGET(m_widget) );
3634
8ce63e9d
RR		 3635 if (newParent)
3636 {
3637 /* insert GTK representation */
3638 (*(newParent->m_insertCallback))(newParent, this);
3639 }
c50f1fb9 3640
5fd11f09
RR		 3641 /* reverse: prevent GTK from deleting the widget arbitrarily */
3642 gtk_widget_unref( m_widget );
148cd9b6 3643
f03fc89f 3644 return TRUE;
362c6693 3645}
c801d85f 3646
1e6feb95 3647void wxWindowGTK::DoAddChild(wxWindowGTK *child)
ddb6bc71 3648{
223d09f6 3649 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
ddb6bc71 3650
223d09f6 3651 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
ddb6bc71 3652
223d09f6 3653 wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
c50f1fb9 3654
ddb6bc71
RR		 3655 /* add to list */
3656 AddChild( child );
c50f1fb9 3657
ddb6bc71
RR		 3658 /* insert GTK representation */
3659 (*m_insertCallback)(this, child);
3660}
3661
1e6feb95 3662void wxWindowGTK::Raise()
362c6693 3663{
223d09f6 3664 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3665
a2053b27
RR		 3666 if (!m_widget->window) return;
3667
f03fc89f 3668 gdk_window_raise( m_widget->window );
362c6693
RR		 3669}
3670
1e6feb95 3671void wxWindowGTK::Lower()
362c6693 3672{
223d09f6 3673 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3674
a2053b27
RR		 3675 if (!m_widget->window) return;
3676
f03fc89f 3677 gdk_window_lower( m_widget->window );
362c6693 3678}
c801d85f 3679
1e6feb95 3680bool wxWindowGTK::SetCursor( const wxCursor &cursor )
86b29a61 3681{
223d09f6 3682 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
86b29a61 3683
f6bcfd97
BP		 3684 if (cursor == m_cursor)
3685 return FALSE;
3686
3687 if (g_isIdle)
3688 wxapp_install_idle_handler();
1e6feb95 3689
f6bcfd97
BP		 3690 if (cursor == wxNullCursor)
3691 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR );
3692 else
3693 return wxWindowBase::SetCursor( cursor );
362c6693 3694}
c801d85f 3695
1e6feb95 3696void wxWindowGTK::WarpPointer( int x, int y )
4f22cf8d 3697{
223d09f6 3698 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
85eb36c2 3699
3bcc8d15
RR		 3700 // We provide this function ourselves as it is
3701 // missing in GDK (top of this file).
148cd9b6 3702
ed673c6a
RR		 3703 GdkWindow *window = (GdkWindow*) NULL;
3704 if (m_wxwindow)
da048e3d 3705 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a
RR		 3706 else
3707 window = GetConnectWidget()->window;
148cd9b6 3708
ed673c6a
RR		 3709 if (window)
3710 gdk_window_warp_pointer( window, x, y );
4f22cf8d
RR		 3711}
3712
3013a903 3713
1e6feb95 3714void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
c801d85f 3715{
f2593d0d 3716 if (!m_widget) return;
a2053b27 3717 if (!m_widget->window) return;
2b5f62a0 3718
4e5a4c69 3719#ifndef __WXGTK20__
ea323db3
RR		 3720 if (g_isIdle)
3721 wxapp_install_idle_handler();
2b5f62a0 3722
75625d79
SN		 3723 wxRect myRect(0,0,0,0);
3724 if (m_wxwindow && rect)
3725 {
3726 myRect.SetSize(wxSize( m_wxwindow->allocation.width,
3727 m_wxwindow->allocation.height));
3728 myRect.Intersect(*rect);
3729 if (!myRect.width || !myRect.height)
3730 // nothing to do, rectangle is empty
3731 return;
3732 rect = &myRect;
3733 }
3734
139adb6a 3735 if (eraseBackground && m_wxwindow && m_wxwindow->window)
c801d85f 3736 {
139adb6a
RR		 3737 if (rect)
3738 {
3bcc8d15
RR		 3739 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3740 m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
139adb6a
RR		 3741 }
3742 else
3743 {
3bcc8d15
RR		 3744 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3745 m_clearRegion.Clear();
3746 m_clearRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
139adb6a
RR		 3747 }
3748 }
ff8bfdbb 3749
3bcc8d15 3750 if (rect)
139adb6a
RR		 3751 {
3752 if (m_wxwindow)
b02da6b1 3753 {
23716407 3754 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3bcc8d15 3755 m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
b02da6b1 3756 }
ff8bfdbb 3757 else
b6fa52db 3758 {
3bcc8d15
RR		 3759 GdkRectangle gdk_rect;
3760 gdk_rect.x = rect->x;
3761 gdk_rect.y = rect->y;
3762 gdk_rect.width = rect->width;
3763 gdk_rect.height = rect->height;
3764 gtk_widget_draw( m_widget, &gdk_rect );
b6fa52db 3765 }
362c6693 3766 }
c801d85f 3767 else
139adb6a 3768 {
139adb6a 3769 if (m_wxwindow)
b02da6b1 3770 {
23716407 3771 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3bcc8d15
RR		 3772 m_updateRegion.Clear();
3773 m_updateRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
b02da6b1 3774 }
139adb6a 3775 else
b6fa52db 3776 {
3bcc8d15 3777 gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
b6fa52db 3778 }
139adb6a 3779 }
4e5a4c69
RR		 3780#else
3781 if (m_wxwindow)
3782 {
3783 if (rect)
3784 {
3785 GdkRectangle gdk_rect;
3786 gdk_rect.x = rect->x;
3787 gdk_rect.y = rect->y;
3788 gdk_rect.width = rect->width;
3789 gdk_rect.height = rect->height;
3790 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, &gdk_rect, TRUE );
3791 }
3792 else
3793 {
3794 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, NULL, TRUE );
3795 }
3796 }
3797#endif
362c6693 3798}
c801d85f 3799
beab25bd 3800void wxWindowGTK::Update()
010afced
RR		 3801{
3802 GtkUpdate();
3803}
3804
3805void wxWindowGTK::GtkUpdate()
beab25bd 3806{
4e5a4c69
RR		 3807#ifdef __WXGTK20__
3808 if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
3809 gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );
b15ed747 3810#else
beab25bd 3811 if (!m_updateRegion.IsEmpty())
23716407 3812 GtkSendPaintEvents();
b15ed747 3813#endif
beab25bd
RR		 3814}
3815
3816void wxWindowGTK::GtkSendPaintEvents()
3817{
3bcc8d15
RR		 3818 if (!m_wxwindow)
3819 {
2b5f62a0 3820#ifndef __WXGTK20__
3bcc8d15 3821 m_clearRegion.Clear();
b15ed747 3822#endif
3bcc8d15
RR		 3823 m_updateRegion.Clear();
3824 return;
3825 }
beab25bd 3826
f90566f5 3827 // Clip to paint region in wxClientDC
3bcc8d15 3828 m_clipPaintRegion = TRUE;
fab591c5 3829
b15ed747
RR		 3830#ifndef __WXGTK20__
3831 // widget to draw on
3832 GtkPizza *pizza = GTK_PIZZA (m_wxwindow);
2b5f62a0 3833
b15ed747 3834 // later for GTK 2.0, too.
f90566f5
RR		 3835 if (GetThemeEnabled())
3836 {
3837 // find ancestor from which to steal background
3838 wxWindow *parent = GetParent();
3839 while (parent && !parent->IsTopLevel())
3840 parent = parent->GetParent();
3841 if (!parent)
cc06fe74 3842 parent = (wxWindow*)this;
2b5f62a0 3843
f90566f5
RR		 3844 wxRegionIterator upd( m_updateRegion );
3845 while (upd)
3846 {
3847 GdkRectangle rect;
3848 rect.x = upd.GetX();
3849 rect.y = upd.GetY();
3850 rect.width = upd.GetWidth();
3851 rect.height = upd.GetHeight();
2b5f62a0 3852
f90566f5
RR		 3853 gtk_paint_flat_box( parent->m_widget->style,
3854 pizza->bin_window,
3855 GTK_STATE_NORMAL,
3856 GTK_SHADOW_NONE,
3857 &rect,
3858 parent->m_widget,
3859 (char *)"base",
3860 0, 0, -1, -1 );
2b5f62a0 3861
f90566f5
RR		 3862 upd ++;
3863 }
3864 }
3865 else
fab591c5 3866#endif
b15ed747
RR		 3867
3868#ifdef __WXGTK20__
3869 {
3870 wxWindowDC dc( (wxWindow*)this );
3871 dc.SetClippingRegion( m_updateRegion );
3872
3873 wxEraseEvent erase_event( GetId(), &dc );
3874 erase_event.SetEventObject( this );
3875
3876 GetEventHandler()->ProcessEvent(erase_event);
3877 }
3878#else
3879 // if (!m_clearRegion.IsEmpty()) // Always send an erase event under GTK 1.2
beab25bd 3880 {
3bcc8d15 3881 wxWindowDC dc( (wxWindow*)this );
62cb3cd8
RR		 3882 if (m_clearRegion.IsEmpty())
3883 dc.SetClippingRegion( m_updateRegion );
3884 else
3885 dc.SetClippingRegion( m_clearRegion );
0fc5dbf5 3886
3bcc8d15
RR		 3887 wxEraseEvent erase_event( GetId(), &dc );
3888 erase_event.SetEventObject( this );
0fc5dbf5 3889
beab25bd
RR		 3890 if (!GetEventHandler()->ProcessEvent(erase_event))
3891 {
994bc575
RR		 3892 if (!g_eraseGC)
3893 {
f90566f5 3894 g_eraseGC = gdk_gc_new( pizza->bin_window );
994bc575
RR		 3895 gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
3896 }
4e5a4c69 3897 gdk_gc_set_foreground( g_eraseGC, m_backgroundColour.GetColor() );
0fc5dbf5 3898
3bcc8d15 3899 wxRegionIterator upd( m_clearRegion );
beab25bd
RR		 3900 while (upd)
3901 {
f90566f5
RR		 3902 gdk_draw_rectangle( pizza->bin_window, g_eraseGC, 1,
3903 upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
beab25bd
RR		 3904 upd ++;
3905 }
3906 }
3bcc8d15 3907 m_clearRegion.Clear();
beab25bd 3908 }
b15ed747 3909#endif
beab25bd
RR		 3910
3911 wxNcPaintEvent nc_paint_event( GetId() );
3912 nc_paint_event.SetEventObject( this );
3913 GetEventHandler()->ProcessEvent( nc_paint_event );
3914
3915 wxPaintEvent paint_event( GetId() );
3916 paint_event.SetEventObject( this );
3917 GetEventHandler()->ProcessEvent( paint_event );
3918
beab25bd 3919 m_clipPaintRegion = FALSE;
c89f5c02 3920
8f3e7ecc 3921#ifndef __WXUNIVERSAL__
4e5a4c69 3922#ifndef __WXGTK20__
8f3e7ecc
RR		 3923 // The following code will result in all window-less widgets
3924 // being redrawn because the wxWindows class is allowed to
3925 // paint over the window-less widgets.
0fc5dbf5 3926
8f3e7ecc
RR		 3927 GList *children = pizza->children;
3928 while (children)
c89f5c02 3929 {
8f3e7ecc
RR		 3930 GtkPizzaChild *child = (GtkPizzaChild*) children->data;
3931 children = children->next;
2b5f62a0 3932
8f3e7ecc
RR		 3933 if (GTK_WIDGET_NO_WINDOW (child->widget) &&
3934 GTK_WIDGET_DRAWABLE (child->widget))
3935 {
3936 // Get intersection of widget area and update region
3937 wxRegion region( m_updateRegion );
0fc5dbf5 3938
8f3e7ecc
RR		 3939 GdkEventExpose gdk_event;
3940 gdk_event.type = GDK_EXPOSE;
3941 gdk_event.window = pizza->bin_window;
3942 gdk_event.count = 0;
0fc5dbf5 3943
8f3e7ecc
RR		 3944 wxRegionIterator upd( m_updateRegion );
3945 while (upd)
c89f5c02 3946 {
8f3e7ecc
RR		 3947 GdkRectangle rect;
3948 rect.x = upd.GetX();
3949 rect.y = upd.GetY();
3950 rect.width = upd.GetWidth();
3951 rect.height = upd.GetHeight();
0fc5dbf5 3952
8f3e7ecc
RR		 3953 if (gtk_widget_intersect (child->widget, &rect, &gdk_event.area))
3954 {
3955 gtk_widget_event (child->widget, (GdkEvent*) &gdk_event);
3956 }
0fc5dbf5 3957
8f3e7ecc 3958 upd ++;
c89f5c02
RR		 3959 }
3960 }
3961 }
4e5a4c69 3962#endif
8f3e7ecc 3963#endif
c89f5c02
RR		 3964
3965 m_updateRegion.Clear();
beab25bd
RR		 3966}
3967
596f1d11 3968void wxWindowGTK::ClearBackground()
c801d85f 3969{
223d09f6 3970 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
47d67540 3971
b15ed747 3972#ifndef __WXGTK20__
f234c60c
RR		 3973 if (m_wxwindow && m_wxwindow->window)
3974 {
d7fa7eaa
RR		 3975 m_clearRegion.Clear();
3976 wxSize size( GetClientSize() );
3977 m_clearRegion.Union( 0,0,size.x,size.y );
2b5f62a0 3978
d7fa7eaa 3979 // Better do this in idle?
010afced 3980 GtkUpdate();
f234c60c 3981 }
b15ed747 3982#endif
362c6693 3983}
c801d85f 3984
ff8bfdbb 3985#if wxUSE_TOOLTIPS
1e6feb95 3986void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
b1170810 3987{
f03fc89f 3988 wxWindowBase::DoSetToolTip(tip);
ff8bfdbb 3989
f03fc89f 3990 if (m_tooltip)
3379ed37 3991 m_tooltip->Apply( (wxWindow *)this );
b1170810
RR		 3992}
3993
1e6feb95 3994void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
b1170810 3995{
dcf924a3 3996 gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
301cd871 3997}
ff8bfdbb 3998#endif // wxUSE_TOOLTIPS
b1170810 3999
ea323db3
RR		 4000void wxWindowGTK::GtkSetBackgroundColour( const wxColour &colour )
4001{
4002 GdkWindow *window = (GdkWindow*) NULL;
4003 if (m_wxwindow)
4004 window = GTK_PIZZA(m_wxwindow)->bin_window;
4005 else
4006 window = GetConnectWidget()->window;
4007
4008 wxASSERT( window );
2b5f62a0 4009
ea323db3
RR		 4010 // We need the pixel value e.g. for background clearing.
4011 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
2b5f62a0 4012
f90566f5 4013 if (m_wxwindow)
ea323db3 4014 {
f90566f5 4015 // wxMSW doesn't clear the window here, either.
ea323db3
RR		 4016 gdk_window_set_background( window, m_backgroundColour.GetColor() );
4017 }
4018
4019 ApplyWidgetStyle();
4020}
4021
1e6feb95 4022bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
c801d85f 4023{
223d09f6 4024 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
8bbe427f 4025
739730ca 4026 if (!wxWindowBase::SetBackgroundColour(colour))
ea323db3 4027 return FALSE;
c50f1fb9 4028
ed673c6a
RR		 4029 GdkWindow *window = (GdkWindow*) NULL;
4030 if (m_wxwindow)
da048e3d 4031 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a
RR		 4032 else
4033 window = GetConnectWidget()->window;
148cd9b6 4034
ed673c6a 4035 if (!window)
739730ca
RR		 4036 {
4037 // indicate that a new style has been set
c50f1fb9
VZ		 4038 // but it couldn't get applied as the
4039 // widget hasn't been realized yet.
4040 m_delayedBackgroundColour = TRUE;
ea323db3 4041 return TRUE;
739730ca 4042 }
ea323db3 4043 else
994bc575 4044 {
ea323db3 4045 GtkSetBackgroundColour( colour );
994bc575 4046 }
ca298c88 4047
ea323db3
RR		 4048 return TRUE;
4049}
8bbe427f 4050
ea323db3
RR		 4051void wxWindowGTK::GtkSetForegroundColour( const wxColour &colour )
4052{
4053 GdkWindow *window = (GdkWindow*) NULL;
4054 if (m_wxwindow)
4055 window = GTK_PIZZA(m_wxwindow)->bin_window;
4056 else
4057 window = GetConnectWidget()->window;
c801d85f 4058
ea323db3
RR		 4059 wxASSERT( window );
4060
4061 ApplyWidgetStyle();
6de97a3b
RR		 4062}
4063
1e6feb95 4064bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
6de97a3b 4065{
223d09f6 4066 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
8bbe427f 4067
739730ca
RR		 4068 if (!wxWindowBase::SetForegroundColour(colour))
4069 {
4070 // don't leave if the GTK widget has just
4071 // been realized
4072 if (!m_delayedForegroundColour) return FALSE;
4073 }
c50f1fb9 4074
ed673c6a
RR		 4075 GdkWindow *window = (GdkWindow*) NULL;
4076 if (m_wxwindow)
da048e3d 4077 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a
RR		 4078 else
4079 window = GetConnectWidget()->window;
148cd9b6 4080
ed673c6a 4081 if (!window)
739730ca
RR		 4082 {
4083 // indicate that a new style has been set
c50f1fb9
VZ		 4084 // but it couldn't get applied as the
4085 // widget hasn't been realized yet.
4086 m_delayedForegroundColour = TRUE;
739730ca 4087 }
ea323db3
RR		 4088 else
4089 {
4090 GtkSetForegroundColour( colour );
4091 }
f03fc89f
VZ		 4092
4093 return TRUE;
58614078
RR		 4094}
4095
2b5f62a0
VZ		 4096#ifdef __WXGTK20__
4097PangoContext *wxWindowGTK::GtkGetPangoDefaultContext()
4098{
4099 return gtk_widget_get_pango_context( m_widget );
4100}
4101
4102PangoContext *wxWindowGTK::GtkGetPangoX11Context()
4103{
4104 if (!m_x11Context)
4105 m_x11Context = pango_x_get_context( gdk_display );
4106
4107 return m_x11Context;
4108}
4109#endif
4110
1e6feb95 4111GtkStyle *wxWindowGTK::GetWidgetStyle()
58614078 4112{
103aab26
RR		 4113 if (m_widgetStyle)
4114 {
4115 GtkStyle *remake = gtk_style_copy( m_widgetStyle );
9e691f46
VZ		 4116
4117 // FIXME: no more klass in 2.0
4118#ifndef __WXGTK20__
103aab26 4119 remake->klass = m_widgetStyle->klass;
dd00f3f6 4120#endif
2daa0ce9 4121
103aab26
RR		 4122 gtk_style_unref( m_widgetStyle );
4123 m_widgetStyle = remake;
4124 }
4125 else
4126 {
4127 GtkStyle *def = gtk_rc_get_style( m_widget );
e6527f9d 4128
103aab26
RR		 4129 if (!def)
4130 def = gtk_widget_get_default_style();
e6527f9d 4131
103aab26 4132 m_widgetStyle = gtk_style_copy( def );
9e691f46
VZ		 4133
4134 // FIXME: no more klass in 2.0
4135#ifndef __WXGTK20__
103aab26 4136 m_widgetStyle->klass = def->klass;
dd00f3f6 4137#endif
103aab26 4138 }
8bbe427f 4139
1ecc4d80 4140 return m_widgetStyle;
58614078
RR		 4141}
4142
1e6feb95 4143void wxWindowGTK::SetWidgetStyle()
58614078 4144{
8f3e7ecc 4145#if DISABLE_STYLE_IF_BROKEN_THEME
fb65642c
RR		 4146 if (m_widget->style->engine_data)
4147 {
4148 static bool s_warningPrinted = FALSE;
4149 if (!s_warningPrinted)
4150 {
4151 printf( "wxWindows warning: Widget styles disabled due to buggy GTK theme.\n" );
4152 s_warningPrinted = TRUE;
4153 }
4154 m_widgetStyle = m_widget->style;
4155 return;
4156 }
a56fcaaf 4157#endif
fb65642c 4158
1ecc4d80
RR		 4159 GtkStyle *style = GetWidgetStyle();
4160
a756f210 4161 if (m_font != wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT ))
db434467 4162 {
288059b2
RR		 4163#ifdef __WXGTK20__
4164 pango_font_description_free( style->font_desc );
7b14c561 4165 style->font_desc = pango_font_description_copy( m_font.GetNativeFontInfo()->description );
288059b2
RR		 4166#else
4167 gdk_font_unref( style->font );
f77cf4e6 4168 style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
cfcc3932 4169#endif
288059b2 4170 }
1ecc4d80
RR		 4171
4172 if (m_foregroundColour.Ok())
4173 {
454e2a22 4174 m_foregroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
a756f210 4175 if (m_foregroundColour != wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT))
db434467
RR		 4176 {
4177 style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
4178 style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
4179 style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
4180 }
1e6feb95 4181 else
f6bcfd97
BP		 4182 {
4183 // Try to restore the gtk default style. This is still a little
4184 // oversimplified for what is probably really needed here for controls
4185 // other than buttons, but is better than not being able to (re)set a
4186 // control's foreground colour to *wxBLACK -- RL
4187 GtkStyle *def = gtk_rc_get_style( m_widget );
4188
4189 if (!def)
4190 def = gtk_widget_get_default_style();
4191
4192 style->fg[GTK_STATE_NORMAL] = def->fg[GTK_STATE_NORMAL];
4193 style->fg[GTK_STATE_PRELIGHT] = def->fg[GTK_STATE_PRELIGHT];
4194 style->fg[GTK_STATE_ACTIVE] = def->fg[GTK_STATE_ACTIVE];
4195 }
1ecc4d80
RR		 4196 }
4197
4198 if (m_backgroundColour.Ok())
4199 {
454e2a22 4200 m_backgroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
a756f210 4201 if (m_backgroundColour != wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE))
db434467
RR		 4202 {
4203 style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
4204 style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
4205 style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
4206 style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
4207 style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
4208 style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
4209 style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
4210 style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
f6bcfd97
BP		 4211 }
4212 else
4213 {
4214 // Try to restore the gtk default style. This is still a little
4215 // oversimplified for what is probably really needed here for controls
4216 // other than buttons, but is better than not being able to (re)set a
4217 // control's background colour to default grey and means resetting a
1e6feb95 4218 // button to wxSYS_COLOUR_BTNFACE will restore its usual highlighting
f6bcfd97
BP		 4219 // behavior -- RL
4220 GtkStyle *def = gtk_rc_get_style( m_widget );
4221
4222 if (!def)
4223 def = gtk_widget_get_default_style();
4224
4225 style->bg[GTK_STATE_NORMAL] = def->bg[GTK_STATE_NORMAL];
4226 style->base[GTK_STATE_NORMAL] = def->base[GTK_STATE_NORMAL];
4227 style->bg[GTK_STATE_PRELIGHT] = def->bg[GTK_STATE_PRELIGHT];
4228 style->base[GTK_STATE_PRELIGHT] = def->base[GTK_STATE_PRELIGHT];
4229 style->bg[GTK_STATE_ACTIVE] = def->bg[GTK_STATE_ACTIVE];
4230 style->base[GTK_STATE_ACTIVE] = def->base[GTK_STATE_ACTIVE];
4231 style->bg[GTK_STATE_INSENSITIVE] = def->bg[GTK_STATE_INSENSITIVE];
4232 style->base[GTK_STATE_INSENSITIVE] = def->base[GTK_STATE_INSENSITIVE];
4233 }
1ecc4d80 4234 }
a81258be
RR		 4235}
4236
1e6feb95 4237void wxWindowGTK::ApplyWidgetStyle()
a81258be 4238{
6de97a3b
RR		 4239}
4240
2259e007
RR		 4241//-----------------------------------------------------------------------------
4242// Pop-up menu stuff
4243//-----------------------------------------------------------------------------
4244
6522713c 4245#if wxUSE_MENUS_NATIVE
1e6feb95 4246
90350682
VZ		 4247extern "C"
4248void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting )
2259e007
RR		 4249{
4250 *is_waiting = FALSE;
4251}
4252
1e6feb95 4253static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win )
30dea054 4254{
1ecc4d80 4255 menu->SetInvokingWindow( win );
222ed1d6 4256 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
1ecc4d80
RR		 4257 while (node)
4258 {
1987af7e 4259 wxMenuItem *menuitem = node->GetData();
1ecc4d80
RR		 4260 if (menuitem->IsSubMenu())
4261 {
ff8bfdbb
VZ		 4262 SetInvokingWindow( menuitem->GetSubMenu(), win );
4263 }
1987af7e
VZ		 4264
4265 node = node->GetNext();
1ecc4d80 4266 }
362c6693 4267}
30dea054 4268
e3473203
VZ		 4269// used to pass the coordinates from wxWindowGTK::DoPopupMenu() to
4270// wxPopupMenuPositionCallback()
4271//
4272// should be safe even in the MT case as the user can hardly popup 2 menus
4273// simultaneously, can he?
0c77152e
RR		 4274static gint gs_pop_x = 0;
4275static gint gs_pop_y = 0;
4276
295272bd
VZ		 4277extern "C" void wxPopupMenuPositionCallback( GtkMenu *menu,
4278 gint *x, gint *y,
9e691f46
VZ		 4279#ifdef __WXGTK20__
4280 gboolean * WXUNUSED(whatever),
4281#endif
295272bd 4282 gpointer WXUNUSED(user_data) )
0c77152e 4283{
e3473203
VZ		 4284 // ensure that the menu appears entirely on screen
4285 GtkRequisition req;
4286 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
4287
4288 wxSize sizeScreen = wxGetDisplaySize();
4289
4290 gint xmax = sizeScreen.x - req.width,
4291 ymax = sizeScreen.y - req.height;
4292
4293 *x = gs_pop_x < xmax ? gs_pop_x : xmax;
4294 *y = gs_pop_y < ymax ? gs_pop_y : ymax;
0c77152e
RR		 4295}
4296
1e6feb95 4297bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
30dea054 4298{
223d09f6 4299 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
47d67540 4300
223d09f6 4301 wxCHECK_MSG( menu != NULL, FALSE, wxT("invalid popup-menu") );
8bbe427f 4302
1ecc4d80 4303 SetInvokingWindow( menu, this );
ff8bfdbb 4304
631f1bfe
JS		 4305 menu->UpdateUI();
4306
0c77152e
RR		 4307 gs_pop_x = x;
4308 gs_pop_y = y;
e3473203 4309 ClientToScreen( &gs_pop_x, &gs_pop_y );
ff8bfdbb 4310
2259e007 4311 bool is_waiting = TRUE;
148cd9b6 4312
90350682
VZ		 4313 gtk_signal_connect( GTK_OBJECT(menu->m_menu),
4314 "hide",
4315 GTK_SIGNAL_FUNC(gtk_pop_hide_callback),
4316 (gpointer)&is_waiting );
2259e007 4317
1ecc4d80 4318 gtk_menu_popup(
47d67540 4319 GTK_MENU(menu->m_menu),
e3473203
VZ		 4320 (GtkWidget *) NULL, // parent menu shell
4321 (GtkWidget *) NULL, // parent menu item
4322 wxPopupMenuPositionCallback, // function to position it
4323 NULL, // client data
4324 0, // button used to activate it
34791896
RR		 4325#ifdef __WXGTK20__
4326 gtk_get_current_event_time()
4327#else
34adc954 4328 gs_timeLastClick // the time of activation
34791896 4329#endif
47d67540 4330 );
148cd9b6 4331
956dbab1
RR		 4332 while (is_waiting)
4333 {
a03cac3f 4334 gtk_main_iteration();
956dbab1 4335 }
2259e007 4336
1ecc4d80 4337 return TRUE;
30dea054
RR		 4338}
4339
6522713c 4340#endif // wxUSE_MENUS_NATIVE
1e6feb95 4341
06cfab17 4342#if wxUSE_DRAG_AND_DROP
ac57418f 4343
1e6feb95 4344void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
c801d85f 4345{
223d09f6 4346 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
47d67540 4347
1ecc4d80 4348 GtkWidget *dnd_widget = GetConnectWidget();
47d67540 4349
1ecc4d80 4350 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
47d67540 4351
1ecc4d80
RR		 4352 if (m_dropTarget) delete m_dropTarget;
4353 m_dropTarget = dropTarget;
47d67540 4354
1ecc4d80 4355 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
362c6693 4356}
c801d85f 4357
f03fc89f 4358#endif // wxUSE_DRAG_AND_DROP
ac57418f 4359
1e6feb95 4360GtkWidget* wxWindowGTK::GetConnectWidget()
e3e65dac 4361{
1ecc4d80
RR		 4362 GtkWidget *connect_widget = m_widget;
4363 if (m_wxwindow) connect_widget = m_wxwindow;
47d67540 4364
1ecc4d80 4365 return connect_widget;
e3e65dac 4366}
47d67540 4367
1e6feb95 4368bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window )
903f689b 4369{
148cd9b6 4370 if (m_wxwindow)
da048e3d 4371 return (window == GTK_PIZZA(m_wxwindow)->bin_window);
148cd9b6 4372
1ecc4d80 4373 return (window == m_widget->window);
903f689b
RR		 4374}
4375
1e6feb95 4376bool wxWindowGTK::SetFont( const wxFont &font )
c801d85f 4377{
133fb2a3 4378 if (!wxWindowBase::SetFont(font) || !m_widget)
739730ca 4379 {
454e2a22 4380 return FALSE;
739730ca 4381 }
9c288e4d 4382
a756f210 4383 wxColour sysbg = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
f03fc89f 4384 if ( sysbg == m_backgroundColour )
ae0bdb01
RR		 4385 {
4386 m_backgroundColour = wxNullColour;
4387 ApplyWidgetStyle();
ff8bfdbb
VZ		 4388 m_backgroundColour = sysbg;
4389 }
ae0bdb01
RR		 4390 else
4391 {
4392 ApplyWidgetStyle();
4393 }
c801d85f 4394
f03fc89f 4395 return TRUE;
362c6693 4396}
c801d85f 4397
94633ad9 4398void wxWindowGTK::DoCaptureMouse()
c801d85f 4399{
b231914f
VZ		 4400 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4401
ed673c6a 4402 GdkWindow *window = (GdkWindow*) NULL;
b231914f
VZ		 4403 if (m_wxwindow)
4404 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a 4405 else
b231914f 4406 window = GetConnectWidget()->window;
148cd9b6 4407
e4606ed9 4408 wxCHECK_RET( window, _T("CaptureMouse() failed") );
c50f1fb9 4409
b231914f 4410 wxCursor* cursor = & m_cursor;
cca602ac
JS		 4411 if (!cursor->Ok())
4412 cursor = wxSTANDARD_CURSOR;
4413
ed673c6a 4414 gdk_pointer_grab( window, FALSE,
1ecc4d80
RR		 4415 (GdkEventMask)
4416 (GDK_BUTTON_PRESS_MASK |
4417 GDK_BUTTON_RELEASE_MASK |
148cd9b6 4418 GDK_POINTER_MOTION_HINT_MASK |
1ecc4d80 4419 GDK_POINTER_MOTION_MASK),
ff8bfdbb 4420 (GdkWindow *) NULL,
cca602ac 4421 cursor->GetCursor(),
b02da6b1 4422 (guint32)GDK_CURRENT_TIME );
b231914f 4423 g_captureWindow = this;
1e6feb95 4424 g_captureWindowHasMouse = TRUE;
362c6693 4425}
c801d85f 4426
94633ad9 4427void wxWindowGTK::DoReleaseMouse()
c801d85f 4428{
b231914f
VZ		 4429 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4430
e4606ed9 4431 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
47d67540 4432
c43430bb
VS		 4433 g_captureWindow = (wxWindowGTK*) NULL;
4434
ed673c6a 4435 GdkWindow *window = (GdkWindow*) NULL;
b231914f
VZ		 4436 if (m_wxwindow)
4437 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a 4438 else
b231914f 4439 window = GetConnectWidget()->window;
148cd9b6 4440
b02da6b1
VZ		 4441 if (!window)
4442 return;
c50f1fb9 4443
b02da6b1 4444 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
362c6693 4445}
c801d85f 4446
1e6feb95
VZ		 4447/* static */
4448wxWindow *wxWindowBase::GetCapture()
4449{
4450 return (wxWindow *)g_captureWindow;
4451}
4452
4453bool wxWindowGTK::IsRetained() const
c801d85f 4454{
1ecc4d80 4455 return FALSE;
362c6693 4456}
c801d85f 4457
1e6feb95 4458void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,
cb43b372 4459 int range, bool refresh )
c801d85f 4460{
223d09f6 4461 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
8bbe427f 4462
223d09f6 4463 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
c801d85f 4464
1ecc4d80 4465 m_hasScrolling = TRUE;
47d67540 4466
1ecc4d80 4467 if (orient == wxHORIZONTAL)
cb43b372 4468 {
1ecc4d80
RR		 4469 float fpos = (float)pos;
4470 float frange = (float)range;
4471 float fthumb = (float)thumbVisible;
4472 if (fpos > frange-fthumb) fpos = frange-fthumb;
4473 if (fpos < 0.0) fpos = 0.0;
4474
4475 if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
4476 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
4477 {
4478 SetScrollPos( orient, pos, refresh );
4479 return;
4480 }
47d67540 4481
1ecc4d80 4482 m_oldHorizontalPos = fpos;
47d67540 4483
1ecc4d80
RR		 4484 m_hAdjust->lower = 0.0;
4485 m_hAdjust->upper = frange;
4486 m_hAdjust->value = fpos;
4487 m_hAdjust->step_increment = 1.0;
4488 m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
4489 m_hAdjust->page_size = fthumb;
cb43b372 4490 }
1ecc4d80
RR		 4491 else
4492 {
4493 float fpos = (float)pos;
4494 float frange = (float)range;
4495 float fthumb = (float)thumbVisible;
4496 if (fpos > frange-fthumb) fpos = frange-fthumb;
4497 if (fpos < 0.0) fpos = 0.0;
4498
4499 if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
4500 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
4501 {
4502 SetScrollPos( orient, pos, refresh );
4503 return;
4504 }
47d67540 4505
1ecc4d80 4506 m_oldVerticalPos = fpos;
47d67540 4507
1ecc4d80
RR		 4508 m_vAdjust->lower = 0.0;
4509 m_vAdjust->upper = frange;
4510 m_vAdjust->value = fpos;
4511 m_vAdjust->step_increment = 1.0;
4512 m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
4513 m_vAdjust->page_size = fthumb;
4514 }
47d67540 4515
eb082a08
RR		 4516 if (orient == wxHORIZONTAL)
4517 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
4518 else
4519 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
362c6693 4520}
c801d85f 4521
1e6feb95 4522void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
c801d85f 4523{
223d09f6 4524 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
1ecc4d80 4525
223d09f6 4526 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
1ecc4d80
RR		 4527
4528 if (orient == wxHORIZONTAL)
4529 {
4530 float fpos = (float)pos;
4531 if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
4532 if (fpos < 0.0) fpos = 0.0;
4533 m_oldHorizontalPos = fpos;
4534
4535 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
4536 m_hAdjust->value = fpos;
4537 }
4538 else
4539 {
4540 float fpos = (float)pos;
4541 if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
4542 if (fpos < 0.0) fpos = 0.0;
4543 m_oldVerticalPos = fpos;
ff8bfdbb 4544
1ecc4d80
RR		 4545 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
4546 m_vAdjust->value = fpos;
4547 }
47d67540 4548
5b8a521e 4549 if (m_wxwindow->window)
47d67540 4550 {
5b8a521e 4551 if (orient == wxHORIZONTAL)
473d087e
RR		 4552 {
4553 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust),
4554 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
2daa0ce9 4555
5b8a521e 4556 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
2daa0ce9 4557
473d087e
RR		 4558 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
4559 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
4560 }
5b8a521e 4561 else
473d087e
RR		 4562 {
4563 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust),
4564 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
2daa0ce9 4565
5b8a521e 4566 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
473d087e
RR		 4567
4568 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
4569 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
4570 }
cb43b372 4571 }
362c6693 4572}
c801d85f 4573
1e6feb95 4574int wxWindowGTK::GetScrollThumb( int orient ) const
c801d85f 4575{
223d09f6 4576 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
47d67540 4577
223d09f6 4578 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
47d67540 4579
1ecc4d80
RR		 4580 if (orient == wxHORIZONTAL)
4581 return (int)(m_hAdjust->page_size+0.5);
4582 else
4583 return (int)(m_vAdjust->page_size+0.5);
362c6693 4584}
c801d85f 4585
1e6feb95 4586int wxWindowGTK::GetScrollPos( int orient ) const
c801d85f 4587{
223d09f6 4588 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
47d67540 4589
223d09f6 4590 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
c801d85f 4591
1ecc4d80
RR		 4592 if (orient == wxHORIZONTAL)
4593 return (int)(m_hAdjust->value+0.5);
4594 else
4595 return (int)(m_vAdjust->value+0.5);
362c6693 4596}
c801d85f 4597
1e6feb95 4598int wxWindowGTK::GetScrollRange( int orient ) const
c801d85f 4599{
223d09f6 4600 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
47d67540 4601
223d09f6 4602 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
c801d85f 4603
1ecc4d80
RR		 4604 if (orient == wxHORIZONTAL)
4605 return (int)(m_hAdjust->upper+0.5);
4606 else
4607 return (int)(m_vAdjust->upper+0.5);
362c6693 4608}
c801d85f 4609
1e6feb95 4610void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
c801d85f 4611{
223d09f6 4612 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
47d67540 4613
223d09f6 4614 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
2b5f62a0 4615
f47ae6e7 4616 // No scrolling requested.
8e217128 4617 if ((dx == 0) && (dy == 0)) return;
0fc5dbf5 4618
4e5a4c69 4619#ifndef __WXGTK20__
35917d22
RR		 4620 if (!m_updateRegion.IsEmpty())
4621 {
4622 m_updateRegion.Offset( dx, dy );
0fc5dbf5 4623
35917d22
RR		 4624 int cw = 0;
4625 int ch = 0;
4626 GetClientSize( &cw, &ch );
4627 m_updateRegion.Intersect( 0, 0, cw, ch );
4628 }
0fc5dbf5 4629
3bcc8d15
RR		 4630 if (!m_clearRegion.IsEmpty())
4631 {
4632 m_clearRegion.Offset( dx, dy );
0fc5dbf5 4633
3bcc8d15
RR		 4634 int cw = 0;
4635 int ch = 0;
4636 GetClientSize( &cw, &ch );
4637 m_clearRegion.Intersect( 0, 0, cw, ch );
4638 }
3fc6e5fa
RR		 4639#endif
4640
b6fa52db 4641 m_clipPaintRegion = TRUE;
0fc5dbf5 4642
da048e3d 4643 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
0fc5dbf5 4644
b6fa52db 4645 m_clipPaintRegion = FALSE;
c801d85f 4646}
3723b7b1 4647
4e5a4c69 4648
3723b7b1
JS		 4649// Find the wxWindow at the current mouse position, also returning the mouse
4650// position.
4651wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4652{
59a12e90
JS		 4653 pt = wxGetMousePosition();
4654 wxWindow* found = wxFindWindowAtPoint(pt);
4655 return found;
3723b7b1
JS		 4656}
4657
4658// Get the current mouse position.
4659wxPoint wxGetMousePosition()
4660{
59a12e90
JS		 4661 /* This crashes when used within wxHelpContext,
4662 so we have to use the X-specific implementation below.
4663 gint x, y;
4664 GdkModifierType *mask;
4665 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4666
4667 return wxPoint(x, y);
4668 */
4669
3723b7b1
JS		 4670 int x, y;
4671 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
59a12e90 4672
37d81cc2 4673 Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
59a12e90
JS		 4674 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4675 Window rootReturn, childReturn;
4676 int rootX, rootY, winX, winY;
4677 unsigned int maskReturn;
4678
4679 XQueryPointer (display,
5cd09f0b
RR		 4680 rootWindow,
4681 &rootReturn,
59a12e90
JS		 4682 &childReturn,
4683 &rootX, &rootY, &winX, &winY, &maskReturn);
4684 return wxPoint(rootX, rootY);
4685
3723b7b1
JS		 4686}
4687
4e5a4c69
RR		 4688// ----------------------------------------------------------------------------
4689// wxDCModule
4690// ----------------------------------------------------------------------------
4691
4692class wxWinModule : public wxModule
4693{
4694public:
4695 bool OnInit();
4696 void OnExit();
4697
4698private:
4699 DECLARE_DYNAMIC_CLASS(wxWinModule)
4700};
4701
4702IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule)
4703
4704bool wxWinModule::OnInit()
4705{
994bc575
RR		 4706 // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
4707 // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
0fc5dbf5 4708
4e5a4c69
RR		 4709 return TRUE;
4710}
4711
4712void wxWinModule::OnExit()
4713{
994bc575
RR		 4714 if (g_eraseGC)
4715 gdk_gc_unref( g_eraseGC );
4e5a4c69
RR		 4716}
4717
6728fb61 4718// vi:sts=4:sw=4:et
wxWidgets (Impactor)