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