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