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