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