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