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


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