projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
merging back XTI branch part 2
[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 if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
2619 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
2620 }
2621
2622 void wxWindowGTK::DoGetSize( int *width, int *height ) const
2623 {
2624 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2625
2626 if (width) (*width) = m_width;
2627 if (height) (*height) = m_height;
2628 }
2629
2630 void wxWindowGTK::DoSetClientSize( int width, int height )
2631 {
2632 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2633
2634 const wxSize size = GetSize();
2635 const wxSize clientSize = GetClientSize();
2636 SetSize(width + (size.x - clientSize.x), height + (size.y - clientSize.y));
2637 }
2638
2639 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
2640 {
2641 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2642
2643 int w = m_width;
2644 int h = m_height;
2645
2646 if ( m_wxwindow )
2647 {
2648 // if window is scrollable, account for scrollbars
2649 if ( GTK_IS_SCROLLED_WINDOW(m_widget) )
2650 {
2651 GtkPolicyType policy[ScrollDir_Max];
2652 gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget),
2653 &policy[ScrollDir_Horz],
2654 &policy[ScrollDir_Vert]);
2655
2656 for ( int i = 0; i < ScrollDir_Max; i++ )
2657 {
2658 // don't account for the scrollbars we don't have
2659 GtkRange * const range = m_scrollBar[i];
2660 if ( !range )
2661 continue;
2662
2663 // nor for the ones we have but don't current show
2664 switch ( policy[i] )
2665 {
2666 case GTK_POLICY_NEVER:
2667 // never shown so doesn't take any place
2668 continue;
2669
2670 case GTK_POLICY_ALWAYS:
2671 // no checks necessary
2672 break;
2673
2674 case GTK_POLICY_AUTOMATIC:
2675 // may be shown or not, check
2676 GtkAdjustment *adj = gtk_range_get_adjustment(range);
2677 if ( adj->upper <= adj->page_size )
2678 continue;
2679 }
2680
2681 GtkScrolledWindowClass *scroll_class =
2682 GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2683
2684 GtkRequisition req;
2685 gtk_widget_size_request(GTK_WIDGET(range), &req);
2686 if (i == ScrollDir_Horz)
2687 h -= req.height + scroll_class->scrollbar_spacing;
2688 else
2689 w -= req.width + scroll_class->scrollbar_spacing;
2690 }
2691 }
2692
2693 const wxSize sizeBorders = DoGetBorderSize();
2694 w -= sizeBorders.x;
2695 h -= sizeBorders.y;
2696
2697 if (w < 0)
2698 w = 0;
2699 if (h < 0)
2700 h = 0;
2701 }
2702
2703 if (width) *width = w;
2704 if (height) *height = h;
2705 }
2706
2707 wxSize wxWindowGTK::DoGetBorderSize() const
2708 {
2709 if ( !m_wxwindow )
2710 return wxWindowBase::DoGetBorderSize();
2711
2712 int x, y;
2713 WX_PIZZA(m_wxwindow)->get_border_widths(x, y);
2714
2715 return 2*wxSize(x, y);
2716 }
2717
2718 void wxWindowGTK::DoGetPosition( int *x, int *y ) const
2719 {
2720 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2721
2722 int dx = 0;
2723 int dy = 0;
2724 if (!IsTopLevel() && m_parent && m_parent->m_wxwindow)
2725 {
2726 wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
2727 dx = pizza->m_scroll_x;
2728 dy = pizza->m_scroll_y;
2729 }
2730
2731 if (m_x == -1 && m_y == -1)
2732 {
2733 GdkWindow *source = NULL;
2734 if (m_wxwindow)
2735 source = m_wxwindow->window;
2736 else
2737 source = m_widget->window;
2738
2739 if (source)
2740 {
2741 int org_x = 0;
2742 int org_y = 0;
2743 gdk_window_get_origin( source, &org_x, &org_y );
2744
2745 if (m_parent)
2746 m_parent->ScreenToClient(&org_x, &org_y);
2747
2748 const_cast<wxWindowGTK*>(this)->m_x = org_x;
2749 const_cast<wxWindowGTK*>(this)->m_y = org_y;
2750 }
2751 }
2752
2753 if (x) (*x) = m_x - dx;
2754 if (y) (*y) = m_y - dy;
2755 }
2756
2757 void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
2758 {
2759 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2760
2761 if (!m_widget->window) return;
2762
2763 GdkWindow *source = NULL;
2764 if (m_wxwindow)
2765 source = m_wxwindow->window;
2766 else
2767 source = m_widget->window;
2768
2769 int org_x = 0;
2770 int org_y = 0;
2771 gdk_window_get_origin( source, &org_x, &org_y );
2772
2773 if (!m_wxwindow)
2774 {
2775 if (GTK_WIDGET_NO_WINDOW (m_widget))
2776 {
2777 org_x += m_widget->allocation.x;
2778 org_y += m_widget->allocation.y;
2779 }
2780 }
2781
2782
2783 if (x)
2784 {
2785 if (GetLayoutDirection() == wxLayout_RightToLeft)
2786 *x = (GetClientSize().x - *x) + org_x;
2787 else
2788 *x += org_x;
2789 }
2790
2791 if (y) *y += org_y;
2792 }
2793
2794 void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
2795 {
2796 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2797
2798 if (!m_widget->window) return;
2799
2800 GdkWindow *source = NULL;
2801 if (m_wxwindow)
2802 source = m_wxwindow->window;
2803 else
2804 source = m_widget->window;
2805
2806 int org_x = 0;
2807 int org_y = 0;
2808 gdk_window_get_origin( source, &org_x, &org_y );
2809
2810 if (!m_wxwindow)
2811 {
2812 if (GTK_WIDGET_NO_WINDOW (m_widget))
2813 {
2814 org_x += m_widget->allocation.x;
2815 org_y += m_widget->allocation.y;
2816 }
2817 }
2818
2819 if (x)
2820 {
2821 if (GetLayoutDirection() == wxLayout_RightToLeft)
2822 *x = (GetClientSize().x - *x) - org_x;
2823 else
2824 *x -= org_x;
2825 }
2826 if (y) *y -= org_y;
2827 }
2828
2829 bool wxWindowGTK::Show( bool show )
2830 {
2831 if ( !wxWindowBase::Show(show) )
2832 {
2833 // nothing to do
2834 return false;
2835 }
2836
2837 // notice that we may call Hide() before the window is created and this is
2838 // actually useful to create it hidden initially -- but we can't call
2839 // Show() before it is created
2840 if ( !m_widget )
2841 {
2842 wxASSERT_MSG( !show, "can't show invalid window" );
2843 return true;
2844 }
2845
2846 if ( show )
2847 {
2848 if ( m_showOnIdle )
2849 {
2850 // defer until later
2851 return true;
2852 }
2853
2854 gtk_widget_show(m_widget);
2855 }
2856 else // hide
2857 {
2858 gtk_widget_hide(m_widget);
2859 }
2860
2861 wxShowEvent eventShow(GetId(), show);
2862 eventShow.SetEventObject(this);
2863 HandleWindowEvent(eventShow);
2864
2865 return true;
2866 }
2867
2868 void wxWindowGTK::DoEnable( bool enable )
2869 {
2870 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2871
2872 gtk_widget_set_sensitive( m_widget, enable );
2873 if (m_wxwindow && (m_wxwindow != m_widget))
2874 gtk_widget_set_sensitive( m_wxwindow, enable );
2875 }
2876
2877 int wxWindowGTK::GetCharHeight() const
2878 {
2879 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
2880
2881 wxFont font = GetFont();
2882 wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
2883
2884 PangoContext* context = gtk_widget_get_pango_context(m_widget);
2885
2886 if (!context)
2887 return 0;
2888
2889 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
2890 PangoLayout *layout = pango_layout_new(context);
2891 pango_layout_set_font_description(layout, desc);
2892 pango_layout_set_text(layout, "H", 1);
2893 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2894
2895 PangoRectangle rect;
2896 pango_layout_line_get_extents(line, NULL, &rect);
2897
2898 g_object_unref (layout);
2899
2900 return (int) PANGO_PIXELS(rect.height);
2901 }
2902
2903 int wxWindowGTK::GetCharWidth() const
2904 {
2905 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
2906
2907 wxFont font = GetFont();
2908 wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
2909
2910 PangoContext* context = gtk_widget_get_pango_context(m_widget);
2911
2912 if (!context)
2913 return 0;
2914
2915 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
2916 PangoLayout *layout = pango_layout_new(context);
2917 pango_layout_set_font_description(layout, desc);
2918 pango_layout_set_text(layout, "g", 1);
2919 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2920
2921 PangoRectangle rect;
2922 pango_layout_line_get_extents(line, NULL, &rect);
2923
2924 g_object_unref (layout);
2925
2926 return (int) PANGO_PIXELS(rect.width);
2927 }
2928
2929 void wxWindowGTK::DoGetTextExtent( const wxString& string,
2930 int *x,
2931 int *y,
2932 int *descent,
2933 int *externalLeading,
2934 const wxFont *theFont ) const
2935 {
2936 wxFont fontToUse = theFont ? *theFont : GetFont();
2937
2938 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
2939
2940 if (string.empty())
2941 {
2942 if (x) (*x) = 0;
2943 if (y) (*y) = 0;
2944 return;
2945 }
2946
2947 PangoContext *context = NULL;
2948 if (m_widget)
2949 context = gtk_widget_get_pango_context( m_widget );
2950
2951 if (!context)
2952 {
2953 if (x) (*x) = 0;
2954 if (y) (*y) = 0;
2955 return;
2956 }
2957
2958 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
2959 PangoLayout *layout = pango_layout_new(context);
2960 pango_layout_set_font_description(layout, desc);
2961 {
2962 const wxCharBuffer data = wxGTK_CONV( string );
2963 if ( data )
2964 pango_layout_set_text(layout, data, strlen(data));
2965 }
2966
2967 PangoRectangle rect;
2968 pango_layout_get_extents(layout, NULL, &rect);
2969
2970 if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width);
2971 if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height);
2972 if (descent)
2973 {
2974 PangoLayoutIter *iter = pango_layout_get_iter(layout);
2975 int baseline = pango_layout_iter_get_baseline(iter);
2976 pango_layout_iter_free(iter);
2977 *descent = *y - PANGO_PIXELS(baseline);
2978 }
2979 if (externalLeading) (*externalLeading) = 0; // ??
2980
2981 g_object_unref (layout);
2982 }
2983
2984 void wxWindowGTK::GTKDisableFocusOutEvent()
2985 {
2986 g_signal_handlers_block_by_func( m_focusWidget,
2987 (gpointer) gtk_window_focus_out_callback, this);
2988 }
2989
2990 void wxWindowGTK::GTKEnableFocusOutEvent()
2991 {
2992 g_signal_handlers_unblock_by_func( m_focusWidget,
2993 (gpointer) gtk_window_focus_out_callback, this);
2994 }
2995
2996 bool wxWindowGTK::GTKHandleFocusIn()
2997 {
2998 // Disable default focus handling for custom windows since the default GTK+
2999 // handler issues a repaint
3000 const bool retval = m_wxwindow ? true : false;
3001
3002
3003 // NB: if there's still unprocessed deferred focus-out event (see
3004 // GTKHandleFocusOut() for explanation), we need to process it first so
3005 // that the order of focus events -- focus-out first, then focus-in
3006 // elsewhere -- is preserved
3007 if ( gs_deferredFocusOut )
3008 {
3009 if ( GTKNeedsToFilterSameWindowFocus() &&
3010 gs_deferredFocusOut == this )
3011 {
3012 // GTK+ focus changed from this wxWindow back to itself, so don't
3013 // emit any events at all
3014 wxLogTrace(TRACE_FOCUS,
3015 "filtered out spurious focus change within %s(%p, %s)",
3016 GetClassInfo()->GetClassName(), this, GetLabel());
3017 gs_deferredFocusOut = NULL;
3018 return retval;
3019 }
3020
3021 // otherwise we need to send focus-out first
3022 wxASSERT_MSG ( gs_deferredFocusOut != this,
3023 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
3024 GTKHandleDeferredFocusOut();
3025 }
3026
3027
3028 wxLogTrace(TRACE_FOCUS,
3029 "handling focus_in event for %s(%p, %s)",
3030 GetClassInfo()->GetClassName(), this, GetLabel());
3031
3032 if (m_imData)
3033 gtk_im_context_focus_in(m_imData->context);
3034
3035 gs_currentFocus = this;
3036 gs_pendingFocus = NULL;
3037
3038 #if wxUSE_CARET
3039 // caret needs to be informed about focus change
3040 wxCaret *caret = GetCaret();
3041 if ( caret )
3042 {
3043 caret->OnSetFocus();
3044 }
3045 #endif // wxUSE_CARET
3046
3047 // Notify the parent keeping track of focus for the kbd navigation
3048 // purposes that we got it.
3049 wxChildFocusEvent eventChildFocus(static_cast<wxWindow*>(this));
3050 GTKProcessEvent(eventChildFocus);
3051
3052 wxFocusEvent eventFocus(wxEVT_SET_FOCUS, GetId());
3053 eventFocus.SetEventObject(this);
3054 GTKProcessEvent(eventFocus);
3055
3056 return retval;
3057 }
3058
3059 bool wxWindowGTK::GTKHandleFocusOut()
3060 {
3061 // Disable default focus handling for custom windows since the default GTK+
3062 // handler issues a repaint
3063 const bool retval = m_wxwindow ? true : false;
3064
3065
3066 // NB: If a control is composed of several GtkWidgets and when focus
3067 // changes from one of them to another within the same wxWindow, we get
3068 // a focus-out event followed by focus-in for another GtkWidget owned
3069 // by the same wx control. We don't want to generate two spurious
3070 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3071 // from GTKHandleFocusOut() until we know for sure it's not coming back
3072 // (i.e. in GTKHandleFocusIn() or at idle time).
3073 if ( GTKNeedsToFilterSameWindowFocus() )
3074 {
3075 wxASSERT_MSG( gs_deferredFocusOut == NULL,
3076 "deferred focus out event already pending" );
3077 wxLogTrace(TRACE_FOCUS,
3078 "deferring focus_out event for %s(%p, %s)",
3079 GetClassInfo()->GetClassName(), this, GetLabel());
3080 gs_deferredFocusOut = this;
3081 return retval;
3082 }
3083
3084 GTKHandleFocusOutNoDeferring();
3085
3086 return retval;
3087 }
3088
3089 void wxWindowGTK::GTKHandleFocusOutNoDeferring()
3090 {
3091 wxLogTrace(TRACE_FOCUS,
3092 "handling focus_out event for %s(%p, %s)",
3093 GetClassInfo()->GetClassName(), this, GetLabel());
3094
3095 if (m_imData)
3096 gtk_im_context_focus_out(m_imData->context);
3097
3098 if ( gs_currentFocus != this )
3099 {
3100 // Something is terribly wrong, gs_currentFocus is out of sync with the
3101 // real focus. We will reset it to NULL anyway, because after this
3102 // focus-out event is handled, one of the following with happen:
3103 //
3104 // * either focus will go out of the app altogether, in which case
3105 // gs_currentFocus _should_ be NULL
3106 //
3107 // * or it goes to another control, in which case focus-in event will
3108 // follow immediately and it will set gs_currentFocus to the right
3109 // value
3110 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3111 GetClassInfo()->GetClassName(), this, GetLabel());
3112 }
3113 gs_currentFocus = NULL;
3114
3115 #if wxUSE_CARET
3116 // caret needs to be informed about focus change
3117 wxCaret *caret = GetCaret();
3118 if ( caret )
3119 {
3120 caret->OnKillFocus();
3121 }
3122 #endif // wxUSE_CARET
3123
3124 wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
3125 event.SetEventObject( this );
3126 GTKProcessEvent( event );
3127 }
3128
3129 /*static*/
3130 void wxWindowGTK::GTKHandleDeferredFocusOut()
3131 {
3132 // NB: See GTKHandleFocusOut() for explanation. This function is called
3133 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3134 // deferred event.
3135 if ( gs_deferredFocusOut )
3136 {
3137 wxWindowGTK *win = gs_deferredFocusOut;
3138 gs_deferredFocusOut = NULL;
3139
3140 wxLogTrace(TRACE_FOCUS,
3141 "processing deferred focus_out event for %s(%p, %s)",
3142 win->GetClassInfo()->GetClassName(), win, win->GetLabel());
3143
3144 win->GTKHandleFocusOutNoDeferring();
3145 }
3146 }
3147
3148 void wxWindowGTK::SetFocus()
3149 {
3150 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3151
3152 // Setting "physical" focus is not immediate in GTK+ and while
3153 // gtk_widget_is_focus ("determines if the widget is the focus widget
3154 // within its toplevel", i.e. returns true for one widget per TLW, not
3155 // globally) returns true immediately after grabbing focus,
3156 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3157 // has focus at the moment) takes affect only after the window is shown
3158 // (if it was hidden at the moment of the call) or at the next event loop
3159 // iteration.
3160 //
3161 // Because we want to FindFocus() call immediately following
3162 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3163 // ourselves.
3164 gs_pendingFocus = this;
3165
3166 GtkWidget *widget = m_wxwindow ? m_wxwindow : m_focusWidget;
3167
3168 if ( GTK_IS_CONTAINER(widget) &&
3169 !GTK_WIDGET_CAN_FOCUS(widget) )
3170 {
3171 wxLogTrace(TRACE_FOCUS,
3172 wxT("Setting focus to a child of %s(%p, %s)"),
3173 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3174 gtk_widget_child_focus(widget, GTK_DIR_TAB_FORWARD);
3175 }
3176 else
3177 {
3178 wxLogTrace(TRACE_FOCUS,
3179 wxT("Setting focus to %s(%p, %s)"),
3180 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3181 gtk_widget_grab_focus(widget);
3182 }
3183 }
3184
3185 void wxWindowGTK::SetCanFocus(bool canFocus)
3186 {
3187 if ( canFocus )
3188 GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS);
3189 else
3190 GTK_WIDGET_UNSET_FLAGS(m_widget, GTK_CAN_FOCUS);
3191
3192 if ( m_wxwindow && (m_widget != m_wxwindow) )
3193 {
3194 if ( canFocus )
3195 GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
3196 else
3197 GTK_WIDGET_UNSET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
3198 }
3199 }
3200
3201 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3202 {
3203 wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
3204
3205 wxWindowGTK *oldParent = m_parent,
3206 *newParent = (wxWindowGTK *)newParentBase;
3207
3208 wxASSERT( GTK_IS_WIDGET(m_widget) );
3209
3210 if ( !wxWindowBase::Reparent(newParent) )
3211 return false;
3212
3213 wxASSERT( GTK_IS_WIDGET(m_widget) );
3214
3215 if (oldParent)
3216 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
3217
3218 wxASSERT( GTK_IS_WIDGET(m_widget) );
3219
3220 if (newParent)
3221 {
3222 if (GTK_WIDGET_VISIBLE (newParent->m_widget))
3223 {
3224 m_showOnIdle = true;
3225 gtk_widget_hide( m_widget );
3226 }
3227 /* insert GTK representation */
3228 newParent->AddChildGTK(this);
3229 }
3230
3231 SetLayoutDirection(wxLayout_Default);
3232
3233 return true;
3234 }
3235
3236 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3237 {
3238 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3239 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3240
3241 /* add to list */
3242 AddChild( child );
3243
3244 /* insert GTK representation */
3245 AddChildGTK(child);
3246 }
3247
3248 void wxWindowGTK::AddChild(wxWindowBase *child)
3249 {
3250 wxWindowBase::AddChild(child);
3251 m_dirtyTabOrder = true;
3252 wxTheApp->WakeUpIdle();
3253 }
3254
3255 void wxWindowGTK::RemoveChild(wxWindowBase *child)
3256 {
3257 wxWindowBase::RemoveChild(child);
3258 m_dirtyTabOrder = true;
3259 wxTheApp->WakeUpIdle();
3260 }
3261
3262 /* static */
3263 wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
3264 {
3265 return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL
3266 ? wxLayout_RightToLeft
3267 : wxLayout_LeftToRight;
3268 }
3269
3270 /* static */
3271 void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir)
3272 {
3273 wxASSERT_MSG( dir != wxLayout_Default, wxT("invalid layout direction") );
3274
3275 gtk_widget_set_direction(widget,
3276 dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
3277 : GTK_TEXT_DIR_LTR);
3278 }
3279
3280 wxLayoutDirection wxWindowGTK::GetLayoutDirection() const
3281 {
3282 return GTKGetLayout(m_widget);
3283 }
3284
3285 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir)
3286 {
3287 if ( dir == wxLayout_Default )
3288 {
3289 const wxWindow *const parent = GetParent();
3290 if ( parent )
3291 {
3292 // inherit layout from parent.
3293 dir = parent->GetLayoutDirection();
3294 }
3295 else // no parent, use global default layout
3296 {
3297 dir = wxTheApp->GetLayoutDirection();
3298 }
3299 }
3300
3301 if ( dir == wxLayout_Default )
3302 return;
3303
3304 GTKSetLayout(m_widget, dir);
3305
3306 if (m_wxwindow && (m_wxwindow != m_widget))
3307 GTKSetLayout(m_wxwindow, dir);
3308 }
3309
3310 wxCoord
3311 wxWindowGTK::AdjustForLayoutDirection(wxCoord x,
3312 wxCoord WXUNUSED(width),
3313 wxCoord WXUNUSED(widthTotal)) const
3314 {
3315 // We now mirror the coordinates of RTL windows in wxPizza
3316 return x;
3317 }
3318
3319 void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, WindowOrder move)
3320 {
3321 wxWindowBase::DoMoveInTabOrder(win, move);
3322 m_dirtyTabOrder = true;
3323 wxTheApp->WakeUpIdle();
3324 }
3325
3326 bool wxWindowGTK::DoNavigateIn(int flags)
3327 {
3328 if ( flags & wxNavigationKeyEvent::WinChange )
3329 {
3330 wxFAIL_MSG( wxT("not implemented") );
3331
3332 return false;
3333 }
3334 else // navigate inside the container
3335 {
3336 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3337 wxCHECK_MSG( parent, false, wxT("every window must have a TLW parent") );
3338
3339 GtkDirectionType dir;
3340 dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD
3341 : GTK_DIR_TAB_BACKWARD;
3342
3343 gboolean rc;
3344 g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
3345
3346 return rc == TRUE;
3347 }
3348 }
3349
3350 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3351 {
3352 // none needed by default
3353 return false;
3354 }
3355
3356 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget* WXUNUSED(w))
3357 {
3358 // nothing to do by default since none is needed
3359 }
3360
3361 void wxWindowGTK::RealizeTabOrder()
3362 {
3363 if (m_wxwindow)
3364 {
3365 if ( !m_children.empty() )
3366 {
3367 // we don't only construct the correct focus chain but also use
3368 // this opportunity to update the mnemonic widgets for the widgets
3369 // that need them
3370
3371 GList *chain = NULL;
3372 wxWindowGTK* mnemonicWindow = NULL;
3373
3374 for ( wxWindowList::const_iterator i = m_children.begin();
3375 i != m_children.end();
3376 ++i )
3377 {
3378 wxWindowGTK *win = *i;
3379
3380 if ( mnemonicWindow )
3381 {
3382 if ( win->AcceptsFocusFromKeyboard() )
3383 {
3384 // wxComboBox et al. needs to focus on on a different
3385 // widget than m_widget, so if the main widget isn't
3386 // focusable try the connect widget
3387 GtkWidget* w = win->m_widget;
3388 if ( !GTK_WIDGET_CAN_FOCUS(w) )
3389 {
3390 w = win->GetConnectWidget();
3391 if ( !GTK_WIDGET_CAN_FOCUS(w) )
3392 w = NULL;
3393 }
3394
3395 if ( w )
3396 {
3397 mnemonicWindow->GTKWidgetDoSetMnemonic(w);
3398 mnemonicWindow = NULL;
3399 }
3400 }
3401 }
3402 else if ( win->GTKWidgetNeedsMnemonic() )
3403 {
3404 mnemonicWindow = win;
3405 }
3406
3407 chain = g_list_prepend(chain, win->m_widget);
3408 }
3409
3410 chain = g_list_reverse(chain);
3411
3412 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain);
3413 g_list_free(chain);
3414 }
3415 else // no children
3416 {
3417 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow));
3418 }
3419 }
3420 }
3421
3422 void wxWindowGTK::Raise()
3423 {
3424 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3425
3426 if (m_wxwindow && m_wxwindow->window)
3427 {
3428 gdk_window_raise( m_wxwindow->window );
3429 }
3430 else if (m_widget->window)
3431 {
3432 gdk_window_raise( m_widget->window );
3433 }
3434 }
3435
3436 void wxWindowGTK::Lower()
3437 {
3438 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3439
3440 if (m_wxwindow && m_wxwindow->window)
3441 {
3442 gdk_window_lower( m_wxwindow->window );
3443 }
3444 else if (m_widget->window)
3445 {
3446 gdk_window_lower( m_widget->window );
3447 }
3448 }
3449
3450 bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3451 {
3452 if ( !wxWindowBase::SetCursor(cursor.Ok() ? cursor : *wxSTANDARD_CURSOR) )
3453 return false;
3454
3455 GTKUpdateCursor();
3456
3457 return true;
3458 }
3459
3460 void wxWindowGTK::GTKUpdateCursor(bool update_self /*=true*/, bool recurse /*=true*/)
3461 {
3462 if (update_self)
3463 {
3464 wxCursor cursor(g_globalCursor.Ok() ? g_globalCursor : GetCursor());
3465 if ( cursor.Ok() )
3466 {
3467 wxArrayGdkWindows windowsThis;
3468 GdkWindow* window = GTKGetWindow(windowsThis);
3469 if (window)
3470 gdk_window_set_cursor( window, cursor.GetCursor() );
3471 else
3472 {
3473 const size_t count = windowsThis.size();
3474 for ( size_t n = 0; n < count; n++ )
3475 {
3476 GdkWindow *win = windowsThis[n];
3477 // It can be zero if the window has not been realized yet.
3478 if ( win )
3479 {
3480 gdk_window_set_cursor(win, cursor.GetCursor());
3481 }
3482 }
3483 }
3484 }
3485 }
3486
3487 if (recurse)
3488 {
3489 for (wxWindowList::iterator it = GetChildren().begin(); it != GetChildren().end(); ++it)
3490 {
3491 (*it)->GTKUpdateCursor( true );
3492 }
3493 }
3494 }
3495
3496 void wxWindowGTK::WarpPointer( int x, int y )
3497 {
3498 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3499
3500 // We provide this function ourselves as it is
3501 // missing in GDK (top of this file).
3502
3503 GdkWindow *window = NULL;
3504 if (m_wxwindow)
3505 window = m_wxwindow->window;
3506 else
3507 window = GetConnectWidget()->window;
3508
3509 if (window)
3510 gdk_window_warp_pointer( window, x, y );
3511 }
3512
3513 wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const
3514 {
3515 // find the scrollbar which generated the event
3516 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
3517 {
3518 if ( range == m_scrollBar[dir] )
3519 return (ScrollDir)dir;
3520 }
3521
3522 wxFAIL_MSG( wxT("event from unknown scrollbar received") );
3523
3524 return ScrollDir_Max;
3525 }
3526
3527 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units)
3528 {
3529 bool changed = false;
3530 GtkRange* range = m_scrollBar[dir];
3531 if ( range && units )
3532 {
3533 GtkAdjustment* adj = range->adjustment;
3534 gdouble inc = unit == ScrollUnit_Line ? adj->step_increment
3535 : adj->page_increment;
3536
3537 const int posOld = int(adj->value + 0.5);
3538 gtk_range_set_value(range, posOld + units*inc);
3539
3540 changed = int(adj->value + 0.5) != posOld;
3541 }
3542
3543 return changed;
3544 }
3545
3546 bool wxWindowGTK::ScrollLines(int lines)
3547 {
3548 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Line, lines);
3549 }
3550
3551 bool wxWindowGTK::ScrollPages(int pages)
3552 {
3553 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages);
3554 }
3555
3556 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground),
3557 const wxRect *rect)
3558 {
3559 if ( !m_widget )
3560 {
3561 // it is valid to call Refresh() for a window which hasn't been created
3562 // yet, it simply doesn't do anything in this case
3563 return;
3564 }
3565
3566 if (!m_wxwindow)
3567 {
3568 if (rect)
3569 gtk_widget_queue_draw_area( m_widget, rect->x, rect->y, rect->width, rect->height );
3570 else
3571 gtk_widget_queue_draw( m_widget );
3572 }
3573 else
3574 {
3575 // Just return if the widget or one of its ancestors isn't mapped
3576 GtkWidget *w;
3577 for (w = m_wxwindow; w != NULL; w = w->parent)
3578 if (!GTK_WIDGET_MAPPED (w))
3579 return;
3580
3581 GdkWindow* window = GTKGetDrawingWindow();
3582 if (rect)
3583 {
3584 int x = rect->x;
3585 if (GetLayoutDirection() == wxLayout_RightToLeft)
3586 x = GetClientSize().x - x - rect->width;
3587 GdkRectangle r;
3588 r.x = rect->x;
3589 r.y = rect->y;
3590 r.width = rect->width;
3591 r.height = rect->height;
3592 gdk_window_invalidate_rect(window, &r, true);
3593 }
3594 else
3595 gdk_window_invalidate_rect(window, NULL, true);
3596 }
3597 }
3598
3599 void wxWindowGTK::Update()
3600 {
3601 if (m_widget && GTK_WIDGET_MAPPED(m_widget))
3602 {
3603 GdkDisplay* display = gtk_widget_get_display(m_widget);
3604 // Flush everything out to the server, and wait for it to finish.
3605 // This ensures nothing will overwrite the drawing we are about to do.
3606 gdk_display_sync(display);
3607
3608 GdkWindow* window = GTKGetDrawingWindow();
3609 if (window == NULL)
3610 window = m_widget->window;
3611 gdk_window_process_updates(window, true);
3612
3613 // Flush again, but no need to wait for it to finish
3614 gdk_display_flush(display);
3615 }
3616 }
3617
3618 bool wxWindowGTK::DoIsExposed( int x, int y ) const
3619 {
3620 return m_updateRegion.Contains(x, y) != wxOutRegion;
3621 }
3622
3623 bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const
3624 {
3625 if (GetLayoutDirection() == wxLayout_RightToLeft)
3626 return m_updateRegion.Contains(x-w, y, w, h) != wxOutRegion;
3627 else
3628 return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
3629 }
3630
3631 void wxWindowGTK::GtkSendPaintEvents()
3632 {
3633 if (!m_wxwindow)
3634 {
3635 m_updateRegion.Clear();
3636 return;
3637 }
3638
3639 // Clip to paint region in wxClientDC
3640 m_clipPaintRegion = true;
3641
3642 m_nativeUpdateRegion = m_updateRegion;
3643
3644 if (GetLayoutDirection() == wxLayout_RightToLeft)
3645 {
3646 // Transform m_updateRegion under RTL
3647 m_updateRegion.Clear();
3648
3649 gint width;
3650 gdk_drawable_get_size(m_wxwindow->window, &width, NULL);
3651
3652 wxRegionIterator upd( m_nativeUpdateRegion );
3653 while (upd)
3654 {
3655 wxRect rect;
3656 rect.x = upd.GetX();
3657 rect.y = upd.GetY();
3658 rect.width = upd.GetWidth();
3659 rect.height = upd.GetHeight();
3660
3661 rect.x = width - rect.x - rect.width;
3662 m_updateRegion.Union( rect );
3663
3664 ++upd;
3665 }
3666 }
3667
3668 switch ( GetBackgroundStyle() )
3669 {
3670 case wxBG_STYLE_ERASE:
3671 {
3672 wxWindowDC dc( (wxWindow*)this );
3673 dc.SetDeviceClippingRegion( m_updateRegion );
3674
3675 // Work around gtk-qt <= 0.60 bug whereby the window colour
3676 // remains grey
3677 if ( UseBgCol() &&
3678 wxSystemOptions::
3679 GetOptionInt("gtk.window.force-background-colour") )
3680 {
3681 dc.SetBackground(GetBackgroundColour());
3682 dc.Clear();
3683 }
3684
3685 wxEraseEvent erase_event( GetId(), &dc );
3686 erase_event.SetEventObject( this );
3687
3688 if ( HandleWindowEvent(erase_event) )
3689 {
3690 // background erased, don't do it again
3691 break;
3692 }
3693 }
3694 // fall through
3695
3696 case wxBG_STYLE_SYSTEM:
3697 if ( GetThemeEnabled() )
3698 {
3699 // find ancestor from which to steal background
3700 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3701 if (!parent)
3702 parent = (wxWindow*)this;
3703
3704 if (GTK_WIDGET_MAPPED(parent->m_widget))
3705 {
3706 wxRegionIterator upd( m_nativeUpdateRegion );
3707 while (upd)
3708 {
3709 GdkRectangle rect;
3710 rect.x = upd.GetX();
3711 rect.y = upd.GetY();
3712 rect.width = upd.GetWidth();
3713 rect.height = upd.GetHeight();
3714
3715 gtk_paint_flat_box( parent->m_widget->style,
3716 GTKGetDrawingWindow(),
3717 (GtkStateType)GTK_WIDGET_STATE(m_wxwindow),
3718 GTK_SHADOW_NONE,
3719 &rect,
3720 parent->m_widget,
3721 (char *)"base",
3722 0, 0, -1, -1 );
3723
3724 ++upd;
3725 }
3726 }
3727 }
3728 break;
3729
3730 case wxBG_STYLE_PAINT:
3731 // nothing to do: window will be painted over in EVT_PAINT
3732 break;
3733
3734 default:
3735 wxFAIL_MSG( "unsupported background style" );
3736 }
3737
3738 wxNcPaintEvent nc_paint_event( GetId() );
3739 nc_paint_event.SetEventObject( this );
3740 HandleWindowEvent( nc_paint_event );
3741
3742 wxPaintEvent paint_event( GetId() );
3743 paint_event.SetEventObject( this );
3744 HandleWindowEvent( paint_event );
3745
3746 m_clipPaintRegion = false;
3747
3748 m_updateRegion.Clear();
3749 m_nativeUpdateRegion.Clear();
3750 }
3751
3752 void wxWindowGTK::SetDoubleBuffered( bool on )
3753 {
3754 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3755
3756 if ( m_wxwindow )
3757 gtk_widget_set_double_buffered( m_wxwindow, on );
3758 }
3759
3760 bool wxWindowGTK::IsDoubleBuffered() const
3761 {
3762 return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow );
3763 }
3764
3765 void wxWindowGTK::ClearBackground()
3766 {
3767 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3768 }
3769
3770 #if wxUSE_TOOLTIPS
3771 void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3772 {
3773 wxWindowBase::DoSetToolTip(tip);
3774
3775 if (m_tooltip)
3776 {
3777 m_tooltip->GTKApply( (wxWindow *)this );
3778 }
3779 else
3780 {
3781 GtkWidget *w = GetConnectWidget();
3782 wxToolTip::GTKApply(w, NULL);
3783 }
3784 }
3785
3786 void wxWindowGTK::GTKApplyToolTip( GtkTooltips *tips, const gchar *tip )
3787 {
3788 GtkWidget *w = GetConnectWidget();
3789
3790 #if GTK_CHECK_VERSION(2, 12, 0)
3791 if (!gtk_check_version(2, 12, 0))
3792 {
3793 gtk_widget_set_tooltip_text (w, tip);
3794 }
3795 else
3796 #endif
3797 {
3798 gtk_tooltips_set_tip(tips, w, tip, NULL);
3799 }
3800 }
3801 #endif // wxUSE_TOOLTIPS
3802
3803 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
3804 {
3805 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3806
3807 if (!wxWindowBase::SetBackgroundColour(colour))
3808 return false;
3809
3810 if (colour.Ok())
3811 {
3812 // We need the pixel value e.g. for background clearing.
3813 m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3814 }
3815
3816 // apply style change (forceStyle=true so that new style is applied
3817 // even if the bg colour changed from valid to wxNullColour)
3818 GTKApplyWidgetStyle(true);
3819
3820 return true;
3821 }
3822
3823 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
3824 {
3825 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3826
3827 if (!wxWindowBase::SetForegroundColour(colour))
3828 {
3829 return false;
3830 }
3831
3832 if (colour.Ok())
3833 {
3834 // We need the pixel value e.g. for background clearing.
3835 m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3836 }
3837
3838 // apply style change (forceStyle=true so that new style is applied
3839 // even if the bg colour changed from valid to wxNullColour):
3840 GTKApplyWidgetStyle(true);
3841
3842 return true;
3843 }
3844
3845 PangoContext *wxWindowGTK::GTKGetPangoDefaultContext()
3846 {
3847 return gtk_widget_get_pango_context( m_widget );
3848 }
3849
3850 GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle)
3851 {
3852 // do we need to apply any changes at all?
3853 if ( !forceStyle &&
3854 !m_font.Ok() &&
3855 !m_foregroundColour.Ok() && !m_backgroundColour.Ok() )
3856 {
3857 return NULL;
3858 }
3859
3860 GtkRcStyle *style = gtk_rc_style_new();
3861
3862 if ( m_font.Ok() )
3863 {
3864 style->font_desc =
3865 pango_font_description_copy( m_font.GetNativeFontInfo()->description );
3866 }
3867
3868 int flagsNormal = 0,
3869 flagsPrelight = 0,
3870 flagsActive = 0,
3871 flagsInsensitive = 0;
3872
3873 if ( m_foregroundColour.Ok() )
3874 {
3875 const GdkColor *fg = m_foregroundColour.GetColor();
3876
3877 style->fg[GTK_STATE_NORMAL] =
3878 style->text[GTK_STATE_NORMAL] = *fg;
3879 flagsNormal |= GTK_RC_FG | GTK_RC_TEXT;
3880
3881 style->fg[GTK_STATE_PRELIGHT] =
3882 style->text[GTK_STATE_PRELIGHT] = *fg;
3883 flagsPrelight |= GTK_RC_FG | GTK_RC_TEXT;
3884
3885 style->fg[GTK_STATE_ACTIVE] =
3886 style->text[GTK_STATE_ACTIVE] = *fg;
3887 flagsActive |= GTK_RC_FG | GTK_RC_TEXT;
3888 }
3889
3890 if ( m_backgroundColour.Ok() )
3891 {
3892 const GdkColor *bg = m_backgroundColour.GetColor();
3893
3894 style->bg[GTK_STATE_NORMAL] =
3895 style->base[GTK_STATE_NORMAL] = *bg;
3896 flagsNormal |= GTK_RC_BG | GTK_RC_BASE;
3897
3898 style->bg[GTK_STATE_PRELIGHT] =
3899 style->base[GTK_STATE_PRELIGHT] = *bg;
3900 flagsPrelight |= GTK_RC_BG | GTK_RC_BASE;
3901
3902 style->bg[GTK_STATE_ACTIVE] =
3903 style->base[GTK_STATE_ACTIVE] = *bg;
3904 flagsActive |= GTK_RC_BG | GTK_RC_BASE;
3905
3906 style->bg[GTK_STATE_INSENSITIVE] =
3907 style->base[GTK_STATE_INSENSITIVE] = *bg;
3908 flagsInsensitive |= GTK_RC_BG | GTK_RC_BASE;
3909 }
3910
3911 style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)flagsNormal;
3912 style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)flagsPrelight;
3913 style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)flagsActive;
3914 style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)flagsInsensitive;
3915
3916 return style;
3917 }
3918
3919 void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle)
3920 {
3921 GtkRcStyle *style = GTKCreateWidgetStyle(forceStyle);
3922 if ( style )
3923 {
3924 DoApplyWidgetStyle(style);
3925 gtk_rc_style_unref(style);
3926 }
3927
3928 // Style change may affect GTK+'s size calculation:
3929 InvalidateBestSize();
3930 }
3931
3932 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
3933 {
3934 if ( m_wxwindow )
3935 {
3936 // block the signal temporarily to avoid sending
3937 // wxSysColourChangedEvents when we change the colours ourselves
3938 bool unblock = false;
3939 if ( IsTopLevel() )
3940 {
3941 unblock = true;
3942 g_signal_handlers_block_by_func(
3943 m_wxwindow, (void *)gtk_window_style_set_callback, this);
3944 }
3945
3946 gtk_widget_modify_style(m_wxwindow, style);
3947
3948 if ( unblock )
3949 {
3950 g_signal_handlers_unblock_by_func(
3951 m_wxwindow, (void *)gtk_window_style_set_callback, this);
3952 }
3953 }
3954 else
3955 {
3956 gtk_widget_modify_style(m_widget, style);
3957 }
3958 }
3959
3960 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
3961 {
3962 wxWindowBase::SetBackgroundStyle(style);
3963
3964 if ( style == wxBG_STYLE_PAINT )
3965 {
3966 GdkWindow *window;
3967 if ( m_wxwindow )
3968 {
3969 window = GTKGetDrawingWindow();
3970 }
3971 else
3972 {
3973 GtkWidget * const w = GetConnectWidget();
3974 window = w ? w->window : NULL;
3975 }
3976
3977 if (window)
3978 {
3979 // Make sure GDK/X11 doesn't refresh the window
3980 // automatically.
3981 gdk_window_set_back_pixmap( window, None, False );
3982 #ifdef __X__
3983 Display* display = GDK_WINDOW_DISPLAY(window);
3984 XFlush(display);
3985 #endif
3986 m_needsStyleChange = false;
3987 }
3988 else // window not realized yet
3989 {
3990 // Do in OnIdle, because the window is not yet available
3991 m_needsStyleChange = true;
3992 }
3993
3994 // Don't apply widget style, or we get a grey background
3995 }
3996 else
3997 {
3998 // apply style change (forceStyle=true so that new style is applied
3999 // even if the bg colour changed from valid to wxNullColour):
4000 GTKApplyWidgetStyle(true);
4001 }
4002
4003 return true;
4004 }
4005
4006 // ----------------------------------------------------------------------------
4007 // Pop-up menu stuff
4008 // ----------------------------------------------------------------------------
4009
4010 #if wxUSE_MENUS_NATIVE
4011
4012 extern "C" {
4013 static
4014 void wxPopupMenuPositionCallback( GtkMenu *menu,
4015 gint *x, gint *y,
4016 gboolean * WXUNUSED(whatever),
4017 gpointer user_data )
4018 {
4019 // ensure that the menu appears entirely on screen
4020 GtkRequisition req;
4021 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
4022
4023 wxSize sizeScreen = wxGetDisplaySize();
4024 wxPoint *pos = (wxPoint*)user_data;
4025
4026 gint xmax = sizeScreen.x - req.width,
4027 ymax = sizeScreen.y - req.height;
4028
4029 *x = pos->x < xmax ? pos->x : xmax;
4030 *y = pos->y < ymax ? pos->y : ymax;
4031 }
4032 }
4033
4034 bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
4035 {
4036 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4037
4038 menu->UpdateUI();
4039
4040 wxPoint pos;
4041 gpointer userdata;
4042 GtkMenuPositionFunc posfunc;
4043 if ( x == -1 && y == -1 )
4044 {
4045 // use GTK's default positioning algorithm
4046 userdata = NULL;
4047 posfunc = NULL;
4048 }
4049 else
4050 {
4051 pos = ClientToScreen(wxPoint(x, y));
4052 userdata = &pos;
4053 posfunc = wxPopupMenuPositionCallback;
4054 }
4055
4056 menu->m_popupShown = true;
4057 gtk_menu_popup(
4058 GTK_MENU(menu->m_menu),
4059 NULL, // parent menu shell
4060 NULL, // parent menu item
4061 posfunc, // function to position it
4062 userdata, // client data
4063 0, // button used to activate it
4064 gtk_get_current_event_time()
4065 );
4066
4067 while (menu->m_popupShown)
4068 {
4069 gtk_main_iteration();
4070 }
4071
4072 return true;
4073 }
4074
4075 #endif // wxUSE_MENUS_NATIVE
4076
4077 #if wxUSE_DRAG_AND_DROP
4078
4079 void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
4080 {
4081 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4082
4083 GtkWidget *dnd_widget = GetConnectWidget();
4084
4085 if (m_dropTarget) m_dropTarget->GtkUnregisterWidget( dnd_widget );
4086
4087 if (m_dropTarget) delete m_dropTarget;
4088 m_dropTarget = dropTarget;
4089
4090 if (m_dropTarget) m_dropTarget->GtkRegisterWidget( dnd_widget );
4091 }
4092
4093 #endif // wxUSE_DRAG_AND_DROP
4094
4095 GtkWidget* wxWindowGTK::GetConnectWidget()
4096 {
4097 GtkWidget *connect_widget = m_widget;
4098 if (m_wxwindow) connect_widget = m_wxwindow;
4099
4100 return connect_widget;
4101 }
4102
4103 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const
4104 {
4105 wxArrayGdkWindows windowsThis;
4106 GdkWindow * const winThis = GTKGetWindow(windowsThis);
4107
4108 return winThis ? window == winThis
4109 : windowsThis.Index(window) != wxNOT_FOUND;
4110 }
4111
4112 GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
4113 {
4114 return m_wxwindow ? GTKGetDrawingWindow() : m_widget->window;
4115 }
4116
4117 bool wxWindowGTK::SetFont( const wxFont &font )
4118 {
4119 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4120
4121 if (!wxWindowBase::SetFont(font))
4122 return false;
4123
4124 // apply style change (forceStyle=true so that new style is applied
4125 // even if the font changed from valid to wxNullFont):
4126 GTKApplyWidgetStyle(true);
4127
4128 return true;
4129 }
4130
4131 void wxWindowGTK::DoCaptureMouse()
4132 {
4133 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4134
4135 GdkWindow *window = NULL;
4136 if (m_wxwindow)
4137 window = GTKGetDrawingWindow();
4138 else
4139 window = GetConnectWidget()->window;
4140
4141 wxCHECK_RET( window, wxT("CaptureMouse() failed") );
4142
4143 const wxCursor* cursor = &m_cursor;
4144 if (!cursor->Ok())
4145 cursor = wxSTANDARD_CURSOR;
4146
4147 gdk_pointer_grab( window, FALSE,
4148 (GdkEventMask)
4149 (GDK_BUTTON_PRESS_MASK |
4150 GDK_BUTTON_RELEASE_MASK |
4151 GDK_POINTER_MOTION_HINT_MASK |
4152 GDK_POINTER_MOTION_MASK),
4153 NULL,
4154 cursor->GetCursor(),
4155 (guint32)GDK_CURRENT_TIME );
4156 g_captureWindow = this;
4157 g_captureWindowHasMouse = true;
4158 }
4159
4160 void wxWindowGTK::DoReleaseMouse()
4161 {
4162 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4163
4164 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
4165
4166 g_captureWindow = NULL;
4167
4168 GdkWindow *window = NULL;
4169 if (m_wxwindow)
4170 window = GTKGetDrawingWindow();
4171 else
4172 window = GetConnectWidget()->window;
4173
4174 if (!window)
4175 return;
4176
4177 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
4178 }
4179
4180 void wxWindowGTK::GTKReleaseMouseAndNotify()
4181 {
4182 DoReleaseMouse();
4183 wxMouseCaptureLostEvent evt(GetId());
4184 evt.SetEventObject( this );
4185 HandleWindowEvent( evt );
4186 }
4187
4188 /* static */
4189 wxWindow *wxWindowBase::GetCapture()
4190 {
4191 return (wxWindow *)g_captureWindow;
4192 }
4193
4194 bool wxWindowGTK::IsRetained() const
4195 {
4196 return false;
4197 }
4198
4199 void wxWindowGTK::SetScrollbar(int orient,
4200 int pos,
4201 int thumbVisible,
4202 int range,
4203 bool WXUNUSED(update))
4204 {
4205 const int dir = ScrollDirFromOrient(orient);
4206 GtkRange* const sb = m_scrollBar[dir];
4207 wxCHECK_RET( sb, wxT("this window is not scrollable") );
4208
4209 if (range <= 0)
4210 {
4211 // GtkRange requires upper > lower
4212 range =
4213 thumbVisible = 1;
4214 }
4215
4216 GtkAdjustment * const adj = sb->adjustment;
4217 adj->step_increment = 1;
4218 adj->page_increment =
4219 adj->page_size = thumbVisible;
4220 adj->value = pos;
4221
4222 g_signal_handlers_block_by_func(
4223 sb, (void*)gtk_scrollbar_value_changed, this);
4224
4225 gtk_range_set_range(sb, 0, range);
4226 m_scrollPos[dir] = sb->adjustment->value;
4227
4228 g_signal_handlers_unblock_by_func(
4229 sb, (void*)gtk_scrollbar_value_changed, this);
4230 }
4231
4232 void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
4233 {
4234 const int dir = ScrollDirFromOrient(orient);
4235 GtkRange * const sb = m_scrollBar[dir];
4236 wxCHECK_RET( sb, wxT("this window is not scrollable") );
4237
4238 // This check is more than an optimization. Without it, the slider
4239 // will not move smoothly while tracking when using wxScrollHelper.
4240 if (GetScrollPos(orient) != pos)
4241 {
4242 g_signal_handlers_block_by_func(
4243 sb, (void*)gtk_scrollbar_value_changed, this);
4244
4245 gtk_range_set_value(sb, pos);
4246 m_scrollPos[dir] = sb->adjustment->value;
4247
4248 g_signal_handlers_unblock_by_func(
4249 sb, (void*)gtk_scrollbar_value_changed, this);
4250 }
4251 }
4252
4253 int wxWindowGTK::GetScrollThumb(int orient) const
4254 {
4255 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4256 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4257
4258 return wxRound(sb->adjustment->page_size);
4259 }
4260
4261 int wxWindowGTK::GetScrollPos( int orient ) const
4262 {
4263 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4264 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4265
4266 return wxRound(sb->adjustment->value);
4267 }
4268
4269 int wxWindowGTK::GetScrollRange( int orient ) const
4270 {
4271 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4272 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4273
4274 return wxRound(sb->adjustment->upper);
4275 }
4276
4277 // Determine if increment is the same as +/-x, allowing for some small
4278 // difference due to possible inexactness in floating point arithmetic
4279 static inline bool IsScrollIncrement(double increment, double x)
4280 {
4281 wxASSERT(increment > 0);
4282 const double tolerance = 1.0 / 1024;
4283 return fabs(increment - fabs(x)) < tolerance;
4284 }
4285
4286 wxEventType wxWindowGTK::GTKGetScrollEventType(GtkRange* range)
4287 {
4288 wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
4289
4290 const int barIndex = range == m_scrollBar[1];
4291 GtkAdjustment* adj = range->adjustment;
4292
4293 const int value = wxRound(adj->value);
4294
4295 // save previous position
4296 const double oldPos = m_scrollPos[barIndex];
4297 // update current position
4298 m_scrollPos[barIndex] = adj->value;
4299 // If event should be ignored, or integral position has not changed
4300 if (!m_hasVMT || g_blockEventsOnDrag || value == wxRound(oldPos))
4301 {
4302 return wxEVT_NULL;
4303 }
4304
4305 wxEventType eventType = wxEVT_SCROLL_THUMBTRACK;
4306 if (!m_isScrolling)
4307 {
4308 // Difference from last change event
4309 const double diff = adj->value - oldPos;
4310 const bool isDown = diff > 0;
4311
4312 if (IsScrollIncrement(adj->step_increment, diff))
4313 {
4314 eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
4315 }
4316 else if (IsScrollIncrement(adj->page_increment, diff))
4317 {
4318 eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
4319 }
4320 else if (m_mouseButtonDown)
4321 {
4322 // Assume track event
4323 m_isScrolling = true;
4324 }
4325 }
4326 return eventType;
4327 }
4328
4329 void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4330 {
4331 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4332
4333 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4334
4335 // No scrolling requested.
4336 if ((dx == 0) && (dy == 0)) return;
4337
4338 m_clipPaintRegion = true;
4339
4340 WX_PIZZA(m_wxwindow)->scroll(dx, dy);
4341
4342 m_clipPaintRegion = false;
4343
4344 #if wxUSE_CARET
4345 bool restoreCaret = (GetCaret() != NULL && GetCaret()->IsVisible());
4346 if (restoreCaret)
4347 {
4348 wxRect caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4349 if (dx > 0)
4350 caretRect.width += dx;
4351 else
4352 {
4353 caretRect.x += dx; caretRect.width -= dx;
4354 }
4355 if (dy > 0)
4356 caretRect.height += dy;
4357 else
4358 {
4359 caretRect.y += dy; caretRect.height -= dy;
4360 }
4361
4362 RefreshRect(caretRect);
4363 }
4364 #endif // wxUSE_CARET
4365 }
4366
4367 void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
4368 {
4369 //RN: Note that static controls usually have no border on gtk, so maybe
4370 //it makes sense to treat that as simply no border at the wx level
4371 //as well...
4372 if (!(wxstyle & wxNO_BORDER) && !(wxstyle & wxBORDER_STATIC))
4373 {
4374 GtkShadowType gtkstyle;
4375
4376 if(wxstyle & wxBORDER_RAISED)
4377 gtkstyle = GTK_SHADOW_OUT;
4378 else if ((wxstyle & wxBORDER_SUNKEN) || (wxstyle & wxBORDER_THEME))
4379 gtkstyle = GTK_SHADOW_IN;
4380 #if 0
4381 // Now obsolete
4382 else if (wxstyle & wxBORDER_DOUBLE)
4383 gtkstyle = GTK_SHADOW_ETCHED_IN;
4384 #endif
4385 else //default
4386 gtkstyle = GTK_SHADOW_IN;
4387
4388 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w),
4389 gtkstyle );
4390 }
4391 }
4392
4393 void wxWindowGTK::SetWindowStyleFlag( long style )
4394 {
4395 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4396 wxWindowBase::SetWindowStyleFlag(style);
4397 }
4398
4399 // Find the wxWindow at the current mouse position, also returning the mouse
4400 // position.
4401 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4402 {
4403 pt = wxGetMousePosition();
4404 wxWindow* found = wxFindWindowAtPoint(pt);
4405 return found;
4406 }
4407
4408 // Get the current mouse position.
4409 wxPoint wxGetMousePosition()
4410 {
4411 /* This crashes when used within wxHelpContext,
4412 so we have to use the X-specific implementation below.
4413 gint x, y;
4414 GdkModifierType *mask;
4415 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4416
4417 return wxPoint(x, y);
4418 */
4419
4420 int x, y;
4421 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4422
4423 Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
4424 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4425 Window rootReturn, childReturn;
4426 int rootX, rootY, winX, winY;
4427 unsigned int maskReturn;
4428
4429 XQueryPointer (display,
4430 rootWindow,
4431 &rootReturn,
4432 &childReturn,
4433 &rootX, &rootY, &winX, &winY, &maskReturn);
4434 return wxPoint(rootX, rootY);
4435
4436 }
4437
4438 GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
4439 {
4440 GdkWindow* window = NULL;
4441 if (m_wxwindow)
4442 window = m_wxwindow->window;
4443 return window;
4444 }
4445
4446 // ----------------------------------------------------------------------------
4447 // freeze/thaw
4448 // ----------------------------------------------------------------------------
4449
4450 extern "C"
4451 {
4452
4453 // this is called if we attempted to freeze unrealized widget when it finally
4454 // is realized (and so can be frozen):
4455 static void wx_frozen_widget_realize(GtkWidget* w, wxWindowGTK* win)
4456 {
4457 wxASSERT( w && !GTK_WIDGET_NO_WINDOW(w) );
4458 wxASSERT( GTK_WIDGET_REALIZED(w) );
4459
4460 g_signal_handlers_disconnect_by_func
4461 (
4462 w,
4463 (void*)wx_frozen_widget_realize,
4464 win
4465 );
4466
4467 GdkWindow* window = w->window;
4468 if (w == win->m_wxwindow)
4469 window = win->GTKGetDrawingWindow();
4470 gdk_window_freeze_updates(window);
4471 }
4472
4473 } // extern "C"
4474
4475 void wxWindowGTK::GTKFreezeWidget(GtkWidget *w)
4476 {
4477 if ( !w || GTK_WIDGET_NO_WINDOW(w) )
4478 return; // window-less widget, cannot be frozen
4479
4480 if ( !GTK_WIDGET_REALIZED(w) )
4481 {
4482 // we can't thaw unrealized widgets because they don't have GdkWindow,
4483 // so set it up to be done immediately after realization:
4484 g_signal_connect_after
4485 (
4486 w,
4487 "realize",
4488 G_CALLBACK(wx_frozen_widget_realize),
4489 this
4490 );
4491 return;
4492 }
4493
4494 GdkWindow* window = w->window;
4495 if (w == m_wxwindow)
4496 window = GTKGetDrawingWindow();
4497 gdk_window_freeze_updates(window);
4498 }
4499
4500 void wxWindowGTK::GTKThawWidget(GtkWidget *w)
4501 {
4502 if ( !w || GTK_WIDGET_NO_WINDOW(w) )
4503 return; // window-less widget, cannot be frozen
4504
4505 if ( !GTK_WIDGET_REALIZED(w) )
4506 {
4507 // the widget wasn't realized yet, no need to thaw
4508 g_signal_handlers_disconnect_by_func
4509 (
4510 w,
4511 (void*)wx_frozen_widget_realize,
4512 this
4513 );
4514 return;
4515 }
4516
4517 GdkWindow* window = w->window;
4518 if (w == m_wxwindow)
4519 window = GTKGetDrawingWindow();
4520 gdk_window_thaw_updates(window);
4521 }
4522
4523 void wxWindowGTK::DoFreeze()
4524 {
4525 GTKFreezeWidget(m_widget);
4526 if ( m_wxwindow && m_widget != m_wxwindow )
4527 GTKFreezeWidget(m_wxwindow);
4528 }
4529
4530 void wxWindowGTK::DoThaw()
4531 {
4532 GTKThawWidget(m_widget);
4533 if ( m_wxwindow && m_widget != m_wxwindow )
4534 GTKThawWidget(m_wxwindow);
4535 }
wxWidgets (Impactor)