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