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