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