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