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