projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Patch update, probably fixes #12090: wxGTK cursor handling revamp
[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 win->GTKUpdateCursor(true, false);
1850 }
1851
1852 //-----------------------------------------------------------------------------
1853 // "size_allocate" from m_wxwindow or m_widget
1854 //-----------------------------------------------------------------------------
1855
1856 static void
1857 size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win)
1858 {
1859 int w = alloc->width;
1860 int h = alloc->height;
1861 if (win->m_wxwindow)
1862 {
1863 int border_x, border_y;
1864 WX_PIZZA(win->m_wxwindow)->get_border_widths(border_x, border_y);
1865 w -= 2 * border_x;
1866 h -= 2 * border_y;
1867 if (w < 0) w = 0;
1868 if (h < 0) h = 0;
1869 }
1870 if (win->m_oldClientWidth != w || win->m_oldClientHeight != h)
1871 {
1872 win->m_oldClientWidth = w;
1873 win->m_oldClientHeight = h;
1874 // this callback can be connected to m_wxwindow,
1875 // so always get size from m_widget->allocation
1876 win->m_width = win->m_widget->allocation.width;
1877 win->m_height = win->m_widget->allocation.height;
1878 if (!win->m_nativeSizeEvent)
1879 {
1880 wxSizeEvent event(win->GetSize(), win->GetId());
1881 event.SetEventObject(win);
1882 win->GTKProcessEvent(event);
1883 }
1884 }
1885 }
1886
1887 //-----------------------------------------------------------------------------
1888 // "grab_broken"
1889 //-----------------------------------------------------------------------------
1890
1891 #if GTK_CHECK_VERSION(2, 8, 0)
1892 static gboolean
1893 gtk_window_grab_broken( GtkWidget*,
1894 GdkEventGrabBroken *event,
1895 wxWindow *win )
1896 {
1897 // Mouse capture has been lost involuntarily, notify the application
1898 if(!event->keyboard && wxWindow::GetCapture() == win)
1899 {
1900 wxMouseCaptureLostEvent evt( win->GetId() );
1901 evt.SetEventObject( win );
1902 win->HandleWindowEvent( evt );
1903 }
1904 return false;
1905 }
1906 #endif
1907
1908 //-----------------------------------------------------------------------------
1909 // "style_set"
1910 //-----------------------------------------------------------------------------
1911
1912 static
1913 void gtk_window_style_set_callback( GtkWidget *WXUNUSED(widget),
1914 GtkStyle *previous_style,
1915 wxWindow* win )
1916 {
1917 if (win && previous_style)
1918 {
1919 wxSysColourChangedEvent event;
1920 event.SetEventObject(win);
1921
1922 win->GTKProcessEvent( event );
1923 }
1924 }
1925
1926 } // extern "C"
1927
1928 // ----------------------------------------------------------------------------
1929 // this wxWindowBase function is implemented here (in platform-specific file)
1930 // because it is static and so couldn't be made virtual
1931 // ----------------------------------------------------------------------------
1932
1933 wxWindow *wxWindowBase::DoFindFocus()
1934 {
1935 wxWindowGTK *focus = gs_pendingFocus ? gs_pendingFocus : gs_currentFocus;
1936 // the cast is necessary when we compile in wxUniversal mode
1937 return static_cast<wxWindow*>(focus);
1938 }
1939
1940 void wxWindowGTK::AddChildGTK(wxWindowGTK* child)
1941 {
1942 wxASSERT_MSG(m_wxwindow, "Cannot add a child to a window without a client area");
1943
1944 // the window might have been scrolled already, we
1945 // have to adapt the position
1946 wxPizza* pizza = WX_PIZZA(m_wxwindow);
1947 child->m_x += pizza->m_scroll_x;
1948 child->m_y += pizza->m_scroll_y;
1949
1950 gtk_widget_set_size_request(
1951 child->m_widget, child->m_width, child->m_height);
1952 pizza->put(child->m_widget, child->m_x, child->m_y);
1953 }
1954
1955 //-----------------------------------------------------------------------------
1956 // global functions
1957 //-----------------------------------------------------------------------------
1958
1959 wxWindow *wxGetActiveWindow()
1960 {
1961 return wxWindow::FindFocus();
1962 }
1963
1964
1965 wxMouseState wxGetMouseState()
1966 {
1967 wxMouseState ms;
1968
1969 gint x;
1970 gint y;
1971 GdkModifierType mask;
1972
1973 gdk_window_get_pointer(NULL, &x, &y, &mask);
1974
1975 ms.SetX(x);
1976 ms.SetY(y);
1977 ms.SetLeftDown((mask & GDK_BUTTON1_MASK) != 0);
1978 ms.SetMiddleDown((mask & GDK_BUTTON2_MASK) != 0);
1979 ms.SetRightDown((mask & GDK_BUTTON3_MASK) != 0);
1980 ms.SetAux1Down((mask & GDK_BUTTON4_MASK) != 0);
1981 ms.SetAux2Down((mask & GDK_BUTTON5_MASK) != 0);
1982
1983 ms.SetControlDown((mask & GDK_CONTROL_MASK) != 0);
1984 ms.SetShiftDown((mask & GDK_SHIFT_MASK) != 0);
1985 ms.SetAltDown((mask & GDK_MOD1_MASK) != 0);
1986 ms.SetMetaDown((mask & GDK_META_MASK) != 0);
1987
1988 return ms;
1989 }
1990
1991 //-----------------------------------------------------------------------------
1992 // wxWindowGTK
1993 //-----------------------------------------------------------------------------
1994
1995 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
1996 // method
1997 #ifdef __WXUNIVERSAL__
1998 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
1999 #else // __WXGTK__
2000 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
2001 #endif // __WXUNIVERSAL__/__WXGTK__
2002
2003 void wxWindowGTK::Init()
2004 {
2005 // GTK specific
2006 m_widget = NULL;
2007 m_wxwindow = NULL;
2008 m_focusWidget = NULL;
2009
2010 // position/size
2011 m_x = 0;
2012 m_y = 0;
2013 m_width = 0;
2014 m_height = 0;
2015
2016 m_hasVMT = false;
2017
2018 m_showOnIdle = false;
2019
2020 m_noExpose = false;
2021 m_nativeSizeEvent = false;
2022
2023 m_isScrolling = false;
2024 m_mouseButtonDown = false;
2025
2026 // initialize scrolling stuff
2027 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
2028 {
2029 m_scrollBar[dir] = NULL;
2030 m_scrollPos[dir] = 0;
2031 }
2032
2033 m_oldClientWidth =
2034 m_oldClientHeight = 0;
2035
2036 m_clipPaintRegion = false;
2037
2038 m_needsStyleChange = false;
2039
2040 m_cursor = *wxSTANDARD_CURSOR;
2041
2042 m_imData = NULL;
2043 m_dirtyTabOrder = false;
2044 }
2045
2046 wxWindowGTK::wxWindowGTK()
2047 {
2048 Init();
2049 }
2050
2051 wxWindowGTK::wxWindowGTK( wxWindow *parent,
2052 wxWindowID id,
2053 const wxPoint &pos,
2054 const wxSize &size,
2055 long style,
2056 const wxString &name )
2057 {
2058 Init();
2059
2060 Create( parent, id, pos, size, style, name );
2061 }
2062
2063 bool wxWindowGTK::Create( wxWindow *parent,
2064 wxWindowID id,
2065 const wxPoint &pos,
2066 const wxSize &size,
2067 long style,
2068 const wxString &name )
2069 {
2070 // Get default border
2071 wxBorder border = GetBorder(style);
2072
2073 style &= ~wxBORDER_MASK;
2074 style |= border;
2075
2076 if (!PreCreation( parent, pos, size ) ||
2077 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2078 {
2079 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2080 return false;
2081 }
2082
2083 // We should accept the native look
2084 #if 0
2085 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2086 scroll_class->scrollbar_spacing = 0;
2087 #endif
2088
2089
2090 m_wxwindow = wxPizza::New(m_windowStyle);
2091 #ifndef __WXUNIVERSAL__
2092 if (HasFlag(wxPizza::BORDER_STYLES))
2093 {
2094 g_signal_connect(m_wxwindow, "parent_set",
2095 G_CALLBACK(parent_set), this);
2096 }
2097 #endif
2098 if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
2099 m_widget = m_wxwindow;
2100 else
2101 {
2102 m_widget = gtk_scrolled_window_new( NULL, NULL );
2103
2104 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
2105
2106 // There is a conflict with default bindings at GTK+
2107 // level between scrolled windows and notebooks both of which want to use
2108 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2109 // direction and notebooks for changing pages -- we decide that if we don't
2110 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2111 // means we can get working keyboard navigation in notebooks
2112 if ( !HasFlag(wxHSCROLL) )
2113 {
2114 GtkBindingSet *
2115 bindings = gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget));
2116 if ( bindings )
2117 {
2118 gtk_binding_entry_remove(bindings, GDK_Page_Up, GDK_CONTROL_MASK);
2119 gtk_binding_entry_remove(bindings, GDK_Page_Down, GDK_CONTROL_MASK);
2120 }
2121 }
2122
2123 if (HasFlag(wxALWAYS_SHOW_SB))
2124 {
2125 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
2126
2127 scrolledWindow->hscrollbar_visible = TRUE;
2128 scrolledWindow->vscrollbar_visible = TRUE;
2129 }
2130 else
2131 {
2132 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
2133 }
2134
2135 m_scrollBar[ScrollDir_Horz] = GTK_RANGE(scrolledWindow->hscrollbar);
2136 m_scrollBar[ScrollDir_Vert] = GTK_RANGE(scrolledWindow->vscrollbar);
2137 if (GetLayoutDirection() == wxLayout_RightToLeft)
2138 gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );
2139
2140 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
2141
2142 // connect various scroll-related events
2143 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
2144 {
2145 // these handlers block mouse events to any window during scrolling
2146 // such as motion events and prevent GTK and wxWidgets from fighting
2147 // over where the slider should be
2148 g_signal_connect(m_scrollBar[dir], "button_press_event",
2149 G_CALLBACK(gtk_scrollbar_button_press_event), this);
2150 g_signal_connect(m_scrollBar[dir], "button_release_event",
2151 G_CALLBACK(gtk_scrollbar_button_release_event), this);
2152
2153 gulong handler_id = g_signal_connect(m_scrollBar[dir], "event_after",
2154 G_CALLBACK(gtk_scrollbar_event_after), this);
2155 g_signal_handler_block(m_scrollBar[dir], handler_id);
2156
2157 // these handlers get notified when scrollbar slider moves
2158 g_signal_connect_after(m_scrollBar[dir], "value_changed",
2159 G_CALLBACK(gtk_scrollbar_value_changed), this);
2160 }
2161
2162 gtk_widget_show( m_wxwindow );
2163 }
2164 g_object_ref(m_widget);
2165
2166 if (m_parent)
2167 m_parent->DoAddChild( this );
2168
2169 m_focusWidget = m_wxwindow;
2170
2171 SetCanFocus(AcceptsFocus());
2172
2173 PostCreation();
2174
2175 return true;
2176 }
2177
2178 wxWindowGTK::~wxWindowGTK()
2179 {
2180 SendDestroyEvent();
2181
2182 if (gs_currentFocus == this)
2183 gs_currentFocus = NULL;
2184 if (gs_pendingFocus == this)
2185 gs_pendingFocus = NULL;
2186
2187 if ( gs_deferredFocusOut == this )
2188 gs_deferredFocusOut = NULL;
2189
2190 m_hasVMT = false;
2191
2192 // destroy children before destroying this window itself
2193 DestroyChildren();
2194
2195 // unhook focus handlers to prevent stray events being
2196 // propagated to this (soon to be) dead object
2197 if (m_focusWidget != NULL)
2198 {
2199 g_signal_handlers_disconnect_by_func (m_focusWidget,
2200 (gpointer) gtk_window_focus_in_callback,
2201 this);
2202 g_signal_handlers_disconnect_by_func (m_focusWidget,
2203 (gpointer) gtk_window_focus_out_callback,
2204 this);
2205 }
2206
2207 if (m_widget)
2208 Show( false );
2209
2210 // delete before the widgets to avoid a crash on solaris
2211 delete m_imData;
2212
2213 // avoid problem with GTK+ 2.18 where a frozen window causes the whole
2214 // TLW to be frozen, and if the window is then destroyed, nothing ever
2215 // gets painted again
2216 if (IsFrozen())
2217 DoThaw();
2218
2219 if (m_widget)
2220 {
2221 // Note that gtk_widget_destroy() does not destroy the widget, it just
2222 // emits the "destroy" signal. The widget is not actually destroyed
2223 // until its reference count drops to zero.
2224 gtk_widget_destroy(m_widget);
2225 // Release our reference, should be the last one
2226 g_object_unref(m_widget);
2227 m_widget = NULL;
2228 }
2229 m_wxwindow = NULL;
2230 }
2231
2232 bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
2233 {
2234 if ( GTKNeedsParent() )
2235 {
2236 wxCHECK_MSG( parent, false, wxT("Must have non-NULL parent") );
2237 }
2238
2239 // Use either the given size, or the default if -1 is given.
2240 // See wxWindowBase for these functions.
2241 m_width = WidthDefault(size.x) ;
2242 m_height = HeightDefault(size.y);
2243
2244 m_x = (int)pos.x;
2245 m_y = (int)pos.y;
2246
2247 return true;
2248 }
2249
2250 void wxWindowGTK::PostCreation()
2251 {
2252 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2253
2254 if (m_wxwindow)
2255 {
2256 if (!m_noExpose)
2257 {
2258 // these get reported to wxWidgets -> wxPaintEvent
2259
2260 g_signal_connect (m_wxwindow, "expose_event",
2261 G_CALLBACK (gtk_window_expose_callback), this);
2262
2263 if (GetLayoutDirection() == wxLayout_LeftToRight)
2264 gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE));
2265 }
2266
2267 // Create input method handler
2268 m_imData = new wxGtkIMData;
2269
2270 // Cannot handle drawing preedited text yet
2271 gtk_im_context_set_use_preedit( m_imData->context, FALSE );
2272
2273 g_signal_connect (m_imData->context, "commit",
2274 G_CALLBACK (gtk_wxwindow_commit_cb), this);
2275 }
2276
2277 // focus handling
2278
2279 if (!GTK_IS_WINDOW(m_widget))
2280 {
2281 if (m_focusWidget == NULL)
2282 m_focusWidget = m_widget;
2283
2284 if (m_wxwindow)
2285 {
2286 g_signal_connect (m_focusWidget, "focus_in_event",
2287 G_CALLBACK (gtk_window_focus_in_callback), this);
2288 g_signal_connect (m_focusWidget, "focus_out_event",
2289 G_CALLBACK (gtk_window_focus_out_callback), this);
2290 }
2291 else
2292 {
2293 g_signal_connect_after (m_focusWidget, "focus_in_event",
2294 G_CALLBACK (gtk_window_focus_in_callback), this);
2295 g_signal_connect_after (m_focusWidget, "focus_out_event",
2296 G_CALLBACK (gtk_window_focus_out_callback), this);
2297 }
2298 }
2299
2300 if ( !AcceptsFocusFromKeyboard() )
2301 {
2302 SetCanFocus(false);
2303
2304 g_signal_connect(m_widget, "focus",
2305 G_CALLBACK(wx_window_focus_callback), this);
2306 }
2307
2308 // connect to the various key and mouse handlers
2309
2310 GtkWidget *connect_widget = GetConnectWidget();
2311
2312 ConnectWidget( connect_widget );
2313
2314 /* We cannot set colours, fonts and cursors before the widget has
2315 been realized, so we do this directly after realization */
2316 g_signal_connect (connect_widget, "realize",
2317 G_CALLBACK (gtk_window_realized_callback), this);
2318
2319 if (!IsTopLevel())
2320 {
2321 g_signal_connect(m_wxwindow ? m_wxwindow : m_widget, "size_allocate",
2322 G_CALLBACK(size_allocate), this);
2323 }
2324
2325 #if GTK_CHECK_VERSION(2, 8, 0)
2326 if ( gtk_check_version(2,8,0) == NULL )
2327 {
2328 // Make sure we can notify the app when mouse capture is lost
2329 if ( m_wxwindow )
2330 {
2331 g_signal_connect (m_wxwindow, "grab_broken_event",
2332 G_CALLBACK (gtk_window_grab_broken), this);
2333 }
2334
2335 if ( connect_widget != m_wxwindow )
2336 {
2337 g_signal_connect (connect_widget, "grab_broken_event",
2338 G_CALLBACK (gtk_window_grab_broken), this);
2339 }
2340 }
2341 #endif // GTK+ >= 2.8
2342
2343 if ( GTKShouldConnectSizeRequest() )
2344 {
2345 // This is needed if we want to add our windows into native
2346 // GTK controls, such as the toolbar. With this callback, the
2347 // toolbar gets to know the correct size (the one set by the
2348 // programmer). Sadly, it misbehaves for wxComboBox.
2349 g_signal_connect (m_widget, "size_request",
2350 G_CALLBACK (wxgtk_window_size_request_callback),
2351 this);
2352 }
2353
2354 InheritAttributes();
2355
2356 m_hasVMT = true;
2357
2358 SetLayoutDirection(wxLayout_Default);
2359
2360 // unless the window was created initially hidden (i.e. Hide() had been
2361 // called before Create()), we should show it at GTK+ level as well
2362 if ( IsShown() )
2363 gtk_widget_show( m_widget );
2364 }
2365
2366 gulong wxWindowGTK::GTKConnectWidget(const char *signal, void (*callback)())
2367 {
2368 return g_signal_connect(m_widget, signal, callback, this);
2369 }
2370
2371 void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2372 {
2373 g_signal_connect (widget, "key_press_event",
2374 G_CALLBACK (gtk_window_key_press_callback), this);
2375 g_signal_connect (widget, "key_release_event",
2376 G_CALLBACK (gtk_window_key_release_callback), this);
2377 g_signal_connect (widget, "button_press_event",
2378 G_CALLBACK (gtk_window_button_press_callback), this);
2379 g_signal_connect (widget, "button_release_event",
2380 G_CALLBACK (gtk_window_button_release_callback), this);
2381 g_signal_connect (widget, "motion_notify_event",
2382 G_CALLBACK (gtk_window_motion_notify_callback), this);
2383
2384 g_signal_connect (widget, "scroll_event",
2385 G_CALLBACK (window_scroll_event), this);
2386 if (m_scrollBar[ScrollDir_Horz])
2387 g_signal_connect (m_scrollBar[ScrollDir_Horz], "scroll_event",
2388 G_CALLBACK (window_scroll_event_hscrollbar), this);
2389 if (m_scrollBar[ScrollDir_Vert])
2390 g_signal_connect (m_scrollBar[ScrollDir_Vert], "scroll_event",
2391 G_CALLBACK (window_scroll_event), this);
2392
2393 g_signal_connect (widget, "popup_menu",
2394 G_CALLBACK (wxgtk_window_popup_menu_callback), this);
2395 g_signal_connect (widget, "enter_notify_event",
2396 G_CALLBACK (gtk_window_enter_callback), this);
2397 g_signal_connect (widget, "leave_notify_event",
2398 G_CALLBACK (gtk_window_leave_callback), this);
2399
2400 if (IsTopLevel() && m_wxwindow)
2401 g_signal_connect (m_wxwindow, "style_set",
2402 G_CALLBACK (gtk_window_style_set_callback), this);
2403 }
2404
2405 bool wxWindowGTK::Destroy()
2406 {
2407 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2408
2409 m_hasVMT = false;
2410
2411 return wxWindowBase::Destroy();
2412 }
2413
2414 void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
2415 {
2416 gtk_widget_set_size_request(m_widget, width, height);
2417
2418 // inform the parent to perform the move
2419 wxASSERT_MSG(m_parent && m_parent->m_wxwindow,
2420 "the parent window has no client area?");
2421 WX_PIZZA(m_parent->m_wxwindow)->move(m_widget, x, y);
2422 }
2423
2424 void wxWindowGTK::ConstrainSize()
2425 {
2426 #ifdef __WXGPE__
2427 // GPE's window manager doesn't like size hints at all, esp. when the user
2428 // has to use the virtual keyboard, so don't constrain size there
2429 if (!IsTopLevel())
2430 #endif
2431 {
2432 const wxSize minSize = GetMinSize();
2433 const wxSize maxSize = GetMaxSize();
2434 if (minSize.x > 0 && m_width < minSize.x) m_width = minSize.x;
2435 if (minSize.y > 0 && m_height < minSize.y) m_height = minSize.y;
2436 if (maxSize.x > 0 && m_width > maxSize.x) m_width = maxSize.x;
2437 if (maxSize.y > 0 && m_height > maxSize.y) m_height = maxSize.y;
2438 }
2439 }
2440
2441 void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2442 {
2443 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2444 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
2445
2446 int currentX, currentY;
2447 GetPosition(&currentX, &currentY);
2448 if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2449 x = currentX;
2450 if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2451 y = currentY;
2452 AdjustForParentClientOrigin(x, y, sizeFlags);
2453
2454 // calculate the best size if we should auto size the window
2455 if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
2456 ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
2457 {
2458 const wxSize sizeBest = GetBestSize();
2459 if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
2460 width = sizeBest.x;
2461 if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
2462 height = sizeBest.y;
2463 }
2464
2465 const wxSize oldSize(m_width, m_height);
2466 if (width != -1)
2467 m_width = width;
2468 if (height != -1)
2469 m_height = height;
2470
2471 if (m_parent->m_wxwindow)
2472 {
2473 wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
2474 m_x = x + pizza->m_scroll_x;
2475 m_y = y + pizza->m_scroll_y;
2476
2477 int left_border = 0;
2478 int right_border = 0;
2479 int top_border = 0;
2480 int bottom_border = 0;
2481
2482 /* the default button has a border around it */
2483 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
2484 {
2485 GtkBorder *default_border = NULL;
2486 gtk_widget_style_get( m_widget, "default_border", &default_border, NULL );
2487 if (default_border)
2488 {
2489 left_border += default_border->left;
2490 right_border += default_border->right;
2491 top_border += default_border->top;
2492 bottom_border += default_border->bottom;
2493 gtk_border_free( default_border );
2494 }
2495 }
2496
2497 DoMoveWindow( m_x - left_border,
2498 m_y - top_border,
2499 m_width+left_border+right_border,
2500 m_height+top_border+bottom_border );
2501 }
2502
2503 if (m_width != oldSize.x || m_height != oldSize.y)
2504 {
2505 // update these variables to keep size_allocate handler
2506 // from sending another size event for this change
2507 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
2508
2509 gtk_widget_queue_resize(m_widget);
2510 if (!m_nativeSizeEvent)
2511 {
2512 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2513 event.SetEventObject( this );
2514 HandleWindowEvent( event );
2515 }
2516 } else
2517 if (sizeFlags & wxSIZE_FORCE_EVENT)
2518 {
2519 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2520 event.SetEventObject( this );
2521 HandleWindowEvent( event );
2522 }
2523 }
2524
2525 bool wxWindowGTK::GTKShowFromOnIdle()
2526 {
2527 if (IsShown() && m_showOnIdle && !GTK_WIDGET_VISIBLE (m_widget))
2528 {
2529 GtkAllocation alloc;
2530 alloc.x = m_x;
2531 alloc.y = m_y;
2532 alloc.width = m_width;
2533 alloc.height = m_height;
2534 gtk_widget_size_allocate( m_widget, &alloc );
2535 gtk_widget_show( m_widget );
2536 wxShowEvent eventShow(GetId(), true);
2537 eventShow.SetEventObject(this);
2538 HandleWindowEvent(eventShow);
2539 m_showOnIdle = false;
2540 return true;
2541 }
2542
2543 return false;
2544 }
2545
2546 void wxWindowGTK::OnInternalIdle()
2547 {
2548 if ( gs_deferredFocusOut )
2549 GTKHandleDeferredFocusOut();
2550
2551 // Check if we have to show window now
2552 if (GTKShowFromOnIdle()) return;
2553
2554 if ( m_dirtyTabOrder )
2555 {
2556 m_dirtyTabOrder = false;
2557 RealizeTabOrder();
2558 }
2559
2560 // Update style if the window was not yet realized when
2561 // SetBackgroundStyle() was called
2562 if (m_needsStyleChange)
2563 {
2564 SetBackgroundStyle(GetBackgroundStyle());
2565 m_needsStyleChange = false;
2566 }
2567
2568 if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
2569 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
2570 }
2571
2572 void wxWindowGTK::DoGetSize( int *width, int *height ) const
2573 {
2574 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2575
2576 if (width) (*width) = m_width;
2577 if (height) (*height) = m_height;
2578 }
2579
2580 void wxWindowGTK::DoSetClientSize( int width, int height )
2581 {
2582 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2583
2584 const wxSize size = GetSize();
2585 const wxSize clientSize = GetClientSize();
2586 SetSize(width + (size.x - clientSize.x), height + (size.y - clientSize.y));
2587 }
2588
2589 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
2590 {
2591 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2592
2593 int w = m_width;
2594 int h = m_height;
2595
2596 if ( m_wxwindow )
2597 {
2598 // if window is scrollable, account for scrollbars
2599 if ( GTK_IS_SCROLLED_WINDOW(m_widget) )
2600 {
2601 GtkPolicyType policy[ScrollDir_Max];
2602 gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget),
2603 &policy[ScrollDir_Horz],
2604 &policy[ScrollDir_Vert]);
2605
2606 for ( int i = 0; i < ScrollDir_Max; i++ )
2607 {
2608 // don't account for the scrollbars we don't have
2609 GtkRange * const range = m_scrollBar[i];
2610 if ( !range )
2611 continue;
2612
2613 // nor for the ones we have but don't current show
2614 switch ( policy[i] )
2615 {
2616 case GTK_POLICY_NEVER:
2617 // never shown so doesn't take any place
2618 continue;
2619
2620 case GTK_POLICY_ALWAYS:
2621 // no checks necessary
2622 break;
2623
2624 case GTK_POLICY_AUTOMATIC:
2625 // may be shown or not, check
2626 GtkAdjustment *adj = gtk_range_get_adjustment(range);
2627 if ( adj->upper <= adj->page_size )
2628 continue;
2629 }
2630
2631 GtkScrolledWindowClass *scroll_class =
2632 GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2633
2634 GtkRequisition req;
2635 gtk_widget_size_request(GTK_WIDGET(range), &req);
2636 if (i == ScrollDir_Horz)
2637 h -= req.height + scroll_class->scrollbar_spacing;
2638 else
2639 w -= req.width + scroll_class->scrollbar_spacing;
2640 }
2641 }
2642
2643 int border_x, border_y;
2644 WX_PIZZA(m_wxwindow)->get_border_widths(border_x, border_y);
2645 w -= 2 * border_x;
2646 h -= 2 * border_y;
2647
2648 if (w < 0)
2649 w = 0;
2650 if (h < 0)
2651 h = 0;
2652 }
2653
2654 if (width) *width = w;
2655 if (height) *height = h;
2656 }
2657
2658 void wxWindowGTK::DoGetPosition( int *x, int *y ) const
2659 {
2660 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2661
2662 int dx = 0;
2663 int dy = 0;
2664 if (!IsTopLevel() && m_parent && m_parent->m_wxwindow)
2665 {
2666 wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
2667 dx = pizza->m_scroll_x;
2668 dy = pizza->m_scroll_y;
2669 }
2670
2671 if (m_x == -1 && m_y == -1)
2672 {
2673 GdkWindow *source = NULL;
2674 if (m_wxwindow)
2675 source = m_wxwindow->window;
2676 else
2677 source = m_widget->window;
2678
2679 if (source)
2680 {
2681 int org_x = 0;
2682 int org_y = 0;
2683 gdk_window_get_origin( source, &org_x, &org_y );
2684
2685 if (m_parent)
2686 m_parent->ScreenToClient(&org_x, &org_y);
2687
2688 const_cast<wxWindowGTK*>(this)->m_x = org_x;
2689 const_cast<wxWindowGTK*>(this)->m_y = org_y;
2690 }
2691 }
2692
2693 if (x) (*x) = m_x - dx;
2694 if (y) (*y) = m_y - dy;
2695 }
2696
2697 void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
2698 {
2699 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2700
2701 if (!m_widget->window) return;
2702
2703 GdkWindow *source = NULL;
2704 if (m_wxwindow)
2705 source = m_wxwindow->window;
2706 else
2707 source = m_widget->window;
2708
2709 int org_x = 0;
2710 int org_y = 0;
2711 gdk_window_get_origin( source, &org_x, &org_y );
2712
2713 if (!m_wxwindow)
2714 {
2715 if (GTK_WIDGET_NO_WINDOW (m_widget))
2716 {
2717 org_x += m_widget->allocation.x;
2718 org_y += m_widget->allocation.y;
2719 }
2720 }
2721
2722
2723 if (x)
2724 {
2725 if (GetLayoutDirection() == wxLayout_RightToLeft)
2726 *x = (GetClientSize().x - *x) + org_x;
2727 else
2728 *x += org_x;
2729 }
2730
2731 if (y) *y += org_y;
2732 }
2733
2734 void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
2735 {
2736 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2737
2738 if (!m_widget->window) return;
2739
2740 GdkWindow *source = NULL;
2741 if (m_wxwindow)
2742 source = m_wxwindow->window;
2743 else
2744 source = m_widget->window;
2745
2746 int org_x = 0;
2747 int org_y = 0;
2748 gdk_window_get_origin( source, &org_x, &org_y );
2749
2750 if (!m_wxwindow)
2751 {
2752 if (GTK_WIDGET_NO_WINDOW (m_widget))
2753 {
2754 org_x += m_widget->allocation.x;
2755 org_y += m_widget->allocation.y;
2756 }
2757 }
2758
2759 if (x)
2760 {
2761 if (GetLayoutDirection() == wxLayout_RightToLeft)
2762 *x = (GetClientSize().x - *x) - org_x;
2763 else
2764 *x -= org_x;
2765 }
2766 if (y) *y -= org_y;
2767 }
2768
2769 bool wxWindowGTK::Show( bool show )
2770 {
2771 if ( !wxWindowBase::Show(show) )
2772 {
2773 // nothing to do
2774 return false;
2775 }
2776
2777 // notice that we may call Hide() before the window is created and this is
2778 // actually useful to create it hidden initially -- but we can't call
2779 // Show() before it is created
2780 if ( !m_widget )
2781 {
2782 wxASSERT_MSG( !show, "can't show invalid window" );
2783 return true;
2784 }
2785
2786 if ( show )
2787 {
2788 if ( m_showOnIdle )
2789 {
2790 // defer until later
2791 return true;
2792 }
2793
2794 gtk_widget_show(m_widget);
2795 }
2796 else // hide
2797 {
2798 gtk_widget_hide(m_widget);
2799 }
2800
2801 wxShowEvent eventShow(GetId(), show);
2802 eventShow.SetEventObject(this);
2803 HandleWindowEvent(eventShow);
2804
2805 return true;
2806 }
2807
2808 void wxWindowGTK::DoEnable( bool enable )
2809 {
2810 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2811
2812 gtk_widget_set_sensitive( m_widget, enable );
2813 if (m_wxwindow && (m_wxwindow != m_widget))
2814 gtk_widget_set_sensitive( m_wxwindow, enable );
2815 }
2816
2817 int wxWindowGTK::GetCharHeight() const
2818 {
2819 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
2820
2821 wxFont font = GetFont();
2822 wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
2823
2824 PangoContext* context = gtk_widget_get_pango_context(m_widget);
2825
2826 if (!context)
2827 return 0;
2828
2829 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
2830 PangoLayout *layout = pango_layout_new(context);
2831 pango_layout_set_font_description(layout, desc);
2832 pango_layout_set_text(layout, "H", 1);
2833 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2834
2835 PangoRectangle rect;
2836 pango_layout_line_get_extents(line, NULL, &rect);
2837
2838 g_object_unref (layout);
2839
2840 return (int) PANGO_PIXELS(rect.height);
2841 }
2842
2843 int wxWindowGTK::GetCharWidth() const
2844 {
2845 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
2846
2847 wxFont font = GetFont();
2848 wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
2849
2850 PangoContext* context = gtk_widget_get_pango_context(m_widget);
2851
2852 if (!context)
2853 return 0;
2854
2855 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
2856 PangoLayout *layout = pango_layout_new(context);
2857 pango_layout_set_font_description(layout, desc);
2858 pango_layout_set_text(layout, "g", 1);
2859 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2860
2861 PangoRectangle rect;
2862 pango_layout_line_get_extents(line, NULL, &rect);
2863
2864 g_object_unref (layout);
2865
2866 return (int) PANGO_PIXELS(rect.width);
2867 }
2868
2869 void wxWindowGTK::DoGetTextExtent( const wxString& string,
2870 int *x,
2871 int *y,
2872 int *descent,
2873 int *externalLeading,
2874 const wxFont *theFont ) const
2875 {
2876 wxFont fontToUse = theFont ? *theFont : GetFont();
2877
2878 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
2879
2880 if (string.empty())
2881 {
2882 if (x) (*x) = 0;
2883 if (y) (*y) = 0;
2884 return;
2885 }
2886
2887 PangoContext *context = NULL;
2888 if (m_widget)
2889 context = gtk_widget_get_pango_context( m_widget );
2890
2891 if (!context)
2892 {
2893 if (x) (*x) = 0;
2894 if (y) (*y) = 0;
2895 return;
2896 }
2897
2898 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
2899 PangoLayout *layout = pango_layout_new(context);
2900 pango_layout_set_font_description(layout, desc);
2901 {
2902 const wxCharBuffer data = wxGTK_CONV( string );
2903 if ( data )
2904 pango_layout_set_text(layout, data, strlen(data));
2905 }
2906
2907 PangoRectangle rect;
2908 pango_layout_get_extents(layout, NULL, &rect);
2909
2910 if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width);
2911 if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height);
2912 if (descent)
2913 {
2914 PangoLayoutIter *iter = pango_layout_get_iter(layout);
2915 int baseline = pango_layout_iter_get_baseline(iter);
2916 pango_layout_iter_free(iter);
2917 *descent = *y - PANGO_PIXELS(baseline);
2918 }
2919 if (externalLeading) (*externalLeading) = 0; // ??
2920
2921 g_object_unref (layout);
2922 }
2923
2924 void wxWindowGTK::GTKDisableFocusOutEvent()
2925 {
2926 g_signal_handlers_block_by_func( m_focusWidget,
2927 (gpointer) gtk_window_focus_out_callback, this);
2928 }
2929
2930 void wxWindowGTK::GTKEnableFocusOutEvent()
2931 {
2932 g_signal_handlers_unblock_by_func( m_focusWidget,
2933 (gpointer) gtk_window_focus_out_callback, this);
2934 }
2935
2936 bool wxWindowGTK::GTKHandleFocusIn()
2937 {
2938 // Disable default focus handling for custom windows since the default GTK+
2939 // handler issues a repaint
2940 const bool retval = m_wxwindow ? true : false;
2941
2942
2943 // NB: if there's still unprocessed deferred focus-out event (see
2944 // GTKHandleFocusOut() for explanation), we need to process it first so
2945 // that the order of focus events -- focus-out first, then focus-in
2946 // elsewhere -- is preserved
2947 if ( gs_deferredFocusOut )
2948 {
2949 if ( GTKNeedsToFilterSameWindowFocus() &&
2950 gs_deferredFocusOut == this )
2951 {
2952 // GTK+ focus changed from this wxWindow back to itself, so don't
2953 // emit any events at all
2954 wxLogTrace(TRACE_FOCUS,
2955 "filtered out spurious focus change within %s(%p, %s)",
2956 GetClassInfo()->GetClassName(), this, GetLabel());
2957 gs_deferredFocusOut = NULL;
2958 return retval;
2959 }
2960
2961 // otherwise we need to send focus-out first
2962 wxASSERT_MSG ( gs_deferredFocusOut != this,
2963 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
2964 GTKHandleDeferredFocusOut();
2965 }
2966
2967
2968 wxLogTrace(TRACE_FOCUS,
2969 "handling focus_in event for %s(%p, %s)",
2970 GetClassInfo()->GetClassName(), this, GetLabel());
2971
2972 if (m_imData)
2973 gtk_im_context_focus_in(m_imData->context);
2974
2975 gs_currentFocus = this;
2976 gs_pendingFocus = NULL;
2977
2978 #if wxUSE_CARET
2979 // caret needs to be informed about focus change
2980 wxCaret *caret = GetCaret();
2981 if ( caret )
2982 {
2983 caret->OnSetFocus();
2984 }
2985 #endif // wxUSE_CARET
2986
2987 // Notify the parent keeping track of focus for the kbd navigation
2988 // purposes that we got it.
2989 wxChildFocusEvent eventChildFocus(static_cast<wxWindow*>(this));
2990 GTKProcessEvent(eventChildFocus);
2991
2992 wxFocusEvent eventFocus(wxEVT_SET_FOCUS, GetId());
2993 eventFocus.SetEventObject(this);
2994 GTKProcessEvent(eventFocus);
2995
2996 return retval;
2997 }
2998
2999 bool wxWindowGTK::GTKHandleFocusOut()
3000 {
3001 // Disable default focus handling for custom windows since the default GTK+
3002 // handler issues a repaint
3003 const bool retval = m_wxwindow ? true : false;
3004
3005
3006 // NB: If a control is composed of several GtkWidgets and when focus
3007 // changes from one of them to another within the same wxWindow, we get
3008 // a focus-out event followed by focus-in for another GtkWidget owned
3009 // by the same wx control. We don't want to generate two spurious
3010 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3011 // from GTKHandleFocusOut() until we know for sure it's not coming back
3012 // (i.e. in GTKHandleFocusIn() or at idle time).
3013 if ( GTKNeedsToFilterSameWindowFocus() )
3014 {
3015 wxASSERT_MSG( gs_deferredFocusOut == NULL,
3016 "deferred focus out event already pending" );
3017 wxLogTrace(TRACE_FOCUS,
3018 "deferring focus_out event for %s(%p, %s)",
3019 GetClassInfo()->GetClassName(), this, GetLabel());
3020 gs_deferredFocusOut = this;
3021 return retval;
3022 }
3023
3024 GTKHandleFocusOutNoDeferring();
3025
3026 return retval;
3027 }
3028
3029 void wxWindowGTK::GTKHandleFocusOutNoDeferring()
3030 {
3031 wxLogTrace(TRACE_FOCUS,
3032 "handling focus_out event for %s(%p, %s)",
3033 GetClassInfo()->GetClassName(), this, GetLabel());
3034
3035 if (m_imData)
3036 gtk_im_context_focus_out(m_imData->context);
3037
3038 if ( gs_currentFocus != this )
3039 {
3040 // Something is terribly wrong, gs_currentFocus is out of sync with the
3041 // real focus. We will reset it to NULL anyway, because after this
3042 // focus-out event is handled, one of the following with happen:
3043 //
3044 // * either focus will go out of the app altogether, in which case
3045 // gs_currentFocus _should_ be NULL
3046 //
3047 // * or it goes to another control, in which case focus-in event will
3048 // follow immediately and it will set gs_currentFocus to the right
3049 // value
3050 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3051 GetClassInfo()->GetClassName(), this, GetLabel());
3052 }
3053 gs_currentFocus = NULL;
3054
3055 #if wxUSE_CARET
3056 // caret needs to be informed about focus change
3057 wxCaret *caret = GetCaret();
3058 if ( caret )
3059 {
3060 caret->OnKillFocus();
3061 }
3062 #endif // wxUSE_CARET
3063
3064 wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
3065 event.SetEventObject( this );
3066 GTKProcessEvent( event );
3067 }
3068
3069 /*static*/
3070 void wxWindowGTK::GTKHandleDeferredFocusOut()
3071 {
3072 // NB: See GTKHandleFocusOut() for explanation. This function is called
3073 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3074 // deferred event.
3075 if ( gs_deferredFocusOut )
3076 {
3077 wxWindowGTK *win = gs_deferredFocusOut;
3078 gs_deferredFocusOut = NULL;
3079
3080 wxLogTrace(TRACE_FOCUS,
3081 "processing deferred focus_out event for %s(%p, %s)",
3082 win->GetClassInfo()->GetClassName(), win, win->GetLabel());
3083
3084 win->GTKHandleFocusOutNoDeferring();
3085 }
3086 }
3087
3088 void wxWindowGTK::SetFocus()
3089 {
3090 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3091
3092 // Setting "physical" focus is not immediate in GTK+ and while
3093 // gtk_widget_is_focus ("determines if the widget is the focus widget
3094 // within its toplevel", i.e. returns true for one widget per TLW, not
3095 // globally) returns true immediately after grabbing focus,
3096 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3097 // has focus at the moment) takes affect only after the window is shown
3098 // (if it was hidden at the moment of the call) or at the next event loop
3099 // iteration.
3100 //
3101 // Because we want to FindFocus() call immediately following
3102 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3103 // ourselves.
3104 gs_pendingFocus = this;
3105
3106 GtkWidget *widget = m_wxwindow ? m_wxwindow : m_focusWidget;
3107
3108 if ( GTK_IS_CONTAINER(widget) &&
3109 !GTK_WIDGET_CAN_FOCUS(widget) )
3110 {
3111 wxLogTrace(TRACE_FOCUS,
3112 wxT("Setting focus to a child of %s(%p, %s)"),
3113 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3114 gtk_widget_child_focus(widget, GTK_DIR_TAB_FORWARD);
3115 }
3116 else
3117 {
3118 wxLogTrace(TRACE_FOCUS,
3119 wxT("Setting focus to %s(%p, %s)"),
3120 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3121 gtk_widget_grab_focus(widget);
3122 }
3123 }
3124
3125 void wxWindowGTK::SetCanFocus(bool canFocus)
3126 {
3127 if ( canFocus )
3128 GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS);
3129 else
3130 GTK_WIDGET_UNSET_FLAGS(m_widget, GTK_CAN_FOCUS);
3131
3132 if ( m_wxwindow && (m_widget != m_wxwindow) )
3133 {
3134 if ( canFocus )
3135 GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
3136 else
3137 GTK_WIDGET_UNSET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
3138 }
3139 }
3140
3141 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3142 {
3143 wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
3144
3145 wxWindowGTK *oldParent = m_parent,
3146 *newParent = (wxWindowGTK *)newParentBase;
3147
3148 wxASSERT( GTK_IS_WIDGET(m_widget) );
3149
3150 if ( !wxWindowBase::Reparent(newParent) )
3151 return false;
3152
3153 wxASSERT( GTK_IS_WIDGET(m_widget) );
3154
3155 if (oldParent)
3156 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
3157
3158 wxASSERT( GTK_IS_WIDGET(m_widget) );
3159
3160 if (newParent)
3161 {
3162 if (GTK_WIDGET_VISIBLE (newParent->m_widget))
3163 {
3164 m_showOnIdle = true;
3165 gtk_widget_hide( m_widget );
3166 }
3167 /* insert GTK representation */
3168 newParent->AddChildGTK(this);
3169 }
3170
3171 SetLayoutDirection(wxLayout_Default);
3172
3173 return true;
3174 }
3175
3176 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3177 {
3178 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3179 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3180
3181 /* add to list */
3182 AddChild( child );
3183
3184 /* insert GTK representation */
3185 AddChildGTK(child);
3186 }
3187
3188 void wxWindowGTK::AddChild(wxWindowBase *child)
3189 {
3190 wxWindowBase::AddChild(child);
3191 m_dirtyTabOrder = true;
3192 wxTheApp->WakeUpIdle();
3193 }
3194
3195 void wxWindowGTK::RemoveChild(wxWindowBase *child)
3196 {
3197 wxWindowBase::RemoveChild(child);
3198 m_dirtyTabOrder = true;
3199 wxTheApp->WakeUpIdle();
3200 }
3201
3202 /* static */
3203 wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
3204 {
3205 return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL
3206 ? wxLayout_RightToLeft
3207 : wxLayout_LeftToRight;
3208 }
3209
3210 /* static */
3211 void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir)
3212 {
3213 wxASSERT_MSG( dir != wxLayout_Default, wxT("invalid layout direction") );
3214
3215 gtk_widget_set_direction(widget,
3216 dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
3217 : GTK_TEXT_DIR_LTR);
3218 }
3219
3220 wxLayoutDirection wxWindowGTK::GetLayoutDirection() const
3221 {
3222 return GTKGetLayout(m_widget);
3223 }
3224
3225 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir)
3226 {
3227 if ( dir == wxLayout_Default )
3228 {
3229 const wxWindow *const parent = GetParent();
3230 if ( parent )
3231 {
3232 // inherit layout from parent.
3233 dir = parent->GetLayoutDirection();
3234 }
3235 else // no parent, use global default layout
3236 {
3237 dir = wxTheApp->GetLayoutDirection();
3238 }
3239 }
3240
3241 if ( dir == wxLayout_Default )
3242 return;
3243
3244 GTKSetLayout(m_widget, dir);
3245
3246 if (m_wxwindow && (m_wxwindow != m_widget))
3247 GTKSetLayout(m_wxwindow, dir);
3248 }
3249
3250 wxCoord
3251 wxWindowGTK::AdjustForLayoutDirection(wxCoord x,
3252 wxCoord WXUNUSED(width),
3253 wxCoord WXUNUSED(widthTotal)) const
3254 {
3255 // We now mirror the coordinates of RTL windows in wxPizza
3256 return x;
3257 }
3258
3259 void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, WindowOrder move)
3260 {
3261 wxWindowBase::DoMoveInTabOrder(win, move);
3262 m_dirtyTabOrder = true;
3263 wxTheApp->WakeUpIdle();
3264 }
3265
3266 bool wxWindowGTK::DoNavigateIn(int flags)
3267 {
3268 if ( flags & wxNavigationKeyEvent::WinChange )
3269 {
3270 wxFAIL_MSG( wxT("not implemented") );
3271
3272 return false;
3273 }
3274 else // navigate inside the container
3275 {
3276 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3277 wxCHECK_MSG( parent, false, wxT("every window must have a TLW parent") );
3278
3279 GtkDirectionType dir;
3280 dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD
3281 : GTK_DIR_TAB_BACKWARD;
3282
3283 gboolean rc;
3284 g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
3285
3286 return rc == TRUE;
3287 }
3288 }
3289
3290 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3291 {
3292 // none needed by default
3293 return false;
3294 }
3295
3296 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget* WXUNUSED(w))
3297 {
3298 // nothing to do by default since none is needed
3299 }
3300
3301 void wxWindowGTK::RealizeTabOrder()
3302 {
3303 if (m_wxwindow)
3304 {
3305 if ( !m_children.empty() )
3306 {
3307 // we don't only construct the correct focus chain but also use
3308 // this opportunity to update the mnemonic widgets for the widgets
3309 // that need them
3310
3311 GList *chain = NULL;
3312 wxWindowGTK* mnemonicWindow = NULL;
3313
3314 for ( wxWindowList::const_iterator i = m_children.begin();
3315 i != m_children.end();
3316 ++i )
3317 {
3318 wxWindowGTK *win = *i;
3319
3320 if ( mnemonicWindow )
3321 {
3322 if ( win->AcceptsFocusFromKeyboard() )
3323 {
3324 // wxComboBox et al. needs to focus on on a different
3325 // widget than m_widget, so if the main widget isn't
3326 // focusable try the connect widget
3327 GtkWidget* w = win->m_widget;
3328 if ( !GTK_WIDGET_CAN_FOCUS(w) )
3329 {
3330 w = win->GetConnectWidget();
3331 if ( !GTK_WIDGET_CAN_FOCUS(w) )
3332 w = NULL;
3333 }
3334
3335 if ( w )
3336 {
3337 mnemonicWindow->GTKWidgetDoSetMnemonic(w);
3338 mnemonicWindow = NULL;
3339 }
3340 }
3341 }
3342 else if ( win->GTKWidgetNeedsMnemonic() )
3343 {
3344 mnemonicWindow = win;
3345 }
3346
3347 chain = g_list_prepend(chain, win->m_widget);
3348 }
3349
3350 chain = g_list_reverse(chain);
3351
3352 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain);
3353 g_list_free(chain);
3354 }
3355 else // no children
3356 {
3357 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow));
3358 }
3359 }
3360 }
3361
3362 void wxWindowGTK::Raise()
3363 {
3364 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3365
3366 if (m_wxwindow && m_wxwindow->window)
3367 {
3368 gdk_window_raise( m_wxwindow->window );
3369 }
3370 else if (m_widget->window)
3371 {
3372 gdk_window_raise( m_widget->window );
3373 }
3374 }
3375
3376 void wxWindowGTK::Lower()
3377 {
3378 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3379
3380 if (m_wxwindow && m_wxwindow->window)
3381 {
3382 gdk_window_lower( m_wxwindow->window );
3383 }
3384 else if (m_widget->window)
3385 {
3386 gdk_window_lower( m_widget->window );
3387 }
3388 }
3389
3390 bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3391 {
3392 if ( !wxWindowBase::SetCursor(cursor.Ok() ? cursor : *wxSTANDARD_CURSOR) )
3393 return false;
3394
3395 GTKUpdateCursor();
3396
3397 return true;
3398 }
3399
3400 void wxWindowGTK::GTKUpdateCursor(bool update_self /*=true*/, bool recurse /*=true*/)
3401 {
3402 if (update_self)
3403 {
3404 wxCursor cursor(g_globalCursor.Ok() ? g_globalCursor : GetCursor());
3405 if ( cursor.Ok() )
3406 {
3407 wxArrayGdkWindows windowsThis;
3408 GdkWindow* window = GTKGetWindow(windowsThis);
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 // It can be zero if the window has not been realized yet.
3418 if ( win )
3419 {
3420 gdk_window_set_cursor(win, cursor.GetCursor());
3421 }
3422 }
3423 }
3424 }
3425 }
3426
3427 if (recurse)
3428 {
3429 for (wxWindowList::iterator it = GetChildren().begin(); it != GetChildren().end(); ++it)
3430 {
3431 (*it)->GTKUpdateCursor( true );
3432 }
3433 }
3434 }
3435
3436 void wxWindowGTK::WarpPointer( int x, int y )
3437 {
3438 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3439
3440 // We provide this function ourselves as it is
3441 // missing in GDK (top of this file).
3442
3443 GdkWindow *window = NULL;
3444 if (m_wxwindow)
3445 window = m_wxwindow->window;
3446 else
3447 window = GetConnectWidget()->window;
3448
3449 if (window)
3450 gdk_window_warp_pointer( window, x, y );
3451 }
3452
3453 wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const
3454 {
3455 // find the scrollbar which generated the event
3456 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
3457 {
3458 if ( range == m_scrollBar[dir] )
3459 return (ScrollDir)dir;
3460 }
3461
3462 wxFAIL_MSG( wxT("event from unknown scrollbar received") );
3463
3464 return ScrollDir_Max;
3465 }
3466
3467 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units)
3468 {
3469 bool changed = false;
3470 GtkRange* range = m_scrollBar[dir];
3471 if ( range && units )
3472 {
3473 GtkAdjustment* adj = range->adjustment;
3474 gdouble inc = unit == ScrollUnit_Line ? adj->step_increment
3475 : adj->page_increment;
3476
3477 const int posOld = int(adj->value + 0.5);
3478 gtk_range_set_value(range, posOld + units*inc);
3479
3480 changed = int(adj->value + 0.5) != posOld;
3481 }
3482
3483 return changed;
3484 }
3485
3486 bool wxWindowGTK::ScrollLines(int lines)
3487 {
3488 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Line, lines);
3489 }
3490
3491 bool wxWindowGTK::ScrollPages(int pages)
3492 {
3493 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages);
3494 }
3495
3496 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground),
3497 const wxRect *rect)
3498 {
3499 if ( !m_widget )
3500 {
3501 // it is valid to call Refresh() for a window which hasn't been created
3502 // yet, it simply doesn't do anything in this case
3503 return;
3504 }
3505
3506 if (!m_wxwindow)
3507 {
3508 if (rect)
3509 gtk_widget_queue_draw_area( m_widget, rect->x, rect->y, rect->width, rect->height );
3510 else
3511 gtk_widget_queue_draw( m_widget );
3512 }
3513 else
3514 {
3515 // Just return if the widget or one of its ancestors isn't mapped
3516 GtkWidget *w;
3517 for (w = m_wxwindow; w != NULL; w = w->parent)
3518 if (!GTK_WIDGET_MAPPED (w))
3519 return;
3520
3521 GdkWindow* window = GTKGetDrawingWindow();
3522 if (rect)
3523 {
3524 int x = rect->x;
3525 if (GetLayoutDirection() == wxLayout_RightToLeft)
3526 x = GetClientSize().x - x - rect->width;
3527 GdkRectangle r;
3528 r.x = rect->x;
3529 r.y = rect->y;
3530 r.width = rect->width;
3531 r.height = rect->height;
3532 gdk_window_invalidate_rect(window, &r, true);
3533 }
3534 else
3535 gdk_window_invalidate_rect(window, NULL, true);
3536 }
3537 }
3538
3539 void wxWindowGTK::Update()
3540 {
3541 if (m_widget && GTK_WIDGET_MAPPED(m_widget))
3542 {
3543 GdkDisplay* display = gtk_widget_get_display(m_widget);
3544 // Flush everything out to the server, and wait for it to finish.
3545 // This ensures nothing will overwrite the drawing we are about to do.
3546 gdk_display_sync(display);
3547
3548 GdkWindow* window = GTKGetDrawingWindow();
3549 if (window == NULL)
3550 window = m_widget->window;
3551 gdk_window_process_updates(window, true);
3552
3553 // Flush again, but no need to wait for it to finish
3554 gdk_display_flush(display);
3555 }
3556 }
3557
3558 bool wxWindowGTK::DoIsExposed( int x, int y ) const
3559 {
3560 return m_updateRegion.Contains(x, y) != wxOutRegion;
3561 }
3562
3563 bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const
3564 {
3565 if (GetLayoutDirection() == wxLayout_RightToLeft)
3566 return m_updateRegion.Contains(x-w, y, w, h) != wxOutRegion;
3567 else
3568 return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
3569 }
3570
3571 void wxWindowGTK::GtkSendPaintEvents()
3572 {
3573 if (!m_wxwindow)
3574 {
3575 m_updateRegion.Clear();
3576 return;
3577 }
3578
3579 // Clip to paint region in wxClientDC
3580 m_clipPaintRegion = true;
3581
3582 m_nativeUpdateRegion = m_updateRegion;
3583
3584 if (GetLayoutDirection() == wxLayout_RightToLeft)
3585 {
3586 // Transform m_updateRegion under RTL
3587 m_updateRegion.Clear();
3588
3589 gint width;
3590 gdk_drawable_get_size(m_wxwindow->window, &width, NULL);
3591
3592 wxRegionIterator upd( m_nativeUpdateRegion );
3593 while (upd)
3594 {
3595 wxRect rect;
3596 rect.x = upd.GetX();
3597 rect.y = upd.GetY();
3598 rect.width = upd.GetWidth();
3599 rect.height = upd.GetHeight();
3600
3601 rect.x = width - rect.x - rect.width;
3602 m_updateRegion.Union( rect );
3603
3604 ++upd;
3605 }
3606 }
3607
3608 switch ( GetBackgroundStyle() )
3609 {
3610 case wxBG_STYLE_ERASE:
3611 {
3612 wxWindowDC dc( (wxWindow*)this );
3613 dc.SetDeviceClippingRegion( m_updateRegion );
3614
3615 // Work around gtk-qt <= 0.60 bug whereby the window colour
3616 // remains grey
3617 if ( UseBgCol() &&
3618 wxSystemOptions::
3619 GetOptionInt("gtk.window.force-background-colour") )
3620 {
3621 dc.SetBackground(GetBackgroundColour());
3622 dc.Clear();
3623 }
3624
3625 wxEraseEvent erase_event( GetId(), &dc );
3626 erase_event.SetEventObject( this );
3627
3628 if ( HandleWindowEvent(erase_event) )
3629 {
3630 // background erased, don't do it again
3631 break;
3632 }
3633 }
3634 // fall through
3635
3636 case wxBG_STYLE_SYSTEM:
3637 if ( GetThemeEnabled() )
3638 {
3639 // find ancestor from which to steal background
3640 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3641 if (!parent)
3642 parent = (wxWindow*)this;
3643
3644 if (GTK_WIDGET_MAPPED(parent->m_widget))
3645 {
3646 wxRegionIterator upd( m_nativeUpdateRegion );
3647 while (upd)
3648 {
3649 GdkRectangle rect;
3650 rect.x = upd.GetX();
3651 rect.y = upd.GetY();
3652 rect.width = upd.GetWidth();
3653 rect.height = upd.GetHeight();
3654
3655 gtk_paint_flat_box( parent->m_widget->style,
3656 GTKGetDrawingWindow(),
3657 (GtkStateType)GTK_WIDGET_STATE(m_wxwindow),
3658 GTK_SHADOW_NONE,
3659 &rect,
3660 parent->m_widget,
3661 (char *)"base",
3662 0, 0, -1, -1 );
3663
3664 ++upd;
3665 }
3666 }
3667 }
3668 break;
3669
3670 case wxBG_STYLE_PAINT:
3671 // nothing to do: window will be painted over in EVT_PAINT
3672 break;
3673
3674 default:
3675 wxFAIL_MSG( "unsupported background style" );
3676 }
3677
3678 wxNcPaintEvent nc_paint_event( GetId() );
3679 nc_paint_event.SetEventObject( this );
3680 HandleWindowEvent( nc_paint_event );
3681
3682 wxPaintEvent paint_event( GetId() );
3683 paint_event.SetEventObject( this );
3684 HandleWindowEvent( paint_event );
3685
3686 m_clipPaintRegion = false;
3687
3688 m_updateRegion.Clear();
3689 m_nativeUpdateRegion.Clear();
3690 }
3691
3692 void wxWindowGTK::SetDoubleBuffered( bool on )
3693 {
3694 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3695
3696 if ( m_wxwindow )
3697 gtk_widget_set_double_buffered( m_wxwindow, on );
3698 }
3699
3700 bool wxWindowGTK::IsDoubleBuffered() const
3701 {
3702 return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow );
3703 }
3704
3705 void wxWindowGTK::ClearBackground()
3706 {
3707 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3708 }
3709
3710 #if wxUSE_TOOLTIPS
3711 void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3712 {
3713 wxWindowBase::DoSetToolTip(tip);
3714
3715 if (m_tooltip)
3716 {
3717 m_tooltip->GTKApply( (wxWindow *)this );
3718 }
3719 else
3720 {
3721 GtkWidget *w = GetConnectWidget();
3722 wxToolTip::GTKApply(w, NULL);
3723 #if GTK_CHECK_VERSION(2, 12, 0)
3724 // Just applying NULL doesn't work on 2.12.0, so also use
3725 // gtk_widget_set_has_tooltip. It is part of the new GtkTooltip API
3726 // but seems also to work with the old GtkTooltips.
3727 if (gtk_check_version(2, 12, 0) == NULL)
3728 gtk_widget_set_has_tooltip(w, FALSE);
3729 #endif
3730 }
3731 }
3732
3733 void wxWindowGTK::GTKApplyToolTip( GtkTooltips *tips, const gchar *tip )
3734 {
3735 gtk_tooltips_set_tip(tips, GetConnectWidget(), tip, NULL);
3736 }
3737 #endif // wxUSE_TOOLTIPS
3738
3739 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
3740 {
3741 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3742
3743 if (!wxWindowBase::SetBackgroundColour(colour))
3744 return false;
3745
3746 if (colour.Ok())
3747 {
3748 // We need the pixel value e.g. for background clearing.
3749 m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3750 }
3751
3752 // apply style change (forceStyle=true so that new style is applied
3753 // even if the bg colour changed from valid to wxNullColour)
3754 GTKApplyWidgetStyle(true);
3755
3756 return true;
3757 }
3758
3759 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
3760 {
3761 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3762
3763 if (!wxWindowBase::SetForegroundColour(colour))
3764 {
3765 return false;
3766 }
3767
3768 if (colour.Ok())
3769 {
3770 // We need the pixel value e.g. for background clearing.
3771 m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3772 }
3773
3774 // apply style change (forceStyle=true so that new style is applied
3775 // even if the bg colour changed from valid to wxNullColour):
3776 GTKApplyWidgetStyle(true);
3777
3778 return true;
3779 }
3780
3781 PangoContext *wxWindowGTK::GTKGetPangoDefaultContext()
3782 {
3783 return gtk_widget_get_pango_context( m_widget );
3784 }
3785
3786 GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle)
3787 {
3788 // do we need to apply any changes at all?
3789 if ( !forceStyle &&
3790 !m_font.Ok() &&
3791 !m_foregroundColour.Ok() && !m_backgroundColour.Ok() )
3792 {
3793 return NULL;
3794 }
3795
3796 GtkRcStyle *style = gtk_rc_style_new();
3797
3798 if ( m_font.Ok() )
3799 {
3800 style->font_desc =
3801 pango_font_description_copy( m_font.GetNativeFontInfo()->description );
3802 }
3803
3804 int flagsNormal = 0,
3805 flagsPrelight = 0,
3806 flagsActive = 0,
3807 flagsInsensitive = 0;
3808
3809 if ( m_foregroundColour.Ok() )
3810 {
3811 const GdkColor *fg = m_foregroundColour.GetColor();
3812
3813 style->fg[GTK_STATE_NORMAL] =
3814 style->text[GTK_STATE_NORMAL] = *fg;
3815 flagsNormal |= GTK_RC_FG | GTK_RC_TEXT;
3816
3817 style->fg[GTK_STATE_PRELIGHT] =
3818 style->text[GTK_STATE_PRELIGHT] = *fg;
3819 flagsPrelight |= GTK_RC_FG | GTK_RC_TEXT;
3820
3821 style->fg[GTK_STATE_ACTIVE] =
3822 style->text[GTK_STATE_ACTIVE] = *fg;
3823 flagsActive |= GTK_RC_FG | GTK_RC_TEXT;
3824 }
3825
3826 if ( m_backgroundColour.Ok() )
3827 {
3828 const GdkColor *bg = m_backgroundColour.GetColor();
3829
3830 style->bg[GTK_STATE_NORMAL] =
3831 style->base[GTK_STATE_NORMAL] = *bg;
3832 flagsNormal |= GTK_RC_BG | GTK_RC_BASE;
3833
3834 style->bg[GTK_STATE_PRELIGHT] =
3835 style->base[GTK_STATE_PRELIGHT] = *bg;
3836 flagsPrelight |= GTK_RC_BG | GTK_RC_BASE;
3837
3838 style->bg[GTK_STATE_ACTIVE] =
3839 style->base[GTK_STATE_ACTIVE] = *bg;
3840 flagsActive |= GTK_RC_BG | GTK_RC_BASE;
3841
3842 style->bg[GTK_STATE_INSENSITIVE] =
3843 style->base[GTK_STATE_INSENSITIVE] = *bg;
3844 flagsInsensitive |= GTK_RC_BG | GTK_RC_BASE;
3845 }
3846
3847 style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)flagsNormal;
3848 style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)flagsPrelight;
3849 style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)flagsActive;
3850 style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)flagsInsensitive;
3851
3852 return style;
3853 }
3854
3855 void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle)
3856 {
3857 GtkRcStyle *style = GTKCreateWidgetStyle(forceStyle);
3858 if ( style )
3859 {
3860 DoApplyWidgetStyle(style);
3861 gtk_rc_style_unref(style);
3862 }
3863
3864 // Style change may affect GTK+'s size calculation:
3865 InvalidateBestSize();
3866 }
3867
3868 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
3869 {
3870 if ( m_wxwindow )
3871 {
3872 // block the signal temporarily to avoid sending
3873 // wxSysColourChangedEvents when we change the colours ourselves
3874 bool unblock = false;
3875 if ( IsTopLevel() )
3876 {
3877 unblock = true;
3878 g_signal_handlers_block_by_func(
3879 m_wxwindow, (void *)gtk_window_style_set_callback, this);
3880 }
3881
3882 gtk_widget_modify_style(m_wxwindow, style);
3883
3884 if ( unblock )
3885 {
3886 g_signal_handlers_unblock_by_func(
3887 m_wxwindow, (void *)gtk_window_style_set_callback, this);
3888 }
3889 }
3890 else
3891 {
3892 gtk_widget_modify_style(m_widget, style);
3893 }
3894 }
3895
3896 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
3897 {
3898 wxWindowBase::SetBackgroundStyle(style);
3899
3900 if ( style == wxBG_STYLE_PAINT )
3901 {
3902 GdkWindow *window;
3903 if ( m_wxwindow )
3904 {
3905 window = GTKGetDrawingWindow();
3906 }
3907 else
3908 {
3909 GtkWidget * const w = GetConnectWidget();
3910 window = w ? w->window : NULL;
3911 }
3912
3913 if (window)
3914 {
3915 // Make sure GDK/X11 doesn't refresh the window
3916 // automatically.
3917 gdk_window_set_back_pixmap( window, None, False );
3918 #ifdef __X__
3919 Display* display = GDK_WINDOW_DISPLAY(window);
3920 XFlush(display);
3921 #endif
3922 m_needsStyleChange = false;
3923 }
3924 else // window not realized yet
3925 {
3926 // Do in OnIdle, because the window is not yet available
3927 m_needsStyleChange = true;
3928 }
3929
3930 // Don't apply widget style, or we get a grey background
3931 }
3932 else
3933 {
3934 // apply style change (forceStyle=true so that new style is applied
3935 // even if the bg colour changed from valid to wxNullColour):
3936 GTKApplyWidgetStyle(true);
3937 }
3938
3939 return true;
3940 }
3941
3942 // ----------------------------------------------------------------------------
3943 // Pop-up menu stuff
3944 // ----------------------------------------------------------------------------
3945
3946 #if wxUSE_MENUS_NATIVE
3947
3948 extern "C" {
3949 static
3950 void wxPopupMenuPositionCallback( GtkMenu *menu,
3951 gint *x, gint *y,
3952 gboolean * WXUNUSED(whatever),
3953 gpointer user_data )
3954 {
3955 // ensure that the menu appears entirely on screen
3956 GtkRequisition req;
3957 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
3958
3959 wxSize sizeScreen = wxGetDisplaySize();
3960 wxPoint *pos = (wxPoint*)user_data;
3961
3962 gint xmax = sizeScreen.x - req.width,
3963 ymax = sizeScreen.y - req.height;
3964
3965 *x = pos->x < xmax ? pos->x : xmax;
3966 *y = pos->y < ymax ? pos->y : ymax;
3967 }
3968 }
3969
3970 bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
3971 {
3972 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3973
3974 menu->UpdateUI();
3975
3976 wxPoint pos;
3977 gpointer userdata;
3978 GtkMenuPositionFunc posfunc;
3979 if ( x == -1 && y == -1 )
3980 {
3981 // use GTK's default positioning algorithm
3982 userdata = NULL;
3983 posfunc = NULL;
3984 }
3985 else
3986 {
3987 pos = ClientToScreen(wxPoint(x, y));
3988 userdata = &pos;
3989 posfunc = wxPopupMenuPositionCallback;
3990 }
3991
3992 menu->m_popupShown = true;
3993 gtk_menu_popup(
3994 GTK_MENU(menu->m_menu),
3995 NULL, // parent menu shell
3996 NULL, // parent menu item
3997 posfunc, // function to position it
3998 userdata, // client data
3999 0, // button used to activate it
4000 gtk_get_current_event_time()
4001 );
4002
4003 while (menu->m_popupShown)
4004 {
4005 gtk_main_iteration();
4006 }
4007
4008 return true;
4009 }
4010
4011 #endif // wxUSE_MENUS_NATIVE
4012
4013 #if wxUSE_DRAG_AND_DROP
4014
4015 void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
4016 {
4017 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4018
4019 GtkWidget *dnd_widget = GetConnectWidget();
4020
4021 if (m_dropTarget) m_dropTarget->GtkUnregisterWidget( dnd_widget );
4022
4023 if (m_dropTarget) delete m_dropTarget;
4024 m_dropTarget = dropTarget;
4025
4026 if (m_dropTarget) m_dropTarget->GtkRegisterWidget( dnd_widget );
4027 }
4028
4029 #endif // wxUSE_DRAG_AND_DROP
4030
4031 GtkWidget* wxWindowGTK::GetConnectWidget()
4032 {
4033 GtkWidget *connect_widget = m_widget;
4034 if (m_wxwindow) connect_widget = m_wxwindow;
4035
4036 return connect_widget;
4037 }
4038
4039 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const
4040 {
4041 wxArrayGdkWindows windowsThis;
4042 GdkWindow * const winThis = GTKGetWindow(windowsThis);
4043
4044 return winThis ? window == winThis
4045 : windowsThis.Index(window) != wxNOT_FOUND;
4046 }
4047
4048 GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
4049 {
4050 return m_wxwindow ? GTKGetDrawingWindow() : m_widget->window;
4051 }
4052
4053 bool wxWindowGTK::SetFont( const wxFont &font )
4054 {
4055 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4056
4057 if (!wxWindowBase::SetFont(font))
4058 return false;
4059
4060 // apply style change (forceStyle=true so that new style is applied
4061 // even if the font changed from valid to wxNullFont):
4062 GTKApplyWidgetStyle(true);
4063
4064 return true;
4065 }
4066
4067 void wxWindowGTK::DoCaptureMouse()
4068 {
4069 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4070
4071 GdkWindow *window = NULL;
4072 if (m_wxwindow)
4073 window = GTKGetDrawingWindow();
4074 else
4075 window = GetConnectWidget()->window;
4076
4077 wxCHECK_RET( window, wxT("CaptureMouse() failed") );
4078
4079 const wxCursor* cursor = &m_cursor;
4080 if (!cursor->Ok())
4081 cursor = wxSTANDARD_CURSOR;
4082
4083 gdk_pointer_grab( window, FALSE,
4084 (GdkEventMask)
4085 (GDK_BUTTON_PRESS_MASK |
4086 GDK_BUTTON_RELEASE_MASK |
4087 GDK_POINTER_MOTION_HINT_MASK |
4088 GDK_POINTER_MOTION_MASK),
4089 NULL,
4090 cursor->GetCursor(),
4091 (guint32)GDK_CURRENT_TIME );
4092 g_captureWindow = this;
4093 g_captureWindowHasMouse = true;
4094 }
4095
4096 void wxWindowGTK::DoReleaseMouse()
4097 {
4098 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4099
4100 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
4101
4102 g_captureWindow = NULL;
4103
4104 GdkWindow *window = NULL;
4105 if (m_wxwindow)
4106 window = GTKGetDrawingWindow();
4107 else
4108 window = GetConnectWidget()->window;
4109
4110 if (!window)
4111 return;
4112
4113 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
4114 }
4115
4116 void wxWindowGTK::GTKReleaseMouseAndNotify()
4117 {
4118 DoReleaseMouse();
4119 wxMouseCaptureLostEvent evt(GetId());
4120 evt.SetEventObject( this );
4121 HandleWindowEvent( evt );
4122 }
4123
4124 /* static */
4125 wxWindow *wxWindowBase::GetCapture()
4126 {
4127 return (wxWindow *)g_captureWindow;
4128 }
4129
4130 bool wxWindowGTK::IsRetained() const
4131 {
4132 return false;
4133 }
4134
4135 void wxWindowGTK::SetScrollbar(int orient,
4136 int pos,
4137 int thumbVisible,
4138 int range,
4139 bool WXUNUSED(update))
4140 {
4141 const int dir = ScrollDirFromOrient(orient);
4142 GtkRange* const sb = m_scrollBar[dir];
4143 wxCHECK_RET( sb, wxT("this window is not scrollable") );
4144
4145 if (range <= 0)
4146 {
4147 // GtkRange requires upper > lower
4148 range =
4149 thumbVisible = 1;
4150 }
4151
4152 GtkAdjustment * const adj = sb->adjustment;
4153 adj->step_increment = 1;
4154 adj->page_increment =
4155 adj->page_size = thumbVisible;
4156 adj->value = pos;
4157
4158 g_signal_handlers_block_by_func(
4159 sb, (void*)gtk_scrollbar_value_changed, this);
4160
4161 gtk_range_set_range(sb, 0, range);
4162 m_scrollPos[dir] = sb->adjustment->value;
4163
4164 g_signal_handlers_unblock_by_func(
4165 sb, (void*)gtk_scrollbar_value_changed, this);
4166 }
4167
4168 void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
4169 {
4170 const int dir = ScrollDirFromOrient(orient);
4171 GtkRange * const sb = m_scrollBar[dir];
4172 wxCHECK_RET( sb, wxT("this window is not scrollable") );
4173
4174 // This check is more than an optimization. Without it, the slider
4175 // will not move smoothly while tracking when using wxScrollHelper.
4176 if (GetScrollPos(orient) != pos)
4177 {
4178 g_signal_handlers_block_by_func(
4179 sb, (void*)gtk_scrollbar_value_changed, this);
4180
4181 gtk_range_set_value(sb, pos);
4182 m_scrollPos[dir] = sb->adjustment->value;
4183
4184 g_signal_handlers_unblock_by_func(
4185 sb, (void*)gtk_scrollbar_value_changed, this);
4186 }
4187 }
4188
4189 int wxWindowGTK::GetScrollThumb(int orient) const
4190 {
4191 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4192 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4193
4194 return wxRound(sb->adjustment->page_size);
4195 }
4196
4197 int wxWindowGTK::GetScrollPos( int orient ) const
4198 {
4199 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4200 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4201
4202 return wxRound(sb->adjustment->value);
4203 }
4204
4205 int wxWindowGTK::GetScrollRange( int orient ) const
4206 {
4207 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4208 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4209
4210 return wxRound(sb->adjustment->upper);
4211 }
4212
4213 // Determine if increment is the same as +/-x, allowing for some small
4214 // difference due to possible inexactness in floating point arithmetic
4215 static inline bool IsScrollIncrement(double increment, double x)
4216 {
4217 wxASSERT(increment > 0);
4218 const double tolerance = 1.0 / 1024;
4219 return fabs(increment - fabs(x)) < tolerance;
4220 }
4221
4222 wxEventType wxWindowGTK::GTKGetScrollEventType(GtkRange* range)
4223 {
4224 wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
4225
4226 const int barIndex = range == m_scrollBar[1];
4227 GtkAdjustment* adj = range->adjustment;
4228
4229 const int value = wxRound(adj->value);
4230
4231 // save previous position
4232 const double oldPos = m_scrollPos[barIndex];
4233 // update current position
4234 m_scrollPos[barIndex] = adj->value;
4235 // If event should be ignored, or integral position has not changed
4236 if (!m_hasVMT || g_blockEventsOnDrag || value == wxRound(oldPos))
4237 {
4238 return wxEVT_NULL;
4239 }
4240
4241 wxEventType eventType = wxEVT_SCROLL_THUMBTRACK;
4242 if (!m_isScrolling)
4243 {
4244 // Difference from last change event
4245 const double diff = adj->value - oldPos;
4246 const bool isDown = diff > 0;
4247
4248 if (IsScrollIncrement(adj->step_increment, diff))
4249 {
4250 eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
4251 }
4252 else if (IsScrollIncrement(adj->page_increment, diff))
4253 {
4254 eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
4255 }
4256 else if (m_mouseButtonDown)
4257 {
4258 // Assume track event
4259 m_isScrolling = true;
4260 }
4261 }
4262 return eventType;
4263 }
4264
4265 void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4266 {
4267 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4268
4269 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4270
4271 // No scrolling requested.
4272 if ((dx == 0) && (dy == 0)) return;
4273
4274 m_clipPaintRegion = true;
4275
4276 WX_PIZZA(m_wxwindow)->scroll(dx, dy);
4277
4278 m_clipPaintRegion = false;
4279
4280 #if wxUSE_CARET
4281 bool restoreCaret = (GetCaret() != NULL && GetCaret()->IsVisible());
4282 if (restoreCaret)
4283 {
4284 wxRect caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4285 if (dx > 0)
4286 caretRect.width += dx;
4287 else
4288 {
4289 caretRect.x += dx; caretRect.width -= dx;
4290 }
4291 if (dy > 0)
4292 caretRect.height += dy;
4293 else
4294 {
4295 caretRect.y += dy; caretRect.height -= dy;
4296 }
4297
4298 RefreshRect(caretRect);
4299 }
4300 #endif // wxUSE_CARET
4301 }
4302
4303 void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
4304 {
4305 //RN: Note that static controls usually have no border on gtk, so maybe
4306 //it makes sense to treat that as simply no border at the wx level
4307 //as well...
4308 if (!(wxstyle & wxNO_BORDER) && !(wxstyle & wxBORDER_STATIC))
4309 {
4310 GtkShadowType gtkstyle;
4311
4312 if(wxstyle & wxBORDER_RAISED)
4313 gtkstyle = GTK_SHADOW_OUT;
4314 else if ((wxstyle & wxBORDER_SUNKEN) || (wxstyle & wxBORDER_THEME))
4315 gtkstyle = GTK_SHADOW_IN;
4316 #if 0
4317 // Now obsolete
4318 else if (wxstyle & wxBORDER_DOUBLE)
4319 gtkstyle = GTK_SHADOW_ETCHED_IN;
4320 #endif
4321 else //default
4322 gtkstyle = GTK_SHADOW_IN;
4323
4324 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w),
4325 gtkstyle );
4326 }
4327 }
4328
4329 void wxWindowGTK::SetWindowStyleFlag( long style )
4330 {
4331 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4332 wxWindowBase::SetWindowStyleFlag(style);
4333 }
4334
4335 // Find the wxWindow at the current mouse position, also returning the mouse
4336 // position.
4337 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4338 {
4339 pt = wxGetMousePosition();
4340 wxWindow* found = wxFindWindowAtPoint(pt);
4341 return found;
4342 }
4343
4344 // Get the current mouse position.
4345 wxPoint wxGetMousePosition()
4346 {
4347 /* This crashes when used within wxHelpContext,
4348 so we have to use the X-specific implementation below.
4349 gint x, y;
4350 GdkModifierType *mask;
4351 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4352
4353 return wxPoint(x, y);
4354 */
4355
4356 int x, y;
4357 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4358
4359 Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
4360 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4361 Window rootReturn, childReturn;
4362 int rootX, rootY, winX, winY;
4363 unsigned int maskReturn;
4364
4365 XQueryPointer (display,
4366 rootWindow,
4367 &rootReturn,
4368 &childReturn,
4369 &rootX, &rootY, &winX, &winY, &maskReturn);
4370 return wxPoint(rootX, rootY);
4371
4372 }
4373
4374 GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
4375 {
4376 GdkWindow* window = NULL;
4377 if (m_wxwindow)
4378 window = m_wxwindow->window;
4379 return window;
4380 }
4381
4382 // ----------------------------------------------------------------------------
4383 // freeze/thaw
4384 // ----------------------------------------------------------------------------
4385
4386 extern "C"
4387 {
4388
4389 // this is called if we attempted to freeze unrealized widget when it finally
4390 // is realized (and so can be frozen):
4391 static void wx_frozen_widget_realize(GtkWidget* w, wxWindowGTK* win)
4392 {
4393 wxASSERT( w && !GTK_WIDGET_NO_WINDOW(w) );
4394 wxASSERT( GTK_WIDGET_REALIZED(w) );
4395
4396 g_signal_handlers_disconnect_by_func
4397 (
4398 w,
4399 (void*)wx_frozen_widget_realize,
4400 win
4401 );
4402
4403 GdkWindow* window = w->window;
4404 if (w == win->m_wxwindow)
4405 window = win->GTKGetDrawingWindow();
4406 gdk_window_freeze_updates(window);
4407 }
4408
4409 } // extern "C"
4410
4411 void wxWindowGTK::GTKFreezeWidget(GtkWidget *w)
4412 {
4413 if ( !w || GTK_WIDGET_NO_WINDOW(w) )
4414 return; // window-less widget, cannot be frozen
4415
4416 if ( !GTK_WIDGET_REALIZED(w) )
4417 {
4418 // we can't thaw unrealized widgets because they don't have GdkWindow,
4419 // so set it up to be done immediately after realization:
4420 g_signal_connect_after
4421 (
4422 w,
4423 "realize",
4424 G_CALLBACK(wx_frozen_widget_realize),
4425 this
4426 );
4427 return;
4428 }
4429
4430 GdkWindow* window = w->window;
4431 if (w == m_wxwindow)
4432 window = GTKGetDrawingWindow();
4433 gdk_window_freeze_updates(window);
4434 }
4435
4436 void wxWindowGTK::GTKThawWidget(GtkWidget *w)
4437 {
4438 if ( !w || GTK_WIDGET_NO_WINDOW(w) )
4439 return; // window-less widget, cannot be frozen
4440
4441 if ( !GTK_WIDGET_REALIZED(w) )
4442 {
4443 // the widget wasn't realized yet, no need to thaw
4444 g_signal_handlers_disconnect_by_func
4445 (
4446 w,
4447 (void*)wx_frozen_widget_realize,
4448 this
4449 );
4450 return;
4451 }
4452
4453 GdkWindow* window = w->window;
4454 if (w == m_wxwindow)
4455 window = GTKGetDrawingWindow();
4456 gdk_window_thaw_updates(window);
4457 }
4458
4459 void wxWindowGTK::DoFreeze()
4460 {
4461 GTKFreezeWidget(m_widget);
4462 if ( m_wxwindow && m_widget != m_wxwindow )
4463 GTKFreezeWidget(m_wxwindow);
4464 }
4465
4466 void wxWindowGTK::DoThaw()
4467 {
4468 GTKThawWidget(m_widget);
4469 if ( m_wxwindow && m_widget != m_wxwindow )
4470 GTKThawWidget(m_wxwindow);
4471 }
wxWidgets (Impactor)