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