]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/window.cpp
projects / wxWidgets.git / blob
? search:


30c48b9e70a8a726aa1278ff3396ffa678d35941
[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 void wxWindowGTK::GTKDisableFocusOutEvent()
2862 {
2863 g_signal_handlers_block_by_func( m_focusWidget,
2864 (gpointer) gtk_window_focus_out_callback, this);
2865 }
2866
2867 void wxWindowGTK::GTKEnableFocusOutEvent()
2868 {
2869 g_signal_handlers_unblock_by_func( m_focusWidget,
2870 (gpointer) gtk_window_focus_out_callback, this);
2871 }
2872
2873 bool wxWindowGTK::GTKHandleFocusIn()
2874 {
2875 // Disable default focus handling for custom windows since the default GTK+
2876 // handler issues a repaint
2877 const bool retval = m_wxwindow ? true : false;
2878
2879
2880 // NB: if there's still unprocessed deferred focus-out event (see
2881 // GTKHandleFocusOut() for explanation), we need to process it first so
2882 // that the order of focus events -- focus-out first, then focus-in
2883 // elsewhere -- is preserved
2884 if ( gs_deferredFocusOut )
2885 {
2886 if ( GTKNeedsToFilterSameWindowFocus() &&
2887 gs_deferredFocusOut == this )
2888 {
2889 // GTK+ focus changed from this wxWindow back to itself, so don't
2890 // emit any events at all
2891 wxLogTrace(TRACE_FOCUS,
2892 "filtered out spurious focus change within %s(%p, %s)",
2893 GetClassInfo()->GetClassName(), this, GetLabel());
2894 gs_deferredFocusOut = NULL;
2895 return retval;
2896 }
2897
2898 // otherwise we need to send focus-out first
2899 wxASSERT_MSG ( gs_deferredFocusOut != this,
2900 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
2901 GTKHandleDeferredFocusOut();
2902 }
2903
2904
2905 wxLogTrace(TRACE_FOCUS,
2906 "handling focus_in event for %s(%p, %s)",
2907 GetClassInfo()->GetClassName(), this, GetLabel());
2908
2909 if (m_imData)
2910 gtk_im_context_focus_in(m_imData->context);
2911
2912 gs_currentFocus = this;
2913 gs_pendingFocus = NULL;
2914
2915 #if wxUSE_CARET
2916 // caret needs to be informed about focus change
2917 wxCaret *caret = GetCaret();
2918 if ( caret )
2919 {
2920 caret->OnSetFocus();
2921 }
2922 #endif // wxUSE_CARET
2923
2924 // Notify the parent keeping track of focus for the kbd navigation
2925 // purposes that we got it.
2926 wxChildFocusEvent eventChildFocus(static_cast<wxWindow*>(this));
2927 GTKProcessEvent(eventChildFocus);
2928
2929 wxFocusEvent eventFocus(wxEVT_SET_FOCUS, GetId());
2930 eventFocus.SetEventObject(this);
2931 GTKProcessEvent(eventFocus);
2932
2933 return retval;
2934 }
2935
2936 bool wxWindowGTK::GTKHandleFocusOut()
2937 {
2938 // Disable default focus handling for custom windows since the default GTK+
2939 // handler issues a repaint
2940 const bool retval = m_wxwindow ? true : false;
2941
2942
2943 // NB: If a control is composed of several GtkWidgets and when focus
2944 // changes from one of them to another within the same wxWindow, we get
2945 // a focus-out event followed by focus-in for another GtkWidget owned
2946 // by the same wx control. We don't want to generate two spurious
2947 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
2948 // from GTKHandleFocusOut() until we know for sure it's not coming back
2949 // (i.e. in GTKHandleFocusIn() or at idle time).
2950 if ( GTKNeedsToFilterSameWindowFocus() )
2951 {
2952 wxASSERT_MSG( gs_deferredFocusOut == NULL,
2953 "deferred focus out event already pending" );
2954 wxLogTrace(TRACE_FOCUS,
2955 "deferring focus_out event for %s(%p, %s)",
2956 GetClassInfo()->GetClassName(), this, GetLabel());
2957 gs_deferredFocusOut = this;
2958 return retval;
2959 }
2960
2961 GTKHandleFocusOutNoDeferring();
2962
2963 return retval;
2964 }
2965
2966 void wxWindowGTK::GTKHandleFocusOutNoDeferring()
2967 {
2968 wxLogTrace(TRACE_FOCUS,
2969 "handling focus_out event for %s(%p, %s)",
2970 GetClassInfo()->GetClassName(), this, GetLabel());
2971
2972 if (m_imData)
2973 gtk_im_context_focus_out(m_imData->context);
2974
2975 if ( gs_currentFocus != this )
2976 {
2977 // Something is terribly wrong, gs_currentFocus is out of sync with the
2978 // real focus. We will reset it to NULL anyway, because after this
2979 // focus-out event is handled, one of the following with happen:
2980 //
2981 // * either focus will go out of the app altogether, in which case
2982 // gs_currentFocus _should_ be NULL
2983 //
2984 // * or it goes to another control, in which case focus-in event will
2985 // follow immediately and it will set gs_currentFocus to the right
2986 // value
2987 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
2988 GetClassInfo()->GetClassName(), this, GetLabel());
2989 }
2990 gs_currentFocus = NULL;
2991
2992 #if wxUSE_CARET
2993 // caret needs to be informed about focus change
2994 wxCaret *caret = GetCaret();
2995 if ( caret )
2996 {
2997 caret->OnKillFocus();
2998 }
2999 #endif // wxUSE_CARET
3000
3001 wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
3002 event.SetEventObject( this );
3003 GTKProcessEvent( event );
3004 }
3005
3006 /*static*/
3007 void wxWindowGTK::GTKHandleDeferredFocusOut()
3008 {
3009 // NB: See GTKHandleFocusOut() for explanation. This function is called
3010 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3011 // deferred event.
3012 if ( gs_deferredFocusOut )
3013 {
3014 wxWindowGTK *win = gs_deferredFocusOut;
3015 gs_deferredFocusOut = NULL;
3016
3017 wxLogTrace(TRACE_FOCUS,
3018 "processing deferred focus_out event for %s(%p, %s)",
3019 win->GetClassInfo()->GetClassName(), win, win->GetLabel());
3020
3021 win->GTKHandleFocusOutNoDeferring();
3022 }
3023 }
3024
3025 void wxWindowGTK::SetFocus()
3026 {
3027 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3028
3029 // Setting "physical" focus is not immediate in GTK+ and while
3030 // gtk_widget_is_focus ("determines if the widget is the focus widget
3031 // within its toplevel", i.e. returns true for one widget per TLW, not
3032 // globally) returns true immediately after grabbing focus,
3033 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3034 // has focus at the moment) takes affect only after the window is shown
3035 // (if it was hidden at the moment of the call) or at the next event loop
3036 // iteration.
3037 //
3038 // Because we want to FindFocus() call immediately following
3039 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3040 // ourselves.
3041 gs_pendingFocus = this;
3042
3043 GtkWidget *widget = m_wxwindow ? m_wxwindow : m_focusWidget;
3044
3045 if ( GTK_IS_CONTAINER(widget) &&
3046 !GTK_WIDGET_CAN_FOCUS(widget) )
3047 {
3048 wxLogTrace(TRACE_FOCUS,
3049 _T("Setting focus to a child of %s(%p, %s)"),
3050 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3051 gtk_widget_child_focus(widget, GTK_DIR_TAB_FORWARD);
3052 }
3053 else
3054 {
3055 wxLogTrace(TRACE_FOCUS,
3056 _T("Setting focus to %s(%p, %s)"),
3057 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3058 gtk_widget_grab_focus(widget);
3059 }
3060 }
3061
3062 void wxWindowGTK::SetCanFocus(bool canFocus)
3063 {
3064 if ( canFocus )
3065 GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS);
3066 else
3067 GTK_WIDGET_UNSET_FLAGS(m_widget, GTK_CAN_FOCUS);
3068
3069 if ( m_wxwindow && (m_widget != m_wxwindow) )
3070 {
3071 if ( canFocus )
3072 GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
3073 else
3074 GTK_WIDGET_UNSET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
3075 }
3076 }
3077
3078 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3079 {
3080 wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
3081
3082 wxWindowGTK *oldParent = m_parent,
3083 *newParent = (wxWindowGTK *)newParentBase;
3084
3085 wxASSERT( GTK_IS_WIDGET(m_widget) );
3086
3087 if ( !wxWindowBase::Reparent(newParent) )
3088 return false;
3089
3090 wxASSERT( GTK_IS_WIDGET(m_widget) );
3091
3092 if (oldParent)
3093 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
3094
3095 wxASSERT( GTK_IS_WIDGET(m_widget) );
3096
3097 if (newParent)
3098 {
3099 if (GTK_WIDGET_VISIBLE (newParent->m_widget))
3100 {
3101 m_showOnIdle = true;
3102 gtk_widget_hide( m_widget );
3103 }
3104 /* insert GTK representation */
3105 newParent->AddChildGTK(this);
3106 }
3107
3108 SetLayoutDirection(wxLayout_Default);
3109
3110 return true;
3111 }
3112
3113 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3114 {
3115 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3116 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3117
3118 /* add to list */
3119 AddChild( child );
3120
3121 /* insert GTK representation */
3122 AddChildGTK(child);
3123 }
3124
3125 void wxWindowGTK::AddChild(wxWindowBase *child)
3126 {
3127 wxWindowBase::AddChild(child);
3128 m_dirtyTabOrder = true;
3129 wxTheApp->WakeUpIdle();
3130 }
3131
3132 void wxWindowGTK::RemoveChild(wxWindowBase *child)
3133 {
3134 wxWindowBase::RemoveChild(child);
3135 m_dirtyTabOrder = true;
3136 wxTheApp->WakeUpIdle();
3137 }
3138
3139 /* static */
3140 wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
3141 {
3142 return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL
3143 ? wxLayout_RightToLeft
3144 : wxLayout_LeftToRight;
3145 }
3146
3147 /* static */
3148 void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir)
3149 {
3150 wxASSERT_MSG( dir != wxLayout_Default, _T("invalid layout direction") );
3151
3152 gtk_widget_set_direction(widget,
3153 dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
3154 : GTK_TEXT_DIR_LTR);
3155 }
3156
3157 wxLayoutDirection wxWindowGTK::GetLayoutDirection() const
3158 {
3159 return GTKGetLayout(m_widget);
3160 }
3161
3162 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir)
3163 {
3164 if ( dir == wxLayout_Default )
3165 {
3166 const wxWindow *const parent = GetParent();
3167 if ( parent )
3168 {
3169 // inherit layout from parent.
3170 dir = parent->GetLayoutDirection();
3171 }
3172 else // no parent, use global default layout
3173 {
3174 dir = wxTheApp->GetLayoutDirection();
3175 }
3176 }
3177
3178 if ( dir == wxLayout_Default )
3179 return;
3180
3181 GTKSetLayout(m_widget, dir);
3182
3183 if (m_wxwindow && (m_wxwindow != m_widget))
3184 GTKSetLayout(m_wxwindow, dir);
3185 }
3186
3187 wxCoord
3188 wxWindowGTK::AdjustForLayoutDirection(wxCoord x,
3189 wxCoord WXUNUSED(width),
3190 wxCoord WXUNUSED(widthTotal)) const
3191 {
3192 // We now mirror the coordinates of RTL windows in wxPizza
3193 return x;
3194 }
3195
3196 void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, WindowOrder move)
3197 {
3198 wxWindowBase::DoMoveInTabOrder(win, move);
3199 m_dirtyTabOrder = true;
3200 wxTheApp->WakeUpIdle();
3201 }
3202
3203 bool wxWindowGTK::DoNavigateIn(int flags)
3204 {
3205 if ( flags & wxNavigationKeyEvent::WinChange )
3206 {
3207 wxFAIL_MSG( _T("not implemented") );
3208
3209 return false;
3210 }
3211 else // navigate inside the container
3212 {
3213 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3214 wxCHECK_MSG( parent, false, _T("every window must have a TLW parent") );
3215
3216 GtkDirectionType dir;
3217 dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD
3218 : GTK_DIR_TAB_BACKWARD;
3219
3220 gboolean rc;
3221 g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
3222
3223 return rc == TRUE;
3224 }
3225 }
3226
3227 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3228 {
3229 // none needed by default
3230 return false;
3231 }
3232
3233 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget* WXUNUSED(w))
3234 {
3235 // nothing to do by default since none is needed
3236 }
3237
3238 void wxWindowGTK::RealizeTabOrder()
3239 {
3240 if (m_wxwindow)
3241 {
3242 if ( !m_children.empty() )
3243 {
3244 // we don't only construct the correct focus chain but also use
3245 // this opportunity to update the mnemonic widgets for the widgets
3246 // that need them
3247
3248 GList *chain = NULL;
3249 wxWindowGTK* mnemonicWindow = NULL;
3250
3251 for ( wxWindowList::const_iterator i = m_children.begin();
3252 i != m_children.end();
3253 ++i )
3254 {
3255 wxWindowGTK *win = *i;
3256
3257 if ( mnemonicWindow )
3258 {
3259 if ( win->AcceptsFocusFromKeyboard() )
3260 {
3261 // wxComboBox et al. needs to focus on on a different
3262 // widget than m_widget, so if the main widget isn't
3263 // focusable try the connect widget
3264 GtkWidget* w = win->m_widget;
3265 if ( !GTK_WIDGET_CAN_FOCUS(w) )
3266 {
3267 w = win->GetConnectWidget();
3268 if ( !GTK_WIDGET_CAN_FOCUS(w) )
3269 w = NULL;
3270 }
3271
3272 if ( w )
3273 {
3274 mnemonicWindow->GTKWidgetDoSetMnemonic(w);
3275 mnemonicWindow = NULL;
3276 }
3277 }
3278 }
3279 else if ( win->GTKWidgetNeedsMnemonic() )
3280 {
3281 mnemonicWindow = win;
3282 }
3283
3284 chain = g_list_prepend(chain, win->m_widget);
3285 }
3286
3287 chain = g_list_reverse(chain);
3288
3289 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain);
3290 g_list_free(chain);
3291 }
3292 else // no children
3293 {
3294 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow));
3295 }
3296 }
3297 }
3298
3299 void wxWindowGTK::Raise()
3300 {
3301 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3302
3303 if (m_wxwindow && m_wxwindow->window)
3304 {
3305 gdk_window_raise( m_wxwindow->window );
3306 }
3307 else if (m_widget->window)
3308 {
3309 gdk_window_raise( m_widget->window );
3310 }
3311 }
3312
3313 void wxWindowGTK::Lower()
3314 {
3315 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3316
3317 if (m_wxwindow && m_wxwindow->window)
3318 {
3319 gdk_window_lower( m_wxwindow->window );
3320 }
3321 else if (m_widget->window)
3322 {
3323 gdk_window_lower( m_widget->window );
3324 }
3325 }
3326
3327 bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3328 {
3329 if ( !wxWindowBase::SetCursor(cursor.Ok() ? cursor : *wxSTANDARD_CURSOR) )
3330 return false;
3331
3332 GTKUpdateCursor();
3333
3334 return true;
3335 }
3336
3337 void wxWindowGTK::GTKUpdateCursor()
3338 {
3339 wxCursor cursor(g_globalCursor.Ok() ? g_globalCursor : GetCursor());
3340 if ( cursor.Ok() )
3341 {
3342 wxArrayGdkWindows windowsThis;
3343 GdkWindow * const winThis = GTKGetWindow(windowsThis);
3344 if ( winThis )
3345 {
3346 gdk_window_set_cursor(winThis, cursor.GetCursor());
3347 }
3348 else
3349 {
3350 const size_t count = windowsThis.size();
3351 for ( size_t n = 0; n < count; n++ )
3352 {
3353 GdkWindow *win = windowsThis[n];
3354 if ( !win )
3355 {
3356 wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?"));
3357 continue;
3358 }
3359
3360 gdk_window_set_cursor(win, cursor.GetCursor());
3361 }
3362 }
3363 }
3364 }
3365
3366 void wxWindowGTK::WarpPointer( int x, int y )
3367 {
3368 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3369
3370 // We provide this function ourselves as it is
3371 // missing in GDK (top of this file).
3372
3373 GdkWindow *window = (GdkWindow*) NULL;
3374 if (m_wxwindow)
3375 window = m_wxwindow->window;
3376 else
3377 window = GetConnectWidget()->window;
3378
3379 if (window)
3380 gdk_window_warp_pointer( window, x, y );
3381 }
3382
3383 wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const
3384 {
3385 // find the scrollbar which generated the event
3386 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
3387 {
3388 if ( range == m_scrollBar[dir] )
3389 return (ScrollDir)dir;
3390 }
3391
3392 wxFAIL_MSG( _T("event from unknown scrollbar received") );
3393
3394 return ScrollDir_Max;
3395 }
3396
3397 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units)
3398 {
3399 bool changed = false;
3400 GtkRange* range = m_scrollBar[dir];
3401 if ( range && units )
3402 {
3403 GtkAdjustment* adj = range->adjustment;
3404 gdouble inc = unit == ScrollUnit_Line ? adj->step_increment
3405 : adj->page_increment;
3406
3407 const int posOld = int(adj->value + 0.5);
3408 gtk_range_set_value(range, posOld + units*inc);
3409
3410 changed = int(adj->value + 0.5) != posOld;
3411 }
3412
3413 return changed;
3414 }
3415
3416 bool wxWindowGTK::ScrollLines(int lines)
3417 {
3418 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Line, lines);
3419 }
3420
3421 bool wxWindowGTK::ScrollPages(int pages)
3422 {
3423 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages);
3424 }
3425
3426 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground),
3427 const wxRect *rect)
3428 {
3429 if (!m_widget)
3430 return;
3431 if (!m_widget->window)
3432 return;
3433
3434 if (m_wxwindow)
3435 {
3436 if (m_wxwindow->window == NULL) return;
3437
3438 GdkRectangle gdk_rect,
3439 *p;
3440 if (rect)
3441 {
3442 gdk_rect.x = rect->x;
3443 gdk_rect.y = rect->y;
3444 gdk_rect.width = rect->width;
3445 gdk_rect.height = rect->height;
3446 if (GetLayoutDirection() == wxLayout_RightToLeft)
3447 gdk_rect.x = GetClientSize().x - gdk_rect.x - gdk_rect.width;
3448
3449 p = &gdk_rect;
3450 }
3451 else // invalidate everything
3452 {
3453 p = NULL;
3454 }
3455
3456 gdk_window_invalidate_rect(m_wxwindow->window, p, true);
3457 }
3458 }
3459
3460 void wxWindowGTK::Update()
3461 {
3462 GtkUpdate();
3463
3464 // when we call Update() we really want to update the window immediately on
3465 // screen, even if it means flushing the entire queue and hence slowing down
3466 // everything -- but it should still be done, it's just that Update() should
3467 // be called very rarely
3468 gdk_flush();
3469 }
3470
3471 void wxWindowGTK::GtkUpdate()
3472 {
3473 if (m_wxwindow && m_wxwindow->window)
3474 gdk_window_process_updates(m_wxwindow->window, false);
3475 if (m_widget && m_widget->window && (m_wxwindow != m_widget))
3476 gdk_window_process_updates( m_widget->window, FALSE );
3477
3478 // for consistency with other platforms (and also because it's convenient
3479 // to be able to update an entire TLW by calling Update() only once), we
3480 // should also update all our children here
3481 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
3482 node;
3483 node = node->GetNext() )
3484 {
3485 node->GetData()->GtkUpdate();
3486 }
3487 }
3488
3489 bool wxWindowGTK::DoIsExposed( int x, int y ) const
3490 {
3491 return m_updateRegion.Contains(x, y) != wxOutRegion;
3492 }
3493
3494
3495 bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const
3496 {
3497 if (GetLayoutDirection() == wxLayout_RightToLeft)
3498 return m_updateRegion.Contains(x-w, y, w, h) != wxOutRegion;
3499 else
3500 return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
3501 }
3502
3503 void wxWindowGTK::GtkSendPaintEvents()
3504 {
3505 if (!m_wxwindow)
3506 {
3507 m_updateRegion.Clear();
3508 return;
3509 }
3510
3511 // Clip to paint region in wxClientDC
3512 m_clipPaintRegion = true;
3513
3514 m_nativeUpdateRegion = m_updateRegion;
3515
3516 if (GetLayoutDirection() == wxLayout_RightToLeft)
3517 {
3518 // Transform m_updateRegion under RTL
3519 m_updateRegion.Clear();
3520
3521 gint width;
3522 gdk_drawable_get_size(m_wxwindow->window, &width, NULL);
3523
3524 wxRegionIterator upd( m_nativeUpdateRegion );
3525 while (upd)
3526 {
3527 wxRect rect;
3528 rect.x = upd.GetX();
3529 rect.y = upd.GetY();
3530 rect.width = upd.GetWidth();
3531 rect.height = upd.GetHeight();
3532
3533 rect.x = width - rect.x - rect.width;
3534 m_updateRegion.Union( rect );
3535
3536 ++upd;
3537 }
3538 }
3539
3540 if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM))
3541 {
3542 // find ancestor from which to steal background
3543 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3544 if (!parent)
3545 parent = (wxWindow*)this;
3546
3547 if (GTK_WIDGET_MAPPED(parent->m_widget))
3548 {
3549 wxRegionIterator upd( m_nativeUpdateRegion );
3550 while (upd)
3551 {
3552 GdkRectangle rect;
3553 rect.x = upd.GetX();
3554 rect.y = upd.GetY();
3555 rect.width = upd.GetWidth();
3556 rect.height = upd.GetHeight();
3557
3558 gtk_paint_flat_box( parent->m_widget->style,
3559 m_wxwindow->window,
3560 (GtkStateType)GTK_WIDGET_STATE(m_wxwindow),
3561 GTK_SHADOW_NONE,
3562 &rect,
3563 parent->m_widget,
3564 (char *)"base",
3565 0, 0, -1, -1 );
3566
3567 ++upd;
3568 }
3569 }
3570 }
3571 else
3572 {
3573 wxWindowDC dc( (wxWindow*)this );
3574 dc.SetDeviceClippingRegion( m_updateRegion );
3575
3576 // Work around gtk-qt <= 0.60 bug whereby the window colour
3577 // remains grey
3578 if (GetBackgroundStyle() == wxBG_STYLE_COLOUR && GetBackgroundColour().Ok() && wxSystemOptions::GetOptionInt(wxT("gtk.window.force-background-colour")) == 1)
3579 {
3580 dc.SetBackground(wxBrush(GetBackgroundColour()));
3581 dc.Clear();
3582 }
3583
3584 wxEraseEvent erase_event( GetId(), &dc );
3585 erase_event.SetEventObject( this );
3586
3587 HandleWindowEvent(erase_event);
3588 }
3589
3590 wxNcPaintEvent nc_paint_event( GetId() );
3591 nc_paint_event.SetEventObject( this );
3592 HandleWindowEvent( nc_paint_event );
3593
3594 wxPaintEvent paint_event( GetId() );
3595 paint_event.SetEventObject( this );
3596 HandleWindowEvent( paint_event );
3597
3598 m_clipPaintRegion = false;
3599
3600 m_updateRegion.Clear();
3601 m_nativeUpdateRegion.Clear();
3602 }
3603
3604 void wxWindowGTK::SetDoubleBuffered( bool on )
3605 {
3606 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3607
3608 if ( m_wxwindow )
3609 gtk_widget_set_double_buffered( m_wxwindow, on );
3610 }
3611
3612 bool wxWindowGTK::IsDoubleBuffered() const
3613 {
3614 return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow );
3615 }
3616
3617 void wxWindowGTK::ClearBackground()
3618 {
3619 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3620 }
3621
3622 #if wxUSE_TOOLTIPS
3623 void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3624 {
3625 wxWindowBase::DoSetToolTip(tip);
3626
3627 if (m_tooltip)
3628 m_tooltip->Apply( (wxWindow *)this );
3629 }
3630
3631 void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const gchar *tip )
3632 {
3633 gtk_tooltips_set_tip(tips, GetConnectWidget(), tip, NULL);
3634 }
3635 #endif // wxUSE_TOOLTIPS
3636
3637 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
3638 {
3639 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3640
3641 if (!wxWindowBase::SetBackgroundColour(colour))
3642 return false;
3643
3644 if (colour.Ok())
3645 {
3646 // We need the pixel value e.g. for background clearing.
3647 m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3648 }
3649
3650 // apply style change (forceStyle=true so that new style is applied
3651 // even if the bg colour changed from valid to wxNullColour)
3652 if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM)
3653 ApplyWidgetStyle(true);
3654
3655 return true;
3656 }
3657
3658 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
3659 {
3660 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3661
3662 if (!wxWindowBase::SetForegroundColour(colour))
3663 {
3664 return false;
3665 }
3666
3667 if (colour.Ok())
3668 {
3669 // We need the pixel value e.g. for background clearing.
3670 m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3671 }
3672
3673 // apply style change (forceStyle=true so that new style is applied
3674 // even if the bg colour changed from valid to wxNullColour):
3675 ApplyWidgetStyle(true);
3676
3677 return true;
3678 }
3679
3680 PangoContext *wxWindowGTK::GtkGetPangoDefaultContext()
3681 {
3682 return gtk_widget_get_pango_context( m_widget );
3683 }
3684
3685 GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle)
3686 {
3687 // do we need to apply any changes at all?
3688 if ( !forceStyle &&
3689 !m_font.Ok() &&
3690 !m_foregroundColour.Ok() && !m_backgroundColour.Ok() )
3691 {
3692 return NULL;
3693 }
3694
3695 GtkRcStyle *style = gtk_rc_style_new();
3696
3697 if ( m_font.Ok() )
3698 {
3699 style->font_desc =
3700 pango_font_description_copy( m_font.GetNativeFontInfo()->description );
3701 }
3702
3703 int flagsNormal = 0,
3704 flagsPrelight = 0,
3705 flagsActive = 0,
3706 flagsInsensitive = 0;
3707
3708 if ( m_foregroundColour.Ok() )
3709 {
3710 const GdkColor *fg = m_foregroundColour.GetColor();
3711
3712 style->fg[GTK_STATE_NORMAL] =
3713 style->text[GTK_STATE_NORMAL] = *fg;
3714 flagsNormal |= GTK_RC_FG | GTK_RC_TEXT;
3715
3716 style->fg[GTK_STATE_PRELIGHT] =
3717 style->text[GTK_STATE_PRELIGHT] = *fg;
3718 flagsPrelight |= GTK_RC_FG | GTK_RC_TEXT;
3719
3720 style->fg[GTK_STATE_ACTIVE] =
3721 style->text[GTK_STATE_ACTIVE] = *fg;
3722 flagsActive |= GTK_RC_FG | GTK_RC_TEXT;
3723 }
3724
3725 if ( m_backgroundColour.Ok() )
3726 {
3727 const GdkColor *bg = m_backgroundColour.GetColor();
3728
3729 style->bg[GTK_STATE_NORMAL] =
3730 style->base[GTK_STATE_NORMAL] = *bg;
3731 flagsNormal |= GTK_RC_BG | GTK_RC_BASE;
3732
3733 style->bg[GTK_STATE_PRELIGHT] =
3734 style->base[GTK_STATE_PRELIGHT] = *bg;
3735 flagsPrelight |= GTK_RC_BG | GTK_RC_BASE;
3736
3737 style->bg[GTK_STATE_ACTIVE] =
3738 style->base[GTK_STATE_ACTIVE] = *bg;
3739 flagsActive |= GTK_RC_BG | GTK_RC_BASE;
3740
3741 style->bg[GTK_STATE_INSENSITIVE] =
3742 style->base[GTK_STATE_INSENSITIVE] = *bg;
3743 flagsInsensitive |= GTK_RC_BG | GTK_RC_BASE;
3744 }
3745
3746 style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)flagsNormal;
3747 style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)flagsPrelight;
3748 style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)flagsActive;
3749 style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)flagsInsensitive;
3750
3751 return style;
3752 }
3753
3754 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle)
3755 {
3756 GtkRcStyle *style = CreateWidgetStyle(forceStyle);
3757 if ( style )
3758 {
3759 DoApplyWidgetStyle(style);
3760 gtk_rc_style_unref(style);
3761 }
3762
3763 // Style change may affect GTK+'s size calculation:
3764 InvalidateBestSize();
3765 }
3766
3767 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
3768 {
3769 wxSuspendStyleEvents s(static_cast<wxWindow*>(this));
3770
3771 if (m_wxwindow)
3772 gtk_widget_modify_style(m_wxwindow, style);
3773 else
3774 gtk_widget_modify_style(m_widget, style);
3775 }
3776
3777 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
3778 {
3779 wxWindowBase::SetBackgroundStyle(style);
3780
3781 if (style == wxBG_STYLE_CUSTOM)
3782 {
3783 GdkWindow *window;
3784 if ( m_wxwindow )
3785 {
3786 window = m_wxwindow->window;
3787 }
3788 else
3789 {
3790 GtkWidget * const w = GetConnectWidget();
3791 window = w ? w->window : NULL;
3792 }
3793
3794 if (window)
3795 {
3796 // Make sure GDK/X11 doesn't refresh the window
3797 // automatically.
3798 gdk_window_set_back_pixmap( window, None, False );
3799 #ifdef __X__
3800 Display* display = GDK_WINDOW_DISPLAY(window);
3801 XFlush(display);
3802 #endif
3803 m_needsStyleChange = false;
3804 }
3805 else // window not realized yet
3806 {
3807 // Do in OnIdle, because the window is not yet available
3808 m_needsStyleChange = true;
3809 }
3810
3811 // Don't apply widget style, or we get a grey background
3812 }
3813 else
3814 {
3815 // apply style change (forceStyle=true so that new style is applied
3816 // even if the bg colour changed from valid to wxNullColour):
3817 ApplyWidgetStyle(true);
3818 }
3819 return true;
3820 }
3821
3822 // ----------------------------------------------------------------------------
3823 // Pop-up menu stuff
3824 // ----------------------------------------------------------------------------
3825
3826 #if wxUSE_MENUS_NATIVE
3827
3828 static void SetInvokingWindow( wxMenu *menu, wxWindow* win )
3829 {
3830 menu->SetInvokingWindow( win );
3831
3832 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
3833 while (node)
3834 {
3835 wxMenuItem *menuitem = node->GetData();
3836 if (menuitem->IsSubMenu())
3837 {
3838 SetInvokingWindow( menuitem->GetSubMenu(), win );
3839 }
3840
3841 node = node->GetNext();
3842 }
3843 }
3844
3845 extern "C" {
3846 static
3847 void wxPopupMenuPositionCallback( GtkMenu *menu,
3848 gint *x, gint *y,
3849 gboolean * WXUNUSED(whatever),
3850 gpointer user_data )
3851 {
3852 // ensure that the menu appears entirely on screen
3853 GtkRequisition req;
3854 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
3855
3856 wxSize sizeScreen = wxGetDisplaySize();
3857 wxPoint *pos = (wxPoint*)user_data;
3858
3859 gint xmax = sizeScreen.x - req.width,
3860 ymax = sizeScreen.y - req.height;
3861
3862 *x = pos->x < xmax ? pos->x : xmax;
3863 *y = pos->y < ymax ? pos->y : ymax;
3864 }
3865 }
3866
3867 void wxWindowGTK::DoPopupMenuUpdateUI(wxMenu* menu)
3868 {
3869 menu->UpdateUI();
3870 }
3871
3872 bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
3873 {
3874 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3875
3876 wxCHECK_MSG( menu != NULL, false, wxT("invalid popup-menu") );
3877
3878 SetInvokingWindow( menu, this );
3879
3880 DoPopupMenuUpdateUI(menu);
3881
3882 wxPoint pos;
3883 gpointer userdata;
3884 GtkMenuPositionFunc posfunc;
3885 if ( x == -1 && y == -1 )
3886 {
3887 // use GTK's default positioning algorithm
3888 userdata = NULL;
3889 posfunc = NULL;
3890 }
3891 else
3892 {
3893 pos = ClientToScreen(wxPoint(x, y));
3894 userdata = &pos;
3895 posfunc = wxPopupMenuPositionCallback;
3896 }
3897
3898 menu->m_popupShown = true;
3899 gtk_menu_popup(
3900 GTK_MENU(menu->m_menu),
3901 (GtkWidget *) NULL, // parent menu shell
3902 (GtkWidget *) NULL, // parent menu item
3903 posfunc, // function to position it
3904 userdata, // client data
3905 0, // button used to activate it
3906 gtk_get_current_event_time()
3907 );
3908
3909 while (menu->m_popupShown)
3910 {
3911 gtk_main_iteration();
3912 }
3913
3914 return true;
3915 }
3916
3917 #endif // wxUSE_MENUS_NATIVE
3918
3919 #if wxUSE_DRAG_AND_DROP
3920
3921 void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
3922 {
3923 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3924
3925 GtkWidget *dnd_widget = GetConnectWidget();
3926
3927 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
3928
3929 if (m_dropTarget) delete m_dropTarget;
3930 m_dropTarget = dropTarget;
3931
3932 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
3933 }
3934
3935 #endif // wxUSE_DRAG_AND_DROP
3936
3937 GtkWidget* wxWindowGTK::GetConnectWidget()
3938 {
3939 GtkWidget *connect_widget = m_widget;
3940 if (m_wxwindow) connect_widget = m_wxwindow;
3941
3942 return connect_widget;
3943 }
3944
3945 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const
3946 {
3947 wxArrayGdkWindows windowsThis;
3948 GdkWindow * const winThis = GTKGetWindow(windowsThis);
3949
3950 return winThis ? window == winThis
3951 : windowsThis.Index(window) != wxNOT_FOUND;
3952 }
3953
3954 GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
3955 {
3956 return m_wxwindow ? m_wxwindow->window : m_widget->window;
3957 }
3958
3959 bool wxWindowGTK::SetFont( const wxFont &font )
3960 {
3961 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3962
3963 if (!wxWindowBase::SetFont(font))
3964 return false;
3965
3966 // apply style change (forceStyle=true so that new style is applied
3967 // even if the font changed from valid to wxNullFont):
3968 ApplyWidgetStyle(true);
3969
3970 return true;
3971 }
3972
3973 void wxWindowGTK::DoCaptureMouse()
3974 {
3975 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3976
3977 GdkWindow *window = (GdkWindow*) NULL;
3978 if (m_wxwindow)
3979 window = m_wxwindow->window;
3980 else
3981 window = GetConnectWidget()->window;
3982
3983 wxCHECK_RET( window, _T("CaptureMouse() failed") );
3984
3985 const wxCursor* cursor = &m_cursor;
3986 if (!cursor->Ok())
3987 cursor = wxSTANDARD_CURSOR;
3988
3989 gdk_pointer_grab( window, FALSE,
3990 (GdkEventMask)
3991 (GDK_BUTTON_PRESS_MASK |
3992 GDK_BUTTON_RELEASE_MASK |
3993 GDK_POINTER_MOTION_HINT_MASK |
3994 GDK_POINTER_MOTION_MASK),
3995 (GdkWindow *) NULL,
3996 cursor->GetCursor(),
3997 (guint32)GDK_CURRENT_TIME );
3998 g_captureWindow = this;
3999 g_captureWindowHasMouse = true;
4000 }
4001
4002 void wxWindowGTK::DoReleaseMouse()
4003 {
4004 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4005
4006 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
4007
4008 g_captureWindow = (wxWindowGTK*) NULL;
4009
4010 GdkWindow *window = (GdkWindow*) NULL;
4011 if (m_wxwindow)
4012 window = m_wxwindow->window;
4013 else
4014 window = GetConnectWidget()->window;
4015
4016 if (!window)
4017 return;
4018
4019 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
4020 }
4021
4022 void wxWindowGTK::GTKReleaseMouseAndNotify()
4023 {
4024 DoReleaseMouse();
4025 wxMouseCaptureLostEvent evt(GetId());
4026 evt.SetEventObject( this );
4027 HandleWindowEvent( evt );
4028 }
4029
4030 /* static */
4031 wxWindow *wxWindowBase::GetCapture()
4032 {
4033 return (wxWindow *)g_captureWindow;
4034 }
4035
4036 bool wxWindowGTK::IsRetained() const
4037 {
4038 return false;
4039 }
4040
4041 void wxWindowGTK::SetScrollbar(int orient,
4042 int pos,
4043 int thumbVisible,
4044 int range,
4045 bool WXUNUSED(update))
4046 {
4047 const int dir = ScrollDirFromOrient(orient);
4048 GtkRange* const sb = m_scrollBar[dir];
4049 wxCHECK_RET( sb, _T("this window is not scrollable") );
4050
4051 if (range <= 0)
4052 {
4053 // GtkRange requires upper > lower
4054 range =
4055 thumbVisible = 1;
4056 }
4057
4058 GtkAdjustment * const adj = sb->adjustment;
4059 adj->step_increment = 1;
4060 adj->page_increment =
4061 adj->page_size = thumbVisible;
4062 adj->value = pos;
4063
4064 g_signal_handlers_block_by_func(
4065 sb, (void*)gtk_scrollbar_value_changed, this);
4066
4067 gtk_range_set_range(sb, 0, range);
4068 m_scrollPos[dir] = sb->adjustment->value;
4069
4070 g_signal_handlers_unblock_by_func(
4071 sb, (void*)gtk_scrollbar_value_changed, this);
4072 }
4073
4074 void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
4075 {
4076 const int dir = ScrollDirFromOrient(orient);
4077 GtkRange * const sb = m_scrollBar[dir];
4078 wxCHECK_RET( sb, _T("this window is not scrollable") );
4079
4080 // This check is more than an optimization. Without it, the slider
4081 // will not move smoothly while tracking when using wxScrollHelper.
4082 if (GetScrollPos(orient) != pos)
4083 {
4084 g_signal_handlers_block_by_func(
4085 sb, (void*)gtk_scrollbar_value_changed, this);
4086
4087 gtk_range_set_value(sb, pos);
4088 m_scrollPos[dir] = sb->adjustment->value;
4089
4090 g_signal_handlers_unblock_by_func(
4091 sb, (void*)gtk_scrollbar_value_changed, this);
4092 }
4093 }
4094
4095 int wxWindowGTK::GetScrollThumb(int orient) const
4096 {
4097 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4098 wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );
4099
4100 return int(sb->adjustment->page_size);
4101 }
4102
4103 int wxWindowGTK::GetScrollPos( int orient ) const
4104 {
4105 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4106 wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );
4107
4108 return int(sb->adjustment->value + 0.5);
4109 }
4110
4111 int wxWindowGTK::GetScrollRange( int orient ) const
4112 {
4113 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4114 wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );
4115
4116 return int(sb->adjustment->upper);
4117 }
4118
4119 // Determine if increment is the same as +/-x, allowing for some small
4120 // difference due to possible inexactness in floating point arithmetic
4121 static inline bool IsScrollIncrement(double increment, double x)
4122 {
4123 wxASSERT(increment > 0);
4124 const double tolerance = 1.0 / 1024;
4125 return fabs(increment - fabs(x)) < tolerance;
4126 }
4127
4128 wxEventType wxWindowGTK::GetScrollEventType(GtkRange* range)
4129 {
4130 wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
4131
4132 const int barIndex = range == m_scrollBar[1];
4133 GtkAdjustment* adj = range->adjustment;
4134
4135 const int value = int(adj->value + 0.5);
4136
4137 // save previous position
4138 const double oldPos = m_scrollPos[barIndex];
4139 // update current position
4140 m_scrollPos[barIndex] = adj->value;
4141 // If event should be ignored, or integral position has not changed
4142 if (!m_hasVMT || g_blockEventsOnDrag || value == int(oldPos + 0.5))
4143 {
4144 return wxEVT_NULL;
4145 }
4146
4147 wxEventType eventType = wxEVT_SCROLL_THUMBTRACK;
4148 if (!m_isScrolling)
4149 {
4150 // Difference from last change event
4151 const double diff = adj->value - oldPos;
4152 const bool isDown = diff > 0;
4153
4154 if (IsScrollIncrement(adj->step_increment, diff))
4155 {
4156 eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
4157 }
4158 else if (IsScrollIncrement(adj->page_increment, diff))
4159 {
4160 eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
4161 }
4162 else if (m_mouseButtonDown)
4163 {
4164 // Assume track event
4165 m_isScrolling = true;
4166 }
4167 }
4168 return eventType;
4169 }
4170
4171 void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4172 {
4173 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4174
4175 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4176
4177 // No scrolling requested.
4178 if ((dx == 0) && (dy == 0)) return;
4179
4180 m_clipPaintRegion = true;
4181
4182 WX_PIZZA(m_wxwindow)->scroll(dx, dy);
4183
4184 m_clipPaintRegion = false;
4185
4186 #if wxUSE_CARET
4187 bool restoreCaret = (GetCaret() != NULL && GetCaret()->IsVisible());
4188 if (restoreCaret)
4189 {
4190 wxRect caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4191 if (dx > 0)
4192 caretRect.width += dx;
4193 else
4194 {
4195 caretRect.x += dx; caretRect.width -= dx;
4196 }
4197 if (dy > 0)
4198 caretRect.height += dy;
4199 else
4200 {
4201 caretRect.y += dy; caretRect.height -= dy;
4202 }
4203
4204 RefreshRect(caretRect);
4205 }
4206 #endif // wxUSE_CARET
4207 }
4208
4209 void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
4210 {
4211 //RN: Note that static controls usually have no border on gtk, so maybe
4212 //it makes sense to treat that as simply no border at the wx level
4213 //as well...
4214 if (!(wxstyle & wxNO_BORDER) && !(wxstyle & wxBORDER_STATIC))
4215 {
4216 GtkShadowType gtkstyle;
4217
4218 if(wxstyle & wxBORDER_RAISED)
4219 gtkstyle = GTK_SHADOW_OUT;
4220 else if (wxstyle & wxBORDER_SUNKEN)
4221 gtkstyle = GTK_SHADOW_IN;
4222 #if 0
4223 // Now obsolete
4224 else if (wxstyle & wxBORDER_DOUBLE)
4225 gtkstyle = GTK_SHADOW_ETCHED_IN;
4226 #endif
4227 else //default
4228 gtkstyle = GTK_SHADOW_IN;
4229
4230 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w),
4231 gtkstyle );
4232 }
4233 }
4234
4235 void wxWindowGTK::SetWindowStyleFlag( long style )
4236 {
4237 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4238 wxWindowBase::SetWindowStyleFlag(style);
4239 }
4240
4241 // Find the wxWindow at the current mouse position, also returning the mouse
4242 // position.
4243 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4244 {
4245 pt = wxGetMousePosition();
4246 wxWindow* found = wxFindWindowAtPoint(pt);
4247 return found;
4248 }
4249
4250 // Get the current mouse position.
4251 wxPoint wxGetMousePosition()
4252 {
4253 /* This crashes when used within wxHelpContext,
4254 so we have to use the X-specific implementation below.
4255 gint x, y;
4256 GdkModifierType *mask;
4257 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4258
4259 return wxPoint(x, y);
4260 */
4261
4262 int x, y;
4263 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4264
4265 Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
4266 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4267 Window rootReturn, childReturn;
4268 int rootX, rootY, winX, winY;
4269 unsigned int maskReturn;
4270
4271 XQueryPointer (display,
4272 rootWindow,
4273 &rootReturn,
4274 &childReturn,
4275 &rootX, &rootY, &winX, &winY, &maskReturn);
4276 return wxPoint(rootX, rootY);
4277
4278 }
4279
4280 GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
4281 {
4282 GdkWindow* window = NULL;
4283 if (m_wxwindow)
4284 window = m_wxwindow->window;
4285 return window;
4286 }
4287
4288 // ----------------------------------------------------------------------------
4289 // freeze/thaw
4290 // ----------------------------------------------------------------------------
4291
4292 extern "C"
4293 {
4294
4295 // this is called if we attempted to freeze unrealized widget when it finally
4296 // is realized (and so can be frozen):
4297 static void wx_frozen_widget_realize(GtkWidget* w, void* WXUNUSED(data))
4298 {
4299 wxASSERT( w && !GTK_WIDGET_NO_WINDOW(w) );
4300 wxASSERT( GTK_WIDGET_REALIZED(w) );
4301
4302 g_signal_handlers_disconnect_by_func
4303 (
4304 w,
4305 (void*)wx_frozen_widget_realize,
4306 NULL
4307 );
4308
4309 gdk_window_freeze_updates(w->window);
4310 }
4311
4312 } // extern "C"
4313
4314 void wxWindowGTK::GTKFreezeWidget(GtkWidget *w)
4315 {
4316 if ( !w || GTK_WIDGET_NO_WINDOW(w) )
4317 return; // window-less widget, cannot be frozen
4318
4319 if ( !GTK_WIDGET_REALIZED(w) )
4320 {
4321 // we can't thaw unrealized widgets because they don't have GdkWindow,
4322 // so set it up to be done immediately after realization:
4323 g_signal_connect_after
4324 (
4325 w,
4326 "realize",
4327 G_CALLBACK(wx_frozen_widget_realize),
4328 NULL
4329 );
4330 return;
4331 }
4332
4333 gdk_window_freeze_updates(w->window);
4334 }
4335
4336 void wxWindowGTK::GTKThawWidget(GtkWidget *w)
4337 {
4338 if ( !w || GTK_WIDGET_NO_WINDOW(w) )
4339 return; // window-less widget, cannot be frozen
4340
4341 if ( !GTK_WIDGET_REALIZED(w) )
4342 {
4343 // the widget wasn't realized yet, no need to thaw
4344 g_signal_handlers_disconnect_by_func
4345 (
4346 w,
4347 (void*)wx_frozen_widget_realize,
4348 NULL
4349 );
4350 return;
4351 }
4352
4353 gdk_window_thaw_updates(w->window);
4354 }
4355
4356 void wxWindowGTK::DoFreeze()
4357 {
4358 GTKFreezeWidget(m_widget);
4359 if ( m_wxwindow && m_widget != m_wxwindow )
4360 GTKFreezeWidget(m_wxwindow);
4361 }
4362
4363 void wxWindowGTK::DoThaw()
4364 {
4365 GTKThawWidget(m_widget);
4366 if ( m_wxwindow && m_widget != m_wxwindow )
4367 GTKThawWidget(m_wxwindow);
4368 }
wxWidgets (Impactor)