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