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