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