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


d30f6f98feda2a5f1d004985a137f7ff28ae8011
[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 extern "C" {
891 static gboolean
892 gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget),
893 GdkEventKey *gdk_event,
894 wxWindow *win )
895 {
896 if (!win->m_hasVMT)
897 return FALSE;
898 if (g_blockEventsOnDrag)
899 return FALSE;
900
901 wxKeyEvent event( wxEVT_KEY_DOWN );
902 bool ret = false;
903 bool return_after_IM = false;
904
905 if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
906 {
907 // Send the CHAR_HOOK event first
908 if ( SendCharHookEvent(event, win) )
909 {
910 // Don't do anything at all with this event any more.
911 return TRUE;
912 }
913
914 // Emit KEY_DOWN event
915 ret = win->HandleWindowEvent( event );
916 }
917 else
918 {
919 // Return after IM processing as we cannot do
920 // anything with it anyhow.
921 return_after_IM = true;
922 }
923
924 if (!ret && win->m_imData)
925 {
926 win->m_imData->lastKeyEvent = gdk_event;
927
928 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
929 // docs, if IM filter returns true, no further processing should be done.
930 // we should send the key_down event anyway.
931 bool intercepted_by_IM = gtk_im_context_filter_keypress(win->m_imData->context, gdk_event);
932 win->m_imData->lastKeyEvent = NULL;
933 if (intercepted_by_IM)
934 {
935 wxLogTrace(TRACE_KEYS, wxT("Key event intercepted by IM"));
936 return TRUE;
937 }
938 }
939
940 if (return_after_IM)
941 return FALSE;
942
943 #if wxUSE_ACCEL
944 if (!ret)
945 {
946 wxWindowGTK *ancestor = win;
947 while (ancestor)
948 {
949 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
950 if (command != -1)
951 {
952 wxCommandEvent menu_event( wxEVT_COMMAND_MENU_SELECTED, command );
953 ret = ancestor->HandleWindowEvent( menu_event );
954
955 if ( !ret )
956 {
957 // if the accelerator wasn't handled as menu event, try
958 // it as button click (for compatibility with other
959 // platforms):
960 wxCommandEvent button_event( wxEVT_COMMAND_BUTTON_CLICKED, command );
961 ret = ancestor->HandleWindowEvent( button_event );
962 }
963
964 break;
965 }
966 if (ancestor->IsTopLevel())
967 break;
968 ancestor = ancestor->GetParent();
969 }
970 }
971 #endif // wxUSE_ACCEL
972
973 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
974 // will only be sent if it is not in an accelerator table.
975 if (!ret)
976 {
977 long key_code;
978 KeySym keysym = gdk_event->keyval;
979 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
980 key_code = wxTranslateKeySymToWXKey(keysym, true /* isChar */);
981 if ( !key_code )
982 {
983 if ( wxIsAsciiKeysym(keysym) )
984 {
985 // ASCII key
986 key_code = (unsigned char)keysym;
987 }
988 // gdk_event->string is actually deprecated
989 else if ( gdk_event->length == 1 )
990 {
991 key_code = (unsigned char)gdk_event->string[0];
992 }
993 }
994
995 if ( key_code )
996 {
997 wxKeyEvent eventChar(wxEVT_CHAR, event);
998
999 wxLogTrace(TRACE_KEYS, wxT("Char event: %ld"), key_code);
1000
1001 eventChar.m_keyCode = key_code;
1002
1003 AdjustCharEventKeyCodes(eventChar);
1004
1005 ret = win->HandleWindowEvent(eventChar);
1006 }
1007 }
1008
1009 return ret;
1010 }
1011 }
1012
1013 extern "C" {
1014 static void
1015 gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context),
1016 const gchar *str,
1017 wxWindow *window)
1018 {
1019 wxKeyEvent event( wxEVT_CHAR );
1020
1021 // take modifiers, cursor position, timestamp etc. from the last
1022 // key_press_event that was fed into Input Method:
1023 if (window->m_imData->lastKeyEvent)
1024 {
1025 wxFillOtherKeyEventFields(event,
1026 window, window->m_imData->lastKeyEvent);
1027 }
1028 else
1029 {
1030 event.SetEventObject( window );
1031 }
1032
1033 const wxString data(wxGTK_CONV_BACK_SYS(str));
1034 if( data.empty() )
1035 return;
1036
1037 for( wxString::const_iterator pstr = data.begin(); pstr != data.end(); ++pstr )
1038 {
1039 #if wxUSE_UNICODE
1040 event.m_uniChar = *pstr;
1041 // Backward compatible for ISO-8859-1
1042 event.m_keyCode = *pstr < 256 ? event.m_uniChar : 0;
1043 wxLogTrace(TRACE_KEYS, wxT("IM sent character '%c'"), event.m_uniChar);
1044 #else
1045 event.m_keyCode = (char)*pstr;
1046 #endif // wxUSE_UNICODE
1047
1048 AdjustCharEventKeyCodes(event);
1049
1050 window->HandleWindowEvent(event);
1051 }
1052 }
1053 }
1054
1055
1056 //-----------------------------------------------------------------------------
1057 // "key_release_event" from any window
1058 //-----------------------------------------------------------------------------
1059
1060 extern "C" {
1061 static gboolean
1062 gtk_window_key_release_callback( GtkWidget * WXUNUSED(widget),
1063 GdkEventKey *gdk_event,
1064 wxWindowGTK *win )
1065 {
1066 if (!win->m_hasVMT)
1067 return FALSE;
1068
1069 if (g_blockEventsOnDrag)
1070 return FALSE;
1071
1072 wxKeyEvent event( wxEVT_KEY_UP );
1073 if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
1074 {
1075 // unknown key pressed, ignore (the event would be useless anyhow)
1076 return FALSE;
1077 }
1078
1079 return win->GTKProcessEvent(event);
1080 }
1081 }
1082
1083 //-----------------------------------------------------------------------------
1084 // key and mouse events, after, from m_widget
1085 //-----------------------------------------------------------------------------
1086
1087 extern "C" {
1088 static gboolean key_and_mouse_event_after(GtkWidget* widget, GdkEventKey*, wxWindow*)
1089 {
1090 // If a widget does not handle a key or mouse event, GTK+ sends it up the
1091 // parent chain until it is handled. These events are not supposed to
1092 // propagate in wxWidgets, so prevent it unless widget is in a native
1093 // container.
1094 return WX_IS_PIZZA(gtk_widget_get_parent(widget));
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 wxWindowGTK *child = 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 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1283
1284 g_lastButtonNumber = gdk_event->button;
1285
1286 // GDK sends surplus button down events
1287 // before a double click event. We
1288 // need to filter these out.
1289 if ((gdk_event->type == GDK_BUTTON_PRESS) && (win->m_wxwindow))
1290 {
1291 GdkEvent *peek_event = gdk_event_peek();
1292 if (peek_event)
1293 {
1294 if ((peek_event->type == GDK_2BUTTON_PRESS) ||
1295 (peek_event->type == GDK_3BUTTON_PRESS))
1296 {
1297 gdk_event_free( peek_event );
1298 return TRUE;
1299 }
1300 else
1301 {
1302 gdk_event_free( peek_event );
1303 }
1304 }
1305 }
1306
1307 wxEventType event_type = wxEVT_NULL;
1308
1309 if ( gdk_event->type == GDK_2BUTTON_PRESS &&
1310 gdk_event->button >= 1 && gdk_event->button <= 3 )
1311 {
1312 // Reset GDK internal timestamp variables in order to disable GDK
1313 // triple click events. GDK will then next time believe no button has
1314 // been clicked just before, and send a normal button click event.
1315 GdkDisplay* display = gtk_widget_get_display (widget);
1316 display->button_click_time[1] = 0;
1317 display->button_click_time[0] = 0;
1318 }
1319
1320 if (gdk_event->button == 1)
1321 {
1322 // note that GDK generates triple click events which are not supported
1323 // by wxWidgets but still have to be passed to the app as otherwise
1324 // clicks would simply go missing
1325 switch (gdk_event->type)
1326 {
1327 // we shouldn't get triple clicks at all for GTK2 because we
1328 // suppress them artificially using the code above but we still
1329 // should map them to something for GTK1 and not just ignore them
1330 // as this would lose clicks
1331 case GDK_3BUTTON_PRESS: // we could also map this to DCLICK...
1332 case GDK_BUTTON_PRESS:
1333 event_type = wxEVT_LEFT_DOWN;
1334 break;
1335
1336 case GDK_2BUTTON_PRESS:
1337 event_type = wxEVT_LEFT_DCLICK;
1338 break;
1339
1340 default:
1341 // just to silence gcc warnings
1342 ;
1343 }
1344 }
1345 else if (gdk_event->button == 2)
1346 {
1347 switch (gdk_event->type)
1348 {
1349 case GDK_3BUTTON_PRESS:
1350 case GDK_BUTTON_PRESS:
1351 event_type = wxEVT_MIDDLE_DOWN;
1352 break;
1353
1354 case GDK_2BUTTON_PRESS:
1355 event_type = wxEVT_MIDDLE_DCLICK;
1356 break;
1357
1358 default:
1359 ;
1360 }
1361 }
1362 else if (gdk_event->button == 3)
1363 {
1364 switch (gdk_event->type)
1365 {
1366 case GDK_3BUTTON_PRESS:
1367 case GDK_BUTTON_PRESS:
1368 event_type = wxEVT_RIGHT_DOWN;
1369 break;
1370
1371 case GDK_2BUTTON_PRESS:
1372 event_type = wxEVT_RIGHT_DCLICK;
1373 break;
1374
1375 default:
1376 ;
1377 }
1378 }
1379
1380 else if (gdk_event->button == 8)
1381 {
1382 switch (gdk_event->type)
1383 {
1384 case GDK_3BUTTON_PRESS:
1385 case GDK_BUTTON_PRESS:
1386 event_type = wxEVT_AUX1_DOWN;
1387 break;
1388
1389 case GDK_2BUTTON_PRESS:
1390 event_type = wxEVT_AUX1_DCLICK;
1391 break;
1392
1393 default:
1394 ;
1395 }
1396 }
1397
1398 else if (gdk_event->button == 9)
1399 {
1400 switch (gdk_event->type)
1401 {
1402 case GDK_3BUTTON_PRESS:
1403 case GDK_BUTTON_PRESS:
1404 event_type = wxEVT_AUX2_DOWN;
1405 break;
1406
1407 case GDK_2BUTTON_PRESS:
1408 event_type = wxEVT_AUX2_DCLICK;
1409 break;
1410
1411 default:
1412 ;
1413 }
1414 }
1415
1416 if ( event_type == wxEVT_NULL )
1417 {
1418 // unknown mouse button or click type
1419 return FALSE;
1420 }
1421
1422 g_lastMouseEvent = (GdkEvent*) gdk_event;
1423
1424 wxMouseEvent event( event_type );
1425 InitMouseEvent( win, event, gdk_event );
1426
1427 AdjustEventButtonState(event);
1428
1429 // find the correct window to send the event to: it may be a different one
1430 // from the one which got it at GTK+ level because some controls don't have
1431 // their own X window and thus cannot get any events.
1432 if ( !g_captureWindow )
1433 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1434
1435 // reset the event object and id in case win changed.
1436 event.SetEventObject( win );
1437 event.SetId( win->GetId() );
1438
1439 bool ret = win->GTKProcessEvent( event );
1440 g_lastMouseEvent = NULL;
1441 if ( ret )
1442 return TRUE;
1443
1444 if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() &&
1445 (gs_currentFocus != win) /* && win->IsFocusable() */)
1446 {
1447 win->SetFocus();
1448 }
1449
1450 if (event_type == wxEVT_RIGHT_DOWN)
1451 {
1452 // generate a "context menu" event: this is similar to right mouse
1453 // click under many GUIs except that it is generated differently
1454 // (right up under MSW, ctrl-click under Mac, right down here) and
1455 //
1456 // (a) it's a command event and so is propagated to the parent
1457 // (b) under some ports it can be generated from kbd too
1458 // (c) it uses screen coords (because of (a))
1459 wxContextMenuEvent evtCtx(
1460 wxEVT_CONTEXT_MENU,
1461 win->GetId(),
1462 win->ClientToScreen(event.GetPosition()));
1463 evtCtx.SetEventObject(win);
1464 return win->GTKProcessEvent(evtCtx);
1465 }
1466
1467 return FALSE;
1468 }
1469
1470 //-----------------------------------------------------------------------------
1471 // "button_release_event"
1472 //-----------------------------------------------------------------------------
1473
1474 static gboolean
1475 gtk_window_button_release_callback( GtkWidget *WXUNUSED(widget),
1476 GdkEventButton *gdk_event,
1477 wxWindowGTK *win )
1478 {
1479 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1480
1481 g_lastButtonNumber = 0;
1482
1483 wxEventType event_type = wxEVT_NULL;
1484
1485 switch (gdk_event->button)
1486 {
1487 case 1:
1488 event_type = wxEVT_LEFT_UP;
1489 break;
1490
1491 case 2:
1492 event_type = wxEVT_MIDDLE_UP;
1493 break;
1494
1495 case 3:
1496 event_type = wxEVT_RIGHT_UP;
1497 break;
1498
1499 case 8:
1500 event_type = wxEVT_AUX1_UP;
1501 break;
1502
1503 case 9:
1504 event_type = wxEVT_AUX2_UP;
1505 break;
1506
1507 default:
1508 // unknown button, don't process
1509 return FALSE;
1510 }
1511
1512 g_lastMouseEvent = (GdkEvent*) gdk_event;
1513
1514 wxMouseEvent event( event_type );
1515 InitMouseEvent( win, event, gdk_event );
1516
1517 AdjustEventButtonState(event);
1518
1519 if ( !g_captureWindow )
1520 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1521
1522 // reset the event object and id in case win changed.
1523 event.SetEventObject( win );
1524 event.SetId( win->GetId() );
1525
1526 bool ret = win->GTKProcessEvent(event);
1527
1528 g_lastMouseEvent = NULL;
1529
1530 return ret;
1531 }
1532
1533 //-----------------------------------------------------------------------------
1534 // "motion_notify_event"
1535 //-----------------------------------------------------------------------------
1536
1537 static gboolean
1538 gtk_window_motion_notify_callback( GtkWidget * WXUNUSED(widget),
1539 GdkEventMotion *gdk_event,
1540 wxWindowGTK *win )
1541 {
1542 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1543
1544 if (gdk_event->is_hint)
1545 {
1546 int x = 0;
1547 int y = 0;
1548 GdkModifierType state;
1549 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1550 gdk_event->x = x;
1551 gdk_event->y = y;
1552 }
1553
1554 g_lastMouseEvent = (GdkEvent*) gdk_event;
1555
1556 wxMouseEvent event( wxEVT_MOTION );
1557 InitMouseEvent(win, event, gdk_event);
1558
1559 if ( g_captureWindow )
1560 {
1561 // synthesise a mouse enter or leave event if needed
1562 GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
1563 // This seems to be necessary and actually been added to
1564 // GDK itself in version 2.0.X
1565 gdk_flush();
1566
1567 bool hasMouse = winUnderMouse == gdk_event->window;
1568 if ( hasMouse != g_captureWindowHasMouse )
1569 {
1570 // the mouse changed window
1571 g_captureWindowHasMouse = hasMouse;
1572
1573 wxMouseEvent eventM(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1574 : wxEVT_LEAVE_WINDOW);
1575 InitMouseEvent(win, eventM, gdk_event);
1576 eventM.SetEventObject(win);
1577 win->GTKProcessEvent(eventM);
1578 }
1579 }
1580 else // no capture
1581 {
1582 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1583
1584 // reset the event object and id in case win changed.
1585 event.SetEventObject( win );
1586 event.SetId( win->GetId() );
1587 }
1588
1589 if ( !g_captureWindow )
1590 {
1591 wxSetCursorEvent cevent( event.m_x, event.m_y );
1592 if (win->GTKProcessEvent( cevent ))
1593 {
1594 win->SetCursor( cevent.GetCursor() );
1595 }
1596 }
1597
1598 bool ret = win->GTKProcessEvent(event);
1599
1600 g_lastMouseEvent = NULL;
1601
1602 return ret;
1603 }
1604
1605 //-----------------------------------------------------------------------------
1606 // "scroll_event" (mouse wheel event)
1607 //-----------------------------------------------------------------------------
1608
1609 static gboolean
1610 window_scroll_event_hscrollbar(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
1611 {
1612 if (gdk_event->direction != GDK_SCROLL_LEFT &&
1613 gdk_event->direction != GDK_SCROLL_RIGHT)
1614 {
1615 return false;
1616 }
1617
1618 GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Horz];
1619
1620 if (range && gtk_widget_get_visible(GTK_WIDGET(range)))
1621 {
1622 GtkAdjustment* adj = gtk_range_get_adjustment(range);
1623 double delta = gtk_adjustment_get_step_increment(adj) * 3;
1624 if (gdk_event->direction == GDK_SCROLL_LEFT)
1625 delta = -delta;
1626
1627 gtk_range_set_value(range, gtk_adjustment_get_value(adj) + delta);
1628
1629 return TRUE;
1630 }
1631
1632 return FALSE;
1633 }
1634
1635 static gboolean
1636 window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
1637 {
1638 if (gdk_event->direction != GDK_SCROLL_UP &&
1639 gdk_event->direction != GDK_SCROLL_DOWN)
1640 {
1641 return false;
1642 }
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 if (gdk_event->direction == GDK_SCROLL_UP)
1651 event.m_wheelRotation = 120;
1652 else
1653 event.m_wheelRotation = -120;
1654
1655 if (win->GTKProcessEvent(event))
1656 return TRUE;
1657
1658 GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Vert];
1659
1660 if (range && gtk_widget_get_visible(GTK_WIDGET(range)))
1661 {
1662 GtkAdjustment* adj = gtk_range_get_adjustment(range);
1663 double delta = gtk_adjustment_get_step_increment(adj) * 3;
1664 if (gdk_event->direction == GDK_SCROLL_UP)
1665 delta = -delta;
1666
1667 gtk_range_set_value(range, gtk_adjustment_get_value(adj) + delta);
1668
1669 return TRUE;
1670 }
1671
1672 return FALSE;
1673 }
1674
1675 //-----------------------------------------------------------------------------
1676 // "popup-menu"
1677 //-----------------------------------------------------------------------------
1678
1679 static gboolean wxgtk_window_popup_menu_callback(GtkWidget*, wxWindowGTK* win)
1680 {
1681 wxContextMenuEvent event(wxEVT_CONTEXT_MENU, win->GetId(), wxPoint(-1, -1));
1682 event.SetEventObject(win);
1683 return win->GTKProcessEvent(event);
1684 }
1685
1686 //-----------------------------------------------------------------------------
1687 // "focus_in_event"
1688 //-----------------------------------------------------------------------------
1689
1690 static gboolean
1691 gtk_window_focus_in_callback( GtkWidget * WXUNUSED(widget),
1692 GdkEventFocus *WXUNUSED(event),
1693 wxWindowGTK *win )
1694 {
1695 return win->GTKHandleFocusIn();
1696 }
1697
1698 //-----------------------------------------------------------------------------
1699 // "focus_out_event"
1700 //-----------------------------------------------------------------------------
1701
1702 static gboolean
1703 gtk_window_focus_out_callback( GtkWidget * WXUNUSED(widget),
1704 GdkEventFocus * WXUNUSED(gdk_event),
1705 wxWindowGTK *win )
1706 {
1707 return win->GTKHandleFocusOut();
1708 }
1709
1710 //-----------------------------------------------------------------------------
1711 // "focus"
1712 //-----------------------------------------------------------------------------
1713
1714 static gboolean
1715 wx_window_focus_callback(GtkWidget *widget,
1716 GtkDirectionType WXUNUSED(direction),
1717 wxWindowGTK *win)
1718 {
1719 // the default handler for focus signal in GtkScrolledWindow sets
1720 // focus to the window itself even if it doesn't accept focus, i.e. has no
1721 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1722 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1723 // any children which might accept focus (we know we don't accept the focus
1724 // ourselves as this signal is only connected in this case)
1725 if ( win->GetChildren().empty() )
1726 g_signal_stop_emission_by_name(widget, "focus");
1727
1728 // we didn't change the focus
1729 return FALSE;
1730 }
1731
1732 //-----------------------------------------------------------------------------
1733 // "enter_notify_event"
1734 //-----------------------------------------------------------------------------
1735
1736 static gboolean
1737 gtk_window_enter_callback( GtkWidget *widget,
1738 GdkEventCrossing *gdk_event,
1739 wxWindowGTK *win )
1740 {
1741 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1742
1743 // Event was emitted after a grab
1744 if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
1745
1746 int x = 0;
1747 int y = 0;
1748 GdkModifierType state = (GdkModifierType)0;
1749
1750 gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, &state);
1751
1752 wxMouseEvent event( wxEVT_ENTER_WINDOW );
1753 InitMouseEvent(win, event, gdk_event);
1754 wxPoint pt = win->GetClientAreaOrigin();
1755 event.m_x = x + pt.x;
1756 event.m_y = y + pt.y;
1757
1758 if ( !g_captureWindow )
1759 {
1760 wxSetCursorEvent cevent( event.m_x, event.m_y );
1761 if (win->GTKProcessEvent( cevent ))
1762 {
1763 win->SetCursor( cevent.GetCursor() );
1764 }
1765 }
1766
1767 return win->GTKProcessEvent(event);
1768 }
1769
1770 //-----------------------------------------------------------------------------
1771 // "leave_notify_event"
1772 //-----------------------------------------------------------------------------
1773
1774 static gboolean
1775 gtk_window_leave_callback( GtkWidget *widget,
1776 GdkEventCrossing *gdk_event,
1777 wxWindowGTK *win )
1778 {
1779 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1780
1781 // Event was emitted after an ungrab
1782 if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
1783
1784 wxMouseEvent event( wxEVT_LEAVE_WINDOW );
1785
1786 int x = 0;
1787 int y = 0;
1788 GdkModifierType state = (GdkModifierType)0;
1789
1790 gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, &state);
1791
1792 InitMouseEvent(win, event, gdk_event);
1793
1794 return win->GTKProcessEvent(event);
1795 }
1796
1797 //-----------------------------------------------------------------------------
1798 // "value_changed" from scrollbar
1799 //-----------------------------------------------------------------------------
1800
1801 static void
1802 gtk_scrollbar_value_changed(GtkRange* range, wxWindow* win)
1803 {
1804 wxEventType eventType = win->GTKGetScrollEventType(range);
1805 if (eventType != wxEVT_NULL)
1806 {
1807 // Convert scroll event type to scrollwin event type
1808 eventType += wxEVT_SCROLLWIN_TOP - wxEVT_SCROLL_TOP;
1809
1810 // find the scrollbar which generated the event
1811 wxWindowGTK::ScrollDir dir = win->ScrollDirFromRange(range);
1812
1813 // generate the corresponding wx event
1814 const int orient = wxWindow::OrientFromScrollDir(dir);
1815 wxScrollWinEvent event(eventType, win->GetScrollPos(orient), orient);
1816 event.SetEventObject(win);
1817
1818 win->GTKProcessEvent(event);
1819 }
1820 }
1821
1822 //-----------------------------------------------------------------------------
1823 // "button_press_event" from scrollbar
1824 //-----------------------------------------------------------------------------
1825
1826 static gboolean
1827 gtk_scrollbar_button_press_event(GtkRange*, GdkEventButton*, wxWindow* win)
1828 {
1829 g_blockEventsOnScroll = true;
1830 win->m_mouseButtonDown = true;
1831
1832 return false;
1833 }
1834
1835 //-----------------------------------------------------------------------------
1836 // "event_after" from scrollbar
1837 //-----------------------------------------------------------------------------
1838
1839 static void
1840 gtk_scrollbar_event_after(GtkRange* range, GdkEvent* event, wxWindow* win)
1841 {
1842 if (event->type == GDK_BUTTON_RELEASE)
1843 {
1844 g_signal_handlers_block_by_func(range, (void*)gtk_scrollbar_event_after, win);
1845
1846 const int orient = wxWindow::OrientFromScrollDir(
1847 win->ScrollDirFromRange(range));
1848 wxScrollWinEvent evt(wxEVT_SCROLLWIN_THUMBRELEASE,
1849 win->GetScrollPos(orient), orient);
1850 evt.SetEventObject(win);
1851 win->GTKProcessEvent(evt);
1852 }
1853 }
1854
1855 //-----------------------------------------------------------------------------
1856 // "button_release_event" from scrollbar
1857 //-----------------------------------------------------------------------------
1858
1859 static gboolean
1860 gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* win)
1861 {
1862 g_blockEventsOnScroll = false;
1863 win->m_mouseButtonDown = false;
1864 // If thumb tracking
1865 if (win->m_isScrolling)
1866 {
1867 win->m_isScrolling = false;
1868 // Hook up handler to send thumb release event after this emission is finished.
1869 // To allow setting scroll position from event handler, sending event must
1870 // be deferred until after the GtkRange handler for this signal has run
1871 g_signal_handlers_unblock_by_func(range, (void*)gtk_scrollbar_event_after, win);
1872 }
1873
1874 return false;
1875 }
1876
1877 //-----------------------------------------------------------------------------
1878 // "realize" from m_widget
1879 //-----------------------------------------------------------------------------
1880
1881 static void
1882 gtk_window_realized_callback(GtkWidget* WXUNUSED(widget), wxWindowGTK* win)
1883 {
1884 win->GTKHandleRealized();
1885 }
1886
1887 //-----------------------------------------------------------------------------
1888 // "unrealize" from m_wxwindow
1889 //-----------------------------------------------------------------------------
1890
1891 static void unrealize(GtkWidget*, wxWindowGTK* win)
1892 {
1893 if (win->m_imData)
1894 gtk_im_context_set_client_window(win->m_imData->context, NULL);
1895 }
1896
1897 //-----------------------------------------------------------------------------
1898 // "size_allocate" from m_wxwindow or m_widget
1899 //-----------------------------------------------------------------------------
1900
1901 static void
1902 size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win)
1903 {
1904 int w = alloc->width;
1905 int h = alloc->height;
1906 if (win->m_wxwindow)
1907 {
1908 int border_x, border_y;
1909 WX_PIZZA(win->m_wxwindow)->get_border_widths(border_x, border_y);
1910 w -= 2 * border_x;
1911 h -= 2 * border_y;
1912 if (w < 0) w = 0;
1913 if (h < 0) h = 0;
1914 }
1915 if (win->m_oldClientWidth != w || win->m_oldClientHeight != h)
1916 {
1917 win->m_oldClientWidth = w;
1918 win->m_oldClientHeight = h;
1919 // this callback can be connected to m_wxwindow,
1920 // so always get size from m_widget->allocation
1921 GtkAllocation a;
1922 gtk_widget_get_allocation(win->m_widget, &a);
1923 win->m_width = a.width;
1924 win->m_height = a.height;
1925 if (!win->m_nativeSizeEvent)
1926 {
1927 wxSizeEvent event(win->GetSize(), win->GetId());
1928 event.SetEventObject(win);
1929 win->GTKProcessEvent(event);
1930 }
1931 }
1932 }
1933
1934 //-----------------------------------------------------------------------------
1935 // "grab_broken"
1936 //-----------------------------------------------------------------------------
1937
1938 #if GTK_CHECK_VERSION(2, 8, 0)
1939 static gboolean
1940 gtk_window_grab_broken( GtkWidget*,
1941 GdkEventGrabBroken *event,
1942 wxWindow *win )
1943 {
1944 // Mouse capture has been lost involuntarily, notify the application
1945 if(!event->keyboard && wxWindow::GetCapture() == win)
1946 {
1947 wxMouseCaptureLostEvent evt( win->GetId() );
1948 evt.SetEventObject( win );
1949 win->HandleWindowEvent( evt );
1950 }
1951 return false;
1952 }
1953 #endif
1954
1955 //-----------------------------------------------------------------------------
1956 // "style_set"
1957 //-----------------------------------------------------------------------------
1958
1959 static
1960 void gtk_window_style_set_callback( GtkWidget *WXUNUSED(widget),
1961 GtkStyle *previous_style,
1962 wxWindow* win )
1963 {
1964 if (win && previous_style)
1965 {
1966 if (win->IsTopLevel())
1967 {
1968 wxSysColourChangedEvent event;
1969 event.SetEventObject(win);
1970 win->GTKProcessEvent(event);
1971 }
1972 else
1973 {
1974 // Border width could change, which will change client size.
1975 // Make sure size event occurs for this
1976 win->m_oldClientWidth = 0;
1977 }
1978 }
1979 }
1980
1981 } // extern "C"
1982
1983 void wxWindowGTK::GTKHandleRealized()
1984 {
1985 if (m_imData)
1986 {
1987 gtk_im_context_set_client_window
1988 (
1989 m_imData->context,
1990 m_wxwindow ? GTKGetDrawingWindow()
1991 : gtk_widget_get_window(m_widget)
1992 );
1993 }
1994
1995 // Use composited window if background is transparent, if supported.
1996 if (m_backgroundStyle == wxBG_STYLE_TRANSPARENT)
1997 {
1998 #if wxGTK_HAS_COMPOSITING_SUPPORT
1999 if (IsTransparentBackgroundSupported())
2000 {
2001 GdkWindow* const window = GTKGetDrawingWindow();
2002 if (window)
2003 gdk_window_set_composited(window, true);
2004 }
2005 else
2006 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
2007 {
2008 // We revert to erase mode if transparency is not supported
2009 m_backgroundStyle = wxBG_STYLE_ERASE;
2010 }
2011 }
2012
2013
2014 // We cannot set colours and fonts before the widget
2015 // been realized, so we do this directly after realization
2016 // or otherwise in idle time
2017
2018 if (m_needsStyleChange)
2019 {
2020 SetBackgroundStyle(GetBackgroundStyle());
2021 m_needsStyleChange = false;
2022 }
2023
2024 wxWindowCreateEvent event(static_cast<wxWindow*>(this));
2025 event.SetEventObject( this );
2026 GTKProcessEvent( event );
2027
2028 GTKUpdateCursor(true, false);
2029 }
2030
2031 // ----------------------------------------------------------------------------
2032 // this wxWindowBase function is implemented here (in platform-specific file)
2033 // because it is static and so couldn't be made virtual
2034 // ----------------------------------------------------------------------------
2035
2036 wxWindow *wxWindowBase::DoFindFocus()
2037 {
2038 wxWindowGTK *focus = gs_pendingFocus ? gs_pendingFocus : gs_currentFocus;
2039 // the cast is necessary when we compile in wxUniversal mode
2040 return static_cast<wxWindow*>(focus);
2041 }
2042
2043 void wxWindowGTK::AddChildGTK(wxWindowGTK* child)
2044 {
2045 wxASSERT_MSG(m_wxwindow, "Cannot add a child to a window without a client area");
2046
2047 // the window might have been scrolled already, we
2048 // have to adapt the position
2049 wxPizza* pizza = WX_PIZZA(m_wxwindow);
2050 child->m_x += pizza->m_scroll_x;
2051 child->m_y += pizza->m_scroll_y;
2052
2053 gtk_widget_set_size_request(
2054 child->m_widget, child->m_width, child->m_height);
2055 pizza->put(child->m_widget, child->m_x, child->m_y);
2056 }
2057
2058 //-----------------------------------------------------------------------------
2059 // global functions
2060 //-----------------------------------------------------------------------------
2061
2062 wxWindow *wxGetActiveWindow()
2063 {
2064 return wxWindow::FindFocus();
2065 }
2066
2067
2068 wxMouseState wxGetMouseState()
2069 {
2070 wxMouseState ms;
2071
2072 gint x;
2073 gint y;
2074 GdkModifierType mask;
2075
2076 gdk_window_get_pointer(NULL, &x, &y, &mask);
2077
2078 ms.SetX(x);
2079 ms.SetY(y);
2080 ms.SetLeftDown((mask & GDK_BUTTON1_MASK) != 0);
2081 ms.SetMiddleDown((mask & GDK_BUTTON2_MASK) != 0);
2082 ms.SetRightDown((mask & GDK_BUTTON3_MASK) != 0);
2083 // see the comment in InitMouseEvent()
2084 ms.SetAux1Down((mask & GDK_BUTTON4_MASK) != 0);
2085 ms.SetAux2Down((mask & GDK_BUTTON5_MASK) != 0);
2086
2087 ms.SetControlDown((mask & GDK_CONTROL_MASK) != 0);
2088 ms.SetShiftDown((mask & GDK_SHIFT_MASK) != 0);
2089 ms.SetAltDown((mask & GDK_MOD1_MASK) != 0);
2090 ms.SetMetaDown((mask & GDK_META_MASK) != 0);
2091
2092 return ms;
2093 }
2094
2095 //-----------------------------------------------------------------------------
2096 // wxWindowGTK
2097 //-----------------------------------------------------------------------------
2098
2099 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2100 // method
2101 #ifdef __WXUNIVERSAL__
2102 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
2103 #endif // __WXUNIVERSAL__
2104
2105 void wxWindowGTK::Init()
2106 {
2107 // GTK specific
2108 m_widget = NULL;
2109 m_wxwindow = NULL;
2110 m_focusWidget = NULL;
2111
2112 // position/size
2113 m_x = 0;
2114 m_y = 0;
2115 m_width = 0;
2116 m_height = 0;
2117
2118 m_hasVMT = false;
2119
2120 m_showOnIdle = false;
2121
2122 m_noExpose = false;
2123 m_nativeSizeEvent = false;
2124
2125 m_isScrolling = false;
2126 m_mouseButtonDown = false;
2127
2128 // initialize scrolling stuff
2129 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
2130 {
2131 m_scrollBar[dir] = NULL;
2132 m_scrollPos[dir] = 0;
2133 }
2134
2135 m_oldClientWidth =
2136 m_oldClientHeight = 0;
2137
2138 m_clipPaintRegion = false;
2139
2140 m_needsStyleChange = false;
2141
2142 m_cursor = *wxSTANDARD_CURSOR;
2143
2144 m_imData = NULL;
2145 m_dirtyTabOrder = false;
2146 }
2147
2148 wxWindowGTK::wxWindowGTK()
2149 {
2150 Init();
2151 }
2152
2153 wxWindowGTK::wxWindowGTK( wxWindow *parent,
2154 wxWindowID id,
2155 const wxPoint &pos,
2156 const wxSize &size,
2157 long style,
2158 const wxString &name )
2159 {
2160 Init();
2161
2162 Create( parent, id, pos, size, style, name );
2163 }
2164
2165 bool wxWindowGTK::Create( wxWindow *parent,
2166 wxWindowID id,
2167 const wxPoint &pos,
2168 const wxSize &size,
2169 long style,
2170 const wxString &name )
2171 {
2172 // Get default border
2173 wxBorder border = GetBorder(style);
2174
2175 style &= ~wxBORDER_MASK;
2176 style |= border;
2177
2178 if (!PreCreation( parent, pos, size ) ||
2179 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2180 {
2181 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2182 return false;
2183 }
2184
2185 // We should accept the native look
2186 #if 0
2187 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2188 scroll_class->scrollbar_spacing = 0;
2189 #endif
2190
2191
2192 m_wxwindow = wxPizza::New(m_windowStyle);
2193 #ifndef __WXUNIVERSAL__
2194 if (HasFlag(wxPizza::BORDER_STYLES))
2195 {
2196 g_signal_connect(m_wxwindow, "parent_set",
2197 G_CALLBACK(parent_set), this);
2198 }
2199 #endif
2200 if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
2201 m_widget = m_wxwindow;
2202 else
2203 {
2204 m_widget = gtk_scrolled_window_new( NULL, NULL );
2205
2206 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
2207
2208 // There is a conflict with default bindings at GTK+
2209 // level between scrolled windows and notebooks both of which want to use
2210 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2211 // direction and notebooks for changing pages -- we decide that if we don't
2212 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2213 // means we can get working keyboard navigation in notebooks
2214 if ( !HasFlag(wxHSCROLL) )
2215 {
2216 GtkBindingSet *
2217 bindings = gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget));
2218 if ( bindings )
2219 {
2220 gtk_binding_entry_remove(bindings, GDK_Page_Up, GDK_CONTROL_MASK);
2221 gtk_binding_entry_remove(bindings, GDK_Page_Down, GDK_CONTROL_MASK);
2222 }
2223 }
2224
2225 if (HasFlag(wxALWAYS_SHOW_SB))
2226 {
2227 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
2228 }
2229 else
2230 {
2231 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
2232 }
2233
2234 m_scrollBar[ScrollDir_Horz] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow));
2235 m_scrollBar[ScrollDir_Vert] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow));
2236 if (GetLayoutDirection() == wxLayout_RightToLeft)
2237 gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );
2238
2239 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
2240
2241 // connect various scroll-related events
2242 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
2243 {
2244 // these handlers block mouse events to any window during scrolling
2245 // such as motion events and prevent GTK and wxWidgets from fighting
2246 // over where the slider should be
2247 g_signal_connect(m_scrollBar[dir], "button_press_event",
2248 G_CALLBACK(gtk_scrollbar_button_press_event), this);
2249 g_signal_connect(m_scrollBar[dir], "button_release_event",
2250 G_CALLBACK(gtk_scrollbar_button_release_event), this);
2251
2252 gulong handler_id = g_signal_connect(m_scrollBar[dir], "event_after",
2253 G_CALLBACK(gtk_scrollbar_event_after), this);
2254 g_signal_handler_block(m_scrollBar[dir], handler_id);
2255
2256 // these handlers get notified when scrollbar slider moves
2257 g_signal_connect_after(m_scrollBar[dir], "value_changed",
2258 G_CALLBACK(gtk_scrollbar_value_changed), this);
2259 }
2260
2261 gtk_widget_show( m_wxwindow );
2262 }
2263 g_object_ref(m_widget);
2264
2265 if (m_parent)
2266 m_parent->DoAddChild( this );
2267
2268 m_focusWidget = m_wxwindow;
2269
2270 SetCanFocus(AcceptsFocus());
2271
2272 PostCreation();
2273
2274 return true;
2275 }
2276
2277 wxWindowGTK::~wxWindowGTK()
2278 {
2279 SendDestroyEvent();
2280
2281 if (gs_currentFocus == this)
2282 gs_currentFocus = NULL;
2283 if (gs_pendingFocus == this)
2284 gs_pendingFocus = NULL;
2285
2286 if ( gs_deferredFocusOut == this )
2287 gs_deferredFocusOut = NULL;
2288
2289 m_hasVMT = false;
2290
2291 // destroy children before destroying this window itself
2292 DestroyChildren();
2293
2294 // unhook focus handlers to prevent stray events being
2295 // propagated to this (soon to be) dead object
2296 if (m_focusWidget != NULL)
2297 {
2298 g_signal_handlers_disconnect_by_func (m_focusWidget,
2299 (gpointer) gtk_window_focus_in_callback,
2300 this);
2301 g_signal_handlers_disconnect_by_func (m_focusWidget,
2302 (gpointer) gtk_window_focus_out_callback,
2303 this);
2304 }
2305
2306 if (m_widget)
2307 Show( false );
2308
2309 // delete before the widgets to avoid a crash on solaris
2310 delete m_imData;
2311 m_imData = NULL;
2312
2313 // avoid problem with GTK+ 2.18 where a frozen window causes the whole
2314 // TLW to be frozen, and if the window is then destroyed, nothing ever
2315 // gets painted again
2316 if (IsFrozen())
2317 DoThaw();
2318
2319 if (m_widget)
2320 {
2321 // Note that gtk_widget_destroy() does not destroy the widget, it just
2322 // emits the "destroy" signal. The widget is not actually destroyed
2323 // until its reference count drops to zero.
2324 gtk_widget_destroy(m_widget);
2325 // Release our reference, should be the last one
2326 g_object_unref(m_widget);
2327 m_widget = NULL;
2328 }
2329 m_wxwindow = NULL;
2330 }
2331
2332 bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
2333 {
2334 if ( GTKNeedsParent() )
2335 {
2336 wxCHECK_MSG( parent, false, wxT("Must have non-NULL parent") );
2337 }
2338
2339 // Use either the given size, or the default if -1 is given.
2340 // See wxWindowBase for these functions.
2341 m_width = WidthDefault(size.x) ;
2342 m_height = HeightDefault(size.y);
2343
2344 m_x = (int)pos.x;
2345 m_y = (int)pos.y;
2346
2347 return true;
2348 }
2349
2350 void wxWindowGTK::PostCreation()
2351 {
2352 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2353
2354 #if wxGTK_HAS_COMPOSITING_SUPPORT
2355 // Set RGBA visual as soon as possible to minimize the possibility that
2356 // somebody uses the wrong one.
2357 if ( m_backgroundStyle == wxBG_STYLE_TRANSPARENT &&
2358 IsTransparentBackgroundSupported() )
2359 {
2360 GdkScreen *screen = gtk_widget_get_screen (m_widget);
2361
2362 GdkColormap *rgba_colormap = gdk_screen_get_rgba_colormap (screen);
2363
2364 if (rgba_colormap)
2365 gtk_widget_set_colormap(m_widget, rgba_colormap);
2366 }
2367 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
2368
2369 if (m_wxwindow)
2370 {
2371 if (!m_noExpose)
2372 {
2373 // these get reported to wxWidgets -> wxPaintEvent
2374
2375 g_signal_connect (m_wxwindow, "expose_event",
2376 G_CALLBACK (gtk_window_expose_callback), this);
2377
2378 if (GetLayoutDirection() == wxLayout_LeftToRight)
2379 gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE));
2380 }
2381
2382 // Create input method handler
2383 m_imData = new wxGtkIMData;
2384
2385 // Cannot handle drawing preedited text yet
2386 gtk_im_context_set_use_preedit( m_imData->context, FALSE );
2387
2388 g_signal_connect (m_imData->context, "commit",
2389 G_CALLBACK (gtk_wxwindow_commit_cb), this);
2390 g_signal_connect(m_wxwindow, "unrealize", G_CALLBACK(unrealize), this);
2391 }
2392
2393 // focus handling
2394
2395 if (!GTK_IS_WINDOW(m_widget))
2396 {
2397 if (m_focusWidget == NULL)
2398 m_focusWidget = m_widget;
2399
2400 if (m_wxwindow)
2401 {
2402 g_signal_connect (m_focusWidget, "focus_in_event",
2403 G_CALLBACK (gtk_window_focus_in_callback), this);
2404 g_signal_connect (m_focusWidget, "focus_out_event",
2405 G_CALLBACK (gtk_window_focus_out_callback), this);
2406 }
2407 else
2408 {
2409 g_signal_connect_after (m_focusWidget, "focus_in_event",
2410 G_CALLBACK (gtk_window_focus_in_callback), this);
2411 g_signal_connect_after (m_focusWidget, "focus_out_event",
2412 G_CALLBACK (gtk_window_focus_out_callback), this);
2413 }
2414 }
2415
2416 if ( !AcceptsFocusFromKeyboard() )
2417 {
2418 SetCanFocus(false);
2419
2420 g_signal_connect(m_widget, "focus",
2421 G_CALLBACK(wx_window_focus_callback), this);
2422 }
2423
2424 // connect to the various key and mouse handlers
2425
2426 GtkWidget *connect_widget = GetConnectWidget();
2427
2428 ConnectWidget( connect_widget );
2429
2430 // connect handler to prevent events from propagating up parent chain
2431 g_signal_connect_after(m_widget,
2432 "key_press_event", G_CALLBACK(key_and_mouse_event_after), this);
2433 g_signal_connect_after(m_widget,
2434 "key_release_event", G_CALLBACK(key_and_mouse_event_after), this);
2435 g_signal_connect_after(m_widget,
2436 "button_press_event", G_CALLBACK(key_and_mouse_event_after), this);
2437 g_signal_connect_after(m_widget,
2438 "button_release_event", G_CALLBACK(key_and_mouse_event_after), this);
2439 g_signal_connect_after(m_widget,
2440 "motion_notify_event", G_CALLBACK(key_and_mouse_event_after), this);
2441
2442 // We cannot set colours, fonts and cursors before the widget has been
2443 // realized, so we do this directly after realization -- unless the widget
2444 // was in fact realized already.
2445 if ( gtk_widget_get_realized(connect_widget) )
2446 {
2447 gtk_window_realized_callback(connect_widget, this);
2448 }
2449 else
2450 {
2451 g_signal_connect (connect_widget, "realize",
2452 G_CALLBACK (gtk_window_realized_callback), this);
2453 }
2454
2455 if (!IsTopLevel())
2456 {
2457 g_signal_connect(m_wxwindow ? m_wxwindow : m_widget, "size_allocate",
2458 G_CALLBACK(size_allocate), this);
2459 }
2460
2461 #if GTK_CHECK_VERSION(2, 8, 0)
2462 if ( gtk_check_version(2,8,0) == NULL )
2463 {
2464 // Make sure we can notify the app when mouse capture is lost
2465 if ( m_wxwindow )
2466 {
2467 g_signal_connect (m_wxwindow, "grab_broken_event",
2468 G_CALLBACK (gtk_window_grab_broken), this);
2469 }
2470
2471 if ( connect_widget != m_wxwindow )
2472 {
2473 g_signal_connect (connect_widget, "grab_broken_event",
2474 G_CALLBACK (gtk_window_grab_broken), this);
2475 }
2476 }
2477 #endif // GTK+ >= 2.8
2478
2479 if ( GTKShouldConnectSizeRequest() )
2480 {
2481 // This is needed if we want to add our windows into native
2482 // GTK controls, such as the toolbar. With this callback, the
2483 // toolbar gets to know the correct size (the one set by the
2484 // programmer). Sadly, it misbehaves for wxComboBox.
2485 g_signal_connect (m_widget, "size_request",
2486 G_CALLBACK (wxgtk_window_size_request_callback),
2487 this);
2488 }
2489
2490 InheritAttributes();
2491
2492 m_hasVMT = true;
2493
2494 SetLayoutDirection(wxLayout_Default);
2495
2496 // unless the window was created initially hidden (i.e. Hide() had been
2497 // called before Create()), we should show it at GTK+ level as well
2498 if ( IsShown() )
2499 gtk_widget_show( m_widget );
2500 }
2501
2502 unsigned long
2503 wxWindowGTK::GTKConnectWidget(const char *signal, wxGTKCallback callback)
2504 {
2505 return g_signal_connect(m_widget, signal, callback, this);
2506 }
2507
2508 void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2509 {
2510 g_signal_connect (widget, "key_press_event",
2511 G_CALLBACK (gtk_window_key_press_callback), this);
2512 g_signal_connect (widget, "key_release_event",
2513 G_CALLBACK (gtk_window_key_release_callback), this);
2514 g_signal_connect (widget, "button_press_event",
2515 G_CALLBACK (gtk_window_button_press_callback), this);
2516 g_signal_connect (widget, "button_release_event",
2517 G_CALLBACK (gtk_window_button_release_callback), this);
2518 g_signal_connect (widget, "motion_notify_event",
2519 G_CALLBACK (gtk_window_motion_notify_callback), this);
2520
2521 g_signal_connect (widget, "scroll_event",
2522 G_CALLBACK (window_scroll_event), this);
2523 if (m_scrollBar[ScrollDir_Horz])
2524 g_signal_connect (m_scrollBar[ScrollDir_Horz], "scroll_event",
2525 G_CALLBACK (window_scroll_event_hscrollbar), this);
2526 if (m_scrollBar[ScrollDir_Vert])
2527 g_signal_connect (m_scrollBar[ScrollDir_Vert], "scroll_event",
2528 G_CALLBACK (window_scroll_event), this);
2529
2530 g_signal_connect (widget, "popup_menu",
2531 G_CALLBACK (wxgtk_window_popup_menu_callback), this);
2532 g_signal_connect (widget, "enter_notify_event",
2533 G_CALLBACK (gtk_window_enter_callback), this);
2534 g_signal_connect (widget, "leave_notify_event",
2535 G_CALLBACK (gtk_window_leave_callback), this);
2536
2537 if (m_wxwindow && (IsTopLevel() || HasFlag(wxBORDER_RAISED | wxBORDER_SUNKEN | wxBORDER_THEME)))
2538 g_signal_connect (m_wxwindow, "style_set",
2539 G_CALLBACK (gtk_window_style_set_callback), this);
2540 }
2541
2542 bool wxWindowGTK::Destroy()
2543 {
2544 m_hasVMT = false;
2545
2546 return wxWindowBase::Destroy();
2547 }
2548
2549 void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
2550 {
2551 gtk_widget_set_size_request(m_widget, width, height);
2552
2553 // inform the parent to perform the move
2554 wxASSERT_MSG(m_parent && m_parent->m_wxwindow,
2555 "the parent window has no client area?");
2556 WX_PIZZA(m_parent->m_wxwindow)->move(m_widget, x, y);
2557 }
2558
2559 void wxWindowGTK::ConstrainSize()
2560 {
2561 #ifdef __WXGPE__
2562 // GPE's window manager doesn't like size hints at all, esp. when the user
2563 // has to use the virtual keyboard, so don't constrain size there
2564 if (!IsTopLevel())
2565 #endif
2566 {
2567 const wxSize minSize = GetMinSize();
2568 const wxSize maxSize = GetMaxSize();
2569 if (minSize.x > 0 && m_width < minSize.x) m_width = minSize.x;
2570 if (minSize.y > 0 && m_height < minSize.y) m_height = minSize.y;
2571 if (maxSize.x > 0 && m_width > maxSize.x) m_width = maxSize.x;
2572 if (maxSize.y > 0 && m_height > maxSize.y) m_height = maxSize.y;
2573 }
2574 }
2575
2576 void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2577 {
2578 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2579 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
2580
2581 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0 && (x == -1 || y == -1))
2582 {
2583 int currentX, currentY;
2584 GetPosition(&currentX, &currentY);
2585 if (x == -1)
2586 x = currentX;
2587 if (y == -1)
2588 y = currentY;
2589 }
2590 AdjustForParentClientOrigin(x, y, sizeFlags);
2591
2592 // calculate the best size if we should auto size the window
2593 if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
2594 ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
2595 {
2596 const wxSize sizeBest = GetBestSize();
2597 if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
2598 width = sizeBest.x;
2599 if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
2600 height = sizeBest.y;
2601 }
2602
2603 const wxSize oldSize(m_width, m_height);
2604 if (width != -1)
2605 m_width = width;
2606 if (height != -1)
2607 m_height = height;
2608
2609 if (m_parent->m_wxwindow)
2610 {
2611 wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
2612 m_x = x + pizza->m_scroll_x;
2613 m_y = y + pizza->m_scroll_y;
2614
2615 int left_border = 0;
2616 int right_border = 0;
2617 int top_border = 0;
2618 int bottom_border = 0;
2619
2620 /* the default button has a border around it */
2621 if (gtk_widget_get_can_default(m_widget))
2622 {
2623 GtkBorder *default_border = NULL;
2624 gtk_widget_style_get( m_widget, "default_border", &default_border, NULL );
2625 if (default_border)
2626 {
2627 left_border += default_border->left;
2628 right_border += default_border->right;
2629 top_border += default_border->top;
2630 bottom_border += default_border->bottom;
2631 gtk_border_free( default_border );
2632 }
2633 }
2634
2635 DoMoveWindow( m_x - left_border,
2636 m_y - top_border,
2637 m_width+left_border+right_border,
2638 m_height+top_border+bottom_border );
2639 }
2640
2641 if (m_width != oldSize.x || m_height != oldSize.y)
2642 {
2643 // update these variables to keep size_allocate handler
2644 // from sending another size event for this change
2645 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
2646
2647 gtk_widget_queue_resize(m_widget);
2648 if (!m_nativeSizeEvent)
2649 {
2650 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2651 event.SetEventObject( this );
2652 HandleWindowEvent( event );
2653 }
2654 } else
2655 if (sizeFlags & wxSIZE_FORCE_EVENT)
2656 {
2657 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2658 event.SetEventObject( this );
2659 HandleWindowEvent( event );
2660 }
2661 }
2662
2663 bool wxWindowGTK::GTKShowFromOnIdle()
2664 {
2665 if (IsShown() && m_showOnIdle && !gtk_widget_get_visible (m_widget))
2666 {
2667 GtkAllocation alloc;
2668 alloc.x = m_x;
2669 alloc.y = m_y;
2670 alloc.width = m_width;
2671 alloc.height = m_height;
2672 gtk_widget_size_allocate( m_widget, &alloc );
2673 gtk_widget_show( m_widget );
2674 wxShowEvent eventShow(GetId(), true);
2675 eventShow.SetEventObject(this);
2676 HandleWindowEvent(eventShow);
2677 m_showOnIdle = false;
2678 return true;
2679 }
2680
2681 return false;
2682 }
2683
2684 void wxWindowGTK::OnInternalIdle()
2685 {
2686 if ( gs_deferredFocusOut )
2687 GTKHandleDeferredFocusOut();
2688
2689 // Check if we have to show window now
2690 if (GTKShowFromOnIdle()) return;
2691
2692 if ( m_dirtyTabOrder )
2693 {
2694 m_dirtyTabOrder = false;
2695 RealizeTabOrder();
2696 }
2697
2698 wxWindowBase::OnInternalIdle();
2699 }
2700
2701 void wxWindowGTK::DoGetSize( int *width, int *height ) const
2702 {
2703 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2704
2705 if (width) (*width) = m_width;
2706 if (height) (*height) = m_height;
2707 }
2708
2709 void wxWindowGTK::DoSetClientSize( int width, int height )
2710 {
2711 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2712
2713 const wxSize size = GetSize();
2714 const wxSize clientSize = GetClientSize();
2715 SetSize(width + (size.x - clientSize.x), height + (size.y - clientSize.y));
2716 }
2717
2718 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
2719 {
2720 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2721
2722 int w = m_width;
2723 int h = m_height;
2724
2725 if ( m_wxwindow )
2726 {
2727 // if window is scrollable, account for scrollbars
2728 if ( GTK_IS_SCROLLED_WINDOW(m_widget) )
2729 {
2730 GtkPolicyType policy[ScrollDir_Max];
2731 gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget),
2732 &policy[ScrollDir_Horz],
2733 &policy[ScrollDir_Vert]);
2734
2735 for ( int i = 0; i < ScrollDir_Max; i++ )
2736 {
2737 // don't account for the scrollbars we don't have
2738 GtkRange * const range = m_scrollBar[i];
2739 if ( !range )
2740 continue;
2741
2742 // nor for the ones we have but don't current show
2743 switch ( policy[i] )
2744 {
2745 case GTK_POLICY_NEVER:
2746 // never shown so doesn't take any place
2747 continue;
2748
2749 case GTK_POLICY_ALWAYS:
2750 // no checks necessary
2751 break;
2752
2753 case GTK_POLICY_AUTOMATIC:
2754 // may be shown or not, check
2755 GtkAdjustment *adj = gtk_range_get_adjustment(range);
2756 if (gtk_adjustment_get_upper(adj) <= gtk_adjustment_get_page_size(adj))
2757 continue;
2758 }
2759
2760 GtkScrolledWindowClass *scroll_class =
2761 GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2762
2763 GtkRequisition req;
2764 gtk_widget_size_request(GTK_WIDGET(range), &req);
2765 if (i == ScrollDir_Horz)
2766 h -= req.height + scroll_class->scrollbar_spacing;
2767 else
2768 w -= req.width + scroll_class->scrollbar_spacing;
2769 }
2770 }
2771
2772 const wxSize sizeBorders = DoGetBorderSize();
2773 w -= sizeBorders.x;
2774 h -= sizeBorders.y;
2775
2776 if (w < 0)
2777 w = 0;
2778 if (h < 0)
2779 h = 0;
2780 }
2781
2782 if (width) *width = w;
2783 if (height) *height = h;
2784 }
2785
2786 wxSize wxWindowGTK::DoGetBorderSize() const
2787 {
2788 if ( !m_wxwindow )
2789 return wxWindowBase::DoGetBorderSize();
2790
2791 int x, y;
2792 WX_PIZZA(m_wxwindow)->get_border_widths(x, y);
2793
2794 return 2*wxSize(x, y);
2795 }
2796
2797 void wxWindowGTK::DoGetPosition( int *x, int *y ) const
2798 {
2799 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2800
2801 int dx = 0;
2802 int dy = 0;
2803 if (!IsTopLevel() && m_parent && m_parent->m_wxwindow)
2804 {
2805 wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
2806 dx = pizza->m_scroll_x;
2807 dy = pizza->m_scroll_y;
2808 }
2809
2810 if (m_x == -1 && m_y == -1)
2811 {
2812 GdkWindow *source = NULL;
2813 if (m_wxwindow)
2814 source = gtk_widget_get_window(m_wxwindow);
2815 else
2816 source = gtk_widget_get_window(m_widget);
2817
2818 if (source)
2819 {
2820 int org_x = 0;
2821 int org_y = 0;
2822 gdk_window_get_origin( source, &org_x, &org_y );
2823
2824 if (m_parent)
2825 m_parent->ScreenToClient(&org_x, &org_y);
2826
2827 const_cast<wxWindowGTK*>(this)->m_x = org_x;
2828 const_cast<wxWindowGTK*>(this)->m_y = org_y;
2829 }
2830 }
2831
2832 if (x) (*x) = m_x - dx;
2833 if (y) (*y) = m_y - dy;
2834 }
2835
2836 void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
2837 {
2838 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2839
2840 if (gtk_widget_get_window(m_widget) == NULL) return;
2841
2842 GdkWindow *source = NULL;
2843 if (m_wxwindow)
2844 source = gtk_widget_get_window(m_wxwindow);
2845 else
2846 source = gtk_widget_get_window(m_widget);
2847
2848 int org_x = 0;
2849 int org_y = 0;
2850 gdk_window_get_origin( source, &org_x, &org_y );
2851
2852 if (!m_wxwindow)
2853 {
2854 if (!gtk_widget_get_has_window(m_widget))
2855 {
2856 GtkAllocation a;
2857 gtk_widget_get_allocation(m_widget, &a);
2858 org_x += a.x;
2859 org_y += a.y;
2860 }
2861 }
2862
2863
2864 if (x)
2865 {
2866 if (GetLayoutDirection() == wxLayout_RightToLeft)
2867 *x = (GetClientSize().x - *x) + org_x;
2868 else
2869 *x += org_x;
2870 }
2871
2872 if (y) *y += org_y;
2873 }
2874
2875 void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
2876 {
2877 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2878
2879 if (!gtk_widget_get_realized(m_widget)) return;
2880
2881 GdkWindow *source = NULL;
2882 if (m_wxwindow)
2883 source = gtk_widget_get_window(m_wxwindow);
2884 else
2885 source = gtk_widget_get_window(m_widget);
2886
2887 int org_x = 0;
2888 int org_y = 0;
2889 gdk_window_get_origin( source, &org_x, &org_y );
2890
2891 if (!m_wxwindow)
2892 {
2893 if (!gtk_widget_get_has_window(m_widget))
2894 {
2895 GtkAllocation a;
2896 gtk_widget_get_allocation(m_widget, &a);
2897 org_x += a.x;
2898 org_y += a.y;
2899 }
2900 }
2901
2902 if (x)
2903 {
2904 if (GetLayoutDirection() == wxLayout_RightToLeft)
2905 *x = (GetClientSize().x - *x) - org_x;
2906 else
2907 *x -= org_x;
2908 }
2909 if (y) *y -= org_y;
2910 }
2911
2912 bool wxWindowGTK::Show( bool show )
2913 {
2914 if ( !wxWindowBase::Show(show) )
2915 {
2916 // nothing to do
2917 return false;
2918 }
2919
2920 // notice that we may call Hide() before the window is created and this is
2921 // actually useful to create it hidden initially -- but we can't call
2922 // Show() before it is created
2923 if ( !m_widget )
2924 {
2925 wxASSERT_MSG( !show, "can't show invalid window" );
2926 return true;
2927 }
2928
2929 if ( show )
2930 {
2931 if ( m_showOnIdle )
2932 {
2933 // defer until later
2934 return true;
2935 }
2936
2937 gtk_widget_show(m_widget);
2938 }
2939 else // hide
2940 {
2941 gtk_widget_hide(m_widget);
2942 }
2943
2944 wxShowEvent eventShow(GetId(), show);
2945 eventShow.SetEventObject(this);
2946 HandleWindowEvent(eventShow);
2947
2948 return true;
2949 }
2950
2951 void wxWindowGTK::DoEnable( bool enable )
2952 {
2953 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2954
2955 gtk_widget_set_sensitive( m_widget, enable );
2956 if (m_wxwindow && (m_wxwindow != m_widget))
2957 gtk_widget_set_sensitive( m_wxwindow, enable );
2958 }
2959
2960 int wxWindowGTK::GetCharHeight() const
2961 {
2962 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
2963
2964 wxFont font = GetFont();
2965 wxCHECK_MSG( font.IsOk(), 12, wxT("invalid font") );
2966
2967 PangoContext* context = gtk_widget_get_pango_context(m_widget);
2968
2969 if (!context)
2970 return 0;
2971
2972 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
2973 PangoLayout *layout = pango_layout_new(context);
2974 pango_layout_set_font_description(layout, desc);
2975 pango_layout_set_text(layout, "H", 1);
2976 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2977
2978 PangoRectangle rect;
2979 pango_layout_line_get_extents(line, NULL, &rect);
2980
2981 g_object_unref (layout);
2982
2983 return (int) PANGO_PIXELS(rect.height);
2984 }
2985
2986 int wxWindowGTK::GetCharWidth() const
2987 {
2988 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
2989
2990 wxFont font = GetFont();
2991 wxCHECK_MSG( font.IsOk(), 8, wxT("invalid font") );
2992
2993 PangoContext* context = gtk_widget_get_pango_context(m_widget);
2994
2995 if (!context)
2996 return 0;
2997
2998 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
2999 PangoLayout *layout = pango_layout_new(context);
3000 pango_layout_set_font_description(layout, desc);
3001 pango_layout_set_text(layout, "g", 1);
3002 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3003
3004 PangoRectangle rect;
3005 pango_layout_line_get_extents(line, NULL, &rect);
3006
3007 g_object_unref (layout);
3008
3009 return (int) PANGO_PIXELS(rect.width);
3010 }
3011
3012 void wxWindowGTK::DoGetTextExtent( const wxString& string,
3013 int *x,
3014 int *y,
3015 int *descent,
3016 int *externalLeading,
3017 const wxFont *theFont ) const
3018 {
3019 wxFont fontToUse = theFont ? *theFont : GetFont();
3020
3021 wxCHECK_RET( fontToUse.IsOk(), wxT("invalid font") );
3022
3023 if (string.empty())
3024 {
3025 if (x) (*x) = 0;
3026 if (y) (*y) = 0;
3027 return;
3028 }
3029
3030 PangoContext *context = NULL;
3031 if (m_widget)
3032 context = gtk_widget_get_pango_context( m_widget );
3033
3034 if (!context)
3035 {
3036 if (x) (*x) = 0;
3037 if (y) (*y) = 0;
3038 return;
3039 }
3040
3041 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
3042 PangoLayout *layout = pango_layout_new(context);
3043 pango_layout_set_font_description(layout, desc);
3044 {
3045 const wxCharBuffer data = wxGTK_CONV( string );
3046 if ( data )
3047 pango_layout_set_text(layout, data, strlen(data));
3048 }
3049
3050 PangoRectangle rect;
3051 pango_layout_get_extents(layout, NULL, &rect);
3052
3053 if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width);
3054 if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height);
3055 if (descent)
3056 {
3057 PangoLayoutIter *iter = pango_layout_get_iter(layout);
3058 int baseline = pango_layout_iter_get_baseline(iter);
3059 pango_layout_iter_free(iter);
3060 *descent = *y - PANGO_PIXELS(baseline);
3061 }
3062 if (externalLeading) (*externalLeading) = 0; // ??
3063
3064 g_object_unref (layout);
3065 }
3066
3067 void wxWindowGTK::GTKDisableFocusOutEvent()
3068 {
3069 g_signal_handlers_block_by_func( m_focusWidget,
3070 (gpointer) gtk_window_focus_out_callback, this);
3071 }
3072
3073 void wxWindowGTK::GTKEnableFocusOutEvent()
3074 {
3075 g_signal_handlers_unblock_by_func( m_focusWidget,
3076 (gpointer) gtk_window_focus_out_callback, this);
3077 }
3078
3079 bool wxWindowGTK::GTKHandleFocusIn()
3080 {
3081 // Disable default focus handling for custom windows since the default GTK+
3082 // handler issues a repaint
3083 const bool retval = m_wxwindow ? true : false;
3084
3085
3086 // NB: if there's still unprocessed deferred focus-out event (see
3087 // GTKHandleFocusOut() for explanation), we need to process it first so
3088 // that the order of focus events -- focus-out first, then focus-in
3089 // elsewhere -- is preserved
3090 if ( gs_deferredFocusOut )
3091 {
3092 if ( GTKNeedsToFilterSameWindowFocus() &&
3093 gs_deferredFocusOut == this )
3094 {
3095 // GTK+ focus changed from this wxWindow back to itself, so don't
3096 // emit any events at all
3097 wxLogTrace(TRACE_FOCUS,
3098 "filtered out spurious focus change within %s(%p, %s)",
3099 GetClassInfo()->GetClassName(), this, GetLabel());
3100 gs_deferredFocusOut = NULL;
3101 return retval;
3102 }
3103
3104 // otherwise we need to send focus-out first
3105 wxASSERT_MSG ( gs_deferredFocusOut != this,
3106 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
3107 GTKHandleDeferredFocusOut();
3108 }
3109
3110
3111 wxLogTrace(TRACE_FOCUS,
3112 "handling focus_in event for %s(%p, %s)",
3113 GetClassInfo()->GetClassName(), this, GetLabel());
3114
3115 if (m_imData)
3116 gtk_im_context_focus_in(m_imData->context);
3117
3118 gs_currentFocus = this;
3119 gs_pendingFocus = NULL;
3120
3121 #if wxUSE_CARET
3122 // caret needs to be informed about focus change
3123 wxCaret *caret = GetCaret();
3124 if ( caret )
3125 {
3126 caret->OnSetFocus();
3127 }
3128 #endif // wxUSE_CARET
3129
3130 // Notify the parent keeping track of focus for the kbd navigation
3131 // purposes that we got it.
3132 wxChildFocusEvent eventChildFocus(static_cast<wxWindow*>(this));
3133 GTKProcessEvent(eventChildFocus);
3134
3135 wxFocusEvent eventFocus(wxEVT_SET_FOCUS, GetId());
3136 eventFocus.SetEventObject(this);
3137 GTKProcessEvent(eventFocus);
3138
3139 return retval;
3140 }
3141
3142 bool wxWindowGTK::GTKHandleFocusOut()
3143 {
3144 // Disable default focus handling for custom windows since the default GTK+
3145 // handler issues a repaint
3146 const bool retval = m_wxwindow ? true : false;
3147
3148
3149 // NB: If a control is composed of several GtkWidgets and when focus
3150 // changes from one of them to another within the same wxWindow, we get
3151 // a focus-out event followed by focus-in for another GtkWidget owned
3152 // by the same wx control. We don't want to generate two spurious
3153 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3154 // from GTKHandleFocusOut() until we know for sure it's not coming back
3155 // (i.e. in GTKHandleFocusIn() or at idle time).
3156 if ( GTKNeedsToFilterSameWindowFocus() )
3157 {
3158 wxASSERT_MSG( gs_deferredFocusOut == NULL,
3159 "deferred focus out event already pending" );
3160 wxLogTrace(TRACE_FOCUS,
3161 "deferring focus_out event for %s(%p, %s)",
3162 GetClassInfo()->GetClassName(), this, GetLabel());
3163 gs_deferredFocusOut = this;
3164 return retval;
3165 }
3166
3167 GTKHandleFocusOutNoDeferring();
3168
3169 return retval;
3170 }
3171
3172 void wxWindowGTK::GTKHandleFocusOutNoDeferring()
3173 {
3174 wxLogTrace(TRACE_FOCUS,
3175 "handling focus_out event for %s(%p, %s)",
3176 GetClassInfo()->GetClassName(), this, GetLabel());
3177
3178 if (m_imData)
3179 gtk_im_context_focus_out(m_imData->context);
3180
3181 if ( gs_currentFocus != this )
3182 {
3183 // Something is terribly wrong, gs_currentFocus is out of sync with the
3184 // real focus. We will reset it to NULL anyway, because after this
3185 // focus-out event is handled, one of the following with happen:
3186 //
3187 // * either focus will go out of the app altogether, in which case
3188 // gs_currentFocus _should_ be NULL
3189 //
3190 // * or it goes to another control, in which case focus-in event will
3191 // follow immediately and it will set gs_currentFocus to the right
3192 // value
3193 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3194 GetClassInfo()->GetClassName(), this, GetLabel());
3195 }
3196 gs_currentFocus = NULL;
3197
3198 #if wxUSE_CARET
3199 // caret needs to be informed about focus change
3200 wxCaret *caret = GetCaret();
3201 if ( caret )
3202 {
3203 caret->OnKillFocus();
3204 }
3205 #endif // wxUSE_CARET
3206
3207 wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
3208 event.SetEventObject( this );
3209 event.SetWindow( FindFocus() );
3210 GTKProcessEvent( event );
3211 }
3212
3213 /*static*/
3214 void wxWindowGTK::GTKHandleDeferredFocusOut()
3215 {
3216 // NB: See GTKHandleFocusOut() for explanation. This function is called
3217 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3218 // deferred event.
3219 if ( gs_deferredFocusOut )
3220 {
3221 wxWindowGTK *win = gs_deferredFocusOut;
3222 gs_deferredFocusOut = NULL;
3223
3224 wxLogTrace(TRACE_FOCUS,
3225 "processing deferred focus_out event for %s(%p, %s)",
3226 win->GetClassInfo()->GetClassName(), win, win->GetLabel());
3227
3228 win->GTKHandleFocusOutNoDeferring();
3229 }
3230 }
3231
3232 void wxWindowGTK::SetFocus()
3233 {
3234 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3235
3236 // Setting "physical" focus is not immediate in GTK+ and while
3237 // gtk_widget_is_focus ("determines if the widget is the focus widget
3238 // within its toplevel", i.e. returns true for one widget per TLW, not
3239 // globally) returns true immediately after grabbing focus,
3240 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3241 // has focus at the moment) takes effect only after the window is shown
3242 // (if it was hidden at the moment of the call) or at the next event loop
3243 // iteration.
3244 //
3245 // Because we want to FindFocus() call immediately following
3246 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3247 // ourselves.
3248 gs_pendingFocus = this;
3249
3250 GtkWidget *widget = m_wxwindow ? m_wxwindow : m_focusWidget;
3251
3252 if ( GTK_IS_CONTAINER(widget) &&
3253 !gtk_widget_get_can_focus(widget) )
3254 {
3255 wxLogTrace(TRACE_FOCUS,
3256 wxT("Setting focus to a child of %s(%p, %s)"),
3257 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3258 gtk_widget_child_focus(widget, GTK_DIR_TAB_FORWARD);
3259 }
3260 else
3261 {
3262 wxLogTrace(TRACE_FOCUS,
3263 wxT("Setting focus to %s(%p, %s)"),
3264 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3265 gtk_widget_grab_focus(widget);
3266 }
3267 }
3268
3269 void wxWindowGTK::SetCanFocus(bool canFocus)
3270 {
3271 gtk_widget_set_can_focus(m_widget, canFocus);
3272
3273 if ( m_wxwindow && (m_widget != m_wxwindow) )
3274 {
3275 gtk_widget_set_can_focus(m_wxwindow, canFocus);
3276 }
3277 }
3278
3279 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3280 {
3281 wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
3282
3283 wxWindowGTK * const newParent = (wxWindowGTK *)newParentBase;
3284
3285 wxASSERT( GTK_IS_WIDGET(m_widget) );
3286
3287 if ( !wxWindowBase::Reparent(newParent) )
3288 return false;
3289
3290 wxASSERT( GTK_IS_WIDGET(m_widget) );
3291
3292 // Notice that old m_parent pointer might be non-NULL here but the widget
3293 // still not have any parent at GTK level if it's a notebook page that had
3294 // been removed from the notebook so test this at GTK level and not wx one.
3295 if ( GtkWidget *parentGTK = gtk_widget_get_parent(m_widget) )
3296 gtk_container_remove(GTK_CONTAINER(parentGTK), m_widget);
3297
3298 wxASSERT( GTK_IS_WIDGET(m_widget) );
3299
3300 if (newParent)
3301 {
3302 if (gtk_widget_get_visible (newParent->m_widget))
3303 {
3304 m_showOnIdle = true;
3305 gtk_widget_hide( m_widget );
3306 }
3307 /* insert GTK representation */
3308 newParent->AddChildGTK(this);
3309 }
3310
3311 SetLayoutDirection(wxLayout_Default);
3312
3313 return true;
3314 }
3315
3316 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3317 {
3318 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3319 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3320
3321 /* add to list */
3322 AddChild( child );
3323
3324 /* insert GTK representation */
3325 AddChildGTK(child);
3326 }
3327
3328 void wxWindowGTK::AddChild(wxWindowBase *child)
3329 {
3330 wxWindowBase::AddChild(child);
3331 m_dirtyTabOrder = true;
3332 wxTheApp->WakeUpIdle();
3333 }
3334
3335 void wxWindowGTK::RemoveChild(wxWindowBase *child)
3336 {
3337 wxWindowBase::RemoveChild(child);
3338 m_dirtyTabOrder = true;
3339 wxTheApp->WakeUpIdle();
3340 }
3341
3342 /* static */
3343 wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
3344 {
3345 return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL
3346 ? wxLayout_RightToLeft
3347 : wxLayout_LeftToRight;
3348 }
3349
3350 /* static */
3351 void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir)
3352 {
3353 wxASSERT_MSG( dir != wxLayout_Default, wxT("invalid layout direction") );
3354
3355 gtk_widget_set_direction(widget,
3356 dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
3357 : GTK_TEXT_DIR_LTR);
3358 }
3359
3360 wxLayoutDirection wxWindowGTK::GetLayoutDirection() const
3361 {
3362 return GTKGetLayout(m_widget);
3363 }
3364
3365 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir)
3366 {
3367 if ( dir == wxLayout_Default )
3368 {
3369 const wxWindow *const parent = GetParent();
3370 if ( parent )
3371 {
3372 // inherit layout from parent.
3373 dir = parent->GetLayoutDirection();
3374 }
3375 else // no parent, use global default layout
3376 {
3377 dir = wxTheApp->GetLayoutDirection();
3378 }
3379 }
3380
3381 if ( dir == wxLayout_Default )
3382 return;
3383
3384 GTKSetLayout(m_widget, dir);
3385
3386 if (m_wxwindow && (m_wxwindow != m_widget))
3387 GTKSetLayout(m_wxwindow, dir);
3388 }
3389
3390 wxCoord
3391 wxWindowGTK::AdjustForLayoutDirection(wxCoord x,
3392 wxCoord WXUNUSED(width),
3393 wxCoord WXUNUSED(widthTotal)) const
3394 {
3395 // We now mirror the coordinates of RTL windows in wxPizza
3396 return x;
3397 }
3398
3399 void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, WindowOrder move)
3400 {
3401 wxWindowBase::DoMoveInTabOrder(win, move);
3402 m_dirtyTabOrder = true;
3403 wxTheApp->WakeUpIdle();
3404 }
3405
3406 bool wxWindowGTK::DoNavigateIn(int flags)
3407 {
3408 if ( flags & wxNavigationKeyEvent::WinChange )
3409 {
3410 wxFAIL_MSG( wxT("not implemented") );
3411
3412 return false;
3413 }
3414 else // navigate inside the container
3415 {
3416 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3417 wxCHECK_MSG( parent, false, wxT("every window must have a TLW parent") );
3418
3419 GtkDirectionType dir;
3420 dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD
3421 : GTK_DIR_TAB_BACKWARD;
3422
3423 gboolean rc;
3424 g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
3425
3426 return rc == TRUE;
3427 }
3428 }
3429
3430 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3431 {
3432 // none needed by default
3433 return false;
3434 }
3435
3436 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget* WXUNUSED(w))
3437 {
3438 // nothing to do by default since none is needed
3439 }
3440
3441 void wxWindowGTK::RealizeTabOrder()
3442 {
3443 if (m_wxwindow)
3444 {
3445 if ( !m_children.empty() )
3446 {
3447 // we don't only construct the correct focus chain but also use
3448 // this opportunity to update the mnemonic widgets for the widgets
3449 // that need them
3450
3451 GList *chain = NULL;
3452 wxWindowGTK* mnemonicWindow = NULL;
3453
3454 for ( wxWindowList::const_iterator i = m_children.begin();
3455 i != m_children.end();
3456 ++i )
3457 {
3458 wxWindowGTK *win = *i;
3459
3460 bool focusableFromKeyboard = win->AcceptsFocusFromKeyboard();
3461
3462 if ( mnemonicWindow )
3463 {
3464 if ( focusableFromKeyboard )
3465 {
3466 // wxComboBox et al. needs to focus on on a different
3467 // widget than m_widget, so if the main widget isn't
3468 // focusable try the connect widget
3469 GtkWidget* w = win->m_widget;
3470 if ( !gtk_widget_get_can_focus(w) )
3471 {
3472 w = win->GetConnectWidget();
3473 if ( !gtk_widget_get_can_focus(w) )
3474 w = NULL;
3475 }
3476
3477 if ( w )
3478 {
3479 mnemonicWindow->GTKWidgetDoSetMnemonic(w);
3480 mnemonicWindow = NULL;
3481 }
3482 }
3483 }
3484 else if ( win->GTKWidgetNeedsMnemonic() )
3485 {
3486 mnemonicWindow = win;
3487 }
3488
3489 if ( focusableFromKeyboard )
3490 chain = g_list_prepend(chain, win->m_widget);
3491 }
3492
3493 chain = g_list_reverse(chain);
3494
3495 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain);
3496 g_list_free(chain);
3497 }
3498 else // no children
3499 {
3500 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow));
3501 }
3502 }
3503 }
3504
3505 void wxWindowGTK::Raise()
3506 {
3507 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3508
3509 if (m_wxwindow && gtk_widget_get_window(m_wxwindow))
3510 {
3511 gdk_window_raise(gtk_widget_get_window(m_wxwindow));
3512 }
3513 else if (gtk_widget_get_window(m_widget))
3514 {
3515 gdk_window_raise(gtk_widget_get_window(m_widget));
3516 }
3517 }
3518
3519 void wxWindowGTK::Lower()
3520 {
3521 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3522
3523 if (m_wxwindow && gtk_widget_get_window(m_wxwindow))
3524 {
3525 gdk_window_lower(gtk_widget_get_window(m_wxwindow));
3526 }
3527 else if (gtk_widget_get_window(m_widget))
3528 {
3529 gdk_window_lower(gtk_widget_get_window(m_widget));
3530 }
3531 }
3532
3533 bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3534 {
3535 if ( !wxWindowBase::SetCursor(cursor.IsOk() ? cursor : *wxSTANDARD_CURSOR) )
3536 return false;
3537
3538 GTKUpdateCursor();
3539
3540 return true;
3541 }
3542
3543 void wxWindowGTK::GTKUpdateCursor(bool update_self /*=true*/, bool recurse /*=true*/)
3544 {
3545 if (update_self)
3546 {
3547 wxCursor cursor(g_globalCursor.IsOk() ? g_globalCursor : GetCursor());
3548 if ( cursor.IsOk() )
3549 {
3550 wxArrayGdkWindows windowsThis;
3551 GdkWindow* window = GTKGetWindow(windowsThis);
3552 if (window)
3553 gdk_window_set_cursor( window, cursor.GetCursor() );
3554 else
3555 {
3556 const size_t count = windowsThis.size();
3557 for ( size_t n = 0; n < count; n++ )
3558 {
3559 GdkWindow *win = windowsThis[n];
3560 // It can be zero if the window has not been realized yet.
3561 if ( win )
3562 {
3563 gdk_window_set_cursor(win, cursor.GetCursor());
3564 }
3565 }
3566 }
3567 }
3568 }
3569
3570 if (recurse)
3571 {
3572 for (wxWindowList::iterator it = GetChildren().begin(); it != GetChildren().end(); ++it)
3573 {
3574 (*it)->GTKUpdateCursor( true );
3575 }
3576 }
3577 }
3578
3579 void wxWindowGTK::WarpPointer( int x, int y )
3580 {
3581 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3582
3583 ClientToScreen(&x, &y);
3584 GdkDisplay* display = gtk_widget_get_display(m_widget);
3585 GdkScreen* screen = gtk_widget_get_screen(m_widget);
3586 #ifdef __WXGTK30__
3587 GdkDeviceManager* manager = gdk_display_get_device_manager(display);
3588 gdk_device_warp(gdk_device_manager_get_client_pointer(manager), screen, x, y);
3589 #else
3590 #ifdef GDK_WINDOWING_X11
3591 XWarpPointer(GDK_DISPLAY_XDISPLAY(display),
3592 None,
3593 GDK_WINDOW_XID(gdk_screen_get_root_window(screen)),
3594 0, 0, 0, 0, x, y);
3595 #endif
3596 #endif
3597 }
3598
3599 wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const
3600 {
3601 // find the scrollbar which generated the event
3602 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
3603 {
3604 if ( range == m_scrollBar[dir] )
3605 return (ScrollDir)dir;
3606 }
3607
3608 wxFAIL_MSG( wxT("event from unknown scrollbar received") );
3609
3610 return ScrollDir_Max;
3611 }
3612
3613 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units)
3614 {
3615 bool changed = false;
3616 GtkRange* range = m_scrollBar[dir];
3617 if ( range && units )
3618 {
3619 GtkAdjustment* adj = gtk_range_get_adjustment(range);
3620 double inc = unit == ScrollUnit_Line ? gtk_adjustment_get_step_increment(adj)
3621 : gtk_adjustment_get_page_increment(adj);
3622
3623 const int posOld = wxRound(gtk_adjustment_get_value(adj));
3624 gtk_range_set_value(range, posOld + units*inc);
3625
3626 changed = wxRound(gtk_adjustment_get_value(adj)) != posOld;
3627 }
3628
3629 return changed;
3630 }
3631
3632 bool wxWindowGTK::ScrollLines(int lines)
3633 {
3634 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Line, lines);
3635 }
3636
3637 bool wxWindowGTK::ScrollPages(int pages)
3638 {
3639 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages);
3640 }
3641
3642 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground),
3643 const wxRect *rect)
3644 {
3645 if (m_wxwindow)
3646 {
3647 if (gtk_widget_get_mapped(m_wxwindow))
3648 {
3649 GdkWindow* window = gtk_widget_get_window(m_wxwindow);
3650 if (rect)
3651 {
3652 GdkRectangle r = { rect->x, rect->y, rect->width, rect->height };
3653 if (GetLayoutDirection() == wxLayout_RightToLeft)
3654 r.x = gdk_window_get_width(window) - r.x - rect->width;
3655 gdk_window_invalidate_rect(window, &r, true);
3656 }
3657 else
3658 gdk_window_invalidate_rect(window, NULL, true);
3659 }
3660 }
3661 else if (m_widget)
3662 {
3663 if (gtk_widget_get_mapped(m_widget))
3664 {
3665 if (rect)
3666 gtk_widget_queue_draw_area(m_widget, rect->x, rect->y, rect->width, rect->height);
3667 else
3668 gtk_widget_queue_draw(m_widget);
3669 }
3670 }
3671 }
3672
3673 void wxWindowGTK::Update()
3674 {
3675 if (m_widget && gtk_widget_get_mapped(m_widget))
3676 {
3677 GdkDisplay* display = gtk_widget_get_display(m_widget);
3678 // Flush everything out to the server, and wait for it to finish.
3679 // This ensures nothing will overwrite the drawing we are about to do.
3680 gdk_display_sync(display);
3681
3682 GdkWindow* window = GTKGetDrawingWindow();
3683 if (window == NULL)
3684 window = gtk_widget_get_window(m_widget);
3685 gdk_window_process_updates(window, true);
3686
3687 // Flush again, but no need to wait for it to finish
3688 gdk_display_flush(display);
3689 }
3690 }
3691
3692 bool wxWindowGTK::DoIsExposed( int x, int y ) const
3693 {
3694 return m_updateRegion.Contains(x, y) != wxOutRegion;
3695 }
3696
3697 bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const
3698 {
3699 if (GetLayoutDirection() == wxLayout_RightToLeft)
3700 return m_updateRegion.Contains(x-w, y, w, h) != wxOutRegion;
3701 else
3702 return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
3703 }
3704
3705 void wxWindowGTK::GtkSendPaintEvents()
3706 {
3707 if (!m_wxwindow)
3708 {
3709 m_updateRegion.Clear();
3710 return;
3711 }
3712 #if wxGTK_HAS_COMPOSITING_SUPPORT
3713 cairo_t* cr = NULL;
3714 #endif
3715 // Clip to paint region in wxClientDC
3716 m_clipPaintRegion = true;
3717
3718 m_nativeUpdateRegion = m_updateRegion;
3719
3720 if (GetLayoutDirection() == wxLayout_RightToLeft)
3721 {
3722 // Transform m_updateRegion under RTL
3723 m_updateRegion.Clear();
3724
3725 gint width;
3726 gdk_drawable_get_size(gtk_widget_get_window(m_wxwindow), &width, NULL);
3727
3728 wxRegionIterator upd( m_nativeUpdateRegion );
3729 while (upd)
3730 {
3731 wxRect rect;
3732 rect.x = upd.GetX();
3733 rect.y = upd.GetY();
3734 rect.width = upd.GetWidth();
3735 rect.height = upd.GetHeight();
3736
3737 rect.x = width - rect.x - rect.width;
3738 m_updateRegion.Union( rect );
3739
3740 ++upd;
3741 }
3742 }
3743
3744 switch ( GetBackgroundStyle() )
3745 {
3746 case wxBG_STYLE_TRANSPARENT:
3747 #if wxGTK_HAS_COMPOSITING_SUPPORT
3748 if (IsTransparentBackgroundSupported())
3749 {
3750 // Set a transparent background, so that overlaying in parent
3751 // might indeed let see through where this child did not
3752 // explicitly paint.
3753 // NB: it works also for top level windows (but this is the
3754 // windows manager which then does the compositing job)
3755 cr = gdk_cairo_create(m_wxwindow->window);
3756 gdk_cairo_region(cr, m_nativeUpdateRegion.GetRegion());
3757 cairo_clip(cr);
3758
3759 cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
3760 cairo_paint(cr);
3761 cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
3762 cairo_surface_flush(cairo_get_target(cr));
3763 }
3764 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
3765 break;
3766
3767 case wxBG_STYLE_ERASE:
3768 {
3769 wxWindowDC dc( (wxWindow*)this );
3770 dc.SetDeviceClippingRegion( m_updateRegion );
3771
3772 // Work around gtk-qt <= 0.60 bug whereby the window colour
3773 // remains grey
3774 if ( UseBgCol() &&
3775 wxSystemOptions::
3776 GetOptionInt("gtk.window.force-background-colour") )
3777 {
3778 dc.SetBackground(GetBackgroundColour());
3779 dc.Clear();
3780 }
3781
3782 wxEraseEvent erase_event( GetId(), &dc );
3783 erase_event.SetEventObject( this );
3784
3785 if ( HandleWindowEvent(erase_event) )
3786 {
3787 // background erased, don't do it again
3788 break;
3789 }
3790 }
3791 // fall through
3792
3793 case wxBG_STYLE_SYSTEM:
3794 if ( GetThemeEnabled() )
3795 {
3796 // find ancestor from which to steal background
3797 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3798 if (!parent)
3799 parent = (wxWindow*)this;
3800
3801 if (gtk_widget_get_mapped(parent->m_widget))
3802 {
3803 wxRegionIterator upd( m_nativeUpdateRegion );
3804 while (upd)
3805 {
3806 GdkRectangle rect;
3807 rect.x = upd.GetX();
3808 rect.y = upd.GetY();
3809 rect.width = upd.GetWidth();
3810 rect.height = upd.GetHeight();
3811
3812 gtk_paint_flat_box(gtk_widget_get_style(parent->m_widget),
3813 GTKGetDrawingWindow(),
3814 gtk_widget_get_state(m_wxwindow),
3815 GTK_SHADOW_NONE,
3816 &rect,
3817 parent->m_widget,
3818 (char *)"base",
3819 0, 0, -1, -1 );
3820
3821 ++upd;
3822 }
3823 }
3824 }
3825 break;
3826
3827 case wxBG_STYLE_PAINT:
3828 // nothing to do: window will be painted over in EVT_PAINT
3829 break;
3830
3831 default:
3832 wxFAIL_MSG( "unsupported background style" );
3833 }
3834
3835 wxNcPaintEvent nc_paint_event( GetId() );
3836 nc_paint_event.SetEventObject( this );
3837 HandleWindowEvent( nc_paint_event );
3838
3839 wxPaintEvent paint_event( GetId() );
3840 paint_event.SetEventObject( this );
3841 HandleWindowEvent( paint_event );
3842
3843 #if wxGTK_HAS_COMPOSITING_SUPPORT
3844 if (IsTransparentBackgroundSupported())
3845 { // now composite children which need it
3846 // Overlay all our composite children on top of the painted area
3847 wxWindowList::compatibility_iterator node;
3848 for ( node = m_children.GetFirst(); node ; node = node->GetNext() )
3849 {
3850 wxWindow *compositeChild = node->GetData();
3851 if (compositeChild->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT)
3852 {
3853 if (cr == NULL)
3854 {
3855 cr = gdk_cairo_create(m_wxwindow->window);
3856 gdk_cairo_region(cr, m_nativeUpdateRegion.GetRegion());
3857 cairo_clip(cr);
3858 }
3859
3860 GtkWidget *child = compositeChild->m_wxwindow;
3861 GtkAllocation alloc;
3862 gtk_widget_get_allocation(child, &alloc);
3863
3864 // The source data is the (composited) child
3865 gdk_cairo_set_source_window(
3866 cr, gtk_widget_get_window(child), alloc.x, alloc.y);
3867
3868 cairo_paint(cr);
3869 }
3870 }
3871 if (cr)
3872 cairo_destroy(cr);
3873 }
3874 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
3875
3876 m_clipPaintRegion = false;
3877
3878 m_updateRegion.Clear();
3879 m_nativeUpdateRegion.Clear();
3880 }
3881
3882 void wxWindowGTK::SetDoubleBuffered( bool on )
3883 {
3884 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3885
3886 if ( m_wxwindow )
3887 gtk_widget_set_double_buffered( m_wxwindow, on );
3888 }
3889
3890 bool wxWindowGTK::IsDoubleBuffered() const
3891 {
3892 return gtk_widget_get_double_buffered( m_wxwindow );
3893 }
3894
3895 void wxWindowGTK::ClearBackground()
3896 {
3897 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3898 }
3899
3900 #if wxUSE_TOOLTIPS
3901 void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3902 {
3903 if (m_tooltip != tip)
3904 {
3905 wxWindowBase::DoSetToolTip(tip);
3906
3907 if (m_tooltip)
3908 m_tooltip->GTKSetWindow(static_cast<wxWindow*>(this));
3909 else
3910 GTKApplyToolTip(NULL);
3911 }
3912 }
3913
3914 void wxWindowGTK::GTKApplyToolTip(const char* tip)
3915 {
3916 wxToolTip::GTKApply(GetConnectWidget(), tip);
3917 }
3918 #endif // wxUSE_TOOLTIPS
3919
3920 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
3921 {
3922 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3923
3924 if (!wxWindowBase::SetBackgroundColour(colour))
3925 return false;
3926
3927 if (colour.IsOk())
3928 {
3929 // We need the pixel value e.g. for background clearing.
3930 m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3931 }
3932
3933 // apply style change (forceStyle=true so that new style is applied
3934 // even if the bg colour changed from valid to wxNullColour)
3935 GTKApplyWidgetStyle(true);
3936
3937 return true;
3938 }
3939
3940 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
3941 {
3942 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3943
3944 if (!wxWindowBase::SetForegroundColour(colour))
3945 {
3946 return false;
3947 }
3948
3949 if (colour.IsOk())
3950 {
3951 // We need the pixel value e.g. for background clearing.
3952 m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3953 }
3954
3955 // apply style change (forceStyle=true so that new style is applied
3956 // even if the bg colour changed from valid to wxNullColour):
3957 GTKApplyWidgetStyle(true);
3958
3959 return true;
3960 }
3961
3962 PangoContext *wxWindowGTK::GTKGetPangoDefaultContext()
3963 {
3964 return gtk_widget_get_pango_context( m_widget );
3965 }
3966
3967 GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle)
3968 {
3969 // do we need to apply any changes at all?
3970 if ( !forceStyle &&
3971 !m_font.IsOk() &&
3972 !m_foregroundColour.IsOk() && !m_backgroundColour.IsOk() )
3973 {
3974 return NULL;
3975 }
3976
3977 GtkRcStyle *style = gtk_rc_style_new();
3978
3979 if ( m_font.IsOk() )
3980 {
3981 style->font_desc =
3982 pango_font_description_copy( m_font.GetNativeFontInfo()->description );
3983 }
3984
3985 int flagsNormal = 0,
3986 flagsPrelight = 0,
3987 flagsActive = 0,
3988 flagsInsensitive = 0;
3989
3990 if ( m_foregroundColour.IsOk() )
3991 {
3992 const GdkColor *fg = m_foregroundColour.GetColor();
3993
3994 style->fg[GTK_STATE_NORMAL] =
3995 style->text[GTK_STATE_NORMAL] = *fg;
3996 flagsNormal |= GTK_RC_FG | GTK_RC_TEXT;
3997
3998 style->fg[GTK_STATE_PRELIGHT] =
3999 style->text[GTK_STATE_PRELIGHT] = *fg;
4000 flagsPrelight |= GTK_RC_FG | GTK_RC_TEXT;
4001
4002 style->fg[GTK_STATE_ACTIVE] =
4003 style->text[GTK_STATE_ACTIVE] = *fg;
4004 flagsActive |= GTK_RC_FG | GTK_RC_TEXT;
4005 }
4006
4007 if ( m_backgroundColour.IsOk() )
4008 {
4009 const GdkColor *bg = m_backgroundColour.GetColor();
4010
4011 style->bg[GTK_STATE_NORMAL] =
4012 style->base[GTK_STATE_NORMAL] = *bg;
4013 flagsNormal |= GTK_RC_BG | GTK_RC_BASE;
4014
4015 style->bg[GTK_STATE_PRELIGHT] =
4016 style->base[GTK_STATE_PRELIGHT] = *bg;
4017 flagsPrelight |= GTK_RC_BG | GTK_RC_BASE;
4018
4019 style->bg[GTK_STATE_ACTIVE] =
4020 style->base[GTK_STATE_ACTIVE] = *bg;
4021 flagsActive |= GTK_RC_BG | GTK_RC_BASE;
4022
4023 style->bg[GTK_STATE_INSENSITIVE] =
4024 style->base[GTK_STATE_INSENSITIVE] = *bg;
4025 flagsInsensitive |= GTK_RC_BG | GTK_RC_BASE;
4026 }
4027
4028 style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)flagsNormal;
4029 style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)flagsPrelight;
4030 style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)flagsActive;
4031 style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)flagsInsensitive;
4032
4033 return style;
4034 }
4035
4036 void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle)
4037 {
4038 GtkRcStyle *style = GTKCreateWidgetStyle(forceStyle);
4039 if ( style )
4040 {
4041 DoApplyWidgetStyle(style);
4042 g_object_unref(style);
4043 }
4044
4045 // Style change may affect GTK+'s size calculation:
4046 InvalidateBestSize();
4047 }
4048
4049 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
4050 {
4051 if ( m_wxwindow )
4052 {
4053 // block the signal temporarily to avoid sending
4054 // wxSysColourChangedEvents when we change the colours ourselves
4055 bool unblock = false;
4056 if ( IsTopLevel() )
4057 {
4058 unblock = true;
4059 g_signal_handlers_block_by_func(
4060 m_wxwindow, (void *)gtk_window_style_set_callback, this);
4061 }
4062
4063 gtk_widget_modify_style(m_wxwindow, style);
4064
4065 if ( unblock )
4066 {
4067 g_signal_handlers_unblock_by_func(
4068 m_wxwindow, (void *)gtk_window_style_set_callback, this);
4069 }
4070 }
4071 else
4072 {
4073 gtk_widget_modify_style(m_widget, style);
4074 }
4075 }
4076
4077 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
4078 {
4079 if (!wxWindowBase::SetBackgroundStyle(style))
4080 return false;
4081
4082 GdkWindow *window;
4083 if ( m_wxwindow )
4084 {
4085 window = GTKGetDrawingWindow();
4086 }
4087 else
4088 {
4089 GtkWidget * const w = GetConnectWidget();
4090 window = w ? gtk_widget_get_window(w) : NULL;
4091 }
4092
4093 bool wantNoBackPixmap = style == wxBG_STYLE_PAINT || style == wxBG_STYLE_TRANSPARENT;
4094
4095 if ( wantNoBackPixmap )
4096 {
4097 if (window)
4098 {
4099 // Make sure GDK/X11 doesn't refresh the window
4100 // automatically.
4101 gdk_window_set_back_pixmap( window, NULL, FALSE );
4102 m_needsStyleChange = false;
4103 }
4104 else // window not realized yet
4105 {
4106 // Do when window is realized
4107 m_needsStyleChange = true;
4108 }
4109
4110 // Don't apply widget style, or we get a grey background
4111 }
4112 else
4113 {
4114 // apply style change (forceStyle=true so that new style is applied
4115 // even if the bg colour changed from valid to wxNullColour):
4116 GTKApplyWidgetStyle(true);
4117 }
4118
4119 return true;
4120 }
4121
4122 bool wxWindowGTK::IsTransparentBackgroundSupported(wxString* reason) const
4123 {
4124 #if wxGTK_HAS_COMPOSITING_SUPPORT
4125 if (gtk_check_version(wxGTK_VERSION_REQUIRED_FOR_COMPOSITING) != NULL)
4126 {
4127 if (reason)
4128 {
4129 *reason = _("GTK+ installed on this machine is too old to "
4130 "support screen compositing, please install "
4131 "GTK+ 2.12 or later.");
4132 }
4133
4134 return false;
4135 }
4136
4137 // NB: We don't check here if the particular kind of widget supports
4138 // transparency, we check only if it would be possible for a generic window
4139
4140 wxCHECK_MSG ( m_widget, false, "Window must be created first" );
4141
4142 if (!gdk_screen_is_composited(gtk_widget_get_screen(m_widget)))
4143 {
4144 if (reason)
4145 {
4146 *reason = _("Compositing not supported by this system, "
4147 "please enable it in your Window Manager.");
4148 }
4149
4150 return false;
4151 }
4152
4153 return true;
4154 #else
4155 if (reason)
4156 {
4157 *reason = _("This program was compiled with a too old version of GTK+, "
4158 "please rebuild with GTK+ 2.12 or newer.");
4159 }
4160 #endif // wxGTK_HAS_COMPOSITING_SUPPORT/!wxGTK_HAS_COMPOSITING_SUPPORT
4161
4162 return false;
4163 }
4164
4165 // ----------------------------------------------------------------------------
4166 // Pop-up menu stuff
4167 // ----------------------------------------------------------------------------
4168
4169 #if wxUSE_MENUS_NATIVE
4170
4171 extern "C" {
4172 static
4173 void wxPopupMenuPositionCallback( GtkMenu *menu,
4174 gint *x, gint *y,
4175 gboolean * WXUNUSED(whatever),
4176 gpointer user_data )
4177 {
4178 // ensure that the menu appears entirely on screen
4179 GtkRequisition req;
4180 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
4181
4182 wxSize sizeScreen = wxGetDisplaySize();
4183 wxPoint *pos = (wxPoint*)user_data;
4184
4185 gint xmax = sizeScreen.x - req.width,
4186 ymax = sizeScreen.y - req.height;
4187
4188 *x = pos->x < xmax ? pos->x : xmax;
4189 *y = pos->y < ymax ? pos->y : ymax;
4190 }
4191 }
4192
4193 bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
4194 {
4195 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4196
4197 // For compatibility with other ports, pretend that the window showing the
4198 // menu has focus while the menu is shown. This is needed because the popup
4199 // menu actually steals the focus from the window it's associated it in
4200 // wxGTK unlike, say, wxMSW.
4201 wxWindowGTK* const oldPendingFocus = gs_pendingFocus;
4202 gs_pendingFocus = this;
4203 wxON_BLOCK_EXIT_SET( gs_pendingFocus, oldPendingFocus );
4204
4205 menu->UpdateUI();
4206
4207 wxPoint pos;
4208 gpointer userdata;
4209 GtkMenuPositionFunc posfunc;
4210 if ( x == -1 && y == -1 )
4211 {
4212 // use GTK's default positioning algorithm
4213 userdata = NULL;
4214 posfunc = NULL;
4215 }
4216 else
4217 {
4218 pos = ClientToScreen(wxPoint(x, y));
4219 userdata = &pos;
4220 posfunc = wxPopupMenuPositionCallback;
4221 }
4222
4223 menu->m_popupShown = true;
4224 gtk_menu_popup(
4225 GTK_MENU(menu->m_menu),
4226 NULL, // parent menu shell
4227 NULL, // parent menu item
4228 posfunc, // function to position it
4229 userdata, // client data
4230 0, // button used to activate it
4231 gtk_get_current_event_time()
4232 );
4233
4234 while (menu->m_popupShown)
4235 {
4236 gtk_main_iteration();
4237 }
4238
4239 return true;
4240 }
4241
4242 #endif // wxUSE_MENUS_NATIVE
4243
4244 #if wxUSE_DRAG_AND_DROP
4245
4246 void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
4247 {
4248 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4249
4250 GtkWidget *dnd_widget = GetConnectWidget();
4251
4252 if (m_dropTarget) m_dropTarget->GtkUnregisterWidget( dnd_widget );
4253
4254 if (m_dropTarget) delete m_dropTarget;
4255 m_dropTarget = dropTarget;
4256
4257 if (m_dropTarget) m_dropTarget->GtkRegisterWidget( dnd_widget );
4258 }
4259
4260 #endif // wxUSE_DRAG_AND_DROP
4261
4262 GtkWidget* wxWindowGTK::GetConnectWidget()
4263 {
4264 GtkWidget *connect_widget = m_widget;
4265 if (m_wxwindow) connect_widget = m_wxwindow;
4266
4267 return connect_widget;
4268 }
4269
4270 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const
4271 {
4272 wxArrayGdkWindows windowsThis;
4273 GdkWindow * const winThis = GTKGetWindow(windowsThis);
4274
4275 return winThis ? window == winThis
4276 : windowsThis.Index(window) != wxNOT_FOUND;
4277 }
4278
4279 GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
4280 {
4281 return m_wxwindow ? GTKGetDrawingWindow() : gtk_widget_get_window(m_widget);
4282 }
4283
4284 bool wxWindowGTK::SetFont( const wxFont &font )
4285 {
4286 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4287
4288 if (!wxWindowBase::SetFont(font))
4289 return false;
4290
4291 // apply style change (forceStyle=true so that new style is applied
4292 // even if the font changed from valid to wxNullFont):
4293 GTKApplyWidgetStyle(true);
4294
4295 return true;
4296 }
4297
4298 void wxWindowGTK::DoCaptureMouse()
4299 {
4300 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4301
4302 GdkWindow *window = NULL;
4303 if (m_wxwindow)
4304 window = GTKGetDrawingWindow();
4305 else
4306 window = gtk_widget_get_window(GetConnectWidget());
4307
4308 wxCHECK_RET( window, wxT("CaptureMouse() failed") );
4309
4310 const wxCursor* cursor = &m_cursor;
4311 if (!cursor->IsOk())
4312 cursor = wxSTANDARD_CURSOR;
4313
4314 gdk_pointer_grab( window, FALSE,
4315 (GdkEventMask)
4316 (GDK_BUTTON_PRESS_MASK |
4317 GDK_BUTTON_RELEASE_MASK |
4318 GDK_POINTER_MOTION_HINT_MASK |
4319 GDK_POINTER_MOTION_MASK),
4320 NULL,
4321 cursor->GetCursor(),
4322 (guint32)GDK_CURRENT_TIME );
4323 g_captureWindow = this;
4324 g_captureWindowHasMouse = true;
4325 }
4326
4327 void wxWindowGTK::DoReleaseMouse()
4328 {
4329 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4330
4331 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
4332
4333 g_captureWindow = NULL;
4334
4335 GdkWindow *window = NULL;
4336 if (m_wxwindow)
4337 window = GTKGetDrawingWindow();
4338 else
4339 window = gtk_widget_get_window(GetConnectWidget());
4340
4341 if (!window)
4342 return;
4343
4344 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
4345 }
4346
4347 void wxWindowGTK::GTKReleaseMouseAndNotify()
4348 {
4349 DoReleaseMouse();
4350 wxMouseCaptureLostEvent evt(GetId());
4351 evt.SetEventObject( this );
4352 HandleWindowEvent( evt );
4353 }
4354
4355 /* static */
4356 wxWindow *wxWindowBase::GetCapture()
4357 {
4358 return (wxWindow *)g_captureWindow;
4359 }
4360
4361 bool wxWindowGTK::IsRetained() const
4362 {
4363 return false;
4364 }
4365
4366 void wxWindowGTK::SetScrollbar(int orient,
4367 int pos,
4368 int thumbVisible,
4369 int range,
4370 bool WXUNUSED(update))
4371 {
4372 const int dir = ScrollDirFromOrient(orient);
4373 GtkRange* const sb = m_scrollBar[dir];
4374 wxCHECK_RET( sb, wxT("this window is not scrollable") );
4375
4376 if (range <= 0)
4377 {
4378 // GtkRange requires upper > lower
4379 range =
4380 thumbVisible = 1;
4381 }
4382
4383 g_signal_handlers_block_by_func(
4384 sb, (void*)gtk_scrollbar_value_changed, this);
4385
4386 gtk_range_set_increments(sb, 1, thumbVisible);
4387 gtk_adjustment_set_page_size(gtk_range_get_adjustment(sb), thumbVisible);
4388 gtk_range_set_range(sb, 0, range);
4389 gtk_range_set_value(sb, pos);
4390 m_scrollPos[dir] = gtk_range_get_value(sb);
4391
4392 g_signal_handlers_unblock_by_func(
4393 sb, (void*)gtk_scrollbar_value_changed, this);
4394 }
4395
4396 void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
4397 {
4398 const int dir = ScrollDirFromOrient(orient);
4399 GtkRange * const sb = m_scrollBar[dir];
4400 wxCHECK_RET( sb, wxT("this window is not scrollable") );
4401
4402 // This check is more than an optimization. Without it, the slider
4403 // will not move smoothly while tracking when using wxScrollHelper.
4404 if (GetScrollPos(orient) != pos)
4405 {
4406 g_signal_handlers_block_by_func(
4407 sb, (void*)gtk_scrollbar_value_changed, this);
4408
4409 gtk_range_set_value(sb, pos);
4410 m_scrollPos[dir] = gtk_range_get_value(sb);
4411
4412 g_signal_handlers_unblock_by_func(
4413 sb, (void*)gtk_scrollbar_value_changed, this);
4414 }
4415 }
4416
4417 int wxWindowGTK::GetScrollThumb(int orient) const
4418 {
4419 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4420 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4421
4422 return wxRound(gtk_adjustment_get_page_size(gtk_range_get_adjustment(sb)));
4423 }
4424
4425 int wxWindowGTK::GetScrollPos( int orient ) const
4426 {
4427 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4428 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4429
4430 return wxRound(gtk_range_get_value(sb));
4431 }
4432
4433 int wxWindowGTK::GetScrollRange( 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_upper(gtk_range_get_adjustment(sb)));
4439 }
4440
4441 // Determine if increment is the same as +/-x, allowing for some small
4442 // difference due to possible inexactness in floating point arithmetic
4443 static inline bool IsScrollIncrement(double increment, double x)
4444 {
4445 wxASSERT(increment > 0);
4446 const double tolerance = 1.0 / 1024;
4447 return fabs(increment - fabs(x)) < tolerance;
4448 }
4449
4450 wxEventType wxWindowGTK::GTKGetScrollEventType(GtkRange* range)
4451 {
4452 wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
4453
4454 const int barIndex = range == m_scrollBar[1];
4455
4456 const double value = gtk_range_get_value(range);
4457
4458 // save previous position
4459 const double oldPos = m_scrollPos[barIndex];
4460 // update current position
4461 m_scrollPos[barIndex] = value;
4462 // If event should be ignored, or integral position has not changed
4463 if (!m_hasVMT || g_blockEventsOnDrag || wxRound(value) == wxRound(oldPos))
4464 {
4465 return wxEVT_NULL;
4466 }
4467
4468 wxEventType eventType = wxEVT_SCROLL_THUMBTRACK;
4469 if (!m_isScrolling)
4470 {
4471 // Difference from last change event
4472 const double diff = value - oldPos;
4473 const bool isDown = diff > 0;
4474
4475 GtkAdjustment* adj = gtk_range_get_adjustment(range);
4476 if (IsScrollIncrement(gtk_adjustment_get_step_increment(adj), diff))
4477 {
4478 eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
4479 }
4480 else if (IsScrollIncrement(gtk_adjustment_get_page_increment(adj), diff))
4481 {
4482 eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
4483 }
4484 else if (m_mouseButtonDown)
4485 {
4486 // Assume track event
4487 m_isScrolling = true;
4488 }
4489 }
4490 return eventType;
4491 }
4492
4493 void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4494 {
4495 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4496
4497 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4498
4499 // No scrolling requested.
4500 if ((dx == 0) && (dy == 0)) return;
4501
4502 m_clipPaintRegion = true;
4503
4504 WX_PIZZA(m_wxwindow)->scroll(dx, dy);
4505
4506 m_clipPaintRegion = false;
4507
4508 #if wxUSE_CARET
4509 bool restoreCaret = (GetCaret() != NULL && GetCaret()->IsVisible());
4510 if (restoreCaret)
4511 {
4512 wxRect caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4513 if (dx > 0)
4514 caretRect.width += dx;
4515 else
4516 {
4517 caretRect.x += dx; caretRect.width -= dx;
4518 }
4519 if (dy > 0)
4520 caretRect.height += dy;
4521 else
4522 {
4523 caretRect.y += dy; caretRect.height -= dy;
4524 }
4525
4526 RefreshRect(caretRect);
4527 }
4528 #endif // wxUSE_CARET
4529 }
4530
4531 void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
4532 {
4533 //RN: Note that static controls usually have no border on gtk, so maybe
4534 //it makes sense to treat that as simply no border at the wx level
4535 //as well...
4536 if (!(wxstyle & wxNO_BORDER) && !(wxstyle & wxBORDER_STATIC))
4537 {
4538 GtkShadowType gtkstyle;
4539
4540 if(wxstyle & wxBORDER_RAISED)
4541 gtkstyle = GTK_SHADOW_OUT;
4542 else if ((wxstyle & wxBORDER_SUNKEN) || (wxstyle & wxBORDER_THEME))
4543 gtkstyle = GTK_SHADOW_IN;
4544 #if 0
4545 // Now obsolete
4546 else if (wxstyle & wxBORDER_DOUBLE)
4547 gtkstyle = GTK_SHADOW_ETCHED_IN;
4548 #endif
4549 else //default
4550 gtkstyle = GTK_SHADOW_IN;
4551
4552 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w),
4553 gtkstyle );
4554 }
4555 }
4556
4557 // Find the wxWindow at the current mouse position, also returning the mouse
4558 // position.
4559 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4560 {
4561 pt = wxGetMousePosition();
4562 wxWindow* found = wxFindWindowAtPoint(pt);
4563 return found;
4564 }
4565
4566 // Get the current mouse position.
4567 wxPoint wxGetMousePosition()
4568 {
4569 wxWindow* tlw = NULL;
4570 if (!wxTopLevelWindows.empty())
4571 tlw = wxTopLevelWindows.front();
4572 GdkDisplay* display;
4573 if (tlw && tlw->m_widget)
4574 display = gtk_widget_get_display(tlw->m_widget);
4575 else
4576 display = gdk_display_get_default();
4577
4578 int x, y;
4579 gdk_display_get_pointer(display, NULL, &x, &y, NULL);
4580 return wxPoint(x, y);
4581 }
4582
4583 GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
4584 {
4585 GdkWindow* window = NULL;
4586 if (m_wxwindow)
4587 window = gtk_widget_get_window(m_wxwindow);
4588 return window;
4589 }
4590
4591 // ----------------------------------------------------------------------------
4592 // freeze/thaw
4593 // ----------------------------------------------------------------------------
4594
4595 extern "C"
4596 {
4597
4598 // this is called if we attempted to freeze unrealized widget when it finally
4599 // is realized (and so can be frozen):
4600 static void wx_frozen_widget_realize(GtkWidget* w, wxWindowGTK* win)
4601 {
4602 wxASSERT( w && gtk_widget_get_has_window(w) );
4603 wxASSERT( gtk_widget_get_realized(w) );
4604
4605 g_signal_handlers_disconnect_by_func
4606 (
4607 w,
4608 (void*)wx_frozen_widget_realize,
4609 win
4610 );
4611
4612 GdkWindow* window;
4613 if (w == win->m_wxwindow)
4614 window = win->GTKGetDrawingWindow();
4615 else
4616 window = gtk_widget_get_window(w);
4617 gdk_window_freeze_updates(window);
4618 }
4619
4620 } // extern "C"
4621
4622 void wxWindowGTK::GTKFreezeWidget(GtkWidget *w)
4623 {
4624 if ( !w || !gtk_widget_get_has_window(w) )
4625 return; // window-less widget, cannot be frozen
4626
4627 GdkWindow* window = gtk_widget_get_window(w);
4628 if (window == NULL)
4629 {
4630 // we can't thaw unrealized widgets because they don't have GdkWindow,
4631 // so set it up to be done immediately after realization:
4632 g_signal_connect_after
4633 (
4634 w,
4635 "realize",
4636 G_CALLBACK(wx_frozen_widget_realize),
4637 this
4638 );
4639 return;
4640 }
4641
4642 if (w == m_wxwindow)
4643 window = GTKGetDrawingWindow();
4644 gdk_window_freeze_updates(window);
4645 }
4646
4647 void wxWindowGTK::GTKThawWidget(GtkWidget *w)
4648 {
4649 if ( !w || !gtk_widget_get_has_window(w) )
4650 return; // window-less widget, cannot be frozen
4651
4652 GdkWindow* window = gtk_widget_get_window(w);
4653 if (window == NULL)
4654 {
4655 // the widget wasn't realized yet, no need to thaw
4656 g_signal_handlers_disconnect_by_func
4657 (
4658 w,
4659 (void*)wx_frozen_widget_realize,
4660 this
4661 );
4662 return;
4663 }
4664
4665 if (w == m_wxwindow)
4666 window = GTKGetDrawingWindow();
4667 gdk_window_thaw_updates(window);
4668 }
4669
4670 void wxWindowGTK::DoFreeze()
4671 {
4672 GTKFreezeWidget(m_widget);
4673 if ( m_wxwindow && m_widget != m_wxwindow )
4674 GTKFreezeWidget(m_wxwindow);
4675 }
4676
4677 void wxWindowGTK::DoThaw()
4678 {
4679 GTKThawWidget(m_widget);
4680 if ( m_wxwindow && m_widget != m_wxwindow )
4681 GTKThawWidget(m_wxwindow);
4682 }
wxWidgets (Impactor)