projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Set modifiers properly for the key events with AltGr in wxGTK.
[wxWidgets.git] / src / gtk / window.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/window.cpp
3 // Purpose: wxWindowGTK implementation
4 // Author: Robert Roebling
5 // Id: $Id$
6 // Copyright: (c) 1998 Robert Roebling, Julian Smart
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
12
13 #ifdef __VMS
14 #define XWarpPointer XWARPPOINTER
15 #endif
16
17 #include "wx/window.h"
18
19 #ifndef WX_PRECOMP
20 #include "wx/log.h"
21 #include "wx/app.h"
22 #include "wx/toplevel.h"
23 #include "wx/dcclient.h"
24 #include "wx/menu.h"
25 #include "wx/settings.h"
26 #include "wx/msgdlg.h"
27 #include "wx/math.h"
28 #endif
29
30 #include "wx/dnd.h"
31 #include "wx/tooltip.h"
32 #include "wx/caret.h"
33 #include "wx/fontutil.h"
34 #include "wx/sysopt.h"
35 #ifdef __WXGTK3__
36 #include "wx/gtk/dc.h"
37 #endif
38
39 #include <ctype.h>
40
41 #include <gtk/gtk.h>
42 #include "wx/gtk/private.h"
43 #include "wx/gtk/private/gtk2-compat.h"
44 #include "wx/gtk/private/event.h"
45 #include "wx/gtk/private/win_gtk.h"
46 using namespace wxGTKImpl;
47
48 #ifdef GDK_WINDOWING_X11
49 #include <gdk/gdkx.h>
50 #include "wx/x11/private/wrapxkb.h"
51 #else
52 typedef guint KeySym;
53 #endif
54
55 #include <gdk/gdkkeysyms.h>
56 #ifdef __WXGTK3__
57 #include <gdk/gdkkeysyms-compat.h>
58 #endif
59
60 // gdk_window_set_composited() is only supported since 2.12
61 #define wxGTK_VERSION_REQUIRED_FOR_COMPOSITING 2,12,0
62 #define wxGTK_HAS_COMPOSITING_SUPPORT GTK_CHECK_VERSION(2,12,0)
63
64 //-----------------------------------------------------------------------------
65 // documentation on internals
66 //-----------------------------------------------------------------------------
67
68 /*
69 I have been asked several times about writing some documentation about
70 the GTK port of wxWidgets, especially its internal structures. Obviously,
71 you cannot understand wxGTK without knowing a little about the GTK, but
72 some more information about what the wxWindow, which is the base class
73 for all other window classes, does seems required as well.
74
75 I)
76
77 What does wxWindow do? It contains the common interface for the following
78 jobs of its descendants:
79
80 1) Define the rudimentary behaviour common to all window classes, such as
81 resizing, intercepting user input (so as to make it possible to use these
82 events for special purposes in a derived class), window names etc.
83
84 2) Provide the possibility to contain and manage children, if the derived
85 class is allowed to contain children, which holds true for those window
86 classes which do not display a native GTK widget. To name them, these
87 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
88 work classes are a special case and are handled a bit differently from
89 the rest. The same holds true for the wxNotebook class.
90
91 3) Provide the possibility to draw into a client area of a window. This,
92 too, only holds true for classes that do not display a native GTK widget
93 as above.
94
95 4) Provide the entire mechanism for scrolling widgets. This actual inter-
96 face for this is usually in wxScrolledWindow, but the GTK implementation
97 is in this class.
98
99 5) A multitude of helper or extra methods for special purposes, such as
100 Drag'n'Drop, managing validators etc.
101
102 6) Display a border (sunken, raised, simple or none).
103
104 Normally one might expect, that one wxWidgets window would always correspond
105 to one GTK widget. Under GTK, there is no such all-round widget that has all
106 the functionality. Moreover, the GTK defines a client area as a different
107 widget from the actual widget you are handling. Last but not least some
108 special classes (e.g. wxFrame) handle different categories of widgets and
109 still have the possibility to draw something in the client area.
110 It was therefore required to write a special purpose GTK widget, that would
111 represent a client area in the sense of wxWidgets capable to do the jobs
112 2), 3) and 4). I have written this class and it resides in win_gtk.c of
113 this directory.
114
115 All windows must have a widget, with which they interact with other under-
116 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
117 the wxWindow class has a member variable called m_widget which holds a
118 pointer to this widget. When the window class represents a GTK native widget,
119 this is (in most cases) the only GTK widget the class manages. E.g. the
120 wxStaticText class handles only a GtkLabel widget a pointer to which you
121 can find in m_widget (defined in wxWindow)
122
123 When the class has a client area for drawing into and for containing children
124 it has to handle the client area widget (of the type wxPizza, defined in
125 win_gtk.cpp), but there could be any number of widgets, handled by a class.
126 The common rule for all windows is only, that the widget that interacts with
127 the rest of GTK must be referenced in m_widget and all other widgets must be
128 children of this widget on the GTK level. The top-most widget, which also
129 represents the client area, must be in the m_wxwindow field and must be of
130 the type wxPizza.
131
132 As I said, the window classes that display a GTK native widget only have
133 one widget, so in the case of e.g. the wxButton class m_widget holds a
134 pointer to a GtkButton widget. But windows with client areas (for drawing
135 and children) have a m_widget field that is a pointer to a GtkScrolled-
136 Window and a m_wxwindow field that is pointer to a wxPizza and this
137 one is (in the GTK sense) a child of the GtkScrolledWindow.
138
139 If the m_wxwindow field is set, then all input to this widget is inter-
140 cepted and sent to the wxWidgets class. If not, all input to the widget
141 that gets pointed to by m_widget gets intercepted and sent to the class.
142
143 II)
144
145 The design of scrolling in wxWidgets is markedly different from that offered
146 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
147 clicking on a scrollbar belonging to scrolled window will inevitably move
148 the window. In wxWidgets, the scrollbar will only emit an event, send this
149 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
150 which actually moves the window and its sub-windows. Note that wxPizza
151 memorizes how much it has been scrolled but that wxWidgets forgets this
152 so that the two coordinates systems have to be kept in synch. This is done
153 in various places using the pizza->m_scroll_x and pizza->m_scroll_y values.
154
155 III)
156
157 Singularly the most broken code in GTK is the code that is supposed to
158 inform subwindows (child windows) about new positions. Very often, duplicate
159 events are sent without changes in size or position, equally often no
160 events are sent at all (All this is due to a bug in the GtkContainer code
161 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
162 GTK's own system and it simply waits for size events for toplevel windows
163 and then iterates down the respective size events to all window. This has
164 the disadvantage that windows might get size events before the GTK widget
165 actually has the reported size. This doesn't normally pose any problem, but
166 the OpenGL drawing routines rely on correct behaviour. Therefore, I have
167 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
168 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
169 window that is used for OpenGL output really has that size (as reported by
170 GTK).
171
172 IV)
173
174 If someone at some point of time feels the immense desire to have a look at,
175 change or attempt to optimise the Refresh() logic, this person will need an
176 intimate understanding of what "draw" and "expose" events are and what
177 they are used for, in particular when used in connection with GTK's
178 own windowless widgets. Beware.
179
180 V)
181
182 Cursors, too, have been a constant source of pleasure. The main difficulty
183 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
184 for the parent. To prevent this from doing too much harm, SetCursor calls
185 GTKUpdateCursor, which will recursively re-set the cursors of all child windows.
186 Also don't forget that cursors (like much else) are connected to GdkWindows,
187 not GtkWidgets and that the "window" field of a GtkWidget might very well
188 point to the GdkWindow of the parent widget (-> "window-less widget") and
189 that the two obviously have very different meanings.
190 */
191
192 //-----------------------------------------------------------------------------
193 // data
194 //-----------------------------------------------------------------------------
195
196 // Don't allow event propagation during drag
197 bool g_blockEventsOnDrag;
198 // Don't allow mouse event propagation during scroll
199 bool g_blockEventsOnScroll;
200 extern wxCursor g_globalCursor;
201
202 // mouse capture state: the window which has it and if the mouse is currently
203 // inside it
204 static wxWindowGTK *g_captureWindow = NULL;
205 static bool g_captureWindowHasMouse = false;
206
207 // The window that currently has focus:
208 static wxWindowGTK *gs_currentFocus = NULL;
209 // The window that is scheduled to get focus in the next event loop iteration
210 // or NULL if there's no pending focus change:
211 static wxWindowGTK *gs_pendingFocus = NULL;
212
213 // the window that has deferred focus-out event pending, if any (see
214 // GTKAddDeferredFocusOut() for details)
215 static wxWindowGTK *gs_deferredFocusOut = NULL;
216
217 // global variables because GTK+ DnD want to have the
218 // mouse event that caused it
219 GdkEvent *g_lastMouseEvent = NULL;
220 int g_lastButtonNumber = 0;
221
222 //-----------------------------------------------------------------------------
223 // debug
224 //-----------------------------------------------------------------------------
225
226 // the trace mask used for the focus debugging messages
227 #define TRACE_FOCUS wxT("focus")
228
229 //-----------------------------------------------------------------------------
230 // "expose_event"/"draw" from m_wxwindow
231 //-----------------------------------------------------------------------------
232
233 extern "C" {
234 #ifdef __WXGTK3__
235 static gboolean draw(GtkWidget*, cairo_t* cr, wxWindow* win)
236 {
237 if (gtk_cairo_should_draw_window(cr, win->GTKGetDrawingWindow()))
238 win->GTKSendPaintEvents(cr);
239
240 return false;
241 }
242 #else // !__WXGTK3__
243 static gboolean expose_event(GtkWidget*, GdkEventExpose* gdk_event, wxWindow* win)
244 {
245 if (gdk_event->window == win->GTKGetDrawingWindow())
246 win->GTKSendPaintEvents(gdk_event->region);
247
248 return false;
249 }
250 #endif // !__WXGTK3__
251 }
252
253 #ifndef __WXUNIVERSAL__
254 //-----------------------------------------------------------------------------
255 // "expose_event"/"draw" from m_wxwindow->parent, for drawing border
256 //-----------------------------------------------------------------------------
257
258 extern "C" {
259 static gboolean
260 #ifdef __WXGTK3__
261 draw_border(GtkWidget*, cairo_t* cr, wxWindow* win)
262 #else
263 draw_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
264 #endif
265 {
266 #ifdef __WXGTK3__
267 if (!gtk_cairo_should_draw_window(cr, gtk_widget_get_parent_window(win->m_wxwindow)))
268 #else
269 if (gdk_event->window != gtk_widget_get_parent_window(win->m_wxwindow))
270 #endif
271 return false;
272
273 if (!win->IsShown())
274 return false;
275
276 GtkAllocation alloc;
277 gtk_widget_get_allocation(win->m_wxwindow, &alloc);
278 const int x = alloc.x;
279 const int y = alloc.y;
280 const int w = alloc.width;
281 const int h = alloc.height;
282
283 if (w <= 0 || h <= 0)
284 return false;
285
286 if (win->HasFlag(wxBORDER_SIMPLE))
287 {
288 #ifdef __WXGTK3__
289 GtkStyleContext* sc = gtk_widget_get_style_context(win->m_wxwindow);
290 GdkRGBA c;
291 gtk_style_context_get_border_color(sc, GTK_STATE_FLAG_NORMAL, &c);
292 gdk_cairo_set_source_rgba(cr, &c);
293 cairo_set_line_width(cr, 1);
294 cairo_rectangle(cr, x + 0.5, y + 0.5, w - 1, h - 1);
295 cairo_stroke(cr);
296 #else
297 gdk_draw_rectangle(gdk_event->window,
298 gtk_widget_get_style(widget)->black_gc, false, x, y, w - 1, h - 1);
299 #endif
300 }
301 else if (win->HasFlag(wxBORDER_RAISED | wxBORDER_SUNKEN | wxBORDER_THEME))
302 {
303 #ifdef __WXGTK3__
304 //TODO: wxBORDER_RAISED/wxBORDER_SUNKEN
305 GtkStyleContext* sc;
306 if (win->HasFlag(wxHSCROLL | wxVSCROLL))
307 sc = gtk_widget_get_style_context(wxGTKPrivate::GetTreeWidget());
308 else
309 sc = gtk_widget_get_style_context(wxGTKPrivate::GetEntryWidget());
310
311 gtk_render_frame(sc, cr, x, y, w, h);
312 #else // !__WXGTK3__
313 GtkShadowType shadow = GTK_SHADOW_IN;
314 if (win->HasFlag(wxBORDER_RAISED))
315 shadow = GTK_SHADOW_OUT;
316
317 GtkStyle* style;
318 const char* detail;
319 if (win->HasFlag(wxHSCROLL | wxVSCROLL))
320 {
321 style = gtk_widget_get_style(wxGTKPrivate::GetTreeWidget());
322 detail = "viewport";
323 }
324 else
325 {
326 style = gtk_widget_get_style(wxGTKPrivate::GetEntryWidget());
327 detail = "entry";
328 }
329
330 // clip rect is required to avoid painting background
331 // over upper left (w,h) of parent window
332 GdkRectangle clipRect = { x, y, w, h };
333 gtk_paint_shadow(
334 style, gdk_event->window, GTK_STATE_NORMAL,
335 shadow, &clipRect, widget, detail, x, y, w, h);
336 #endif // !__WXGTK3__
337 }
338 return false;
339 }
340 }
341
342 //-----------------------------------------------------------------------------
343 // "parent_set" from m_wxwindow
344 //-----------------------------------------------------------------------------
345
346 extern "C" {
347 static void
348 parent_set(GtkWidget* widget, GtkWidget* old_parent, wxWindow* win)
349 {
350 if (old_parent)
351 {
352 g_signal_handlers_disconnect_by_func(
353 old_parent, (void*)draw_border, win);
354 }
355 GtkWidget* parent = gtk_widget_get_parent(widget);
356 if (parent)
357 {
358 #ifdef __WXGTK3__
359 g_signal_connect_after(parent, "draw", G_CALLBACK(draw_border), win);
360 #else
361 g_signal_connect_after(parent, "expose_event", G_CALLBACK(draw_border), win);
362 #endif
363 }
364 }
365 }
366 #endif // !__WXUNIVERSAL__
367
368 //-----------------------------------------------------------------------------
369 // "key_press_event" from any window
370 //-----------------------------------------------------------------------------
371
372 // set WXTRACE to this to see the key event codes on the console
373 #define TRACE_KEYS wxT("keyevent")
374
375 // translates an X key symbol to WXK_XXX value
376 //
377 // if isChar is true it means that the value returned will be used for EVT_CHAR
378 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
379 // for example, while if it is false it means that the value is going to be
380 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
381 // WXK_NUMPAD_DIVIDE
382 static long wxTranslateKeySymToWXKey(KeySym keysym, bool isChar)
383 {
384 long key_code;
385
386 switch ( keysym )
387 {
388 // Shift, Control and Alt don't generate the CHAR events at all
389 case GDK_Shift_L:
390 case GDK_Shift_R:
391 key_code = isChar ? 0 : WXK_SHIFT;
392 break;
393 case GDK_Control_L:
394 case GDK_Control_R:
395 key_code = isChar ? 0 : WXK_CONTROL;
396 break;
397 case GDK_Meta_L:
398 case GDK_Meta_R:
399 case GDK_Alt_L:
400 case GDK_Alt_R:
401 case GDK_Super_L:
402 case GDK_Super_R:
403 key_code = isChar ? 0 : WXK_ALT;
404 break;
405
406 // neither do the toggle modifies
407 case GDK_Scroll_Lock:
408 key_code = isChar ? 0 : WXK_SCROLL;
409 break;
410
411 case GDK_Caps_Lock:
412 key_code = isChar ? 0 : WXK_CAPITAL;
413 break;
414
415 case GDK_Num_Lock:
416 key_code = isChar ? 0 : WXK_NUMLOCK;
417 break;
418
419
420 // various other special keys
421 case GDK_Menu:
422 key_code = WXK_MENU;
423 break;
424
425 case GDK_Help:
426 key_code = WXK_HELP;
427 break;
428
429 case GDK_BackSpace:
430 key_code = WXK_BACK;
431 break;
432
433 case GDK_ISO_Left_Tab:
434 case GDK_Tab:
435 key_code = WXK_TAB;
436 break;
437
438 case GDK_Linefeed:
439 case GDK_Return:
440 key_code = WXK_RETURN;
441 break;
442
443 case GDK_Clear:
444 key_code = WXK_CLEAR;
445 break;
446
447 case GDK_Pause:
448 key_code = WXK_PAUSE;
449 break;
450
451 case GDK_Select:
452 key_code = WXK_SELECT;
453 break;
454
455 case GDK_Print:
456 key_code = WXK_PRINT;
457 break;
458
459 case GDK_Execute:
460 key_code = WXK_EXECUTE;
461 break;
462
463 case GDK_Escape:
464 key_code = WXK_ESCAPE;
465 break;
466
467 // cursor and other extended keyboard keys
468 case GDK_Delete:
469 key_code = WXK_DELETE;
470 break;
471
472 case GDK_Home:
473 key_code = WXK_HOME;
474 break;
475
476 case GDK_Left:
477 key_code = WXK_LEFT;
478 break;
479
480 case GDK_Up:
481 key_code = WXK_UP;
482 break;
483
484 case GDK_Right:
485 key_code = WXK_RIGHT;
486 break;
487
488 case GDK_Down:
489 key_code = WXK_DOWN;
490 break;
491
492 case GDK_Prior: // == GDK_Page_Up
493 key_code = WXK_PAGEUP;
494 break;
495
496 case GDK_Next: // == GDK_Page_Down
497 key_code = WXK_PAGEDOWN;
498 break;
499
500 case GDK_End:
501 key_code = WXK_END;
502 break;
503
504 case GDK_Begin:
505 key_code = WXK_HOME;
506 break;
507
508 case GDK_Insert:
509 key_code = WXK_INSERT;
510 break;
511
512
513 // numpad keys
514 case GDK_KP_0:
515 case GDK_KP_1:
516 case GDK_KP_2:
517 case GDK_KP_3:
518 case GDK_KP_4:
519 case GDK_KP_5:
520 case GDK_KP_6:
521 case GDK_KP_7:
522 case GDK_KP_8:
523 case GDK_KP_9:
524 key_code = (isChar ? '0' : int(WXK_NUMPAD0)) + keysym - GDK_KP_0;
525 break;
526
527 case GDK_KP_Space:
528 key_code = isChar ? ' ' : int(WXK_NUMPAD_SPACE);
529 break;
530
531 case GDK_KP_Tab:
532 key_code = isChar ? WXK_TAB : WXK_NUMPAD_TAB;
533 break;
534
535 case GDK_KP_Enter:
536 key_code = isChar ? WXK_RETURN : WXK_NUMPAD_ENTER;
537 break;
538
539 case GDK_KP_F1:
540 key_code = isChar ? WXK_F1 : WXK_NUMPAD_F1;
541 break;
542
543 case GDK_KP_F2:
544 key_code = isChar ? WXK_F2 : WXK_NUMPAD_F2;
545 break;
546
547 case GDK_KP_F3:
548 key_code = isChar ? WXK_F3 : WXK_NUMPAD_F3;
549 break;
550
551 case GDK_KP_F4:
552 key_code = isChar ? WXK_F4 : WXK_NUMPAD_F4;
553 break;
554
555 case GDK_KP_Home:
556 key_code = isChar ? WXK_HOME : WXK_NUMPAD_HOME;
557 break;
558
559 case GDK_KP_Left:
560 key_code = isChar ? WXK_LEFT : WXK_NUMPAD_LEFT;
561 break;
562
563 case GDK_KP_Up:
564 key_code = isChar ? WXK_UP : WXK_NUMPAD_UP;
565 break;
566
567 case GDK_KP_Right:
568 key_code = isChar ? WXK_RIGHT : WXK_NUMPAD_RIGHT;
569 break;
570
571 case GDK_KP_Down:
572 key_code = isChar ? WXK_DOWN : WXK_NUMPAD_DOWN;
573 break;
574
575 case GDK_KP_Prior: // == GDK_KP_Page_Up
576 key_code = isChar ? WXK_PAGEUP : WXK_NUMPAD_PAGEUP;
577 break;
578
579 case GDK_KP_Next: // == GDK_KP_Page_Down
580 key_code = isChar ? WXK_PAGEDOWN : WXK_NUMPAD_PAGEDOWN;
581 break;
582
583 case GDK_KP_End:
584 key_code = isChar ? WXK_END : WXK_NUMPAD_END;
585 break;
586
587 case GDK_KP_Begin:
588 key_code = isChar ? WXK_HOME : WXK_NUMPAD_BEGIN;
589 break;
590
591 case GDK_KP_Insert:
592 key_code = isChar ? WXK_INSERT : WXK_NUMPAD_INSERT;
593 break;
594
595 case GDK_KP_Delete:
596 key_code = isChar ? WXK_DELETE : WXK_NUMPAD_DELETE;
597 break;
598
599 case GDK_KP_Equal:
600 key_code = isChar ? '=' : int(WXK_NUMPAD_EQUAL);
601 break;
602
603 case GDK_KP_Multiply:
604 key_code = isChar ? '*' : int(WXK_NUMPAD_MULTIPLY);
605 break;
606
607 case GDK_KP_Add:
608 key_code = isChar ? '+' : int(WXK_NUMPAD_ADD);
609 break;
610
611 case GDK_KP_Separator:
612 // FIXME: what is this?
613 key_code = isChar ? '.' : int(WXK_NUMPAD_SEPARATOR);
614 break;
615
616 case GDK_KP_Subtract:
617 key_code = isChar ? '-' : int(WXK_NUMPAD_SUBTRACT);
618 break;
619
620 case GDK_KP_Decimal:
621 key_code = isChar ? '.' : int(WXK_NUMPAD_DECIMAL);
622 break;
623
624 case GDK_KP_Divide:
625 key_code = isChar ? '/' : int(WXK_NUMPAD_DIVIDE);
626 break;
627
628
629 // function keys
630 case GDK_F1:
631 case GDK_F2:
632 case GDK_F3:
633 case GDK_F4:
634 case GDK_F5:
635 case GDK_F6:
636 case GDK_F7:
637 case GDK_F8:
638 case GDK_F9:
639 case GDK_F10:
640 case GDK_F11:
641 case GDK_F12:
642 key_code = WXK_F1 + keysym - GDK_F1;
643 break;
644
645 default:
646 key_code = 0;
647 }
648
649 return key_code;
650 }
651
652 static inline bool wxIsAsciiKeysym(KeySym ks)
653 {
654 return ks < 256;
655 }
656
657 static void wxFillOtherKeyEventFields(wxKeyEvent& event,
658 wxWindowGTK *win,
659 GdkEventKey *gdk_event)
660 {
661 event.SetTimestamp( gdk_event->time );
662 event.SetId(win->GetId());
663
664 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0;
665 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
666 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
667 event.m_metaDown = (gdk_event->state & GDK_META_MASK) != 0;
668
669 // At least with current Linux systems, MOD5 corresponds to AltGr key and
670 // we represent it, for consistency with Windows, which really allows to
671 // use Ctrl+Alt as a replacement for AltGr if this key is not present, as a
672 // combination of these two modifiers.
673 if ( gdk_event->state & GDK_MOD5_MASK )
674 {
675 event.m_controlDown =
676 event.m_altDown = true;
677 }
678
679 // Normally we take the state of modifiers directly from the low level GDK
680 // event but unfortunately GDK uses a different convention from MSW for the
681 // key events corresponding to the modifier keys themselves: in it, when
682 // e.g. Shift key is pressed, GDK_SHIFT_MASK is not set while it is set
683 // when Shift is released. Under MSW the situation is exactly reversed and
684 // the modifier corresponding to the key is set when it is pressed and
685 // unset when it is released. To ensure consistent behaviour between
686 // platforms (and because it seems to make slightly more sense, although
687 // arguably both behaviours are reasonable) we follow MSW here.
688 //
689 // Final notice: we set the flags to the desired value instead of just
690 // inverting them because they are not set correctly (i.e. in the same way
691 // as for the real events generated by the user) for wxUIActionSimulator-
692 // produced events and it seems better to keep that class code the same
693 // among all platforms and fix the discrepancy here instead of adding
694 // wxGTK-specific code to wxUIActionSimulator.
695 const bool isPress = gdk_event->type == GDK_KEY_PRESS;
696 switch ( gdk_event->keyval )
697 {
698 case GDK_Shift_L:
699 case GDK_Shift_R:
700 event.m_shiftDown = isPress;
701 break;
702
703 case GDK_Control_L:
704 case GDK_Control_R:
705 event.m_controlDown = isPress;
706 break;
707
708 case GDK_Alt_L:
709 case GDK_Alt_R:
710 event.m_altDown = isPress;
711 break;
712
713 case GDK_Meta_L:
714 case GDK_Meta_R:
715 case GDK_Super_L:
716 case GDK_Super_R:
717 event.m_metaDown = isPress;
718 break;
719 }
720
721 event.m_rawCode = (wxUint32) gdk_event->keyval;
722 event.m_rawFlags = gdk_event->hardware_keycode;
723
724 event.SetEventObject( win );
725 }
726
727
728 static bool
729 wxTranslateGTKKeyEventToWx(wxKeyEvent& event,
730 wxWindowGTK *win,
731 GdkEventKey *gdk_event)
732 {
733 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
734 // but only event->keyval which is quite useless to us, so remember
735 // the last character from GDK_KEY_PRESS and reuse it as last resort
736 //
737 // NB: should be MT-safe as we're always called from the main thread only
738 static struct
739 {
740 KeySym keysym;
741 long keycode;
742 } s_lastKeyPress = { 0, 0 };
743
744 KeySym keysym = gdk_event->keyval;
745
746 wxLogTrace(TRACE_KEYS, wxT("Key %s event: keysym = %ld"),
747 event.GetEventType() == wxEVT_KEY_UP ? wxT("release")
748 : wxT("press"),
749 keysym);
750
751 long key_code = wxTranslateKeySymToWXKey(keysym, false /* !isChar */);
752
753 if ( !key_code )
754 {
755 // do we have the translation or is it a plain ASCII character?
756 if ( (gdk_event->length == 1) || wxIsAsciiKeysym(keysym) )
757 {
758 // we should use keysym if it is ASCII as X does some translations
759 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
760 // which we don't want here (but which we do use for OnChar())
761 if ( !wxIsAsciiKeysym(keysym) )
762 {
763 keysym = (KeySym)gdk_event->string[0];
764 }
765
766 #ifdef GDK_WINDOWING_X11
767 // we want to always get the same key code when the same key is
768 // pressed regardless of the state of the modifiers, i.e. on a
769 // standard US keyboard pressing '5' or '%' ('5' key with
770 // Shift) should result in the same key code in OnKeyDown():
771 // '5' (although OnChar() will get either '5' or '%').
772 //
773 // to do it we first translate keysym to keycode (== scan code)
774 // and then back but always using the lower register
775 Display *dpy = (Display *)wxGetDisplay();
776 KeyCode keycode = XKeysymToKeycode(dpy, keysym);
777
778 wxLogTrace(TRACE_KEYS, wxT("\t-> keycode %d"), keycode);
779
780 #ifdef HAVE_X11_XKBLIB_H
781 KeySym keysymNormalized = XkbKeycodeToKeysym(dpy, keycode, 0, 0);
782 #else
783 KeySym keysymNormalized = XKeycodeToKeysym(dpy, keycode, 0);
784 #endif
785
786 // use the normalized, i.e. lower register, keysym if we've
787 // got one
788 key_code = keysymNormalized ? keysymNormalized : keysym;
789 #else
790 key_code = keysym;
791 #endif
792
793 // as explained above, we want to have lower register key codes
794 // normally but for the letter keys we want to have the upper ones
795 //
796 // NB: don't use XConvertCase() here, we want to do it for letters
797 // only
798 key_code = toupper(key_code);
799 }
800 else // non ASCII key, what to do?
801 {
802 // by default, ignore it
803 key_code = 0;
804
805 // but if we have cached information from the last KEY_PRESS
806 if ( gdk_event->type == GDK_KEY_RELEASE )
807 {
808 // then reuse it
809 if ( keysym == s_lastKeyPress.keysym )
810 {
811 key_code = s_lastKeyPress.keycode;
812 }
813 }
814 }
815
816 if ( gdk_event->type == GDK_KEY_PRESS )
817 {
818 // remember it to be reused for KEY_UP event later
819 s_lastKeyPress.keysym = keysym;
820 s_lastKeyPress.keycode = key_code;
821 }
822 }
823
824 wxLogTrace(TRACE_KEYS, wxT("\t-> wxKeyCode %ld"), key_code);
825
826 // sending unknown key events doesn't really make sense
827 if ( !key_code )
828 return false;
829
830 event.m_keyCode = key_code;
831
832 #if wxUSE_UNICODE
833 event.m_uniChar = gdk_keyval_to_unicode(key_code ? key_code : keysym);
834 if ( !event.m_uniChar && event.m_keyCode <= WXK_DELETE )
835 {
836 // Set Unicode key code to the ASCII equivalent for compatibility. E.g.
837 // let RETURN generate the key event with both key and Unicode key
838 // codes of 13.
839 event.m_uniChar = event.m_keyCode;
840 }
841 #endif // wxUSE_UNICODE
842
843 // now fill all the other fields
844 wxFillOtherKeyEventFields(event, win, gdk_event);
845
846 return true;
847 }
848
849
850 struct wxGtkIMData
851 {
852 GtkIMContext *context;
853 GdkEventKey *lastKeyEvent;
854
855 wxGtkIMData()
856 {
857 context = gtk_im_multicontext_new();
858 lastKeyEvent = NULL;
859 }
860 ~wxGtkIMData()
861 {
862 g_object_unref (context);
863 }
864 };
865
866 namespace
867 {
868
869 // Send wxEVT_CHAR_HOOK event to the parent of the window and return true only
870 // if it was processed (and not skipped).
871 bool SendCharHookEvent(const wxKeyEvent& event, wxWindow *win)
872 {
873 // wxEVT_CHAR_HOOK must be sent to allow the parent windows (e.g. a dialog
874 // which typically closes when Esc key is pressed in any of its controls)
875 // to handle key events in all of its children unless the mouse is captured
876 // in which case we consider that the keyboard should be "captured" too.
877 if ( !g_captureWindow )
878 {
879 wxKeyEvent eventCharHook(wxEVT_CHAR_HOOK, event);
880 if ( win->HandleWindowEvent(eventCharHook)
881 && !event.IsNextEventAllowed() )
882 return true;
883 }
884
885 return false;
886 }
887
888 // Adjust wxEVT_CHAR event key code fields. This function takes care of two
889 // conventions:
890 // (a) Ctrl-letter key presses generate key codes in range 1..26
891 // (b) Unicode key codes are same as key codes for the codes in 1..255 range
892 void AdjustCharEventKeyCodes(wxKeyEvent& event)
893 {
894 const int code = event.m_keyCode;
895
896 // Check for (a) above.
897 if ( event.ControlDown() )
898 {
899 // We intentionally don't use isupper/lower() here, we really need
900 // ASCII letters only as it doesn't make sense to translate any other
901 // ones into this range which has only 26 slots.
902 if ( code >= 'a' && code <= 'z' )
903 event.m_keyCode = code - 'a' + 1;
904 else if ( code >= 'A' && code <= 'Z' )
905 event.m_keyCode = code - 'A' + 1;
906
907 #if wxUSE_UNICODE
908 // Adjust the Unicode equivalent in the same way too.
909 if ( event.m_keyCode != code )
910 event.m_uniChar = event.m_keyCode;
911 #endif // wxUSE_UNICODE
912 }
913
914 #if wxUSE_UNICODE
915 // Check for (b) from above.
916 //
917 // FIXME: Should we do it for key codes up to 255?
918 if ( !event.m_uniChar && code < WXK_DELETE )
919 event.m_uniChar = code;
920 #endif // wxUSE_UNICODE
921 }
922
923 } // anonymous namespace
924
925 // If a widget does not handle a key or mouse event, GTK+ sends it up the
926 // parent chain until it is handled. These events are not supposed to propagate
927 // in wxWidgets, so this code avoids handling them in any parent wxWindow,
928 // while still allowing the event to propagate so things like native keyboard
929 // navigation will work.
930 #define wxPROCESS_EVENT_ONCE(EventType, event) \
931 static EventType eventPrev; \
932 if (memcmp(&eventPrev, event, sizeof(EventType)) == 0) \
933 return false; \
934 eventPrev = *event
935
936 extern "C" {
937 static gboolean
938 gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget),
939 GdkEventKey *gdk_event,
940 wxWindow *win )
941 {
942 if (!win->m_hasVMT)
943 return FALSE;
944 if (g_blockEventsOnDrag)
945 return FALSE;
946
947 wxPROCESS_EVENT_ONCE(GdkEventKey, gdk_event);
948
949 wxKeyEvent event( wxEVT_KEY_DOWN );
950 bool ret = false;
951 bool return_after_IM = false;
952
953 if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
954 {
955 // Send the CHAR_HOOK event first
956 if ( SendCharHookEvent(event, win) )
957 {
958 // Don't do anything at all with this event any more.
959 return TRUE;
960 }
961
962 // Next check for accelerators.
963 #if wxUSE_ACCEL
964 wxWindowGTK *ancestor = win;
965 while (ancestor)
966 {
967 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
968 if (command != -1)
969 {
970 wxCommandEvent menu_event( wxEVT_COMMAND_MENU_SELECTED, command );
971 ret = ancestor->HandleWindowEvent( menu_event );
972
973 if ( !ret )
974 {
975 // if the accelerator wasn't handled as menu event, try
976 // it as button click (for compatibility with other
977 // platforms):
978 wxCommandEvent button_event( wxEVT_COMMAND_BUTTON_CLICKED, command );
979 ret = ancestor->HandleWindowEvent( button_event );
980 }
981
982 break;
983 }
984 if (ancestor->IsTopLevel())
985 break;
986 ancestor = ancestor->GetParent();
987 }
988 #endif // wxUSE_ACCEL
989
990 // If not an accelerator, then emit KEY_DOWN event
991 if ( !ret )
992 ret = win->HandleWindowEvent( event );
993 }
994 else
995 {
996 // Return after IM processing as we cannot do
997 // anything with it anyhow.
998 return_after_IM = true;
999 }
1000
1001 if (!ret && win->m_imData)
1002 {
1003 win->m_imData->lastKeyEvent = gdk_event;
1004
1005 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
1006 // docs, if IM filter returns true, no further processing should be done.
1007 // we should send the key_down event anyway.
1008 bool intercepted_by_IM =
1009 gtk_im_context_filter_keypress(win->m_imData->context, gdk_event) != 0;
1010 win->m_imData->lastKeyEvent = NULL;
1011 if (intercepted_by_IM)
1012 {
1013 wxLogTrace(TRACE_KEYS, wxT("Key event intercepted by IM"));
1014 return TRUE;
1015 }
1016 }
1017
1018 if (return_after_IM)
1019 return FALSE;
1020
1021 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1022 // will only be sent if it is not in an accelerator table.
1023 if (!ret)
1024 {
1025 KeySym keysym = gdk_event->keyval;
1026 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1027 long key_code = wxTranslateKeySymToWXKey(keysym, true /* isChar */);
1028 if ( !key_code )
1029 {
1030 if ( wxIsAsciiKeysym(keysym) )
1031 {
1032 // ASCII key
1033 key_code = (unsigned char)keysym;
1034 }
1035 // gdk_event->string is actually deprecated
1036 else if ( gdk_event->length == 1 )
1037 {
1038 key_code = (unsigned char)gdk_event->string[0];
1039 }
1040 }
1041
1042 if ( key_code )
1043 {
1044 wxKeyEvent eventChar(wxEVT_CHAR, event);
1045
1046 wxLogTrace(TRACE_KEYS, wxT("Char event: %ld"), key_code);
1047
1048 eventChar.m_keyCode = key_code;
1049 #if wxUSE_UNICODE
1050 eventChar.m_uniChar = gdk_keyval_to_unicode(key_code);
1051 #endif // wxUSE_UNICODE
1052
1053 AdjustCharEventKeyCodes(eventChar);
1054
1055 ret = win->HandleWindowEvent(eventChar);
1056 }
1057 }
1058
1059 return ret;
1060 }
1061 }
1062
1063 extern "C" {
1064 static void
1065 gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context),
1066 const gchar *str,
1067 wxWindow *window)
1068 {
1069 wxKeyEvent event( wxEVT_CHAR );
1070
1071 // take modifiers, cursor position, timestamp etc. from the last
1072 // key_press_event that was fed into Input Method:
1073 if (window->m_imData->lastKeyEvent)
1074 {
1075 wxFillOtherKeyEventFields(event,
1076 window, window->m_imData->lastKeyEvent);
1077 }
1078 else
1079 {
1080 event.SetEventObject( window );
1081 }
1082
1083 const wxString data(wxGTK_CONV_BACK_SYS(str));
1084 if( data.empty() )
1085 return;
1086
1087 for( wxString::const_iterator pstr = data.begin(); pstr != data.end(); ++pstr )
1088 {
1089 #if wxUSE_UNICODE
1090 event.m_uniChar = *pstr;
1091 // Backward compatible for ISO-8859-1
1092 event.m_keyCode = *pstr < 256 ? event.m_uniChar : 0;
1093 wxLogTrace(TRACE_KEYS, wxT("IM sent character '%c'"), event.m_uniChar);
1094 #else
1095 event.m_keyCode = (char)*pstr;
1096 #endif // wxUSE_UNICODE
1097
1098 AdjustCharEventKeyCodes(event);
1099
1100 window->HandleWindowEvent(event);
1101 }
1102 }
1103 }
1104
1105
1106 //-----------------------------------------------------------------------------
1107 // "key_release_event" from any window
1108 //-----------------------------------------------------------------------------
1109
1110 extern "C" {
1111 static gboolean
1112 gtk_window_key_release_callback( GtkWidget * WXUNUSED(widget),
1113 GdkEventKey *gdk_event,
1114 wxWindowGTK *win )
1115 {
1116 if (!win->m_hasVMT)
1117 return FALSE;
1118
1119 if (g_blockEventsOnDrag)
1120 return FALSE;
1121
1122 wxPROCESS_EVENT_ONCE(GdkEventKey, gdk_event);
1123
1124 wxKeyEvent event( wxEVT_KEY_UP );
1125 if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
1126 {
1127 // unknown key pressed, ignore (the event would be useless anyhow)
1128 return FALSE;
1129 }
1130
1131 return win->GTKProcessEvent(event);
1132 }
1133 }
1134
1135 // ============================================================================
1136 // the mouse events
1137 // ============================================================================
1138
1139 // ----------------------------------------------------------------------------
1140 // mouse event processing helpers
1141 // ----------------------------------------------------------------------------
1142
1143 static void AdjustEventButtonState(wxMouseEvent& event)
1144 {
1145 // GDK reports the old state of the button for a button press event, but
1146 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1147 // for a LEFT_DOWN event, not FALSE, so we will invert
1148 // left/right/middleDown for the corresponding click events
1149
1150 if ((event.GetEventType() == wxEVT_LEFT_DOWN) ||
1151 (event.GetEventType() == wxEVT_LEFT_DCLICK) ||
1152 (event.GetEventType() == wxEVT_LEFT_UP))
1153 {
1154 event.m_leftDown = !event.m_leftDown;
1155 return;
1156 }
1157
1158 if ((event.GetEventType() == wxEVT_MIDDLE_DOWN) ||
1159 (event.GetEventType() == wxEVT_MIDDLE_DCLICK) ||
1160 (event.GetEventType() == wxEVT_MIDDLE_UP))
1161 {
1162 event.m_middleDown = !event.m_middleDown;
1163 return;
1164 }
1165
1166 if ((event.GetEventType() == wxEVT_RIGHT_DOWN) ||
1167 (event.GetEventType() == wxEVT_RIGHT_DCLICK) ||
1168 (event.GetEventType() == wxEVT_RIGHT_UP))
1169 {
1170 event.m_rightDown = !event.m_rightDown;
1171 return;
1172 }
1173
1174 if ((event.GetEventType() == wxEVT_AUX1_DOWN) ||
1175 (event.GetEventType() == wxEVT_AUX1_DCLICK))
1176 {
1177 event.m_aux1Down = true;
1178 return;
1179 }
1180
1181 if ((event.GetEventType() == wxEVT_AUX2_DOWN) ||
1182 (event.GetEventType() == wxEVT_AUX2_DCLICK))
1183 {
1184 event.m_aux2Down = true;
1185 return;
1186 }
1187 }
1188
1189 // find the window to send the mouse event to
1190 static
1191 wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
1192 {
1193 wxCoord xx = x;
1194 wxCoord yy = y;
1195
1196 if (win->m_wxwindow)
1197 {
1198 wxPizza* pizza = WX_PIZZA(win->m_wxwindow);
1199 xx += pizza->m_scroll_x;
1200 yy += pizza->m_scroll_y;
1201 }
1202
1203 wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
1204 while (node)
1205 {
1206 wxWindow* child = static_cast<wxWindow*>(node->GetData());
1207
1208 node = node->GetNext();
1209 if (!child->IsShown())
1210 continue;
1211
1212 if (child->GTKIsTransparentForMouse())
1213 {
1214 // wxStaticBox is transparent in the box itself
1215 int xx1 = child->m_x;
1216 int yy1 = child->m_y;
1217 int xx2 = child->m_x + child->m_width;
1218 int yy2 = child->m_y + child->m_height;
1219
1220 // left
1221 if (((xx >= xx1) && (xx <= xx1+10) && (yy >= yy1) && (yy <= yy2)) ||
1222 // right
1223 ((xx >= xx2-10) && (xx <= xx2) && (yy >= yy1) && (yy <= yy2)) ||
1224 // top
1225 ((xx >= xx1) && (xx <= xx2) && (yy >= yy1) && (yy <= yy1+10)) ||
1226 // bottom
1227 ((xx >= xx1) && (xx <= xx2) && (yy >= yy2-1) && (yy <= yy2)))
1228 {
1229 win = child;
1230 x -= child->m_x;
1231 y -= child->m_y;
1232 break;
1233 }
1234
1235 }
1236 else
1237 {
1238 if ((child->m_wxwindow == NULL) &&
1239 win->IsClientAreaChild(child) &&
1240 (child->m_x <= xx) &&
1241 (child->m_y <= yy) &&
1242 (child->m_x+child->m_width >= xx) &&
1243 (child->m_y+child->m_height >= yy))
1244 {
1245 win = child;
1246 x -= child->m_x;
1247 y -= child->m_y;
1248 break;
1249 }
1250 }
1251 }
1252
1253 return win;
1254 }
1255
1256 // ----------------------------------------------------------------------------
1257 // common event handlers helpers
1258 // ----------------------------------------------------------------------------
1259
1260 bool wxWindowGTK::GTKProcessEvent(wxEvent& event) const
1261 {
1262 // nothing special at this level
1263 return HandleWindowEvent(event);
1264 }
1265
1266 bool wxWindowGTK::GTKShouldIgnoreEvent() const
1267 {
1268 return !m_hasVMT || g_blockEventsOnDrag;
1269 }
1270
1271 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const
1272 {
1273 if (!m_hasVMT)
1274 return FALSE;
1275 if (g_blockEventsOnDrag)
1276 return TRUE;
1277 if (g_blockEventsOnScroll)
1278 return TRUE;
1279
1280 if (!GTKIsOwnWindow(event->window))
1281 return FALSE;
1282
1283 return -1;
1284 }
1285
1286 // overloads for all GDK event types we use here: we need to have this as
1287 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1288 // derives from it in the sense that the structs have the same layout
1289 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1290 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1291 { \
1292 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1293 }
1294
1295 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton)
1296 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion)
1297 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing)
1298
1299 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1300
1301 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1302 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1303 if ( rc != -1 ) \
1304 return rc
1305
1306 // all event handlers must have C linkage as they're called from GTK+ C code
1307 extern "C"
1308 {
1309
1310 //-----------------------------------------------------------------------------
1311 // "button_press_event"
1312 //-----------------------------------------------------------------------------
1313
1314 static gboolean
1315 gtk_window_button_press_callback( GtkWidget* WXUNUSED_IN_GTK3(widget),
1316 GdkEventButton *gdk_event,
1317 wxWindowGTK *win )
1318 {
1319 wxPROCESS_EVENT_ONCE(GdkEventButton, gdk_event);
1320
1321 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1322
1323 g_lastButtonNumber = gdk_event->button;
1324
1325 wxEventType event_type;
1326 wxEventType down;
1327 wxEventType dclick;
1328 switch (gdk_event->button)
1329 {
1330 case 1:
1331 down = wxEVT_LEFT_DOWN;
1332 dclick = wxEVT_LEFT_DCLICK;
1333 break;
1334 case 2:
1335 down = wxEVT_MIDDLE_DOWN;
1336 dclick = wxEVT_MIDDLE_DCLICK;
1337 break;
1338 case 3:
1339 down = wxEVT_RIGHT_DOWN;
1340 dclick = wxEVT_RIGHT_DCLICK;
1341 break;
1342 case 8:
1343 down = wxEVT_AUX1_DOWN;
1344 dclick = wxEVT_AUX1_DCLICK;
1345 break;
1346 case 9:
1347 down = wxEVT_AUX2_DOWN;
1348 dclick = wxEVT_AUX2_DCLICK;
1349 break;
1350 default:
1351 return false;
1352 }
1353 switch (gdk_event->type)
1354 {
1355 case GDK_BUTTON_PRESS:
1356 event_type = down;
1357 // GDK sends surplus button down events
1358 // before a double click event. We
1359 // need to filter these out.
1360 if (win->m_wxwindow)
1361 {
1362 GdkEvent* peek_event = gdk_event_peek();
1363 if (peek_event)
1364 {
1365 const GdkEventType peek_event_type = peek_event->type;
1366 gdk_event_free(peek_event);
1367 if (peek_event_type == GDK_2BUTTON_PRESS ||
1368 peek_event_type == GDK_3BUTTON_PRESS)
1369 {
1370 return true;
1371 }
1372 }
1373 }
1374 break;
1375 case GDK_2BUTTON_PRESS:
1376 event_type = dclick;
1377 #ifndef __WXGTK3__
1378 if (gdk_event->button >= 1 && gdk_event->button <= 3)
1379 {
1380 // Reset GDK internal timestamp variables in order to disable GDK
1381 // triple click events. GDK will then next time believe no button has
1382 // been clicked just before, and send a normal button click event.
1383 GdkDisplay* display = gtk_widget_get_display(widget);
1384 display->button_click_time[1] = 0;
1385 display->button_click_time[0] = 0;
1386 }
1387 #endif // !__WXGTK3__
1388 break;
1389 // we shouldn't get triple clicks at all for GTK2 because we
1390 // suppress them artificially using the code above but we still
1391 // should map them to something for GTK3 and not just ignore them
1392 // as this would lose clicks
1393 case GDK_3BUTTON_PRESS:
1394 event_type = down;
1395 break;
1396 default:
1397 return false;
1398 }
1399
1400 g_lastMouseEvent = (GdkEvent*) gdk_event;
1401
1402 wxMouseEvent event( event_type );
1403 InitMouseEvent( win, event, gdk_event );
1404
1405 AdjustEventButtonState(event);
1406
1407 // find the correct window to send the event to: it may be a different one
1408 // from the one which got it at GTK+ level because some controls don't have
1409 // their own X window and thus cannot get any events.
1410 if ( !g_captureWindow )
1411 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1412
1413 // reset the event object and id in case win changed.
1414 event.SetEventObject( win );
1415 event.SetId( win->GetId() );
1416
1417 bool ret = win->GTKProcessEvent( event );
1418 g_lastMouseEvent = NULL;
1419 if ( ret )
1420 return TRUE;
1421
1422 if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() &&
1423 (gs_currentFocus != win) /* && win->IsFocusable() */)
1424 {
1425 win->SetFocus();
1426 }
1427
1428 if (event_type == wxEVT_RIGHT_DOWN)
1429 {
1430 // generate a "context menu" event: this is similar to right mouse
1431 // click under many GUIs except that it is generated differently
1432 // (right up under MSW, ctrl-click under Mac, right down here) and
1433 //
1434 // (a) it's a command event and so is propagated to the parent
1435 // (b) under some ports it can be generated from kbd too
1436 // (c) it uses screen coords (because of (a))
1437 wxContextMenuEvent evtCtx(
1438 wxEVT_CONTEXT_MENU,
1439 win->GetId(),
1440 win->ClientToScreen(event.GetPosition()));
1441 evtCtx.SetEventObject(win);
1442 return win->GTKProcessEvent(evtCtx);
1443 }
1444
1445 return FALSE;
1446 }
1447
1448 //-----------------------------------------------------------------------------
1449 // "button_release_event"
1450 //-----------------------------------------------------------------------------
1451
1452 static gboolean
1453 gtk_window_button_release_callback( GtkWidget *WXUNUSED(widget),
1454 GdkEventButton *gdk_event,
1455 wxWindowGTK *win )
1456 {
1457 wxPROCESS_EVENT_ONCE(GdkEventButton, gdk_event);
1458
1459 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1460
1461 g_lastButtonNumber = 0;
1462
1463 wxEventType event_type = wxEVT_NULL;
1464
1465 switch (gdk_event->button)
1466 {
1467 case 1:
1468 event_type = wxEVT_LEFT_UP;
1469 break;
1470
1471 case 2:
1472 event_type = wxEVT_MIDDLE_UP;
1473 break;
1474
1475 case 3:
1476 event_type = wxEVT_RIGHT_UP;
1477 break;
1478
1479 case 8:
1480 event_type = wxEVT_AUX1_UP;
1481 break;
1482
1483 case 9:
1484 event_type = wxEVT_AUX2_UP;
1485 break;
1486
1487 default:
1488 // unknown button, don't process
1489 return FALSE;
1490 }
1491
1492 g_lastMouseEvent = (GdkEvent*) gdk_event;
1493
1494 wxMouseEvent event( event_type );
1495 InitMouseEvent( win, event, gdk_event );
1496
1497 AdjustEventButtonState(event);
1498
1499 if ( !g_captureWindow )
1500 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1501
1502 // reset the event object and id in case win changed.
1503 event.SetEventObject( win );
1504 event.SetId( win->GetId() );
1505
1506 bool ret = win->GTKProcessEvent(event);
1507
1508 g_lastMouseEvent = NULL;
1509
1510 return ret;
1511 }
1512
1513 //-----------------------------------------------------------------------------
1514 // "motion_notify_event"
1515 //-----------------------------------------------------------------------------
1516
1517 static gboolean
1518 gtk_window_motion_notify_callback( GtkWidget * WXUNUSED(widget),
1519 GdkEventMotion *gdk_event,
1520 wxWindowGTK *win )
1521 {
1522 wxPROCESS_EVENT_ONCE(GdkEventMotion, gdk_event);
1523
1524 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1525
1526 if (gdk_event->is_hint)
1527 {
1528 int x = 0;
1529 int y = 0;
1530 GdkModifierType state;
1531 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1532 gdk_event->x = x;
1533 gdk_event->y = y;
1534 }
1535
1536 g_lastMouseEvent = (GdkEvent*) gdk_event;
1537
1538 wxMouseEvent event( wxEVT_MOTION );
1539 InitMouseEvent(win, event, gdk_event);
1540
1541 if ( g_captureWindow )
1542 {
1543 // synthesise a mouse enter or leave event if needed
1544 GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
1545 // This seems to be necessary and actually been added to
1546 // GDK itself in version 2.0.X
1547 gdk_flush();
1548
1549 bool hasMouse = winUnderMouse == gdk_event->window;
1550 if ( hasMouse != g_captureWindowHasMouse )
1551 {
1552 // the mouse changed window
1553 g_captureWindowHasMouse = hasMouse;
1554
1555 wxMouseEvent eventM(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1556 : wxEVT_LEAVE_WINDOW);
1557 InitMouseEvent(win, eventM, gdk_event);
1558 eventM.SetEventObject(win);
1559 win->GTKProcessEvent(eventM);
1560 }
1561 }
1562 else // no capture
1563 {
1564 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1565
1566 // reset the event object and id in case win changed.
1567 event.SetEventObject( win );
1568 event.SetId( win->GetId() );
1569 }
1570
1571 if ( !g_captureWindow )
1572 {
1573 wxSetCursorEvent cevent( event.m_x, event.m_y );
1574 if (win->GTKProcessEvent( cevent ))
1575 {
1576 win->SetCursor( cevent.GetCursor() );
1577 }
1578 }
1579
1580 bool ret = win->GTKProcessEvent(event);
1581
1582 g_lastMouseEvent = NULL;
1583
1584 return ret;
1585 }
1586
1587 //-----------------------------------------------------------------------------
1588 // "scroll_event" (mouse wheel event)
1589 //-----------------------------------------------------------------------------
1590
1591 static gboolean
1592 window_scroll_event_hscrollbar(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
1593 {
1594 if (gdk_event->direction != GDK_SCROLL_LEFT &&
1595 gdk_event->direction != GDK_SCROLL_RIGHT)
1596 {
1597 return false;
1598 }
1599
1600 GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Horz];
1601
1602 if (range && gtk_widget_get_visible(GTK_WIDGET(range)))
1603 {
1604 GtkAdjustment* adj = gtk_range_get_adjustment(range);
1605 double delta = gtk_adjustment_get_step_increment(adj) * 3;
1606 if (gdk_event->direction == GDK_SCROLL_LEFT)
1607 delta = -delta;
1608
1609 gtk_range_set_value(range, gtk_adjustment_get_value(adj) + delta);
1610
1611 return TRUE;
1612 }
1613
1614 return FALSE;
1615 }
1616
1617 static gboolean
1618 window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
1619 {
1620 wxMouseEvent event(wxEVT_MOUSEWHEEL);
1621 InitMouseEvent(win, event, gdk_event);
1622
1623 // FIXME: Get these values from GTK or GDK
1624 event.m_linesPerAction = 3;
1625 event.m_wheelDelta = 120;
1626
1627 // Determine the scroll direction.
1628 switch (gdk_event->direction)
1629 {
1630 case GDK_SCROLL_UP:
1631 case GDK_SCROLL_RIGHT:
1632 event.m_wheelRotation = 120;
1633 break;
1634
1635 case GDK_SCROLL_DOWN:
1636 case GDK_SCROLL_LEFT:
1637 event.m_wheelRotation = -120;
1638 break;
1639
1640 default:
1641 return false; // Unknown/unhandled direction
1642 }
1643
1644 // And the scroll axis.
1645 switch (gdk_event->direction)
1646 {
1647 case GDK_SCROLL_UP:
1648 case GDK_SCROLL_DOWN:
1649 event.m_wheelAxis = wxMOUSE_WHEEL_VERTICAL;
1650 break;
1651
1652 case GDK_SCROLL_LEFT:
1653 case GDK_SCROLL_RIGHT:
1654 event.m_wheelAxis = wxMOUSE_WHEEL_HORIZONTAL;
1655 break;
1656 }
1657
1658 if (win->GTKProcessEvent(event))
1659 return TRUE;
1660
1661 GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Vert];
1662
1663 if (range && gtk_widget_get_visible(GTK_WIDGET(range)))
1664 {
1665 GtkAdjustment* adj = gtk_range_get_adjustment(range);
1666 double delta = gtk_adjustment_get_step_increment(adj) * 3;
1667 if (gdk_event->direction == GDK_SCROLL_UP)
1668 delta = -delta;
1669
1670 gtk_range_set_value(range, gtk_adjustment_get_value(adj) + delta);
1671
1672 return TRUE;
1673 }
1674
1675 return FALSE;
1676 }
1677
1678 //-----------------------------------------------------------------------------
1679 // "popup-menu"
1680 //-----------------------------------------------------------------------------
1681
1682 static gboolean wxgtk_window_popup_menu_callback(GtkWidget*, wxWindowGTK* win)
1683 {
1684 wxContextMenuEvent event(wxEVT_CONTEXT_MENU, win->GetId(), wxPoint(-1, -1));
1685 event.SetEventObject(win);
1686 return win->GTKProcessEvent(event);
1687 }
1688
1689 //-----------------------------------------------------------------------------
1690 // "focus_in_event"
1691 //-----------------------------------------------------------------------------
1692
1693 static gboolean
1694 gtk_window_focus_in_callback( GtkWidget * WXUNUSED(widget),
1695 GdkEventFocus *WXUNUSED(event),
1696 wxWindowGTK *win )
1697 {
1698 return win->GTKHandleFocusIn();
1699 }
1700
1701 //-----------------------------------------------------------------------------
1702 // "focus_out_event"
1703 //-----------------------------------------------------------------------------
1704
1705 static gboolean
1706 gtk_window_focus_out_callback( GtkWidget * WXUNUSED(widget),
1707 GdkEventFocus * WXUNUSED(gdk_event),
1708 wxWindowGTK *win )
1709 {
1710 return win->GTKHandleFocusOut();
1711 }
1712
1713 //-----------------------------------------------------------------------------
1714 // "focus"
1715 //-----------------------------------------------------------------------------
1716
1717 static gboolean
1718 wx_window_focus_callback(GtkWidget *widget,
1719 GtkDirectionType WXUNUSED(direction),
1720 wxWindowGTK *win)
1721 {
1722 // the default handler for focus signal in GtkScrolledWindow sets
1723 // focus to the window itself even if it doesn't accept focus, i.e. has no
1724 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1725 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1726 // any children which might accept focus (we know we don't accept the focus
1727 // ourselves as this signal is only connected in this case)
1728 if ( win->GetChildren().empty() )
1729 g_signal_stop_emission_by_name(widget, "focus");
1730
1731 // we didn't change the focus
1732 return FALSE;
1733 }
1734
1735 //-----------------------------------------------------------------------------
1736 // "enter_notify_event"
1737 //-----------------------------------------------------------------------------
1738
1739 static gboolean
1740 gtk_window_enter_callback( GtkWidget *widget,
1741 GdkEventCrossing *gdk_event,
1742 wxWindowGTK *win )
1743 {
1744 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1745
1746 // Event was emitted after a grab
1747 if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
1748
1749 int x = 0;
1750 int y = 0;
1751 GdkModifierType state = (GdkModifierType)0;
1752
1753 gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, &state);
1754
1755 wxMouseEvent event( wxEVT_ENTER_WINDOW );
1756 InitMouseEvent(win, event, gdk_event);
1757 wxPoint pt = win->GetClientAreaOrigin();
1758 event.m_x = x + pt.x;
1759 event.m_y = y + pt.y;
1760
1761 if ( !g_captureWindow )
1762 {
1763 wxSetCursorEvent cevent( event.m_x, event.m_y );
1764 if (win->GTKProcessEvent( cevent ))
1765 {
1766 win->SetCursor( cevent.GetCursor() );
1767 }
1768 }
1769
1770 return win->GTKProcessEvent(event);
1771 }
1772
1773 //-----------------------------------------------------------------------------
1774 // "leave_notify_event"
1775 //-----------------------------------------------------------------------------
1776
1777 static gboolean
1778 gtk_window_leave_callback( GtkWidget *widget,
1779 GdkEventCrossing *gdk_event,
1780 wxWindowGTK *win )
1781 {
1782 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1783
1784 // Event was emitted after an ungrab
1785 if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
1786
1787 wxMouseEvent event( wxEVT_LEAVE_WINDOW );
1788
1789 int x = 0;
1790 int y = 0;
1791 GdkModifierType state = (GdkModifierType)0;
1792
1793 gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, &state);
1794
1795 InitMouseEvent(win, event, gdk_event);
1796
1797 return win->GTKProcessEvent(event);
1798 }
1799
1800 //-----------------------------------------------------------------------------
1801 // "value_changed" from scrollbar
1802 //-----------------------------------------------------------------------------
1803
1804 static void
1805 gtk_scrollbar_value_changed(GtkRange* range, wxWindow* win)
1806 {
1807 wxEventType eventType = win->GTKGetScrollEventType(range);
1808 if (eventType != wxEVT_NULL)
1809 {
1810 // Convert scroll event type to scrollwin event type
1811 eventType += wxEVT_SCROLLWIN_TOP - wxEVT_SCROLL_TOP;
1812
1813 // find the scrollbar which generated the event
1814 wxWindowGTK::ScrollDir dir = win->ScrollDirFromRange(range);
1815
1816 // generate the corresponding wx event
1817 const int orient = wxWindow::OrientFromScrollDir(dir);
1818 wxScrollWinEvent event(eventType, win->GetScrollPos(orient), orient);
1819 event.SetEventObject(win);
1820
1821 win->GTKProcessEvent(event);
1822 }
1823 }
1824
1825 //-----------------------------------------------------------------------------
1826 // "button_press_event" from scrollbar
1827 //-----------------------------------------------------------------------------
1828
1829 static gboolean
1830 gtk_scrollbar_button_press_event(GtkRange*, GdkEventButton*, wxWindow* win)
1831 {
1832 g_blockEventsOnScroll = true;
1833 win->m_mouseButtonDown = true;
1834
1835 return false;
1836 }
1837
1838 //-----------------------------------------------------------------------------
1839 // "event_after" from scrollbar
1840 //-----------------------------------------------------------------------------
1841
1842 static void
1843 gtk_scrollbar_event_after(GtkRange* range, GdkEvent* event, wxWindow* win)
1844 {
1845 if (event->type == GDK_BUTTON_RELEASE)
1846 {
1847 g_signal_handlers_block_by_func(range, (void*)gtk_scrollbar_event_after, win);
1848
1849 const int orient = wxWindow::OrientFromScrollDir(
1850 win->ScrollDirFromRange(range));
1851 wxScrollWinEvent evt(wxEVT_SCROLLWIN_THUMBRELEASE,
1852 win->GetScrollPos(orient), orient);
1853 evt.SetEventObject(win);
1854 win->GTKProcessEvent(evt);
1855 }
1856 }
1857
1858 //-----------------------------------------------------------------------------
1859 // "button_release_event" from scrollbar
1860 //-----------------------------------------------------------------------------
1861
1862 static gboolean
1863 gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* win)
1864 {
1865 g_blockEventsOnScroll = false;
1866 win->m_mouseButtonDown = false;
1867 // If thumb tracking
1868 if (win->m_isScrolling)
1869 {
1870 win->m_isScrolling = false;
1871 // Hook up handler to send thumb release event after this emission is finished.
1872 // To allow setting scroll position from event handler, sending event must
1873 // be deferred until after the GtkRange handler for this signal has run
1874 g_signal_handlers_unblock_by_func(range, (void*)gtk_scrollbar_event_after, win);
1875 }
1876
1877 return false;
1878 }
1879
1880 //-----------------------------------------------------------------------------
1881 // "realize" from m_widget
1882 //-----------------------------------------------------------------------------
1883
1884 static void
1885 gtk_window_realized_callback(GtkWidget* WXUNUSED(widget), wxWindowGTK* win)
1886 {
1887 win->GTKHandleRealized();
1888 }
1889
1890 //-----------------------------------------------------------------------------
1891 // "size_allocate" from m_wxwindow or m_widget
1892 //-----------------------------------------------------------------------------
1893
1894 static void
1895 size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win)
1896 {
1897 int w = alloc->width;
1898 int h = alloc->height;
1899 if (win->m_wxwindow)
1900 {
1901 GtkBorder border;
1902 WX_PIZZA(win->m_wxwindow)->get_border(border);
1903 w -= border.left + border.right;
1904 h -= border.top + border.bottom;
1905 if (w < 0) w = 0;
1906 if (h < 0) h = 0;
1907 }
1908 if (win->m_oldClientWidth != w || win->m_oldClientHeight != h)
1909 {
1910 win->m_oldClientWidth = w;
1911 win->m_oldClientHeight = h;
1912 // this callback can be connected to m_wxwindow,
1913 // so always get size from m_widget->allocation
1914 GtkAllocation a;
1915 gtk_widget_get_allocation(win->m_widget, &a);
1916 win->m_width = a.width;
1917 win->m_height = a.height;
1918 if (!win->m_nativeSizeEvent)
1919 {
1920 wxSizeEvent event(win->GetSize(), win->GetId());
1921 event.SetEventObject(win);
1922 win->GTKProcessEvent(event);
1923 }
1924 }
1925 }
1926
1927 //-----------------------------------------------------------------------------
1928 // "grab_broken"
1929 //-----------------------------------------------------------------------------
1930
1931 #if GTK_CHECK_VERSION(2, 8, 0)
1932 static gboolean
1933 gtk_window_grab_broken( GtkWidget*,
1934 GdkEventGrabBroken *event,
1935 wxWindow *win )
1936 {
1937 // Mouse capture has been lost involuntarily, notify the application
1938 if(!event->keyboard && wxWindow::GetCapture() == win)
1939 {
1940 wxMouseCaptureLostEvent evt( win->GetId() );
1941 evt.SetEventObject( win );
1942 win->HandleWindowEvent( evt );
1943 }
1944 return false;
1945 }
1946 #endif
1947
1948 //-----------------------------------------------------------------------------
1949 // "style_set"/"style_updated"
1950 //-----------------------------------------------------------------------------
1951
1952 #ifdef __WXGTK3__
1953 static void style_updated(GtkWidget*, wxWindow* win)
1954 #else
1955 static void style_updated(GtkWidget*, GtkStyle*, wxWindow* win)
1956 #endif
1957 {
1958 if (win->IsTopLevel())
1959 {
1960 wxSysColourChangedEvent event;
1961 event.SetEventObject(win);
1962 win->GTKProcessEvent(event);
1963 }
1964 else
1965 {
1966 // Border width could change, which will change client size.
1967 // Make sure size event occurs for this
1968 win->m_oldClientWidth = 0;
1969 }
1970 }
1971
1972 //-----------------------------------------------------------------------------
1973 // "unrealize" from m_wxwindow
1974 //-----------------------------------------------------------------------------
1975
1976 static void unrealize(GtkWidget*, wxWindow* win)
1977 {
1978 if (win->m_imData)
1979 gtk_im_context_set_client_window(win->m_imData->context, NULL);
1980
1981 g_signal_handlers_disconnect_by_func(
1982 win->m_wxwindow, (void*)style_updated, win);
1983 }
1984
1985 } // extern "C"
1986
1987 void wxWindowGTK::GTKHandleRealized()
1988 {
1989 if (m_imData)
1990 {
1991 gtk_im_context_set_client_window
1992 (
1993 m_imData->context,
1994 m_wxwindow ? GTKGetDrawingWindow()
1995 : gtk_widget_get_window(m_widget)
1996 );
1997 }
1998
1999 // Use composited window if background is transparent, if supported.
2000 if (m_backgroundStyle == wxBG_STYLE_TRANSPARENT)
2001 {
2002 #if wxGTK_HAS_COMPOSITING_SUPPORT
2003 if (IsTransparentBackgroundSupported())
2004 {
2005 GdkWindow* const window = GTKGetDrawingWindow();
2006 if (window)
2007 gdk_window_set_composited(window, true);
2008 }
2009 else
2010 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
2011 {
2012 // We revert to erase mode if transparency is not supported
2013 m_backgroundStyle = wxBG_STYLE_ERASE;
2014 }
2015 }
2016
2017
2018 // We cannot set colours and fonts before the widget
2019 // been realized, so we do this directly after realization
2020 // or otherwise in idle time
2021
2022 if (m_needsStyleChange)
2023 {
2024 SetBackgroundStyle(GetBackgroundStyle());
2025 m_needsStyleChange = false;
2026 }
2027
2028 wxWindowCreateEvent event(static_cast<wxWindow*>(this));
2029 event.SetEventObject( this );
2030 GTKProcessEvent( event );
2031
2032 GTKUpdateCursor(true, false);
2033
2034 if (m_wxwindow &&
2035 (IsTopLevel() || HasFlag(wxBORDER_RAISED | wxBORDER_SUNKEN | wxBORDER_THEME)))
2036 {
2037 // attaching to style changed signal after realization avoids initial
2038 // changes we don't care about
2039 const gchar *detailed_signal =
2040 #ifdef __WXGTK3__
2041 "style_updated";
2042 #else
2043 "style_set";
2044 #endif
2045 g_signal_connect(m_wxwindow,
2046 detailed_signal,
2047 G_CALLBACK(style_updated), this);
2048 }
2049 }
2050
2051 // ----------------------------------------------------------------------------
2052 // this wxWindowBase function is implemented here (in platform-specific file)
2053 // because it is static and so couldn't be made virtual
2054 // ----------------------------------------------------------------------------
2055
2056 wxWindow *wxWindowBase::DoFindFocus()
2057 {
2058 // For compatibility with wxMSW, pretend that showing a popup menu doesn't
2059 // change the focus and that it remains on the window showing it, even
2060 // though the real focus does change in GTK.
2061 extern wxMenu *wxCurrentPopupMenu;
2062 if ( wxCurrentPopupMenu )
2063 return wxCurrentPopupMenu->GetInvokingWindow();
2064
2065 wxWindowGTK *focus = gs_pendingFocus ? gs_pendingFocus : gs_currentFocus;
2066 // the cast is necessary when we compile in wxUniversal mode
2067 return static_cast<wxWindow*>(focus);
2068 }
2069
2070 void wxWindowGTK::AddChildGTK(wxWindowGTK* child)
2071 {
2072 wxASSERT_MSG(m_wxwindow, "Cannot add a child to a window without a client area");
2073
2074 // the window might have been scrolled already, we
2075 // have to adapt the position
2076 wxPizza* pizza = WX_PIZZA(m_wxwindow);
2077 child->m_x += pizza->m_scroll_x;
2078 child->m_y += pizza->m_scroll_y;
2079
2080 pizza->put(child->m_widget,
2081 child->m_x, child->m_y, child->m_width, child->m_height);
2082 }
2083
2084 //-----------------------------------------------------------------------------
2085 // global functions
2086 //-----------------------------------------------------------------------------
2087
2088 wxWindow *wxGetActiveWindow()
2089 {
2090 return wxWindow::FindFocus();
2091 }
2092
2093
2094 // Under Unix this is implemented using X11 functions in utilsx11.cpp but we
2095 // need to have this function under Windows too, so provide at least a stub.
2096 #ifndef GDK_WINDOWING_X11
2097 bool wxGetKeyState(wxKeyCode WXUNUSED(key))
2098 {
2099 wxFAIL_MSG(wxS("Not implemented under Windows"));
2100 return false;
2101 }
2102 #endif // __WINDOWS__
2103
2104 static void GetMouseState(int& x, int& y, GdkModifierType& mask)
2105 {
2106 wxWindow* tlw = NULL;
2107 if (!wxTopLevelWindows.empty())
2108 tlw = wxTopLevelWindows.front();
2109 GdkDisplay* display;
2110 if (tlw && tlw->m_widget)
2111 display = gtk_widget_get_display(tlw->m_widget);
2112 else
2113 display = gdk_display_get_default();
2114 gdk_display_get_pointer(display, NULL, &x, &y, &mask);
2115 }
2116
2117 wxMouseState wxGetMouseState()
2118 {
2119 wxMouseState ms;
2120
2121 gint x;
2122 gint y;
2123 GdkModifierType mask;
2124
2125 GetMouseState(x, y, mask);
2126
2127 ms.SetX(x);
2128 ms.SetY(y);
2129 ms.SetLeftDown((mask & GDK_BUTTON1_MASK) != 0);
2130 ms.SetMiddleDown((mask & GDK_BUTTON2_MASK) != 0);
2131 ms.SetRightDown((mask & GDK_BUTTON3_MASK) != 0);
2132 // see the comment in InitMouseEvent()
2133 ms.SetAux1Down((mask & GDK_BUTTON4_MASK) != 0);
2134 ms.SetAux2Down((mask & GDK_BUTTON5_MASK) != 0);
2135
2136 ms.SetControlDown((mask & GDK_CONTROL_MASK) != 0);
2137 ms.SetShiftDown((mask & GDK_SHIFT_MASK) != 0);
2138 ms.SetAltDown((mask & GDK_MOD1_MASK) != 0);
2139 ms.SetMetaDown((mask & GDK_META_MASK) != 0);
2140
2141 return ms;
2142 }
2143
2144 //-----------------------------------------------------------------------------
2145 // wxWindowGTK
2146 //-----------------------------------------------------------------------------
2147
2148 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2149 // method
2150 #ifdef __WXUNIVERSAL__
2151 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
2152 #endif // __WXUNIVERSAL__
2153
2154 void wxWindowGTK::Init()
2155 {
2156 // GTK specific
2157 m_widget = NULL;
2158 m_wxwindow = NULL;
2159 m_focusWidget = NULL;
2160
2161 // position/size
2162 m_x = 0;
2163 m_y = 0;
2164 m_width = 0;
2165 m_height = 0;
2166
2167 m_hasVMT = false;
2168
2169 m_showOnIdle = false;
2170
2171 m_noExpose = false;
2172 m_nativeSizeEvent = false;
2173 #ifdef __WXGTK3__
2174 m_paintContext = NULL;
2175 #endif
2176
2177 m_isScrolling = false;
2178 m_mouseButtonDown = false;
2179
2180 // initialize scrolling stuff
2181 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
2182 {
2183 m_scrollBar[dir] = NULL;
2184 m_scrollPos[dir] = 0;
2185 }
2186
2187 m_oldClientWidth =
2188 m_oldClientHeight = 0;
2189
2190 m_clipPaintRegion = false;
2191
2192 m_needsStyleChange = false;
2193
2194 m_cursor = *wxSTANDARD_CURSOR;
2195
2196 m_imData = NULL;
2197 m_dirtyTabOrder = false;
2198 }
2199
2200 wxWindowGTK::wxWindowGTK()
2201 {
2202 Init();
2203 }
2204
2205 wxWindowGTK::wxWindowGTK( wxWindow *parent,
2206 wxWindowID id,
2207 const wxPoint &pos,
2208 const wxSize &size,
2209 long style,
2210 const wxString &name )
2211 {
2212 Init();
2213
2214 Create( parent, id, pos, size, style, name );
2215 }
2216
2217 void wxWindowGTK::GTKCreateScrolledWindowWith(GtkWidget* view)
2218 {
2219 wxASSERT_MSG( HasFlag(wxHSCROLL) || HasFlag(wxVSCROLL),
2220 wxS("Must not be called if scrolling is not needed.") );
2221
2222 m_widget = gtk_scrolled_window_new( NULL, NULL );
2223
2224 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
2225
2226 // There is a conflict with default bindings at GTK+
2227 // level between scrolled windows and notebooks both of which want to use
2228 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2229 // direction and notebooks for changing pages -- we decide that if we don't
2230 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2231 // means we can get working keyboard navigation in notebooks
2232 if ( !HasFlag(wxHSCROLL) )
2233 {
2234 GtkBindingSet *
2235 bindings = gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget));
2236 if ( bindings )
2237 {
2238 gtk_binding_entry_remove(bindings, GDK_Page_Up, GDK_CONTROL_MASK);
2239 gtk_binding_entry_remove(bindings, GDK_Page_Down, GDK_CONTROL_MASK);
2240 }
2241 }
2242
2243 if (HasFlag(wxALWAYS_SHOW_SB))
2244 {
2245 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
2246 }
2247 else
2248 {
2249 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
2250 }
2251
2252 m_scrollBar[ScrollDir_Horz] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow));
2253 m_scrollBar[ScrollDir_Vert] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow));
2254 if (GetLayoutDirection() == wxLayout_RightToLeft)
2255 gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );
2256
2257 gtk_container_add( GTK_CONTAINER(m_widget), view );
2258
2259 // connect various scroll-related events
2260 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
2261 {
2262 // these handlers block mouse events to any window during scrolling
2263 // such as motion events and prevent GTK and wxWidgets from fighting
2264 // over where the slider should be
2265 g_signal_connect(m_scrollBar[dir], "button_press_event",
2266 G_CALLBACK(gtk_scrollbar_button_press_event), this);
2267 g_signal_connect(m_scrollBar[dir], "button_release_event",
2268 G_CALLBACK(gtk_scrollbar_button_release_event), this);
2269
2270 gulong handler_id = g_signal_connect(m_scrollBar[dir], "event_after",
2271 G_CALLBACK(gtk_scrollbar_event_after), this);
2272 g_signal_handler_block(m_scrollBar[dir], handler_id);
2273
2274 // these handlers get notified when scrollbar slider moves
2275 g_signal_connect_after(m_scrollBar[dir], "value_changed",
2276 G_CALLBACK(gtk_scrollbar_value_changed), this);
2277 }
2278
2279 gtk_widget_show( view );
2280 }
2281
2282 bool wxWindowGTK::Create( wxWindow *parent,
2283 wxWindowID id,
2284 const wxPoint &pos,
2285 const wxSize &size,
2286 long style,
2287 const wxString &name )
2288 {
2289 // Get default border
2290 wxBorder border = GetBorder(style);
2291
2292 style &= ~wxBORDER_MASK;
2293 style |= border;
2294
2295 if (!PreCreation( parent, pos, size ) ||
2296 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2297 {
2298 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2299 return false;
2300 }
2301
2302 // We should accept the native look
2303 #if 0
2304 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2305 scroll_class->scrollbar_spacing = 0;
2306 #endif
2307
2308
2309 m_wxwindow = wxPizza::New(m_windowStyle);
2310 #ifndef __WXUNIVERSAL__
2311 if (HasFlag(wxPizza::BORDER_STYLES))
2312 {
2313 g_signal_connect(m_wxwindow, "parent_set",
2314 G_CALLBACK(parent_set), this);
2315 }
2316 #endif
2317 if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
2318 m_widget = m_wxwindow;
2319 else
2320 GTKCreateScrolledWindowWith(m_wxwindow);
2321 g_object_ref(m_widget);
2322
2323 if (m_parent)
2324 m_parent->DoAddChild( this );
2325
2326 m_focusWidget = m_wxwindow;
2327
2328 SetCanFocus(AcceptsFocus());
2329
2330 PostCreation();
2331
2332 return true;
2333 }
2334
2335 wxWindowGTK::~wxWindowGTK()
2336 {
2337 SendDestroyEvent();
2338
2339 if (gs_currentFocus == this)
2340 gs_currentFocus = NULL;
2341 if (gs_pendingFocus == this)
2342 gs_pendingFocus = NULL;
2343
2344 if ( gs_deferredFocusOut == this )
2345 gs_deferredFocusOut = NULL;
2346
2347 m_hasVMT = false;
2348
2349 // destroy children before destroying this window itself
2350 DestroyChildren();
2351
2352 // unhook focus handlers to prevent stray events being
2353 // propagated to this (soon to be) dead object
2354 if (m_focusWidget != NULL)
2355 {
2356 g_signal_handlers_disconnect_by_func (m_focusWidget,
2357 (gpointer) gtk_window_focus_in_callback,
2358 this);
2359 g_signal_handlers_disconnect_by_func (m_focusWidget,
2360 (gpointer) gtk_window_focus_out_callback,
2361 this);
2362 }
2363
2364 if (m_widget)
2365 Show( false );
2366
2367 // delete before the widgets to avoid a crash on solaris
2368 delete m_imData;
2369 m_imData = NULL;
2370
2371 // avoid problem with GTK+ 2.18 where a frozen window causes the whole
2372 // TLW to be frozen, and if the window is then destroyed, nothing ever
2373 // gets painted again
2374 if (IsFrozen())
2375 DoThaw();
2376
2377 if (m_widget)
2378 {
2379 // Note that gtk_widget_destroy() does not destroy the widget, it just
2380 // emits the "destroy" signal. The widget is not actually destroyed
2381 // until its reference count drops to zero.
2382 gtk_widget_destroy(m_widget);
2383 // Release our reference, should be the last one
2384 g_object_unref(m_widget);
2385 m_widget = NULL;
2386 }
2387 m_wxwindow = NULL;
2388 }
2389
2390 bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
2391 {
2392 if ( GTKNeedsParent() )
2393 {
2394 wxCHECK_MSG( parent, false, wxT("Must have non-NULL parent") );
2395 }
2396
2397 // Use either the given size, or the default if -1 is given.
2398 // See wxWindowBase for these functions.
2399 m_width = WidthDefault(size.x) ;
2400 m_height = HeightDefault(size.y);
2401
2402 if (pos != wxDefaultPosition)
2403 {
2404 m_x = pos.x;
2405 m_y = pos.y;
2406 }
2407
2408 return true;
2409 }
2410
2411 void wxWindowGTK::PostCreation()
2412 {
2413 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2414
2415 #if wxGTK_HAS_COMPOSITING_SUPPORT
2416 // Set RGBA visual as soon as possible to minimize the possibility that
2417 // somebody uses the wrong one.
2418 if ( m_backgroundStyle == wxBG_STYLE_TRANSPARENT &&
2419 IsTransparentBackgroundSupported() )
2420 {
2421 GdkScreen *screen = gtk_widget_get_screen (m_widget);
2422 #ifdef __WXGTK3__
2423 gtk_widget_set_visual(m_widget, gdk_screen_get_rgba_visual(screen));
2424 #else
2425 GdkColormap *rgba_colormap = gdk_screen_get_rgba_colormap (screen);
2426
2427 if (rgba_colormap)
2428 gtk_widget_set_colormap(m_widget, rgba_colormap);
2429 #endif
2430 }
2431 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
2432
2433 if (m_wxwindow)
2434 {
2435 if (!m_noExpose)
2436 {
2437 // these get reported to wxWidgets -> wxPaintEvent
2438 #ifdef __WXGTK3__
2439 g_signal_connect(m_wxwindow, "draw", G_CALLBACK(draw), this);
2440 #else
2441 g_signal_connect(m_wxwindow, "expose_event", G_CALLBACK(expose_event), this);
2442 #endif
2443
2444 if (GetLayoutDirection() == wxLayout_LeftToRight)
2445 gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE));
2446 }
2447
2448 // Create input method handler
2449 m_imData = new wxGtkIMData;
2450
2451 // Cannot handle drawing preedited text yet
2452 gtk_im_context_set_use_preedit( m_imData->context, FALSE );
2453
2454 g_signal_connect (m_imData->context, "commit",
2455 G_CALLBACK (gtk_wxwindow_commit_cb), this);
2456 g_signal_connect(m_wxwindow, "unrealize", G_CALLBACK(unrealize), this);
2457 }
2458
2459 // focus handling
2460
2461 if (!GTK_IS_WINDOW(m_widget))
2462 {
2463 if (m_focusWidget == NULL)
2464 m_focusWidget = m_widget;
2465
2466 if (m_wxwindow)
2467 {
2468 g_signal_connect (m_focusWidget, "focus_in_event",
2469 G_CALLBACK (gtk_window_focus_in_callback), this);
2470 g_signal_connect (m_focusWidget, "focus_out_event",
2471 G_CALLBACK (gtk_window_focus_out_callback), this);
2472 }
2473 else
2474 {
2475 g_signal_connect_after (m_focusWidget, "focus_in_event",
2476 G_CALLBACK (gtk_window_focus_in_callback), this);
2477 g_signal_connect_after (m_focusWidget, "focus_out_event",
2478 G_CALLBACK (gtk_window_focus_out_callback), this);
2479 }
2480 }
2481
2482 if ( !AcceptsFocusFromKeyboard() )
2483 {
2484 SetCanFocus(false);
2485
2486 g_signal_connect(m_widget, "focus",
2487 G_CALLBACK(wx_window_focus_callback), this);
2488 }
2489
2490 // connect to the various key and mouse handlers
2491
2492 GtkWidget *connect_widget = GetConnectWidget();
2493
2494 ConnectWidget( connect_widget );
2495
2496 // We cannot set colours, fonts and cursors before the widget has been
2497 // realized, so we do this directly after realization -- unless the widget
2498 // was in fact realized already.
2499 if ( gtk_widget_get_realized(connect_widget) )
2500 {
2501 gtk_window_realized_callback(connect_widget, this);
2502 }
2503 else
2504 {
2505 g_signal_connect (connect_widget, "realize",
2506 G_CALLBACK (gtk_window_realized_callback), this);
2507 }
2508
2509 if (!IsTopLevel())
2510 {
2511 g_signal_connect(m_wxwindow ? m_wxwindow : m_widget, "size_allocate",
2512 G_CALLBACK(size_allocate), this);
2513 }
2514
2515 #if GTK_CHECK_VERSION(2, 8, 0)
2516 #ifndef __WXGTK3__
2517 if ( gtk_check_version(2,8,0) == NULL )
2518 #endif
2519 {
2520 // Make sure we can notify the app when mouse capture is lost
2521 if ( m_wxwindow )
2522 {
2523 g_signal_connect (m_wxwindow, "grab_broken_event",
2524 G_CALLBACK (gtk_window_grab_broken), this);
2525 }
2526
2527 if ( connect_widget != m_wxwindow )
2528 {
2529 g_signal_connect (connect_widget, "grab_broken_event",
2530 G_CALLBACK (gtk_window_grab_broken), this);
2531 }
2532 }
2533 #endif // GTK+ >= 2.8
2534
2535 if (!WX_IS_PIZZA(gtk_widget_get_parent(m_widget)) && !GTK_IS_WINDOW(m_widget))
2536 gtk_widget_set_size_request(m_widget, m_width, m_height);
2537
2538 InheritAttributes();
2539
2540 m_hasVMT = true;
2541
2542 SetLayoutDirection(wxLayout_Default);
2543
2544 // unless the window was created initially hidden (i.e. Hide() had been
2545 // called before Create()), we should show it at GTK+ level as well
2546 if ( IsShown() )
2547 gtk_widget_show( m_widget );
2548 }
2549
2550 unsigned long
2551 wxWindowGTK::GTKConnectWidget(const char *signal, wxGTKCallback callback)
2552 {
2553 return g_signal_connect(m_widget, signal, callback, this);
2554 }
2555
2556 void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2557 {
2558 g_signal_connect (widget, "key_press_event",
2559 G_CALLBACK (gtk_window_key_press_callback), this);
2560 g_signal_connect (widget, "key_release_event",
2561 G_CALLBACK (gtk_window_key_release_callback), this);
2562 g_signal_connect (widget, "button_press_event",
2563 G_CALLBACK (gtk_window_button_press_callback), this);
2564 g_signal_connect (widget, "button_release_event",
2565 G_CALLBACK (gtk_window_button_release_callback), this);
2566 g_signal_connect (widget, "motion_notify_event",
2567 G_CALLBACK (gtk_window_motion_notify_callback), this);
2568
2569 g_signal_connect (widget, "scroll_event",
2570 G_CALLBACK (window_scroll_event), this);
2571 if (m_scrollBar[ScrollDir_Horz])
2572 g_signal_connect (m_scrollBar[ScrollDir_Horz], "scroll_event",
2573 G_CALLBACK (window_scroll_event_hscrollbar), this);
2574 if (m_scrollBar[ScrollDir_Vert])
2575 g_signal_connect (m_scrollBar[ScrollDir_Vert], "scroll_event",
2576 G_CALLBACK (window_scroll_event), this);
2577
2578 g_signal_connect (widget, "popup_menu",
2579 G_CALLBACK (wxgtk_window_popup_menu_callback), this);
2580 g_signal_connect (widget, "enter_notify_event",
2581 G_CALLBACK (gtk_window_enter_callback), this);
2582 g_signal_connect (widget, "leave_notify_event",
2583 G_CALLBACK (gtk_window_leave_callback), this);
2584 }
2585
2586 bool wxWindowGTK::Destroy()
2587 {
2588 m_hasVMT = false;
2589
2590 return wxWindowBase::Destroy();
2591 }
2592
2593 static GSList* gs_queueResizeList;
2594
2595 extern "C" {
2596 static gboolean queue_resize(void*)
2597 {
2598 gdk_threads_enter();
2599 for (GSList* p = gs_queueResizeList; p; p = p->next)
2600 {
2601 if (p->data)
2602 {
2603 gtk_widget_queue_resize(GTK_WIDGET(p->data));
2604 g_object_remove_weak_pointer(G_OBJECT(p->data), &p->data);
2605 }
2606 }
2607 g_slist_free(gs_queueResizeList);
2608 gs_queueResizeList = NULL;
2609 gdk_threads_leave();
2610 return false;
2611 }
2612 }
2613
2614 void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
2615 {
2616 gtk_widget_set_size_request(m_widget, width, height);
2617 GtkWidget* parent = gtk_widget_get_parent(m_widget);
2618 if (WX_IS_PIZZA(parent))
2619 WX_PIZZA(parent)->move(m_widget, x, y, width, height);
2620
2621 // With GTK3, gtk_widget_queue_resize() is ignored while a size-allocate
2622 // is in progress. This situation is common in wxWidgets, since
2623 // size-allocate can generate wxSizeEvent and size event handlers often
2624 // call SetSize(), directly or indirectly. Work around this by deferring
2625 // the queue-resize until after size-allocate processing is finished.
2626 if (g_slist_find(gs_queueResizeList, m_widget) == NULL)
2627 {
2628 if (gs_queueResizeList == NULL)
2629 g_idle_add_full(GTK_PRIORITY_RESIZE, queue_resize, NULL, NULL);
2630 gs_queueResizeList = g_slist_prepend(gs_queueResizeList, m_widget);
2631 g_object_add_weak_pointer(G_OBJECT(m_widget), &gs_queueResizeList->data);
2632 }
2633 }
2634
2635 void wxWindowGTK::ConstrainSize()
2636 {
2637 #ifdef __WXGPE__
2638 // GPE's window manager doesn't like size hints at all, esp. when the user
2639 // has to use the virtual keyboard, so don't constrain size there
2640 if (!IsTopLevel())
2641 #endif
2642 {
2643 const wxSize minSize = GetMinSize();
2644 const wxSize maxSize = GetMaxSize();
2645 if (minSize.x > 0 && m_width < minSize.x) m_width = minSize.x;
2646 if (minSize.y > 0 && m_height < minSize.y) m_height = minSize.y;
2647 if (maxSize.x > 0 && m_width > maxSize.x) m_width = maxSize.x;
2648 if (maxSize.y > 0 && m_height > maxSize.y) m_height = maxSize.y;
2649 }
2650 }
2651
2652 void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2653 {
2654 wxCHECK_RET(m_widget, "invalid window");
2655
2656 int scrollX = 0, scrollY = 0;
2657 GtkWidget* parent = gtk_widget_get_parent(m_widget);
2658 if (WX_IS_PIZZA(parent))
2659 {
2660 wxPizza* pizza = WX_PIZZA(parent);
2661 scrollX = pizza->m_scroll_x;
2662 scrollY = pizza->m_scroll_y;
2663 }
2664 if (x != -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2665 x += scrollX;
2666 else
2667 x = m_x;
2668 if (y != -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2669 y += scrollY;
2670 else
2671 y = m_y;
2672
2673 // calculate the best size if we should auto size the window
2674 if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
2675 ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
2676 {
2677 const wxSize sizeBest = GetBestSize();
2678 if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
2679 width = sizeBest.x;
2680 if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
2681 height = sizeBest.y;
2682 }
2683
2684 if (width == -1)
2685 width = m_width;
2686 if (height == -1)
2687 height = m_height;
2688
2689 const bool sizeChange = m_width != width || m_height != height;
2690 if (sizeChange || m_x != x || m_y != y)
2691 {
2692 m_x = x;
2693 m_y = y;
2694 m_width = width;
2695 m_height = height;
2696
2697 /* the default button has a border around it */
2698 if (gtk_widget_get_can_default(m_widget))
2699 {
2700 GtkBorder *default_border = NULL;
2701 gtk_widget_style_get( m_widget, "default_border", &default_border, NULL );
2702 if (default_border)
2703 {
2704 x -= default_border->left;
2705 y -= default_border->top;
2706 width += default_border->left + default_border->right;
2707 height += default_border->top + default_border->bottom;
2708 gtk_border_free( default_border );
2709 }
2710 }
2711
2712 DoMoveWindow(x, y, width, height);
2713 }
2714
2715 if ((sizeChange && !m_nativeSizeEvent) || (sizeFlags & wxSIZE_FORCE_EVENT))
2716 {
2717 // update these variables to keep size_allocate handler
2718 // from sending another size event for this change
2719 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
2720
2721 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2722 event.SetEventObject( this );
2723 HandleWindowEvent( event );
2724 }
2725 }
2726
2727 bool wxWindowGTK::GTKShowFromOnIdle()
2728 {
2729 if (IsShown() && m_showOnIdle && !gtk_widget_get_visible (m_widget))
2730 {
2731 GtkAllocation alloc;
2732 alloc.x = m_x;
2733 alloc.y = m_y;
2734 alloc.width = m_width;
2735 alloc.height = m_height;
2736 gtk_widget_size_allocate( m_widget, &alloc );
2737 gtk_widget_show( m_widget );
2738 wxShowEvent eventShow(GetId(), true);
2739 eventShow.SetEventObject(this);
2740 HandleWindowEvent(eventShow);
2741 m_showOnIdle = false;
2742 return true;
2743 }
2744
2745 return false;
2746 }
2747
2748 void wxWindowGTK::OnInternalIdle()
2749 {
2750 if ( gs_deferredFocusOut )
2751 GTKHandleDeferredFocusOut();
2752
2753 // Check if we have to show window now
2754 if (GTKShowFromOnIdle()) return;
2755
2756 if ( m_dirtyTabOrder )
2757 {
2758 m_dirtyTabOrder = false;
2759 RealizeTabOrder();
2760 }
2761
2762 wxWindowBase::OnInternalIdle();
2763 }
2764
2765 void wxWindowGTK::DoGetSize( int *width, int *height ) const
2766 {
2767 if (width) (*width) = m_width;
2768 if (height) (*height) = m_height;
2769 }
2770
2771 void wxWindowGTK::DoSetClientSize( int width, int height )
2772 {
2773 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2774
2775 const wxSize size = GetSize();
2776 const wxSize clientSize = GetClientSize();
2777 SetSize(width + (size.x - clientSize.x), height + (size.y - clientSize.y));
2778 }
2779
2780 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
2781 {
2782 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2783
2784 int w = m_width;
2785 int h = m_height;
2786
2787 if ( m_wxwindow )
2788 {
2789 // if window is scrollable, account for scrollbars
2790 if ( GTK_IS_SCROLLED_WINDOW(m_widget) )
2791 {
2792 GtkPolicyType policy[ScrollDir_Max];
2793 gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget),
2794 &policy[ScrollDir_Horz],
2795 &policy[ScrollDir_Vert]);
2796 const int scrollbar_spacing =
2797 GTK_SCROLLED_WINDOW_GET_CLASS(m_widget)->scrollbar_spacing;
2798
2799 for ( int i = 0; i < ScrollDir_Max; i++ )
2800 {
2801 // don't account for the scrollbars we don't have
2802 GtkRange * const range = m_scrollBar[i];
2803 if ( !range )
2804 continue;
2805
2806 // nor for the ones we have but don't current show
2807 switch ( policy[i] )
2808 {
2809 case GTK_POLICY_NEVER:
2810 // never shown so doesn't take any place
2811 continue;
2812
2813 case GTK_POLICY_ALWAYS:
2814 // no checks necessary
2815 break;
2816
2817 case GTK_POLICY_AUTOMATIC:
2818 // may be shown or not, check
2819 GtkAdjustment *adj = gtk_range_get_adjustment(range);
2820 if (gtk_adjustment_get_upper(adj) <= gtk_adjustment_get_page_size(adj))
2821 continue;
2822 }
2823
2824 GtkRequisition req;
2825 #ifdef __WXGTK3__
2826 GtkWidget* widget = GTK_WIDGET(range);
2827 if (i == ScrollDir_Horz)
2828 {
2829 if (height)
2830 {
2831 gtk_widget_get_preferred_height(widget, NULL, &req.height);
2832 h -= req.height + scrollbar_spacing;
2833 }
2834 }
2835 else
2836 {
2837 if (width)
2838 {
2839 gtk_widget_get_preferred_width(widget, NULL, &req.width);
2840 w -= req.width + scrollbar_spacing;
2841 }
2842 }
2843 #else // !__WXGTK3__
2844 gtk_widget_size_request(GTK_WIDGET(range), &req);
2845 if (i == ScrollDir_Horz)
2846 h -= req.height + scrollbar_spacing;
2847 else
2848 w -= req.width + scrollbar_spacing;
2849 #endif // !__WXGTK3__
2850 }
2851 }
2852
2853 const wxSize sizeBorders = DoGetBorderSize();
2854 w -= sizeBorders.x;
2855 h -= sizeBorders.y;
2856
2857 if (w < 0)
2858 w = 0;
2859 if (h < 0)
2860 h = 0;
2861 }
2862
2863 if (width) *width = w;
2864 if (height) *height = h;
2865 }
2866
2867 wxSize wxWindowGTK::DoGetBorderSize() const
2868 {
2869 if ( !m_wxwindow )
2870 return wxWindowBase::DoGetBorderSize();
2871
2872 GtkBorder border;
2873 WX_PIZZA(m_wxwindow)->get_border(border);
2874 return wxSize(border.left + border.right, border.top + border.bottom);
2875 }
2876
2877 void wxWindowGTK::DoGetPosition( int *x, int *y ) const
2878 {
2879 int dx = 0;
2880 int dy = 0;
2881 GtkWidget* parent = NULL;
2882 if (m_widget)
2883 parent = gtk_widget_get_parent(m_widget);
2884 if (WX_IS_PIZZA(parent))
2885 {
2886 wxPizza* pizza = WX_PIZZA(parent);
2887 dx = pizza->m_scroll_x;
2888 dy = pizza->m_scroll_y;
2889 }
2890 if (x) (*x) = m_x - dx;
2891 if (y) (*y) = m_y - dy;
2892 }
2893
2894 void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
2895 {
2896 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2897
2898 if (gtk_widget_get_window(m_widget) == NULL) return;
2899
2900 GdkWindow *source = NULL;
2901 if (m_wxwindow)
2902 source = gtk_widget_get_window(m_wxwindow);
2903 else
2904 source = gtk_widget_get_window(m_widget);
2905
2906 int org_x = 0;
2907 int org_y = 0;
2908 gdk_window_get_origin( source, &org_x, &org_y );
2909
2910 if (!m_wxwindow)
2911 {
2912 if (!gtk_widget_get_has_window(m_widget))
2913 {
2914 GtkAllocation a;
2915 gtk_widget_get_allocation(m_widget, &a);
2916 org_x += a.x;
2917 org_y += a.y;
2918 }
2919 }
2920
2921
2922 if (x)
2923 {
2924 if (GetLayoutDirection() == wxLayout_RightToLeft)
2925 *x = (GetClientSize().x - *x) + org_x;
2926 else
2927 *x += org_x;
2928 }
2929
2930 if (y) *y += org_y;
2931 }
2932
2933 void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
2934 {
2935 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2936
2937 if (!gtk_widget_get_realized(m_widget)) return;
2938
2939 GdkWindow *source = NULL;
2940 if (m_wxwindow)
2941 source = gtk_widget_get_window(m_wxwindow);
2942 else
2943 source = gtk_widget_get_window(m_widget);
2944
2945 int org_x = 0;
2946 int org_y = 0;
2947 gdk_window_get_origin( source, &org_x, &org_y );
2948
2949 if (!m_wxwindow)
2950 {
2951 if (!gtk_widget_get_has_window(m_widget))
2952 {
2953 GtkAllocation a;
2954 gtk_widget_get_allocation(m_widget, &a);
2955 org_x += a.x;
2956 org_y += a.y;
2957 }
2958 }
2959
2960 if (x)
2961 {
2962 if (GetLayoutDirection() == wxLayout_RightToLeft)
2963 *x = (GetClientSize().x - *x) - org_x;
2964 else
2965 *x -= org_x;
2966 }
2967 if (y) *y -= org_y;
2968 }
2969
2970 bool wxWindowGTK::Show( bool show )
2971 {
2972 if ( !wxWindowBase::Show(show) )
2973 {
2974 // nothing to do
2975 return false;
2976 }
2977
2978 // notice that we may call Hide() before the window is created and this is
2979 // actually useful to create it hidden initially -- but we can't call
2980 // Show() before it is created
2981 if ( !m_widget )
2982 {
2983 wxASSERT_MSG( !show, "can't show invalid window" );
2984 return true;
2985 }
2986
2987 if ( show )
2988 {
2989 if ( m_showOnIdle )
2990 {
2991 // defer until later
2992 return true;
2993 }
2994
2995 gtk_widget_show(m_widget);
2996 }
2997 else // hide
2998 {
2999 gtk_widget_hide(m_widget);
3000 }
3001
3002 wxShowEvent eventShow(GetId(), show);
3003 eventShow.SetEventObject(this);
3004 HandleWindowEvent(eventShow);
3005
3006 return true;
3007 }
3008
3009 void wxWindowGTK::DoEnable( bool enable )
3010 {
3011 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3012
3013 gtk_widget_set_sensitive( m_widget, enable );
3014 if (m_wxwindow && (m_wxwindow != m_widget))
3015 gtk_widget_set_sensitive( m_wxwindow, enable );
3016 }
3017
3018 int wxWindowGTK::GetCharHeight() const
3019 {
3020 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
3021
3022 wxFont font = GetFont();
3023 wxCHECK_MSG( font.IsOk(), 12, wxT("invalid font") );
3024
3025 PangoContext* context = gtk_widget_get_pango_context(m_widget);
3026
3027 if (!context)
3028 return 0;
3029
3030 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
3031 PangoLayout *layout = pango_layout_new(context);
3032 pango_layout_set_font_description(layout, desc);
3033 pango_layout_set_text(layout, "H", 1);
3034 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3035
3036 PangoRectangle rect;
3037 pango_layout_line_get_extents(line, NULL, &rect);
3038
3039 g_object_unref (layout);
3040
3041 return (int) PANGO_PIXELS(rect.height);
3042 }
3043
3044 int wxWindowGTK::GetCharWidth() const
3045 {
3046 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
3047
3048 wxFont font = GetFont();
3049 wxCHECK_MSG( font.IsOk(), 8, wxT("invalid font") );
3050
3051 PangoContext* context = gtk_widget_get_pango_context(m_widget);
3052
3053 if (!context)
3054 return 0;
3055
3056 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
3057 PangoLayout *layout = pango_layout_new(context);
3058 pango_layout_set_font_description(layout, desc);
3059 pango_layout_set_text(layout, "g", 1);
3060 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3061
3062 PangoRectangle rect;
3063 pango_layout_line_get_extents(line, NULL, &rect);
3064
3065 g_object_unref (layout);
3066
3067 return (int) PANGO_PIXELS(rect.width);
3068 }
3069
3070 void wxWindowGTK::DoGetTextExtent( const wxString& string,
3071 int *x,
3072 int *y,
3073 int *descent,
3074 int *externalLeading,
3075 const wxFont *theFont ) const
3076 {
3077 wxFont fontToUse = theFont ? *theFont : GetFont();
3078
3079 wxCHECK_RET( fontToUse.IsOk(), wxT("invalid font") );
3080
3081 if (string.empty())
3082 {
3083 if (x) (*x) = 0;
3084 if (y) (*y) = 0;
3085 return;
3086 }
3087
3088 PangoContext *context = NULL;
3089 if (m_widget)
3090 context = gtk_widget_get_pango_context( m_widget );
3091
3092 if (!context)
3093 {
3094 if (x) (*x) = 0;
3095 if (y) (*y) = 0;
3096 return;
3097 }
3098
3099 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
3100 PangoLayout *layout = pango_layout_new(context);
3101 pango_layout_set_font_description(layout, desc);
3102 {
3103 const wxCharBuffer data = wxGTK_CONV( string );
3104 if ( data )
3105 pango_layout_set_text(layout, data, strlen(data));
3106 }
3107
3108 PangoRectangle rect;
3109 pango_layout_get_extents(layout, NULL, &rect);
3110
3111 if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width);
3112 if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height);
3113 if (descent)
3114 {
3115 PangoLayoutIter *iter = pango_layout_get_iter(layout);
3116 int baseline = pango_layout_iter_get_baseline(iter);
3117 pango_layout_iter_free(iter);
3118 *descent = *y - PANGO_PIXELS(baseline);
3119 }
3120 if (externalLeading) (*externalLeading) = 0; // ??
3121
3122 g_object_unref (layout);
3123 }
3124
3125 void wxWindowGTK::GTKDisableFocusOutEvent()
3126 {
3127 g_signal_handlers_block_by_func( m_focusWidget,
3128 (gpointer) gtk_window_focus_out_callback, this);
3129 }
3130
3131 void wxWindowGTK::GTKEnableFocusOutEvent()
3132 {
3133 g_signal_handlers_unblock_by_func( m_focusWidget,
3134 (gpointer) gtk_window_focus_out_callback, this);
3135 }
3136
3137 bool wxWindowGTK::GTKHandleFocusIn()
3138 {
3139 // Disable default focus handling for custom windows since the default GTK+
3140 // handler issues a repaint
3141 const bool retval = m_wxwindow ? true : false;
3142
3143
3144 // NB: if there's still unprocessed deferred focus-out event (see
3145 // GTKHandleFocusOut() for explanation), we need to process it first so
3146 // that the order of focus events -- focus-out first, then focus-in
3147 // elsewhere -- is preserved
3148 if ( gs_deferredFocusOut )
3149 {
3150 if ( GTKNeedsToFilterSameWindowFocus() &&
3151 gs_deferredFocusOut == this )
3152 {
3153 // GTK+ focus changed from this wxWindow back to itself, so don't
3154 // emit any events at all
3155 wxLogTrace(TRACE_FOCUS,
3156 "filtered out spurious focus change within %s(%p, %s)",
3157 GetClassInfo()->GetClassName(), this, GetLabel());
3158 gs_deferredFocusOut = NULL;
3159 return retval;
3160 }
3161
3162 // otherwise we need to send focus-out first
3163 wxASSERT_MSG ( gs_deferredFocusOut != this,
3164 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
3165 GTKHandleDeferredFocusOut();
3166 }
3167
3168
3169 wxLogTrace(TRACE_FOCUS,
3170 "handling focus_in event for %s(%p, %s)",
3171 GetClassInfo()->GetClassName(), this, GetLabel());
3172
3173 if (m_imData)
3174 gtk_im_context_focus_in(m_imData->context);
3175
3176 gs_currentFocus = this;
3177 gs_pendingFocus = NULL;
3178
3179 #if wxUSE_CARET
3180 // caret needs to be informed about focus change
3181 wxCaret *caret = GetCaret();
3182 if ( caret )
3183 {
3184 caret->OnSetFocus();
3185 }
3186 #endif // wxUSE_CARET
3187
3188 // Notify the parent keeping track of focus for the kbd navigation
3189 // purposes that we got it.
3190 wxChildFocusEvent eventChildFocus(static_cast<wxWindow*>(this));
3191 GTKProcessEvent(eventChildFocus);
3192
3193 wxFocusEvent eventFocus(wxEVT_SET_FOCUS, GetId());
3194 eventFocus.SetEventObject(this);
3195 GTKProcessEvent(eventFocus);
3196
3197 return retval;
3198 }
3199
3200 bool wxWindowGTK::GTKHandleFocusOut()
3201 {
3202 // Disable default focus handling for custom windows since the default GTK+
3203 // handler issues a repaint
3204 const bool retval = m_wxwindow ? true : false;
3205
3206
3207 // NB: If a control is composed of several GtkWidgets and when focus
3208 // changes from one of them to another within the same wxWindow, we get
3209 // a focus-out event followed by focus-in for another GtkWidget owned
3210 // by the same wx control. We don't want to generate two spurious
3211 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3212 // from GTKHandleFocusOut() until we know for sure it's not coming back
3213 // (i.e. in GTKHandleFocusIn() or at idle time).
3214 if ( GTKNeedsToFilterSameWindowFocus() )
3215 {
3216 wxASSERT_MSG( gs_deferredFocusOut == NULL,
3217 "deferred focus out event already pending" );
3218 wxLogTrace(TRACE_FOCUS,
3219 "deferring focus_out event for %s(%p, %s)",
3220 GetClassInfo()->GetClassName(), this, GetLabel());
3221 gs_deferredFocusOut = this;
3222 return retval;
3223 }
3224
3225 GTKHandleFocusOutNoDeferring();
3226
3227 return retval;
3228 }
3229
3230 void wxWindowGTK::GTKHandleFocusOutNoDeferring()
3231 {
3232 wxLogTrace(TRACE_FOCUS,
3233 "handling focus_out event for %s(%p, %s)",
3234 GetClassInfo()->GetClassName(), this, GetLabel());
3235
3236 if (m_imData)
3237 gtk_im_context_focus_out(m_imData->context);
3238
3239 if ( gs_currentFocus != this )
3240 {
3241 // Something is terribly wrong, gs_currentFocus is out of sync with the
3242 // real focus. We will reset it to NULL anyway, because after this
3243 // focus-out event is handled, one of the following with happen:
3244 //
3245 // * either focus will go out of the app altogether, in which case
3246 // gs_currentFocus _should_ be NULL
3247 //
3248 // * or it goes to another control, in which case focus-in event will
3249 // follow immediately and it will set gs_currentFocus to the right
3250 // value
3251 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3252 GetClassInfo()->GetClassName(), this, GetLabel());
3253 }
3254 gs_currentFocus = NULL;
3255
3256 #if wxUSE_CARET
3257 // caret needs to be informed about focus change
3258 wxCaret *caret = GetCaret();
3259 if ( caret )
3260 {
3261 caret->OnKillFocus();
3262 }
3263 #endif // wxUSE_CARET
3264
3265 wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
3266 event.SetEventObject( this );
3267 event.SetWindow( FindFocus() );
3268 GTKProcessEvent( event );
3269 }
3270
3271 /*static*/
3272 void wxWindowGTK::GTKHandleDeferredFocusOut()
3273 {
3274 // NB: See GTKHandleFocusOut() for explanation. This function is called
3275 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3276 // deferred event.
3277 if ( gs_deferredFocusOut )
3278 {
3279 wxWindowGTK *win = gs_deferredFocusOut;
3280 gs_deferredFocusOut = NULL;
3281
3282 wxLogTrace(TRACE_FOCUS,
3283 "processing deferred focus_out event for %s(%p, %s)",
3284 win->GetClassInfo()->GetClassName(), win, win->GetLabel());
3285
3286 win->GTKHandleFocusOutNoDeferring();
3287 }
3288 }
3289
3290 void wxWindowGTK::SetFocus()
3291 {
3292 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3293
3294 // Setting "physical" focus is not immediate in GTK+ and while
3295 // gtk_widget_is_focus ("determines if the widget is the focus widget
3296 // within its toplevel", i.e. returns true for one widget per TLW, not
3297 // globally) returns true immediately after grabbing focus,
3298 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3299 // has focus at the moment) takes effect only after the window is shown
3300 // (if it was hidden at the moment of the call) or at the next event loop
3301 // iteration.
3302 //
3303 // Because we want to FindFocus() call immediately following
3304 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3305 // ourselves.
3306 gs_pendingFocus = this;
3307
3308 GtkWidget *widget = m_wxwindow ? m_wxwindow : m_focusWidget;
3309
3310 if ( GTK_IS_CONTAINER(widget) &&
3311 !gtk_widget_get_can_focus(widget) )
3312 {
3313 wxLogTrace(TRACE_FOCUS,
3314 wxT("Setting focus to a child of %s(%p, %s)"),
3315 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3316 gtk_widget_child_focus(widget, GTK_DIR_TAB_FORWARD);
3317 }
3318 else
3319 {
3320 wxLogTrace(TRACE_FOCUS,
3321 wxT("Setting focus to %s(%p, %s)"),
3322 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3323 gtk_widget_grab_focus(widget);
3324 }
3325 }
3326
3327 void wxWindowGTK::SetCanFocus(bool canFocus)
3328 {
3329 gtk_widget_set_can_focus(m_widget, canFocus);
3330
3331 if ( m_wxwindow && (m_widget != m_wxwindow) )
3332 {
3333 gtk_widget_set_can_focus(m_wxwindow, canFocus);
3334 }
3335 }
3336
3337 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3338 {
3339 wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
3340
3341 wxWindowGTK * const newParent = (wxWindowGTK *)newParentBase;
3342
3343 wxASSERT( GTK_IS_WIDGET(m_widget) );
3344
3345 if ( !wxWindowBase::Reparent(newParent) )
3346 return false;
3347
3348 wxASSERT( GTK_IS_WIDGET(m_widget) );
3349
3350 // Notice that old m_parent pointer might be non-NULL here but the widget
3351 // still not have any parent at GTK level if it's a notebook page that had
3352 // been removed from the notebook so test this at GTK level and not wx one.
3353 if ( GtkWidget *parentGTK = gtk_widget_get_parent(m_widget) )
3354 gtk_container_remove(GTK_CONTAINER(parentGTK), m_widget);
3355
3356 wxASSERT( GTK_IS_WIDGET(m_widget) );
3357
3358 if (newParent)
3359 {
3360 if (gtk_widget_get_visible (newParent->m_widget))
3361 {
3362 m_showOnIdle = true;
3363 gtk_widget_hide( m_widget );
3364 }
3365 /* insert GTK representation */
3366 newParent->AddChildGTK(this);
3367 }
3368
3369 SetLayoutDirection(wxLayout_Default);
3370
3371 return true;
3372 }
3373
3374 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3375 {
3376 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3377 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3378
3379 /* add to list */
3380 AddChild( child );
3381
3382 /* insert GTK representation */
3383 AddChildGTK(child);
3384 }
3385
3386 void wxWindowGTK::AddChild(wxWindowBase *child)
3387 {
3388 wxWindowBase::AddChild(child);
3389 m_dirtyTabOrder = true;
3390 wxTheApp->WakeUpIdle();
3391 }
3392
3393 void wxWindowGTK::RemoveChild(wxWindowBase *child)
3394 {
3395 wxWindowBase::RemoveChild(child);
3396 m_dirtyTabOrder = true;
3397 wxTheApp->WakeUpIdle();
3398 }
3399
3400 /* static */
3401 wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
3402 {
3403 return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL
3404 ? wxLayout_RightToLeft
3405 : wxLayout_LeftToRight;
3406 }
3407
3408 /* static */
3409 void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir)
3410 {
3411 wxASSERT_MSG( dir != wxLayout_Default, wxT("invalid layout direction") );
3412
3413 gtk_widget_set_direction(widget,
3414 dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
3415 : GTK_TEXT_DIR_LTR);
3416 }
3417
3418 wxLayoutDirection wxWindowGTK::GetLayoutDirection() const
3419 {
3420 return GTKGetLayout(m_widget);
3421 }
3422
3423 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir)
3424 {
3425 if ( dir == wxLayout_Default )
3426 {
3427 const wxWindow *const parent = GetParent();
3428 if ( parent )
3429 {
3430 // inherit layout from parent.
3431 dir = parent->GetLayoutDirection();
3432 }
3433 else // no parent, use global default layout
3434 {
3435 dir = wxTheApp->GetLayoutDirection();
3436 }
3437 }
3438
3439 if ( dir == wxLayout_Default )
3440 return;
3441
3442 GTKSetLayout(m_widget, dir);
3443
3444 if (m_wxwindow && (m_wxwindow != m_widget))
3445 GTKSetLayout(m_wxwindow, dir);
3446 }
3447
3448 wxCoord
3449 wxWindowGTK::AdjustForLayoutDirection(wxCoord x,
3450 wxCoord WXUNUSED(width),
3451 wxCoord WXUNUSED(widthTotal)) const
3452 {
3453 // We now mirror the coordinates of RTL windows in wxPizza
3454 return x;
3455 }
3456
3457 void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, WindowOrder move)
3458 {
3459 wxWindowBase::DoMoveInTabOrder(win, move);
3460 m_dirtyTabOrder = true;
3461 wxTheApp->WakeUpIdle();
3462 }
3463
3464 bool wxWindowGTK::DoNavigateIn(int flags)
3465 {
3466 if ( flags & wxNavigationKeyEvent::WinChange )
3467 {
3468 wxFAIL_MSG( wxT("not implemented") );
3469
3470 return false;
3471 }
3472 else // navigate inside the container
3473 {
3474 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3475 wxCHECK_MSG( parent, false, wxT("every window must have a TLW parent") );
3476
3477 GtkDirectionType dir;
3478 dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD
3479 : GTK_DIR_TAB_BACKWARD;
3480
3481 gboolean rc;
3482 g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
3483
3484 return rc != 0;
3485 }
3486 }
3487
3488 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3489 {
3490 // none needed by default
3491 return false;
3492 }
3493
3494 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget* WXUNUSED(w))
3495 {
3496 // nothing to do by default since none is needed
3497 }
3498
3499 void wxWindowGTK::RealizeTabOrder()
3500 {
3501 if (m_wxwindow)
3502 {
3503 if ( !m_children.empty() )
3504 {
3505 // we don't only construct the correct focus chain but also use
3506 // this opportunity to update the mnemonic widgets for the widgets
3507 // that need them
3508
3509 GList *chain = NULL;
3510 wxWindowGTK* mnemonicWindow = NULL;
3511
3512 for ( wxWindowList::const_iterator i = m_children.begin();
3513 i != m_children.end();
3514 ++i )
3515 {
3516 wxWindowGTK *win = *i;
3517
3518 bool focusableFromKeyboard = win->AcceptsFocusFromKeyboard();
3519
3520 if ( mnemonicWindow )
3521 {
3522 if ( focusableFromKeyboard )
3523 {
3524 // wxComboBox et al. needs to focus on on a different
3525 // widget than m_widget, so if the main widget isn't
3526 // focusable try the connect widget
3527 GtkWidget* w = win->m_widget;
3528 if ( !gtk_widget_get_can_focus(w) )
3529 {
3530 w = win->GetConnectWidget();
3531 if ( !gtk_widget_get_can_focus(w) )
3532 w = NULL;
3533 }
3534
3535 if ( w )
3536 {
3537 mnemonicWindow->GTKWidgetDoSetMnemonic(w);
3538 mnemonicWindow = NULL;
3539 }
3540 }
3541 }
3542 else if ( win->GTKWidgetNeedsMnemonic() )
3543 {
3544 mnemonicWindow = win;
3545 }
3546
3547 if ( focusableFromKeyboard )
3548 chain = g_list_prepend(chain, win->m_widget);
3549 }
3550
3551 chain = g_list_reverse(chain);
3552
3553 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain);
3554 g_list_free(chain);
3555 }
3556 else // no children
3557 {
3558 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow));
3559 }
3560 }
3561 }
3562
3563 void wxWindowGTK::Raise()
3564 {
3565 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3566
3567 if (m_wxwindow && gtk_widget_get_window(m_wxwindow))
3568 {
3569 gdk_window_raise(gtk_widget_get_window(m_wxwindow));
3570 }
3571 else if (gtk_widget_get_window(m_widget))
3572 {
3573 gdk_window_raise(gtk_widget_get_window(m_widget));
3574 }
3575 }
3576
3577 void wxWindowGTK::Lower()
3578 {
3579 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3580
3581 if (m_wxwindow && gtk_widget_get_window(m_wxwindow))
3582 {
3583 gdk_window_lower(gtk_widget_get_window(m_wxwindow));
3584 }
3585 else if (gtk_widget_get_window(m_widget))
3586 {
3587 gdk_window_lower(gtk_widget_get_window(m_widget));
3588 }
3589 }
3590
3591 bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3592 {
3593 if ( !wxWindowBase::SetCursor(cursor.IsOk() ? cursor : *wxSTANDARD_CURSOR) )
3594 return false;
3595
3596 GTKUpdateCursor();
3597
3598 return true;
3599 }
3600
3601 void wxWindowGTK::GTKUpdateCursor(bool update_self /*=true*/, bool recurse /*=true*/)
3602 {
3603 if (update_self)
3604 {
3605 wxCursor cursor(g_globalCursor.IsOk() ? g_globalCursor : GetCursor());
3606 if ( cursor.IsOk() )
3607 {
3608 wxArrayGdkWindows windowsThis;
3609 GdkWindow* window = GTKGetWindow(windowsThis);
3610 if (window)
3611 gdk_window_set_cursor( window, cursor.GetCursor() );
3612 else
3613 {
3614 const size_t count = windowsThis.size();
3615 for ( size_t n = 0; n < count; n++ )
3616 {
3617 GdkWindow *win = windowsThis[n];
3618 // It can be zero if the window has not been realized yet.
3619 if ( win )
3620 {
3621 gdk_window_set_cursor(win, cursor.GetCursor());
3622 }
3623 }
3624 }
3625 }
3626 }
3627
3628 if (recurse)
3629 {
3630 for (wxWindowList::iterator it = GetChildren().begin(); it != GetChildren().end(); ++it)
3631 {
3632 (*it)->GTKUpdateCursor( true );
3633 }
3634 }
3635 }
3636
3637 void wxWindowGTK::WarpPointer( int x, int y )
3638 {
3639 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3640
3641 ClientToScreen(&x, &y);
3642 GdkDisplay* display = gtk_widget_get_display(m_widget);
3643 GdkScreen* screen = gtk_widget_get_screen(m_widget);
3644 #ifdef __WXGTK3__
3645 GdkDeviceManager* manager = gdk_display_get_device_manager(display);
3646 gdk_device_warp(gdk_device_manager_get_client_pointer(manager), screen, x, y);
3647 #else
3648 #ifdef GDK_WINDOWING_X11
3649 XWarpPointer(GDK_DISPLAY_XDISPLAY(display),
3650 None,
3651 GDK_WINDOW_XID(gdk_screen_get_root_window(screen)),
3652 0, 0, 0, 0, x, y);
3653 #endif
3654 #endif
3655 }
3656
3657 wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const
3658 {
3659 // find the scrollbar which generated the event
3660 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
3661 {
3662 if ( range == m_scrollBar[dir] )
3663 return (ScrollDir)dir;
3664 }
3665
3666 wxFAIL_MSG( wxT("event from unknown scrollbar received") );
3667
3668 return ScrollDir_Max;
3669 }
3670
3671 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units)
3672 {
3673 bool changed = false;
3674 GtkRange* range = m_scrollBar[dir];
3675 if ( range && units )
3676 {
3677 GtkAdjustment* adj = gtk_range_get_adjustment(range);
3678 double inc = unit == ScrollUnit_Line ? gtk_adjustment_get_step_increment(adj)
3679 : gtk_adjustment_get_page_increment(adj);
3680
3681 const int posOld = wxRound(gtk_adjustment_get_value(adj));
3682 gtk_range_set_value(range, posOld + units*inc);
3683
3684 changed = wxRound(gtk_adjustment_get_value(adj)) != posOld;
3685 }
3686
3687 return changed;
3688 }
3689
3690 bool wxWindowGTK::ScrollLines(int lines)
3691 {
3692 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Line, lines);
3693 }
3694
3695 bool wxWindowGTK::ScrollPages(int pages)
3696 {
3697 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages);
3698 }
3699
3700 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground),
3701 const wxRect *rect)
3702 {
3703 if (m_wxwindow)
3704 {
3705 if (gtk_widget_get_mapped(m_wxwindow))
3706 {
3707 GdkWindow* window = gtk_widget_get_window(m_wxwindow);
3708 if (rect)
3709 {
3710 GdkRectangle r = { rect->x, rect->y, rect->width, rect->height };
3711 if (GetLayoutDirection() == wxLayout_RightToLeft)
3712 r.x = gdk_window_get_width(window) - r.x - rect->width;
3713 gdk_window_invalidate_rect(window, &r, true);
3714 }
3715 else
3716 gdk_window_invalidate_rect(window, NULL, true);
3717 }
3718 }
3719 else if (m_widget)
3720 {
3721 if (gtk_widget_get_mapped(m_widget))
3722 {
3723 if (rect)
3724 gtk_widget_queue_draw_area(m_widget, rect->x, rect->y, rect->width, rect->height);
3725 else
3726 gtk_widget_queue_draw(m_widget);
3727 }
3728 }
3729 }
3730
3731 void wxWindowGTK::Update()
3732 {
3733 if (m_widget && gtk_widget_get_mapped(m_widget))
3734 {
3735 GdkDisplay* display = gtk_widget_get_display(m_widget);
3736 // Flush everything out to the server, and wait for it to finish.
3737 // This ensures nothing will overwrite the drawing we are about to do.
3738 gdk_display_sync(display);
3739
3740 GdkWindow* window = GTKGetDrawingWindow();
3741 if (window == NULL)
3742 window = gtk_widget_get_window(m_widget);
3743 gdk_window_process_updates(window, true);
3744
3745 // Flush again, but no need to wait for it to finish
3746 gdk_display_flush(display);
3747 }
3748 }
3749
3750 bool wxWindowGTK::DoIsExposed( int x, int y ) const
3751 {
3752 return m_updateRegion.Contains(x, y) != wxOutRegion;
3753 }
3754
3755 bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const
3756 {
3757 if (GetLayoutDirection() == wxLayout_RightToLeft)
3758 return m_updateRegion.Contains(x-w, y, w, h) != wxOutRegion;
3759 else
3760 return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
3761 }
3762
3763 #ifdef __WXGTK3__
3764 void wxWindowGTK::GTKSendPaintEvents(cairo_t* cr)
3765 #else
3766 void wxWindowGTK::GTKSendPaintEvents(const GdkRegion* region)
3767 #endif
3768 {
3769 #ifdef __WXGTK3__
3770 m_paintContext = cr;
3771 double x1, y1, x2, y2;
3772 cairo_clip_extents(cr, &x1, &y1, &x2, &y2);
3773 m_updateRegion = wxRegion(int(x1), int(y1), int(x2 - x1), int(y2 - y1));
3774 #else // !__WXGTK3__
3775 m_updateRegion = wxRegion(region);
3776 #if wxGTK_HAS_COMPOSITING_SUPPORT
3777 cairo_t* cr = NULL;
3778 #endif
3779 #endif // !__WXGTK3__
3780 // Clip to paint region in wxClientDC
3781 m_clipPaintRegion = true;
3782
3783 m_nativeUpdateRegion = m_updateRegion;
3784
3785 if (GetLayoutDirection() == wxLayout_RightToLeft)
3786 {
3787 // Transform m_updateRegion under RTL
3788 m_updateRegion.Clear();
3789
3790 const int width = gdk_window_get_width(GTKGetDrawingWindow());
3791
3792 wxRegionIterator upd( m_nativeUpdateRegion );
3793 while (upd)
3794 {
3795 wxRect rect;
3796 rect.x = upd.GetX();
3797 rect.y = upd.GetY();
3798 rect.width = upd.GetWidth();
3799 rect.height = upd.GetHeight();
3800
3801 rect.x = width - rect.x - rect.width;
3802 m_updateRegion.Union( rect );
3803
3804 ++upd;
3805 }
3806 }
3807
3808 switch ( GetBackgroundStyle() )
3809 {
3810 case wxBG_STYLE_TRANSPARENT:
3811 #if wxGTK_HAS_COMPOSITING_SUPPORT
3812 if (IsTransparentBackgroundSupported())
3813 {
3814 // Set a transparent background, so that overlaying in parent
3815 // might indeed let see through where this child did not
3816 // explicitly paint.
3817 // NB: it works also for top level windows (but this is the
3818 // windows manager which then does the compositing job)
3819 #ifndef __WXGTK3__
3820 cr = gdk_cairo_create(m_wxwindow->window);
3821 gdk_cairo_region(cr, m_nativeUpdateRegion.GetRegion());
3822 cairo_clip(cr);
3823 #endif
3824 cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
3825 cairo_paint(cr);
3826 cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
3827 #ifndef __WXGTK3__
3828 cairo_surface_flush(cairo_get_target(cr));
3829 #endif
3830 }
3831 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
3832 break;
3833
3834 case wxBG_STYLE_ERASE:
3835 {
3836 #ifdef __WXGTK3__
3837 wxGTKCairoDC dc(cr);
3838 #else
3839 wxWindowDC dc( (wxWindow*)this );
3840 dc.SetDeviceClippingRegion( m_updateRegion );
3841
3842 // Work around gtk-qt <= 0.60 bug whereby the window colour
3843 // remains grey
3844 if ( UseBgCol() &&
3845 wxSystemOptions::
3846 GetOptionInt("gtk.window.force-background-colour") )
3847 {
3848 dc.SetBackground(GetBackgroundColour());
3849 dc.Clear();
3850 }
3851 #endif // !__WXGTK3__
3852 wxEraseEvent erase_event( GetId(), &dc );
3853 erase_event.SetEventObject( this );
3854
3855 if ( HandleWindowEvent(erase_event) )
3856 {
3857 // background erased, don't do it again
3858 break;
3859 }
3860 }
3861 // fall through
3862
3863 case wxBG_STYLE_SYSTEM:
3864 if ( GetThemeEnabled() )
3865 {
3866 GdkWindow* gdkWindow = GTKGetDrawingWindow();
3867 const int w = gdk_window_get_width(gdkWindow);
3868 const int h = gdk_window_get_height(gdkWindow);
3869 #ifdef __WXGTK3__
3870 GtkStyleContext* sc = gtk_widget_get_style_context(m_wxwindow);
3871 gtk_render_background(sc, cr, 0, 0, w, h);
3872 #else
3873 // find ancestor from which to steal background
3874 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3875 if (!parent)
3876 parent = (wxWindow*)this;
3877 GdkRectangle rect;
3878 m_nativeUpdateRegion.GetBox(rect.x, rect.y, rect.width, rect.height);
3879 gtk_paint_flat_box(gtk_widget_get_style(parent->m_widget),
3880 gdkWindow,
3881 gtk_widget_get_state(m_wxwindow),
3882 GTK_SHADOW_NONE,
3883 &rect,
3884 parent->m_widget,
3885 (char *)"base",
3886 0, 0, w, h);
3887 #endif // !__WXGTK3__
3888 }
3889 break;
3890
3891 case wxBG_STYLE_PAINT:
3892 // nothing to do: window will be painted over in EVT_PAINT
3893 break;
3894
3895 default:
3896 wxFAIL_MSG( "unsupported background style" );
3897 }
3898
3899 wxNcPaintEvent nc_paint_event( GetId() );
3900 nc_paint_event.SetEventObject( this );
3901 HandleWindowEvent( nc_paint_event );
3902
3903 wxPaintEvent paint_event( GetId() );
3904 paint_event.SetEventObject( this );
3905 HandleWindowEvent( paint_event );
3906
3907 #if wxGTK_HAS_COMPOSITING_SUPPORT
3908 if (IsTransparentBackgroundSupported())
3909 { // now composite children which need it
3910 // Overlay all our composite children on top of the painted area
3911 wxWindowList::compatibility_iterator node;
3912 for ( node = m_children.GetFirst(); node ; node = node->GetNext() )
3913 {
3914 wxWindow *compositeChild = node->GetData();
3915 if (compositeChild->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT)
3916 {
3917 #ifndef __WXGTK3__
3918 if (cr == NULL)
3919 {
3920 cr = gdk_cairo_create(m_wxwindow->window);
3921 gdk_cairo_region(cr, m_nativeUpdateRegion.GetRegion());
3922 cairo_clip(cr);
3923 }
3924 #endif // !__WXGTK3__
3925 GtkWidget *child = compositeChild->m_wxwindow;
3926 GtkAllocation alloc;
3927 gtk_widget_get_allocation(child, &alloc);
3928
3929 // The source data is the (composited) child
3930 gdk_cairo_set_source_window(
3931 cr, gtk_widget_get_window(child), alloc.x, alloc.y);
3932
3933 cairo_paint(cr);
3934 }
3935 }
3936 #ifndef __WXGTK3__
3937 if (cr)
3938 cairo_destroy(cr);
3939 #endif
3940 }
3941 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
3942
3943 m_clipPaintRegion = false;
3944 #ifdef __WXGTK3__
3945 m_paintContext = NULL;
3946 #endif
3947 m_updateRegion.Clear();
3948 m_nativeUpdateRegion.Clear();
3949 }
3950
3951 void wxWindowGTK::SetDoubleBuffered( bool on )
3952 {
3953 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3954
3955 if ( m_wxwindow )
3956 gtk_widget_set_double_buffered( m_wxwindow, on );
3957 }
3958
3959 bool wxWindowGTK::IsDoubleBuffered() const
3960 {
3961 return gtk_widget_get_double_buffered( m_wxwindow ) != 0;
3962 }
3963
3964 void wxWindowGTK::ClearBackground()
3965 {
3966 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3967 }
3968
3969 #if wxUSE_TOOLTIPS
3970 void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3971 {
3972 if (m_tooltip != tip)
3973 {
3974 wxWindowBase::DoSetToolTip(tip);
3975
3976 if (m_tooltip)
3977 m_tooltip->GTKSetWindow(static_cast<wxWindow*>(this));
3978 else
3979 GTKApplyToolTip(NULL);
3980 }
3981 }
3982
3983 void wxWindowGTK::GTKApplyToolTip(const char* tip)
3984 {
3985 wxToolTip::GTKApply(GetConnectWidget(), tip);
3986 }
3987 #endif // wxUSE_TOOLTIPS
3988
3989 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
3990 {
3991 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3992
3993 if (!wxWindowBase::SetBackgroundColour(colour))
3994 return false;
3995
3996 #ifndef __WXGTK3__
3997 if (colour.IsOk())
3998 {
3999 // We need the pixel value e.g. for background clearing.
4000 m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
4001 }
4002 #endif
4003
4004 // apply style change (forceStyle=true so that new style is applied
4005 // even if the bg colour changed from valid to wxNullColour)
4006 GTKApplyWidgetStyle(true);
4007
4008 return true;
4009 }
4010
4011 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
4012 {
4013 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4014
4015 if (!wxWindowBase::SetForegroundColour(colour))
4016 {
4017 return false;
4018 }
4019
4020 #ifndef __WXGTK3__
4021 if (colour.IsOk())
4022 {
4023 // We need the pixel value e.g. for background clearing.
4024 m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
4025 }
4026 #endif
4027
4028 // apply style change (forceStyle=true so that new style is applied
4029 // even if the bg colour changed from valid to wxNullColour):
4030 GTKApplyWidgetStyle(true);
4031
4032 return true;
4033 }
4034
4035 PangoContext *wxWindowGTK::GTKGetPangoDefaultContext()
4036 {
4037 return gtk_widget_get_pango_context( m_widget );
4038 }
4039
4040 #ifndef __WXGTK3__
4041 GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle)
4042 {
4043 // do we need to apply any changes at all?
4044 if ( !forceStyle &&
4045 !m_font.IsOk() &&
4046 !m_foregroundColour.IsOk() && !m_backgroundColour.IsOk() )
4047 {
4048 return NULL;
4049 }
4050
4051 GtkRcStyle *style = gtk_rc_style_new();
4052
4053 if ( m_font.IsOk() )
4054 {
4055 style->font_desc =
4056 pango_font_description_copy( m_font.GetNativeFontInfo()->description );
4057 }
4058
4059 int flagsNormal = 0,
4060 flagsPrelight = 0,
4061 flagsActive = 0,
4062 flagsInsensitive = 0;
4063
4064 if ( m_foregroundColour.IsOk() )
4065 {
4066 const GdkColor *fg = m_foregroundColour.GetColor();
4067
4068 style->fg[GTK_STATE_NORMAL] =
4069 style->text[GTK_STATE_NORMAL] = *fg;
4070 flagsNormal |= GTK_RC_FG | GTK_RC_TEXT;
4071
4072 style->fg[GTK_STATE_PRELIGHT] =
4073 style->text[GTK_STATE_PRELIGHT] = *fg;
4074 flagsPrelight |= GTK_RC_FG | GTK_RC_TEXT;
4075
4076 style->fg[GTK_STATE_ACTIVE] =
4077 style->text[GTK_STATE_ACTIVE] = *fg;
4078 flagsActive |= GTK_RC_FG | GTK_RC_TEXT;
4079 }
4080
4081 if ( m_backgroundColour.IsOk() )
4082 {
4083 const GdkColor *bg = m_backgroundColour.GetColor();
4084
4085 style->bg[GTK_STATE_NORMAL] =
4086 style->base[GTK_STATE_NORMAL] = *bg;
4087 flagsNormal |= GTK_RC_BG | GTK_RC_BASE;
4088
4089 style->bg[GTK_STATE_PRELIGHT] =
4090 style->base[GTK_STATE_PRELIGHT] = *bg;
4091 flagsPrelight |= GTK_RC_BG | GTK_RC_BASE;
4092
4093 style->bg[GTK_STATE_ACTIVE] =
4094 style->base[GTK_STATE_ACTIVE] = *bg;
4095 flagsActive |= GTK_RC_BG | GTK_RC_BASE;
4096
4097 style->bg[GTK_STATE_INSENSITIVE] =
4098 style->base[GTK_STATE_INSENSITIVE] = *bg;
4099 flagsInsensitive |= GTK_RC_BG | GTK_RC_BASE;
4100 }
4101
4102 style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)flagsNormal;
4103 style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)flagsPrelight;
4104 style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)flagsActive;
4105 style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)flagsInsensitive;
4106
4107 return style;
4108 }
4109 #endif // !__WXGTK3__
4110
4111 void wxWindowGTK::GTKApplyWidgetStyle(bool WXUNUSED_IN_GTK3(forceStyle))
4112 {
4113 #ifdef __WXGTK3__
4114 DoApplyWidgetStyle(NULL);
4115 #else
4116 GtkRcStyle *style = GTKCreateWidgetStyle(forceStyle);
4117 if ( style )
4118 {
4119 DoApplyWidgetStyle(style);
4120 g_object_unref(style);
4121 }
4122 #endif
4123
4124 // Style change may affect GTK+'s size calculation:
4125 InvalidateBestSize();
4126 }
4127
4128 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
4129 {
4130 GtkWidget* widget = m_wxwindow ? m_wxwindow : m_widget;
4131
4132 // block the signal temporarily to avoid sending
4133 // wxSysColourChangedEvents when we change the colours ourselves
4134 bool unblock = false;
4135 if (m_wxwindow && IsTopLevel())
4136 {
4137 unblock = true;
4138 g_signal_handlers_block_by_func(
4139 m_wxwindow, (void*)style_updated, this);
4140 }
4141
4142 GTKApplyStyle(widget, style);
4143
4144 if (unblock)
4145 {
4146 g_signal_handlers_unblock_by_func(
4147 m_wxwindow, (void*)style_updated, this);
4148 }
4149 }
4150
4151 void wxWindowGTK::GTKApplyStyle(GtkWidget* widget, GtkRcStyle* WXUNUSED_IN_GTK3(style))
4152 {
4153 #ifdef __WXGTK3__
4154 const PangoFontDescription* pfd = NULL;
4155 if (m_font.IsOk())
4156 pfd = pango_font_description_copy(m_font.GetNativeFontInfo()->description);
4157 gtk_widget_override_font(widget, pfd);
4158 gtk_widget_override_color(widget, GTK_STATE_FLAG_NORMAL, m_foregroundColour);
4159 gtk_widget_override_background_color(widget, GTK_STATE_FLAG_NORMAL, m_backgroundColour);
4160 #else
4161 gtk_widget_modify_style(widget, style);
4162 #endif
4163 }
4164
4165 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
4166 {
4167 if (!wxWindowBase::SetBackgroundStyle(style))
4168 return false;
4169
4170 #ifndef __WXGTK3__
4171 GdkWindow *window;
4172 if ( m_wxwindow )
4173 {
4174 window = GTKGetDrawingWindow();
4175 }
4176 else
4177 {
4178 GtkWidget * const w = GetConnectWidget();
4179 window = w ? gtk_widget_get_window(w) : NULL;
4180 }
4181
4182 bool wantNoBackPixmap = style == wxBG_STYLE_PAINT || style == wxBG_STYLE_TRANSPARENT;
4183
4184 if ( wantNoBackPixmap )
4185 {
4186 if (window)
4187 {
4188 // Make sure GDK/X11 doesn't refresh the window
4189 // automatically.
4190 gdk_window_set_back_pixmap( window, NULL, FALSE );
4191 m_needsStyleChange = false;
4192 }
4193 else // window not realized yet
4194 {
4195 // Do when window is realized
4196 m_needsStyleChange = true;
4197 }
4198
4199 // Don't apply widget style, or we get a grey background
4200 }
4201 else
4202 {
4203 // apply style change (forceStyle=true so that new style is applied
4204 // even if the bg colour changed from valid to wxNullColour):
4205 GTKApplyWidgetStyle(true);
4206 }
4207 #endif // !__WXGTK3__
4208
4209 return true;
4210 }
4211
4212 bool wxWindowGTK::IsTransparentBackgroundSupported(wxString* reason) const
4213 {
4214 #if wxGTK_HAS_COMPOSITING_SUPPORT
4215 #ifndef __WXGTK3__
4216 if (gtk_check_version(wxGTK_VERSION_REQUIRED_FOR_COMPOSITING) != NULL)
4217 {
4218 if (reason)
4219 {
4220 *reason = _("GTK+ installed on this machine is too old to "
4221 "support screen compositing, please install "
4222 "GTK+ 2.12 or later.");
4223 }
4224
4225 return false;
4226 }
4227 #endif // !__WXGTK3__
4228
4229 // NB: We don't check here if the particular kind of widget supports
4230 // transparency, we check only if it would be possible for a generic window
4231
4232 wxCHECK_MSG ( m_widget, false, "Window must be created first" );
4233
4234 if (!gdk_screen_is_composited(gtk_widget_get_screen(m_widget)))
4235 {
4236 if (reason)
4237 {
4238 *reason = _("Compositing not supported by this system, "
4239 "please enable it in your Window Manager.");
4240 }
4241
4242 return false;
4243 }
4244
4245 return true;
4246 #else
4247 if (reason)
4248 {
4249 *reason = _("This program was compiled with a too old version of GTK+, "
4250 "please rebuild with GTK+ 2.12 or newer.");
4251 }
4252
4253 return false;
4254 #endif // wxGTK_HAS_COMPOSITING_SUPPORT/!wxGTK_HAS_COMPOSITING_SUPPORT
4255 }
4256
4257 // ----------------------------------------------------------------------------
4258 // Pop-up menu stuff
4259 // ----------------------------------------------------------------------------
4260
4261 #if wxUSE_MENUS_NATIVE
4262
4263 extern "C" {
4264 static
4265 void wxPopupMenuPositionCallback( GtkMenu *menu,
4266 gint *x, gint *y,
4267 gboolean * WXUNUSED(whatever),
4268 gpointer user_data )
4269 {
4270 // ensure that the menu appears entirely on screen
4271 GtkRequisition req;
4272 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
4273
4274 wxSize sizeScreen = wxGetDisplaySize();
4275 wxPoint *pos = (wxPoint*)user_data;
4276
4277 gint xmax = sizeScreen.x - req.width,
4278 ymax = sizeScreen.y - req.height;
4279
4280 *x = pos->x < xmax ? pos->x : xmax;
4281 *y = pos->y < ymax ? pos->y : ymax;
4282 }
4283 }
4284
4285 bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
4286 {
4287 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4288
4289 menu->UpdateUI();
4290
4291 wxPoint pos;
4292 gpointer userdata;
4293 GtkMenuPositionFunc posfunc;
4294 if ( x == -1 && y == -1 )
4295 {
4296 // use GTK's default positioning algorithm
4297 userdata = NULL;
4298 posfunc = NULL;
4299 }
4300 else
4301 {
4302 pos = ClientToScreen(wxPoint(x, y));
4303 userdata = &pos;
4304 posfunc = wxPopupMenuPositionCallback;
4305 }
4306
4307 menu->m_popupShown = true;
4308 gtk_menu_popup(
4309 GTK_MENU(menu->m_menu),
4310 NULL, // parent menu shell
4311 NULL, // parent menu item
4312 posfunc, // function to position it
4313 userdata, // client data
4314 0, // button used to activate it
4315 gtk_get_current_event_time()
4316 );
4317
4318 while (menu->m_popupShown)
4319 {
4320 gtk_main_iteration();
4321 }
4322
4323 return true;
4324 }
4325
4326 #endif // wxUSE_MENUS_NATIVE
4327
4328 #if wxUSE_DRAG_AND_DROP
4329
4330 void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
4331 {
4332 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4333
4334 GtkWidget *dnd_widget = GetConnectWidget();
4335
4336 if (m_dropTarget) m_dropTarget->GtkUnregisterWidget( dnd_widget );
4337
4338 if (m_dropTarget) delete m_dropTarget;
4339 m_dropTarget = dropTarget;
4340
4341 if (m_dropTarget) m_dropTarget->GtkRegisterWidget( dnd_widget );
4342 }
4343
4344 #endif // wxUSE_DRAG_AND_DROP
4345
4346 GtkWidget* wxWindowGTK::GetConnectWidget()
4347 {
4348 GtkWidget *connect_widget = m_widget;
4349 if (m_wxwindow) connect_widget = m_wxwindow;
4350
4351 return connect_widget;
4352 }
4353
4354 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const
4355 {
4356 wxArrayGdkWindows windowsThis;
4357 GdkWindow * const winThis = GTKGetWindow(windowsThis);
4358
4359 return winThis ? window == winThis
4360 : windowsThis.Index(window) != wxNOT_FOUND;
4361 }
4362
4363 GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
4364 {
4365 return m_wxwindow ? GTKGetDrawingWindow() : gtk_widget_get_window(m_widget);
4366 }
4367
4368 bool wxWindowGTK::SetFont( const wxFont &font )
4369 {
4370 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4371
4372 if (!wxWindowBase::SetFont(font))
4373 return false;
4374
4375 // apply style change (forceStyle=true so that new style is applied
4376 // even if the font changed from valid to wxNullFont):
4377 GTKApplyWidgetStyle(true);
4378
4379 return true;
4380 }
4381
4382 void wxWindowGTK::DoCaptureMouse()
4383 {
4384 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4385
4386 GdkWindow *window = NULL;
4387 if (m_wxwindow)
4388 window = GTKGetDrawingWindow();
4389 else
4390 window = gtk_widget_get_window(GetConnectWidget());
4391
4392 wxCHECK_RET( window, wxT("CaptureMouse() failed") );
4393
4394 const wxCursor* cursor = &m_cursor;
4395 if (!cursor->IsOk())
4396 cursor = wxSTANDARD_CURSOR;
4397
4398 gdk_pointer_grab( window, FALSE,
4399 (GdkEventMask)
4400 (GDK_BUTTON_PRESS_MASK |
4401 GDK_BUTTON_RELEASE_MASK |
4402 GDK_POINTER_MOTION_HINT_MASK |
4403 GDK_POINTER_MOTION_MASK),
4404 NULL,
4405 cursor->GetCursor(),
4406 (guint32)GDK_CURRENT_TIME );
4407 g_captureWindow = this;
4408 g_captureWindowHasMouse = true;
4409 }
4410
4411 void wxWindowGTK::DoReleaseMouse()
4412 {
4413 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4414
4415 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
4416
4417 g_captureWindow = NULL;
4418
4419 GdkWindow *window = NULL;
4420 if (m_wxwindow)
4421 window = GTKGetDrawingWindow();
4422 else
4423 window = gtk_widget_get_window(GetConnectWidget());
4424
4425 if (!window)
4426 return;
4427
4428 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
4429 }
4430
4431 void wxWindowGTK::GTKReleaseMouseAndNotify()
4432 {
4433 DoReleaseMouse();
4434 wxMouseCaptureLostEvent evt(GetId());
4435 evt.SetEventObject( this );
4436 HandleWindowEvent( evt );
4437 }
4438
4439 /* static */
4440 wxWindow *wxWindowBase::GetCapture()
4441 {
4442 return (wxWindow *)g_captureWindow;
4443 }
4444
4445 bool wxWindowGTK::IsRetained() const
4446 {
4447 return false;
4448 }
4449
4450 void wxWindowGTK::SetScrollbar(int orient,
4451 int pos,
4452 int thumbVisible,
4453 int range,
4454 bool WXUNUSED(update))
4455 {
4456 const int dir = ScrollDirFromOrient(orient);
4457 GtkRange* const sb = m_scrollBar[dir];
4458 wxCHECK_RET( sb, wxT("this window is not scrollable") );
4459
4460 if (range <= 0)
4461 {
4462 // GtkRange requires upper > lower
4463 range =
4464 thumbVisible = 1;
4465 }
4466
4467 g_signal_handlers_block_by_func(
4468 sb, (void*)gtk_scrollbar_value_changed, this);
4469
4470 gtk_range_set_increments(sb, 1, thumbVisible);
4471 gtk_adjustment_set_page_size(gtk_range_get_adjustment(sb), thumbVisible);
4472 gtk_range_set_range(sb, 0, range);
4473 gtk_range_set_value(sb, pos);
4474 m_scrollPos[dir] = gtk_range_get_value(sb);
4475
4476 g_signal_handlers_unblock_by_func(
4477 sb, (void*)gtk_scrollbar_value_changed, this);
4478 }
4479
4480 void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
4481 {
4482 const int dir = ScrollDirFromOrient(orient);
4483 GtkRange * const sb = m_scrollBar[dir];
4484 wxCHECK_RET( sb, wxT("this window is not scrollable") );
4485
4486 // This check is more than an optimization. Without it, the slider
4487 // will not move smoothly while tracking when using wxScrollHelper.
4488 if (GetScrollPos(orient) != pos)
4489 {
4490 g_signal_handlers_block_by_func(
4491 sb, (void*)gtk_scrollbar_value_changed, this);
4492
4493 gtk_range_set_value(sb, pos);
4494 m_scrollPos[dir] = gtk_range_get_value(sb);
4495
4496 g_signal_handlers_unblock_by_func(
4497 sb, (void*)gtk_scrollbar_value_changed, this);
4498 }
4499 }
4500
4501 int wxWindowGTK::GetScrollThumb(int orient) const
4502 {
4503 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4504 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4505
4506 return wxRound(gtk_adjustment_get_page_size(gtk_range_get_adjustment(sb)));
4507 }
4508
4509 int wxWindowGTK::GetScrollPos( int orient ) const
4510 {
4511 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4512 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4513
4514 return wxRound(gtk_range_get_value(sb));
4515 }
4516
4517 int wxWindowGTK::GetScrollRange( int orient ) const
4518 {
4519 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4520 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4521
4522 return wxRound(gtk_adjustment_get_upper(gtk_range_get_adjustment(sb)));
4523 }
4524
4525 // Determine if increment is the same as +/-x, allowing for some small
4526 // difference due to possible inexactness in floating point arithmetic
4527 static inline bool IsScrollIncrement(double increment, double x)
4528 {
4529 wxASSERT(increment > 0);
4530 const double tolerance = 1.0 / 1024;
4531 return fabs(increment - fabs(x)) < tolerance;
4532 }
4533
4534 wxEventType wxWindowGTK::GTKGetScrollEventType(GtkRange* range)
4535 {
4536 wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
4537
4538 const int barIndex = range == m_scrollBar[1];
4539
4540 const double value = gtk_range_get_value(range);
4541
4542 // save previous position
4543 const double oldPos = m_scrollPos[barIndex];
4544 // update current position
4545 m_scrollPos[barIndex] = value;
4546 // If event should be ignored, or integral position has not changed
4547 if (!m_hasVMT || g_blockEventsOnDrag || wxRound(value) == wxRound(oldPos))
4548 {
4549 return wxEVT_NULL;
4550 }
4551
4552 wxEventType eventType = wxEVT_SCROLL_THUMBTRACK;
4553 if (!m_isScrolling)
4554 {
4555 // Difference from last change event
4556 const double diff = value - oldPos;
4557 const bool isDown = diff > 0;
4558
4559 GtkAdjustment* adj = gtk_range_get_adjustment(range);
4560 if (IsScrollIncrement(gtk_adjustment_get_step_increment(adj), diff))
4561 {
4562 eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
4563 }
4564 else if (IsScrollIncrement(gtk_adjustment_get_page_increment(adj), diff))
4565 {
4566 eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
4567 }
4568 else if (m_mouseButtonDown)
4569 {
4570 // Assume track event
4571 m_isScrolling = true;
4572 }
4573 }
4574 return eventType;
4575 }
4576
4577 void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4578 {
4579 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4580
4581 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4582
4583 // No scrolling requested.
4584 if ((dx == 0) && (dy == 0)) return;
4585
4586 m_clipPaintRegion = true;
4587
4588 WX_PIZZA(m_wxwindow)->scroll(dx, dy);
4589
4590 m_clipPaintRegion = false;
4591
4592 #if wxUSE_CARET
4593 bool restoreCaret = (GetCaret() != NULL && GetCaret()->IsVisible());
4594 if (restoreCaret)
4595 {
4596 wxRect caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4597 if (dx > 0)
4598 caretRect.width += dx;
4599 else
4600 {
4601 caretRect.x += dx; caretRect.width -= dx;
4602 }
4603 if (dy > 0)
4604 caretRect.height += dy;
4605 else
4606 {
4607 caretRect.y += dy; caretRect.height -= dy;
4608 }
4609
4610 RefreshRect(caretRect);
4611 }
4612 #endif // wxUSE_CARET
4613 }
4614
4615 void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
4616 {
4617 //RN: Note that static controls usually have no border on gtk, so maybe
4618 //it makes sense to treat that as simply no border at the wx level
4619 //as well...
4620 if (!(wxstyle & wxNO_BORDER) && !(wxstyle & wxBORDER_STATIC))
4621 {
4622 GtkShadowType gtkstyle;
4623
4624 if(wxstyle & wxBORDER_RAISED)
4625 gtkstyle = GTK_SHADOW_OUT;
4626 else if ((wxstyle & wxBORDER_SUNKEN) || (wxstyle & wxBORDER_THEME))
4627 gtkstyle = GTK_SHADOW_IN;
4628 #if 0
4629 // Now obsolete
4630 else if (wxstyle & wxBORDER_DOUBLE)
4631 gtkstyle = GTK_SHADOW_ETCHED_IN;
4632 #endif
4633 else //default
4634 gtkstyle = GTK_SHADOW_IN;
4635
4636 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w),
4637 gtkstyle );
4638 }
4639 }
4640
4641 // Find the wxWindow at the current mouse position, also returning the mouse
4642 // position.
4643 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4644 {
4645 pt = wxGetMousePosition();
4646 wxWindow* found = wxFindWindowAtPoint(pt);
4647 return found;
4648 }
4649
4650 // Get the current mouse position.
4651 wxPoint wxGetMousePosition()
4652 {
4653 int x, y;
4654 GdkModifierType unused;
4655 GetMouseState(x, y, unused);
4656 return wxPoint(x, y);
4657 }
4658
4659 GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
4660 {
4661 GdkWindow* window = NULL;
4662 if (m_wxwindow)
4663 window = gtk_widget_get_window(m_wxwindow);
4664 return window;
4665 }
4666
4667 // ----------------------------------------------------------------------------
4668 // freeze/thaw
4669 // ----------------------------------------------------------------------------
4670
4671 extern "C"
4672 {
4673
4674 // this is called if we attempted to freeze unrealized widget when it finally
4675 // is realized (and so can be frozen):
4676 static void wx_frozen_widget_realize(GtkWidget* w, wxWindowGTK* win)
4677 {
4678 wxASSERT( w && gtk_widget_get_has_window(w) );
4679 wxASSERT( gtk_widget_get_realized(w) );
4680
4681 g_signal_handlers_disconnect_by_func
4682 (
4683 w,
4684 (void*)wx_frozen_widget_realize,
4685 win
4686 );
4687
4688 GdkWindow* window;
4689 if (w == win->m_wxwindow)
4690 window = win->GTKGetDrawingWindow();
4691 else
4692 window = gtk_widget_get_window(w);
4693 gdk_window_freeze_updates(window);
4694 }
4695
4696 } // extern "C"
4697
4698 void wxWindowGTK::GTKFreezeWidget(GtkWidget *w)
4699 {
4700 if ( !w || !gtk_widget_get_has_window(w) )
4701 return; // window-less widget, cannot be frozen
4702
4703 GdkWindow* window = gtk_widget_get_window(w);
4704 if (window == NULL)
4705 {
4706 // we can't thaw unrealized widgets because they don't have GdkWindow,
4707 // so set it up to be done immediately after realization:
4708 g_signal_connect_after
4709 (
4710 w,
4711 "realize",
4712 G_CALLBACK(wx_frozen_widget_realize),
4713 this
4714 );
4715 return;
4716 }
4717
4718 if (w == m_wxwindow)
4719 window = GTKGetDrawingWindow();
4720 gdk_window_freeze_updates(window);
4721 }
4722
4723 void wxWindowGTK::GTKThawWidget(GtkWidget *w)
4724 {
4725 if ( !w || !gtk_widget_get_has_window(w) )
4726 return; // window-less widget, cannot be frozen
4727
4728 GdkWindow* window = gtk_widget_get_window(w);
4729 if (window == NULL)
4730 {
4731 // the widget wasn't realized yet, no need to thaw
4732 g_signal_handlers_disconnect_by_func
4733 (
4734 w,
4735 (void*)wx_frozen_widget_realize,
4736 this
4737 );
4738 return;
4739 }
4740
4741 if (w == m_wxwindow)
4742 window = GTKGetDrawingWindow();
4743 gdk_window_thaw_updates(window);
4744 }
4745
4746 void wxWindowGTK::DoFreeze()
4747 {
4748 GTKFreezeWidget(m_widget);
4749 if ( m_wxwindow && m_widget != m_wxwindow )
4750 GTKFreezeWidget(m_wxwindow);
4751 }
4752
4753 void wxWindowGTK::DoThaw()
4754 {
4755 GTKThawWidget(m_widget);
4756 if ( m_wxwindow && m_widget != m_wxwindow )
4757 GTKThawWidget(m_wxwindow);
4758 }
wxWidgets (Impactor)