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