]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/window.cpp
projects / wxWidgets.git / blob
? search:


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