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