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