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