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