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