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