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