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