]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/window.cpp
projects / wxWidgets.git / blob
? search:


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