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