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