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