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


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