]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/window.cpp
Made wxDataViewCtrl sample use a real, expandabl data tree
[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
1248 wxPoint pt = win->GetClientAreaOrigin();
1249 event.m_x = (wxCoord)gdk_event->x - pt.x;
1250 event.m_y = (wxCoord)gdk_event->y - pt.y;
1251
1252 if ((win->m_wxwindow) && (win->GetLayoutDirection() == wxLayout_RightToLeft))
1253 {
1254 // origin in the upper right corner
1255 int window_width = gtk_pizza_get_rtl_offset( GTK_PIZZA(win->m_wxwindow) );
1256 event.m_x = window_width - event.m_x;
1257 }
1258
1259 event.SetEventObject( win );
1260 event.SetId( win->GetId() );
1261 event.SetTimestamp( gdk_event->time );
1262 }
1263
1264 static void AdjustEventButtonState(wxMouseEvent& event)
1265 {
1266 // GDK reports the old state of the button for a button press event, but
1267 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1268 // for a LEFT_DOWN event, not FALSE, so we will invert
1269 // left/right/middleDown for the corresponding click events
1270
1271 if ((event.GetEventType() == wxEVT_LEFT_DOWN) ||
1272 (event.GetEventType() == wxEVT_LEFT_DCLICK) ||
1273 (event.GetEventType() == wxEVT_LEFT_UP))
1274 {
1275 event.m_leftDown = !event.m_leftDown;
1276 return;
1277 }
1278
1279 if ((event.GetEventType() == wxEVT_MIDDLE_DOWN) ||
1280 (event.GetEventType() == wxEVT_MIDDLE_DCLICK) ||
1281 (event.GetEventType() == wxEVT_MIDDLE_UP))
1282 {
1283 event.m_middleDown = !event.m_middleDown;
1284 return;
1285 }
1286
1287 if ((event.GetEventType() == wxEVT_RIGHT_DOWN) ||
1288 (event.GetEventType() == wxEVT_RIGHT_DCLICK) ||
1289 (event.GetEventType() == wxEVT_RIGHT_UP))
1290 {
1291 event.m_rightDown = !event.m_rightDown;
1292 return;
1293 }
1294 }
1295
1296 // find the window to send the mouse event too
1297 static
1298 wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
1299 {
1300 wxCoord xx = x;
1301 wxCoord yy = y;
1302
1303 if (win->m_wxwindow)
1304 {
1305 GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
1306 xx += gtk_pizza_get_xoffset( pizza );
1307 yy += gtk_pizza_get_yoffset( pizza );
1308 }
1309
1310 wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
1311 while (node)
1312 {
1313 wxWindowGTK *child = node->GetData();
1314
1315 node = node->GetNext();
1316 if (!child->IsShown())
1317 continue;
1318
1319 if (child->IsTransparentForMouse())
1320 {
1321 // wxStaticBox is transparent in the box itself
1322 int xx1 = child->m_x;
1323 int yy1 = child->m_y;
1324 int xx2 = child->m_x + child->m_width;
1325 int yy2 = child->m_y + child->m_height;
1326
1327 // left
1328 if (((xx >= xx1) && (xx <= xx1+10) && (yy >= yy1) && (yy <= yy2)) ||
1329 // right
1330 ((xx >= xx2-10) && (xx <= xx2) && (yy >= yy1) && (yy <= yy2)) ||
1331 // top
1332 ((xx >= xx1) && (xx <= xx2) && (yy >= yy1) && (yy <= yy1+10)) ||
1333 // bottom
1334 ((xx >= xx1) && (xx <= xx2) && (yy >= yy2-1) && (yy <= yy2)))
1335 {
1336 win = child;
1337 x -= child->m_x;
1338 y -= child->m_y;
1339 break;
1340 }
1341
1342 }
1343 else
1344 {
1345 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
1346 (child->m_x <= xx) &&
1347 (child->m_y <= yy) &&
1348 (child->m_x+child->m_width >= xx) &&
1349 (child->m_y+child->m_height >= yy))
1350 {
1351 win = child;
1352 x -= child->m_x;
1353 y -= child->m_y;
1354 break;
1355 }
1356 }
1357 }
1358
1359 return win;
1360 }
1361
1362 // ----------------------------------------------------------------------------
1363 // common event handlers helpers
1364 // ----------------------------------------------------------------------------
1365
1366 bool wxWindowGTK::GTKProcessEvent(wxEvent& event) const
1367 {
1368 // nothing special at this level
1369 return GetEventHandler()->ProcessEvent(event);
1370 }
1371
1372 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const
1373 {
1374 DEBUG_MAIN_THREAD
1375
1376 if (!m_hasVMT)
1377 return FALSE;
1378 if (g_blockEventsOnDrag)
1379 return TRUE;
1380 if (g_blockEventsOnScroll)
1381 return TRUE;
1382
1383 if (!GTKIsOwnWindow(event->window))
1384 return FALSE;
1385
1386 return -1;
1387 }
1388
1389 // overloads for all GDK event types we use here: we need to have this as
1390 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1391 // derives from it in the sense that the structs have the same layout
1392 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1393 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1394 { \
1395 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1396 }
1397
1398 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton)
1399 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion)
1400 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing)
1401
1402 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1403
1404 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1405 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1406 if ( rc != -1 ) \
1407 return rc
1408
1409 // send the wxChildFocusEvent and wxFocusEvent, common code of
1410 // gtk_window_focus_in_callback() and SetFocus()
1411 static bool DoSendFocusEvents(wxWindow *win)
1412 {
1413 // Notify the parent keeping track of focus for the kbd navigation
1414 // purposes that we got it.
1415 wxChildFocusEvent eventChildFocus(win);
1416 (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
1417
1418 wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
1419 eventFocus.SetEventObject(win);
1420
1421 return win->GetEventHandler()->ProcessEvent(eventFocus);
1422 }
1423
1424 // all event handlers must have C linkage as they're called from GTK+ C code
1425 extern "C"
1426 {
1427
1428 //-----------------------------------------------------------------------------
1429 // "button_press_event"
1430 //-----------------------------------------------------------------------------
1431
1432 static gboolean
1433 gtk_window_button_press_callback( GtkWidget *widget,
1434 GdkEventButton *gdk_event,
1435 wxWindowGTK *win )
1436 {
1437 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1438
1439 g_lastButtonNumber = gdk_event->button;
1440
1441 if (win->m_wxwindow && (g_focusWindow != win) && win->IsFocusable())
1442 {
1443 gtk_widget_grab_focus( win->m_wxwindow );
1444 }
1445
1446 // GDK sends surplus button down events
1447 // before a double click event. We
1448 // need to filter these out.
1449 if ((gdk_event->type == GDK_BUTTON_PRESS) && (win->m_wxwindow))
1450 {
1451 GdkEvent *peek_event = gdk_event_peek();
1452 if (peek_event)
1453 {
1454 if ((peek_event->type == GDK_2BUTTON_PRESS) ||
1455 (peek_event->type == GDK_3BUTTON_PRESS))
1456 {
1457 gdk_event_free( peek_event );
1458 return TRUE;
1459 }
1460 else
1461 {
1462 gdk_event_free( peek_event );
1463 }
1464 }
1465 }
1466
1467 wxEventType event_type = wxEVT_NULL;
1468
1469 // GdkDisplay is a GTK+ 2.2.0 thing
1470 #if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0)
1471 if ( gdk_event->type == GDK_2BUTTON_PRESS &&
1472 !gtk_check_version(2,2,0) &&
1473 gdk_event->button >= 1 && gdk_event->button <= 3 )
1474 {
1475 // Reset GDK internal timestamp variables in order to disable GDK
1476 // triple click events. GDK will then next time believe no button has
1477 // been clicked just before, and send a normal button click event.
1478 GdkDisplay* display = gtk_widget_get_display (widget);
1479 display->button_click_time[1] = 0;
1480 display->button_click_time[0] = 0;
1481 }
1482 #endif // GTK 2+
1483
1484 if (gdk_event->button == 1)
1485 {
1486 // note that GDK generates triple click events which are not supported
1487 // by wxWidgets but still have to be passed to the app as otherwise
1488 // clicks would simply go missing
1489 switch (gdk_event->type)
1490 {
1491 // we shouldn't get triple clicks at all for GTK2 because we
1492 // suppress them artificially using the code above but we still
1493 // should map them to something for GTK1 and not just ignore them
1494 // as this would lose clicks
1495 case GDK_3BUTTON_PRESS: // we could also map this to DCLICK...
1496 case GDK_BUTTON_PRESS:
1497 event_type = wxEVT_LEFT_DOWN;
1498 break;
1499
1500 case GDK_2BUTTON_PRESS:
1501 event_type = wxEVT_LEFT_DCLICK;
1502 break;
1503
1504 default:
1505 // just to silence gcc warnings
1506 ;
1507 }
1508 }
1509 else if (gdk_event->button == 2)
1510 {
1511 switch (gdk_event->type)
1512 {
1513 case GDK_3BUTTON_PRESS:
1514 case GDK_BUTTON_PRESS:
1515 event_type = wxEVT_MIDDLE_DOWN;
1516 break;
1517
1518 case GDK_2BUTTON_PRESS:
1519 event_type = wxEVT_MIDDLE_DCLICK;
1520 break;
1521
1522 default:
1523 ;
1524 }
1525 }
1526 else if (gdk_event->button == 3)
1527 {
1528 switch (gdk_event->type)
1529 {
1530 case GDK_3BUTTON_PRESS:
1531 case GDK_BUTTON_PRESS:
1532 event_type = wxEVT_RIGHT_DOWN;
1533 break;
1534
1535 case GDK_2BUTTON_PRESS:
1536 event_type = wxEVT_RIGHT_DCLICK;
1537 break;
1538
1539 default:
1540 ;
1541 }
1542 }
1543
1544 if ( event_type == wxEVT_NULL )
1545 {
1546 // unknown mouse button or click type
1547 return FALSE;
1548 }
1549
1550 g_lastMouseEvent = (GdkEvent*) gdk_event;
1551
1552 wxMouseEvent event( event_type );
1553 InitMouseEvent( win, event, gdk_event );
1554
1555 AdjustEventButtonState(event);
1556
1557 // wxListBox actually gets mouse events from the item, so we need to give it
1558 // a chance to correct this
1559 win->FixUpMouseEvent(widget, event.m_x, event.m_y);
1560
1561 // find the correct window to send the event to: it may be a different one
1562 // from the one which got it at GTK+ level because some controls don't have
1563 // their own X window and thus cannot get any events.
1564 if ( !g_captureWindow )
1565 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1566
1567 // reset the event object and id in case win changed.
1568 event.SetEventObject( win );
1569 event.SetId( win->GetId() );
1570
1571 bool ret = win->GTKProcessEvent( event );
1572 g_lastMouseEvent = NULL;
1573 if ( ret )
1574 return TRUE;
1575
1576 if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() &&
1577 (g_focusWindow != win) && win->IsFocusable())
1578 {
1579 gtk_widget_grab_focus( win->m_wxwindow );
1580 }
1581
1582 if (event_type == wxEVT_RIGHT_DOWN)
1583 {
1584 // generate a "context menu" event: this is similar to right mouse
1585 // click under many GUIs except that it is generated differently
1586 // (right up under MSW, ctrl-click under Mac, right down here) and
1587 //
1588 // (a) it's a command event and so is propagated to the parent
1589 // (b) under some ports it can be generated from kbd too
1590 // (c) it uses screen coords (because of (a))
1591 wxContextMenuEvent evtCtx(
1592 wxEVT_CONTEXT_MENU,
1593 win->GetId(),
1594 win->ClientToScreen(event.GetPosition()));
1595 evtCtx.SetEventObject(win);
1596 return win->GTKProcessEvent(evtCtx);
1597 }
1598
1599 return FALSE;
1600 }
1601
1602 //-----------------------------------------------------------------------------
1603 // "button_release_event"
1604 //-----------------------------------------------------------------------------
1605
1606 static gboolean
1607 gtk_window_button_release_callback( GtkWidget *widget,
1608 GdkEventButton *gdk_event,
1609 wxWindowGTK *win )
1610 {
1611 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1612
1613 g_lastButtonNumber = 0;
1614
1615 wxEventType event_type = wxEVT_NULL;
1616
1617 switch (gdk_event->button)
1618 {
1619 case 1:
1620 event_type = wxEVT_LEFT_UP;
1621 break;
1622
1623 case 2:
1624 event_type = wxEVT_MIDDLE_UP;
1625 break;
1626
1627 case 3:
1628 event_type = wxEVT_RIGHT_UP;
1629 break;
1630
1631 default:
1632 // unknown button, don't process
1633 return FALSE;
1634 }
1635
1636 g_lastMouseEvent = (GdkEvent*) gdk_event;
1637
1638 wxMouseEvent event( event_type );
1639 InitMouseEvent( win, event, gdk_event );
1640
1641 AdjustEventButtonState(event);
1642
1643 // same wxListBox hack as above
1644 win->FixUpMouseEvent(widget, event.m_x, event.m_y);
1645
1646 if ( !g_captureWindow )
1647 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1648
1649 // reset the event object and id in case win changed.
1650 event.SetEventObject( win );
1651 event.SetId( win->GetId() );
1652
1653 bool ret = win->GTKProcessEvent(event);
1654
1655 g_lastMouseEvent = NULL;
1656
1657 return ret;
1658 }
1659
1660 //-----------------------------------------------------------------------------
1661 // "motion_notify_event"
1662 //-----------------------------------------------------------------------------
1663
1664 static gboolean
1665 gtk_window_motion_notify_callback( GtkWidget *widget,
1666 GdkEventMotion *gdk_event,
1667 wxWindowGTK *win )
1668 {
1669 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1670
1671 if (gdk_event->is_hint)
1672 {
1673 int x = 0;
1674 int y = 0;
1675 GdkModifierType state;
1676 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1677 gdk_event->x = x;
1678 gdk_event->y = y;
1679 }
1680
1681 g_lastMouseEvent = (GdkEvent*) gdk_event;
1682
1683 wxMouseEvent event( wxEVT_MOTION );
1684 InitMouseEvent(win, event, gdk_event);
1685
1686 if ( g_captureWindow )
1687 {
1688 // synthesise a mouse enter or leave event if needed
1689 GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
1690 // This seems to be necessary and actually been added to
1691 // GDK itself in version 2.0.X
1692 gdk_flush();
1693
1694 bool hasMouse = winUnderMouse == gdk_event->window;
1695 if ( hasMouse != g_captureWindowHasMouse )
1696 {
1697 // the mouse changed window
1698 g_captureWindowHasMouse = hasMouse;
1699
1700 wxMouseEvent eventM(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1701 : wxEVT_LEAVE_WINDOW);
1702 InitMouseEvent(win, eventM, gdk_event);
1703 eventM.SetEventObject(win);
1704 win->GTKProcessEvent(eventM);
1705 }
1706 }
1707 else // no capture
1708 {
1709 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1710
1711 // reset the event object and id in case win changed.
1712 event.SetEventObject( win );
1713 event.SetId( win->GetId() );
1714 }
1715
1716 if ( !g_captureWindow )
1717 {
1718 wxSetCursorEvent cevent( event.m_x, event.m_y );
1719 if (win->GTKProcessEvent( cevent ))
1720 {
1721 win->SetCursor( cevent.GetCursor() );
1722 }
1723 }
1724
1725 bool ret = win->GTKProcessEvent(event);
1726
1727 g_lastMouseEvent = NULL;
1728
1729 return ret;
1730 }
1731
1732 //-----------------------------------------------------------------------------
1733 // "scroll_event" (mouse wheel event)
1734 //-----------------------------------------------------------------------------
1735
1736 static gboolean
1737 window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
1738 {
1739 DEBUG_MAIN_THREAD
1740
1741 if (gdk_event->direction != GDK_SCROLL_UP &&
1742 gdk_event->direction != GDK_SCROLL_DOWN)
1743 {
1744 return false;
1745 }
1746
1747 wxMouseEvent event(wxEVT_MOUSEWHEEL);
1748 // Can't use InitMouse macro because scroll events don't have button
1749 event.SetTimestamp( gdk_event->time );
1750 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
1751 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
1752 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
1753 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
1754 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
1755 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
1756 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
1757 event.m_linesPerAction = 3;
1758 event.m_wheelDelta = 120;
1759 if (gdk_event->direction == GDK_SCROLL_UP)
1760 event.m_wheelRotation = 120;
1761 else
1762 event.m_wheelRotation = -120;
1763
1764 wxPoint pt = win->GetClientAreaOrigin();
1765 event.m_x = (wxCoord)gdk_event->x - pt.x;
1766 event.m_y = (wxCoord)gdk_event->y - pt.y;
1767
1768 event.SetEventObject( win );
1769 event.SetId( win->GetId() );
1770 event.SetTimestamp( gdk_event->time );
1771
1772 return win->GTKProcessEvent(event);
1773 }
1774
1775 //-----------------------------------------------------------------------------
1776 // "popup-menu"
1777 //-----------------------------------------------------------------------------
1778
1779 static gboolean wxgtk_window_popup_menu_callback(GtkWidget*, wxWindowGTK* win)
1780 {
1781 wxContextMenuEvent event(wxEVT_CONTEXT_MENU, win->GetId(), wxPoint(-1, -1));
1782 event.SetEventObject(win);
1783 return win->GTKProcessEvent(event);
1784 }
1785
1786 //-----------------------------------------------------------------------------
1787 // "focus_in_event"
1788 //-----------------------------------------------------------------------------
1789
1790 static gboolean
1791 gtk_window_focus_in_callback( GtkWidget *widget,
1792 GdkEventFocus *WXUNUSED(event),
1793 wxWindow *win )
1794 {
1795 DEBUG_MAIN_THREAD
1796
1797 if (win->m_imData)
1798 gtk_im_context_focus_in(win->m_imData->context);
1799
1800 g_focusWindowLast =
1801 g_focusWindow = win;
1802
1803 wxLogTrace(TRACE_FOCUS,
1804 _T("%s: focus in"), win->GetName().c_str());
1805
1806 #if wxUSE_CARET
1807 // caret needs to be informed about focus change
1808 wxCaret *caret = win->GetCaret();
1809 if ( caret )
1810 {
1811 caret->OnSetFocus();
1812 }
1813 #endif // wxUSE_CARET
1814
1815 gboolean ret = FALSE;
1816
1817 // does the window itself think that it has the focus?
1818 if ( !win->m_hasFocus )
1819 {
1820 // not yet, notify it
1821 win->m_hasFocus = true;
1822
1823 (void)DoSendFocusEvents(win);
1824
1825 ret = TRUE;
1826 }
1827
1828 // Disable default focus handling for custom windows
1829 // since the default GTK+ handler issues a repaint
1830 if (win->m_wxwindow)
1831 return ret;
1832
1833 return FALSE;
1834 }
1835
1836 //-----------------------------------------------------------------------------
1837 // "focus_out_event"
1838 //-----------------------------------------------------------------------------
1839
1840 static gboolean
1841 gtk_window_focus_out_callback( GtkWidget *widget,
1842 GdkEventFocus *gdk_event,
1843 wxWindowGTK *win )
1844 {
1845 DEBUG_MAIN_THREAD
1846
1847 if (win->m_imData)
1848 gtk_im_context_focus_out(win->m_imData->context);
1849
1850 wxLogTrace( TRACE_FOCUS,
1851 _T("%s: focus out"), win->GetName().c_str() );
1852
1853
1854 wxWindowGTK *winFocus = wxFindFocusedChild(win);
1855 if ( winFocus )
1856 win = winFocus;
1857
1858 g_focusWindow = (wxWindowGTK *)NULL;
1859
1860 #if wxUSE_CARET
1861 // caret needs to be informed about focus change
1862 wxCaret *caret = win->GetCaret();
1863 if ( caret )
1864 {
1865 caret->OnKillFocus();
1866 }
1867 #endif // wxUSE_CARET
1868
1869 // don't send the window a kill focus event if it thinks that it doesn't
1870 // have focus already
1871 if ( win->m_hasFocus )
1872 {
1873 // the event handler might delete the window when it loses focus, so
1874 // check whether this is a custom window before calling it
1875 const bool has_wxwindow = win->m_wxwindow != NULL;
1876
1877 win->m_hasFocus = false;
1878
1879 wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
1880 event.SetEventObject( win );
1881
1882 (void)win->GTKProcessEvent( event );
1883
1884 // Disable default focus handling for custom windows
1885 // since the default GTK+ handler issues a repaint
1886 if ( has_wxwindow )
1887 return TRUE;
1888 }
1889
1890 // continue with normal processing
1891 return FALSE;
1892 }
1893
1894 static gboolean
1895 wx_window_focus_callback(GtkWidget *widget,
1896 GtkDirectionType direction,
1897 wxWindowGTK *win)
1898 {
1899 // the default handler for focus signal in GtkPizza (or, rather, in
1900 // GtkScrolledWindow from which GtkPizza inherits this behaviour) sets
1901 // focus to the window itself even if it doesn't accept focus, i.e. has no
1902 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1903 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1904 // any children which might accept focus (we know we don't accept the focus
1905 // ourselves as this signal is only connected in this case)
1906 if ( win->GetChildren().empty() )
1907 g_signal_stop_emission_by_name(widget, "focus");
1908
1909 // we didn't change the focus
1910 return FALSE;
1911 }
1912
1913 //-----------------------------------------------------------------------------
1914 // "enter_notify_event"
1915 //-----------------------------------------------------------------------------
1916
1917 static gboolean
1918 gtk_window_enter_callback( GtkWidget *widget,
1919 GdkEventCrossing *gdk_event,
1920 wxWindowGTK *win )
1921 {
1922 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1923
1924 // Event was emitted after a grab
1925 if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
1926
1927 int x = 0;
1928 int y = 0;
1929 GdkModifierType state = (GdkModifierType)0;
1930
1931 gdk_window_get_pointer( widget->window, &x, &y, &state );
1932
1933 wxMouseEvent event( wxEVT_ENTER_WINDOW );
1934 InitMouseEvent(win, event, gdk_event);
1935 wxPoint pt = win->GetClientAreaOrigin();
1936 event.m_x = x + pt.x;
1937 event.m_y = y + pt.y;
1938
1939 if ( !g_captureWindow )
1940 {
1941 wxSetCursorEvent cevent( event.m_x, event.m_y );
1942 if (win->GTKProcessEvent( cevent ))
1943 {
1944 win->SetCursor( cevent.GetCursor() );
1945 }
1946 }
1947
1948 return win->GTKProcessEvent(event);
1949 }
1950
1951 //-----------------------------------------------------------------------------
1952 // "leave_notify_event"
1953 //-----------------------------------------------------------------------------
1954
1955 static gboolean
1956 gtk_window_leave_callback( GtkWidget *widget,
1957 GdkEventCrossing *gdk_event,
1958 wxWindowGTK *win )
1959 {
1960 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1961
1962 // Event was emitted after an ungrab
1963 if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
1964
1965 wxMouseEvent event( wxEVT_LEAVE_WINDOW );
1966 event.SetTimestamp( gdk_event->time );
1967 event.SetEventObject( win );
1968
1969 int x = 0;
1970 int y = 0;
1971 GdkModifierType state = (GdkModifierType)0;
1972
1973 gdk_window_get_pointer( widget->window, &x, &y, &state );
1974
1975 event.m_shiftDown = (state & GDK_SHIFT_MASK) != 0;
1976 event.m_controlDown = (state & GDK_CONTROL_MASK) != 0;
1977 event.m_altDown = (state & GDK_MOD1_MASK) != 0;
1978 event.m_metaDown = (state & GDK_MOD2_MASK) != 0;
1979 event.m_leftDown = (state & GDK_BUTTON1_MASK) != 0;
1980 event.m_middleDown = (state & GDK_BUTTON2_MASK) != 0;
1981 event.m_rightDown = (state & GDK_BUTTON3_MASK) != 0;
1982
1983 wxPoint pt = win->GetClientAreaOrigin();
1984 event.m_x = x + pt.x;
1985 event.m_y = y + pt.y;
1986
1987 return win->GTKProcessEvent(event);
1988 }
1989
1990 //-----------------------------------------------------------------------------
1991 // "value_changed" from scrollbar
1992 //-----------------------------------------------------------------------------
1993
1994 static void
1995 gtk_scrollbar_value_changed(GtkRange* range, wxWindow* win)
1996 {
1997 wxEventType eventType = win->GetScrollEventType(range);
1998 if (eventType != wxEVT_NULL)
1999 {
2000 // Convert scroll event type to scrollwin event type
2001 eventType += wxEVT_SCROLLWIN_TOP - wxEVT_SCROLL_TOP;
2002
2003 // find the scrollbar which generated the event
2004 wxWindowGTK::ScrollDir dir = win->ScrollDirFromRange(range);
2005
2006 // generate the corresponding wx event
2007 const int orient = wxWindow::OrientFromScrollDir(dir);
2008 wxScrollWinEvent event(eventType, win->GetScrollPos(orient), orient);
2009 event.SetEventObject(win);
2010
2011 win->GTKProcessEvent(event);
2012 }
2013 }
2014
2015 //-----------------------------------------------------------------------------
2016 // "button_press_event" from scrollbar
2017 //-----------------------------------------------------------------------------
2018
2019 static gboolean
2020 gtk_scrollbar_button_press_event(GtkRange*, GdkEventButton*, wxWindow* win)
2021 {
2022 DEBUG_MAIN_THREAD
2023
2024 g_blockEventsOnScroll = true;
2025 win->m_mouseButtonDown = true;
2026
2027 return false;
2028 }
2029
2030 //-----------------------------------------------------------------------------
2031 // "event_after" from scrollbar
2032 //-----------------------------------------------------------------------------
2033
2034 static void
2035 gtk_scrollbar_event_after(GtkRange* range, GdkEvent* event, wxWindow* win)
2036 {
2037 if (event->type == GDK_BUTTON_RELEASE)
2038 {
2039 g_signal_handlers_block_by_func(range, (void*)gtk_scrollbar_event_after, win);
2040
2041 const int orient = wxWindow::OrientFromScrollDir(
2042 win->ScrollDirFromRange(range));
2043 wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBRELEASE, win->GetScrollPos(orient), orient);
2044 event.SetEventObject(win);
2045 win->GTKProcessEvent(event);
2046 }
2047 }
2048
2049 //-----------------------------------------------------------------------------
2050 // "button_release_event" from scrollbar
2051 //-----------------------------------------------------------------------------
2052
2053 static gboolean
2054 gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* win)
2055 {
2056 DEBUG_MAIN_THREAD
2057
2058 g_blockEventsOnScroll = false;
2059 win->m_mouseButtonDown = false;
2060 // If thumb tracking
2061 if (win->m_isScrolling)
2062 {
2063 win->m_isScrolling = false;
2064 // Hook up handler to send thumb release event after this emission is finished.
2065 // To allow setting scroll position from event handler, sending event must
2066 // be deferred until after the GtkRange handler for this signal has run
2067 g_signal_handlers_unblock_by_func(range, (void*)gtk_scrollbar_event_after, win);
2068 }
2069
2070 return false;
2071 }
2072
2073 //-----------------------------------------------------------------------------
2074 // "realize" from m_widget
2075 //-----------------------------------------------------------------------------
2076
2077 static void
2078 gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
2079 {
2080 DEBUG_MAIN_THREAD
2081
2082 if (win->m_imData)
2083 {
2084 GtkPizza *pizza = GTK_PIZZA( m_widget );
2085 gtk_im_context_set_client_window( win->m_imData->context,
2086 pizza->bin_window );
2087 }
2088
2089 // We cannot set colours and fonts before the widget
2090 // been realized, so we do this directly after realization
2091 // or otherwise in idle time
2092
2093 if (win->m_needsStyleChange)
2094 {
2095 win->SetBackgroundStyle(win->GetBackgroundStyle());
2096 win->m_needsStyleChange = false;
2097 }
2098
2099 wxWindowCreateEvent event( win );
2100 event.SetEventObject( win );
2101 win->GTKProcessEvent( event );
2102 }
2103
2104 //-----------------------------------------------------------------------------
2105 // "size_allocate"
2106 //-----------------------------------------------------------------------------
2107
2108 static
2109 void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
2110 GtkAllocation *alloc,
2111 wxWindow *win )
2112 {
2113 int client_width = 0;
2114 int client_height = 0;
2115 win->GetClientSize( &client_width, &client_height );
2116 if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight))
2117 return;
2118
2119 if ( !client_width && !client_height )
2120 {
2121 // the window is currently unmapped, don't generate size events
2122 return;
2123 }
2124
2125 win->m_oldClientWidth = client_width;
2126 win->m_oldClientHeight = client_height;
2127
2128 if (!win->m_nativeSizeEvent)
2129 {
2130 wxSizeEvent event( win->GetSize(), win->GetId() );
2131 event.SetEventObject( win );
2132 win->GTKProcessEvent( event );
2133 }
2134 }
2135
2136 } // extern "C"
2137
2138 // ----------------------------------------------------------------------------
2139 // this wxWindowBase function is implemented here (in platform-specific file)
2140 // because it is static and so couldn't be made virtual
2141 // ----------------------------------------------------------------------------
2142
2143 wxWindow *wxWindowBase::DoFindFocus()
2144 {
2145 // the cast is necessary when we compile in wxUniversal mode
2146 return (wxWindow *)g_focusWindow;
2147 }
2148
2149 //-----------------------------------------------------------------------------
2150 // InsertChild for wxWindowGTK.
2151 //-----------------------------------------------------------------------------
2152
2153 /* Callback for wxWindowGTK. This very strange beast has to be used because
2154 * C++ has no virtual methods in a constructor. We have to emulate a
2155 * virtual function here as wxNotebook requires a different way to insert
2156 * a child in it. I had opted for creating a wxNotebookPage window class
2157 * which would have made this superfluous (such in the MDI window system),
2158 * but no-one was listening to me... */
2159
2160 static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
2161 {
2162 /* the window might have been scrolled already, do we
2163 have to adapt the position */
2164 GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
2165 child->m_x += gtk_pizza_get_xoffset( pizza );
2166 child->m_y += gtk_pizza_get_yoffset( pizza );
2167
2168 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
2169 child->m_widget,
2170 child->m_x,
2171 child->m_y,
2172 child->m_width,
2173 child->m_height );
2174 }
2175
2176 //-----------------------------------------------------------------------------
2177 // global functions
2178 //-----------------------------------------------------------------------------
2179
2180 wxWindow *wxGetActiveWindow()
2181 {
2182 return wxWindow::FindFocus();
2183 }
2184
2185
2186 wxMouseState wxGetMouseState()
2187 {
2188 wxMouseState ms;
2189
2190 gint x;
2191 gint y;
2192 GdkModifierType mask;
2193
2194 gdk_window_get_pointer(NULL, &x, &y, &mask);
2195
2196 ms.SetX(x);
2197 ms.SetY(y);
2198 ms.SetLeftDown(mask & GDK_BUTTON1_MASK);
2199 ms.SetMiddleDown(mask & GDK_BUTTON2_MASK);
2200 ms.SetRightDown(mask & GDK_BUTTON3_MASK);
2201
2202 ms.SetControlDown(mask & GDK_CONTROL_MASK);
2203 ms.SetShiftDown(mask & GDK_SHIFT_MASK);
2204 ms.SetAltDown(mask & GDK_MOD1_MASK);
2205 ms.SetMetaDown(mask & GDK_MOD2_MASK);
2206
2207 return ms;
2208 }
2209
2210 //-----------------------------------------------------------------------------
2211 // wxWindowGTK
2212 //-----------------------------------------------------------------------------
2213
2214 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2215 // method
2216 #ifdef __WXUNIVERSAL__
2217 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
2218 #else // __WXGTK__
2219 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
2220 #endif // __WXUNIVERSAL__/__WXGTK__
2221
2222 void wxWindowGTK::Init()
2223 {
2224 // GTK specific
2225 m_widget = (GtkWidget *) NULL;
2226 m_wxwindow = (GtkWidget *) NULL;
2227 m_focusWidget = (GtkWidget *) NULL;
2228
2229 // position/size
2230 m_x = 0;
2231 m_y = 0;
2232 m_width = 0;
2233 m_height = 0;
2234
2235 m_hasVMT = false;
2236 m_isBeingDeleted = false;
2237
2238 m_showOnIdle= false;
2239
2240 m_noExpose = false;
2241 m_nativeSizeEvent = false;
2242
2243 m_hasScrolling = false;
2244 m_isScrolling = false;
2245 m_mouseButtonDown = false;
2246 m_blockScrollEvent = false;
2247
2248 // initialize scrolling stuff
2249 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
2250 {
2251 m_scrollBar[dir] = NULL;
2252 m_scrollPos[dir] = 0;
2253 }
2254
2255 m_oldClientWidth =
2256 m_oldClientHeight = 0;
2257
2258 m_resizing = false;
2259
2260 m_insertCallback = wxInsertChildInWindow;
2261
2262 m_hasFocus = false;
2263
2264 m_clipPaintRegion = false;
2265
2266 m_needsStyleChange = false;
2267
2268 m_cursor = *wxSTANDARD_CURSOR;
2269
2270 m_imData = NULL;
2271 m_dirtyTabOrder = false;
2272 }
2273
2274 wxWindowGTK::wxWindowGTK()
2275 {
2276 Init();
2277 }
2278
2279 wxWindowGTK::wxWindowGTK( wxWindow *parent,
2280 wxWindowID id,
2281 const wxPoint &pos,
2282 const wxSize &size,
2283 long style,
2284 const wxString &name )
2285 {
2286 Init();
2287
2288 Create( parent, id, pos, size, style, name );
2289 }
2290
2291 bool wxWindowGTK::Create( wxWindow *parent,
2292 wxWindowID id,
2293 const wxPoint &pos,
2294 const wxSize &size,
2295 long style,
2296 const wxString &name )
2297 {
2298 if (!PreCreation( parent, pos, size ) ||
2299 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2300 {
2301 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2302 return false;
2303 }
2304
2305 if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
2306 {
2307 m_wxwindow = gtk_pizza_new_no_scroll();
2308
2309 #ifndef __WXUNIVERSAL__
2310 if (HasFlag(wxSIMPLE_BORDER))
2311 gtk_container_set_border_width((GtkContainer*)m_wxwindow, 1);
2312 else if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2313 gtk_container_set_border_width((GtkContainer*)m_wxwindow, 2);
2314 #endif // __WXUNIVERSAL__
2315
2316 m_widget = m_wxwindow;
2317 }
2318 else
2319 {
2320 m_wxwindow = gtk_pizza_new();
2321
2322 #ifndef __WXUNIVERSAL__
2323 if (HasFlag(wxSIMPLE_BORDER))
2324 gtk_container_set_border_width((GtkContainer*)m_wxwindow, 1);
2325 else if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2326 gtk_container_set_border_width((GtkContainer*)m_wxwindow, 2);
2327 #endif // __WXUNIVERSAL__
2328
2329 m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
2330
2331 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
2332
2333 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2334 scroll_class->scrollbar_spacing = 0;
2335
2336 // There is a conflict with default bindings at GTK+
2337 // level between scrolled windows and notebooks both of which want to use
2338 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2339 // direction and notebooks for changing pages -- we decide that if we don't
2340 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2341 // means we can get working keyboard navigation in notebooks
2342 if ( !HasFlag(wxHSCROLL) )
2343 {
2344 GtkBindingSet *
2345 bindings = gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget));
2346 if ( bindings )
2347 {
2348 gtk_binding_entry_remove(bindings, GDK_Page_Up, GDK_CONTROL_MASK);
2349 gtk_binding_entry_remove(bindings, GDK_Page_Down, GDK_CONTROL_MASK);
2350 }
2351 }
2352
2353 if (HasFlag(wxALWAYS_SHOW_SB))
2354 {
2355 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
2356
2357 scrolledWindow->hscrollbar_visible = TRUE;
2358 scrolledWindow->vscrollbar_visible = TRUE;
2359 }
2360 else
2361 {
2362 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
2363 }
2364
2365 m_scrollBar[ScrollDir_Horz] = GTK_RANGE(scrolledWindow->hscrollbar);
2366 m_scrollBar[ScrollDir_Vert] = GTK_RANGE(scrolledWindow->vscrollbar);
2367 if (GetLayoutDirection() == wxLayout_RightToLeft)
2368 gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );
2369
2370 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
2371
2372 // connect various scroll-related events
2373 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
2374 {
2375 // these handlers block mouse events to any window during scrolling
2376 // such as motion events and prevent GTK and wxWidgets from fighting
2377 // over where the slider should be
2378 g_signal_connect(m_scrollBar[dir], "button_press_event",
2379 G_CALLBACK(gtk_scrollbar_button_press_event), this);
2380 g_signal_connect(m_scrollBar[dir], "button_release_event",
2381 G_CALLBACK(gtk_scrollbar_button_release_event), this);
2382
2383 gulong handler_id = g_signal_connect(m_scrollBar[dir], "event_after",
2384 G_CALLBACK(gtk_scrollbar_event_after), this);
2385 g_signal_handler_block(m_scrollBar[dir], handler_id);
2386
2387 // these handlers get notified when scrollbar slider moves
2388 g_signal_connect_after(m_scrollBar[dir], "value_changed",
2389 G_CALLBACK(gtk_scrollbar_value_changed), this);
2390 }
2391
2392 gtk_widget_show( m_wxwindow );
2393 }
2394
2395 if (m_parent)
2396 m_parent->DoAddChild( this );
2397
2398 m_focusWidget = m_wxwindow;
2399
2400 PostCreation();
2401
2402 return true;
2403 }
2404
2405 wxWindowGTK::~wxWindowGTK()
2406 {
2407 SendDestroyEvent();
2408
2409 if (g_focusWindow == this)
2410 g_focusWindow = NULL;
2411
2412 if ( g_delayedFocus == this )
2413 g_delayedFocus = NULL;
2414
2415 m_isBeingDeleted = true;
2416 m_hasVMT = false;
2417
2418 // destroy children before destroying this window itself
2419 DestroyChildren();
2420
2421 // unhook focus handlers to prevent stray events being
2422 // propagated to this (soon to be) dead object
2423 if (m_focusWidget != NULL)
2424 {
2425 g_signal_handlers_disconnect_by_func (m_focusWidget,
2426 (gpointer) gtk_window_focus_in_callback,
2427 this);
2428 g_signal_handlers_disconnect_by_func (m_focusWidget,
2429 (gpointer) gtk_window_focus_out_callback,
2430 this);
2431 }
2432
2433 if (m_widget)
2434 Show( false );
2435
2436 // delete before the widgets to avoid a crash on solaris
2437 delete m_imData;
2438
2439 if (m_wxwindow && (m_wxwindow != m_widget))
2440 {
2441 gtk_widget_destroy( m_wxwindow );
2442 m_wxwindow = (GtkWidget*) NULL;
2443 }
2444
2445 if (m_widget)
2446 {
2447 gtk_widget_destroy( m_widget );
2448 m_widget = (GtkWidget*) NULL;
2449 }
2450 }
2451
2452 bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
2453 {
2454 if ( GTKNeedsParent() )
2455 {
2456 wxCHECK_MSG( parent, false, wxT("Must have non-NULL parent") );
2457 }
2458
2459 // Use either the given size, or the default if -1 is given.
2460 // See wxWindowBase for these functions.
2461 m_width = WidthDefault(size.x) ;
2462 m_height = HeightDefault(size.y);
2463
2464 m_x = (int)pos.x;
2465 m_y = (int)pos.y;
2466
2467 return true;
2468 }
2469
2470 void wxWindowGTK::PostCreation()
2471 {
2472 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2473
2474 if (m_wxwindow)
2475 {
2476 if (!m_noExpose)
2477 {
2478 // these get reported to wxWidgets -> wxPaintEvent
2479
2480 g_signal_connect (m_wxwindow, "expose_event",
2481 G_CALLBACK (gtk_window_expose_callback), this);
2482
2483 if (GetLayoutDirection() == wxLayout_LeftToRight)
2484 gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
2485 }
2486
2487 // Create input method handler
2488 m_imData = new wxGtkIMData;
2489
2490 // Cannot handle drawing preedited text yet
2491 gtk_im_context_set_use_preedit( m_imData->context, FALSE );
2492
2493 g_signal_connect (m_imData->context, "commit",
2494 G_CALLBACK (gtk_wxwindow_commit_cb), this);
2495
2496 // these are called when the "sunken" or "raised" borders are drawn
2497 g_signal_connect (m_widget, "expose_event",
2498 G_CALLBACK (gtk_window_own_expose_callback), this);
2499 }
2500
2501 // focus handling
2502
2503 if (!GTK_IS_WINDOW(m_widget))
2504 {
2505 if (m_focusWidget == NULL)
2506 m_focusWidget = m_widget;
2507
2508 if (m_wxwindow)
2509 {
2510 g_signal_connect (m_focusWidget, "focus_in_event",
2511 G_CALLBACK (gtk_window_focus_in_callback), this);
2512 g_signal_connect (m_focusWidget, "focus_out_event",
2513 G_CALLBACK (gtk_window_focus_out_callback), this);
2514 }
2515 else
2516 {
2517 g_signal_connect_after (m_focusWidget, "focus_in_event",
2518 G_CALLBACK (gtk_window_focus_in_callback), this);
2519 g_signal_connect_after (m_focusWidget, "focus_out_event",
2520 G_CALLBACK (gtk_window_focus_out_callback), this);
2521 }
2522 }
2523
2524 if ( !AcceptsFocusFromKeyboard() )
2525 {
2526 SetCanFocus(false);
2527
2528 g_signal_connect(m_widget, "focus",
2529 G_CALLBACK(wx_window_focus_callback), this);
2530 }
2531
2532 // connect to the various key and mouse handlers
2533
2534 GtkWidget *connect_widget = GetConnectWidget();
2535
2536 ConnectWidget( connect_widget );
2537
2538 /* We cannot set colours, fonts and cursors before the widget has
2539 been realized, so we do this directly after realization */
2540 g_signal_connect (connect_widget, "realize",
2541 G_CALLBACK (gtk_window_realized_callback), this);
2542
2543 if (m_wxwindow)
2544 {
2545 // Catch native resize events
2546 g_signal_connect (m_wxwindow, "size_allocate",
2547 G_CALLBACK (gtk_window_size_callback), this);
2548 }
2549
2550 #if wxUSE_COMBOBOX
2551 if (GTK_IS_COMBO(m_widget))
2552 {
2553 GtkCombo *gcombo = GTK_COMBO(m_widget);
2554
2555 g_signal_connect (gcombo->entry, "size_request",
2556 G_CALLBACK (wxgtk_combo_size_request_callback),
2557 this);
2558 } else
2559 #endif // wxUSE_COMBOBOX
2560 #ifdef GTK_IS_FILE_CHOOSER_BUTTON
2561 if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget))
2562 {
2563 // If we connect to the "size_request" signal of a GtkFileChooserButton
2564 // then that control won't be sized properly when placed inside sizers
2565 // (this can be tested removing this elseif and running XRC or WIDGETS samples)
2566 // FIXME: what should be done here ?
2567 } else
2568 #endif
2569 if ( !IsTopLevel() ) // top level windows use their own callback
2570 {
2571 // This is needed if we want to add our windows into native
2572 // GTK controls, such as the toolbar. With this callback, the
2573 // toolbar gets to know the correct size (the one set by the
2574 // programmer). Sadly, it misbehaves for wxComboBox.
2575 g_signal_connect (m_widget, "size_request",
2576 G_CALLBACK (wxgtk_window_size_request_callback),
2577 this);
2578 }
2579
2580 InheritAttributes();
2581
2582 m_hasVMT = true;
2583
2584 SetLayoutDirection(wxLayout_Default);
2585
2586 // unless the window was created initially hidden (i.e. Hide() had been
2587 // called before Create()), we should show it at GTK+ level as well
2588 if ( IsShown() )
2589 gtk_widget_show( m_widget );
2590 }
2591
2592 void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2593 {
2594 g_signal_connect (widget, "key_press_event",
2595 G_CALLBACK (gtk_window_key_press_callback), this);
2596 g_signal_connect (widget, "key_release_event",
2597 G_CALLBACK (gtk_window_key_release_callback), this);
2598 g_signal_connect (widget, "button_press_event",
2599 G_CALLBACK (gtk_window_button_press_callback), this);
2600 g_signal_connect (widget, "button_release_event",
2601 G_CALLBACK (gtk_window_button_release_callback), this);
2602 g_signal_connect (widget, "motion_notify_event",
2603 G_CALLBACK (gtk_window_motion_notify_callback), this);
2604 g_signal_connect (widget, "scroll_event",
2605 G_CALLBACK (window_scroll_event), this);
2606 g_signal_connect (widget, "popup_menu",
2607 G_CALLBACK (wxgtk_window_popup_menu_callback), this);
2608 g_signal_connect (widget, "enter_notify_event",
2609 G_CALLBACK (gtk_window_enter_callback), this);
2610 g_signal_connect (widget, "leave_notify_event",
2611 G_CALLBACK (gtk_window_leave_callback), this);
2612 }
2613
2614 bool wxWindowGTK::Destroy()
2615 {
2616 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2617
2618 m_hasVMT = false;
2619
2620 return wxWindowBase::Destroy();
2621 }
2622
2623 void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
2624 {
2625 // inform the parent to perform the move
2626 gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
2627
2628 }
2629
2630 void wxWindowGTK::ConstrainSize()
2631 {
2632 #ifdef __WXGPE__
2633 // GPE's window manager doesn't like size hints at all, esp. when the user
2634 // has to use the virtual keyboard, so don't constrain size there
2635 if (!IsTopLevel())
2636 #endif
2637 {
2638 const wxSize minSize = GetMinSize();
2639 const wxSize maxSize = GetMaxSize();
2640 if (minSize.x > 0 && m_width < minSize.x) m_width = minSize.x;
2641 if (minSize.y > 0 && m_height < minSize.y) m_height = minSize.y;
2642 if (maxSize.x > 0 && m_width > maxSize.x) m_width = maxSize.x;
2643 if (maxSize.y > 0 && m_height > maxSize.y) m_height = maxSize.y;
2644 }
2645 }
2646
2647 void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2648 {
2649 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2650 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
2651
2652 if (m_resizing) return; /* I don't like recursions */
2653 m_resizing = true;
2654
2655 int currentX, currentY;
2656 GetPosition(&currentX, &currentY);
2657 if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2658 x = currentX;
2659 if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2660 y = currentY;
2661 AdjustForParentClientOrigin(x, y, sizeFlags);
2662
2663 // calculate the best size if we should auto size the window
2664 if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
2665 ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
2666 {
2667 const wxSize sizeBest = GetBestSize();
2668 if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
2669 width = sizeBest.x;
2670 if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
2671 height = sizeBest.y;
2672 }
2673
2674 if (width != -1)
2675 m_width = width;
2676 if (height != -1)
2677 m_height = height;
2678
2679 ConstrainSize();
2680
2681 #if wxUSE_TOOLBAR_NATIVE
2682 if (wxDynamicCast(GetParent(), wxToolBar))
2683 {
2684 // don't take the x,y values, they're wrong because toolbar sets them
2685 GtkWidget *widget = m_widget;
2686 gtk_widget_set_size_request (widget, m_width, m_height);
2687 }
2688 else
2689 #endif
2690 if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook
2691 {
2692 // don't set the size for children of wxNotebook, just take the values.
2693 m_x = x;
2694 m_y = y;
2695 m_width = width;
2696 m_height = height;
2697 }
2698 else
2699 {
2700 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2701 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
2702 {
2703 if (x != -1) m_x = x + gtk_pizza_get_xoffset( pizza );
2704 if (y != -1) m_y = y + gtk_pizza_get_yoffset( pizza );
2705 }
2706 else
2707 {
2708 m_x = x + gtk_pizza_get_xoffset( pizza );
2709 m_y = y + gtk_pizza_get_yoffset( pizza );
2710 }
2711
2712 int left_border = 0;
2713 int right_border = 0;
2714 int top_border = 0;
2715 int bottom_border = 0;
2716
2717 /* the default button has a border around it */
2718 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
2719 {
2720 GtkBorder *default_border = NULL;
2721 gtk_widget_style_get( m_widget, "default_border", &default_border, NULL );
2722 if (default_border)
2723 {
2724 left_border += default_border->left;
2725 right_border += default_border->right;
2726 top_border += default_border->top;
2727 bottom_border += default_border->bottom;
2728 gtk_border_free( default_border );
2729 }
2730 }
2731
2732 DoMoveWindow( m_x - left_border,
2733 m_y - top_border,
2734 m_width+left_border+right_border,
2735 m_height+top_border+bottom_border );
2736 }
2737
2738 if (m_hasScrolling)
2739 {
2740 /* Sometimes the client area changes size without the
2741 whole windows's size changing, but if the whole
2742 windows's size doesn't change, no wxSizeEvent will
2743 normally be sent. Here we add an extra test if
2744 the client test has been changed and this will
2745 be used then. */
2746 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
2747 }
2748
2749 /*
2750 wxPrintf( "OnSize sent from " );
2751 if (GetClassInfo() && GetClassInfo()->GetClassName())
2752 wxPrintf( GetClassInfo()->GetClassName() );
2753 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2754 */
2755
2756 if (!m_nativeSizeEvent)
2757 {
2758 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2759 event.SetEventObject( this );
2760 GetEventHandler()->ProcessEvent( event );
2761 }
2762
2763 m_resizing = false;
2764 }
2765
2766 bool wxWindowGTK::GtkShowFromOnIdle()
2767 {
2768 if (IsShown() && m_showOnIdle && !GTK_WIDGET_VISIBLE (m_widget))
2769 {
2770 GtkAllocation alloc;
2771 alloc.x = m_x;
2772 alloc.y = m_y;
2773 alloc.width = m_width;
2774 alloc.height = m_height;
2775 gtk_widget_size_allocate( m_widget, &alloc );
2776 gtk_widget_show( m_widget );
2777 wxShowEvent eventShow(GetId(), true);
2778 eventShow.SetEventObject(this);
2779 GetEventHandler()->ProcessEvent(eventShow);
2780 m_showOnIdle = false;
2781 return true;
2782 }
2783
2784 return false;
2785 }
2786
2787 void wxWindowGTK::OnInternalIdle()
2788 {
2789 // Check if we have to show window now
2790 if (GtkShowFromOnIdle()) return;
2791
2792 if ( m_dirtyTabOrder )
2793 {
2794 m_dirtyTabOrder = false;
2795 RealizeTabOrder();
2796 }
2797
2798 // Update style if the window was not yet realized
2799 // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
2800 if (m_needsStyleChange)
2801 {
2802 SetBackgroundStyle(GetBackgroundStyle());
2803 m_needsStyleChange = false;
2804 }
2805
2806 wxCursor cursor = m_cursor;
2807 if (g_globalCursor.Ok()) cursor = g_globalCursor;
2808
2809 if (cursor.Ok())
2810 {
2811 /* I now set the cursor anew in every OnInternalIdle call
2812 as setting the cursor in a parent window also effects the
2813 windows above so that checking for the current cursor is
2814 not possible. */
2815
2816 if (m_wxwindow && (m_wxwindow != m_widget))
2817 {
2818 GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
2819 if (window)
2820 gdk_window_set_cursor( window, cursor.GetCursor() );
2821
2822 if (!g_globalCursor.Ok())
2823 cursor = *wxSTANDARD_CURSOR;
2824
2825 window = m_widget->window;
2826 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2827 gdk_window_set_cursor( window, cursor.GetCursor() );
2828
2829 }
2830 else if ( m_widget )
2831 {
2832 GdkWindow *window = m_widget->window;
2833 if ( window && !GTK_WIDGET_NO_WINDOW(m_widget) )
2834 gdk_window_set_cursor( window, cursor.GetCursor() );
2835 }
2836 }
2837
2838 if (wxUpdateUIEvent::CanUpdate(this))
2839 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
2840 }
2841
2842 void wxWindowGTK::DoGetSize( int *width, int *height ) const
2843 {
2844 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2845
2846 if (width) (*width) = m_width;
2847 if (height) (*height) = m_height;
2848 }
2849
2850 void wxWindowGTK::DoSetClientSize( int width, int height )
2851 {
2852 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2853
2854 const wxSize size = GetSize();
2855 const wxSize clientSize = GetClientSize();
2856 SetSize(width + (size.x - clientSize.x), height + (size.y - clientSize.y));
2857 }
2858
2859 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
2860 {
2861 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2862
2863 int w = m_width;
2864 int h = m_height;
2865
2866 if (m_wxwindow)
2867 {
2868 int dw = 0;
2869 int dh = 0;
2870
2871 if (m_hasScrolling)
2872 GetScrollbarWidth(m_widget, dw, dh);
2873
2874 const int border = GTK_CONTAINER(m_wxwindow)->border_width;
2875 dw += 2 * border;
2876 dh += 2 * border;
2877
2878 w -= dw;
2879 h -= dh;
2880 if (w < 0)
2881 w = 0;
2882 if (h < 0)
2883 h = 0;
2884 }
2885
2886 if (width) *width = w;
2887 if (height) *height = h;
2888 }
2889
2890 void wxWindowGTK::DoGetPosition( int *x, int *y ) const
2891 {
2892 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2893
2894 int dx = 0;
2895 int dy = 0;
2896 if (m_parent && m_parent->m_wxwindow)
2897 {
2898 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2899 dx = gtk_pizza_get_xoffset( pizza );
2900 dy = gtk_pizza_get_yoffset( pizza );
2901 }
2902
2903 if (m_x == -1 && m_y == -1)
2904 {
2905 GdkWindow *source = (GdkWindow *) NULL;
2906 if (m_wxwindow)
2907 source = GTK_PIZZA(m_wxwindow)->bin_window;
2908 else
2909 source = m_widget->window;
2910
2911 if (source)
2912 {
2913 int org_x = 0;
2914 int org_y = 0;
2915 gdk_window_get_origin( source, &org_x, &org_y );
2916
2917 if (m_parent)
2918 m_parent->ScreenToClient(&org_x, &org_y);
2919
2920 wx_const_cast(wxWindowGTK*, this)->m_x = org_x;
2921 wx_const_cast(wxWindowGTK*, this)->m_y = org_y;
2922 }
2923 }
2924
2925 if (x) (*x) = m_x - dx;
2926 if (y) (*y) = m_y - dy;
2927 }
2928
2929 void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
2930 {
2931 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2932
2933 if (!m_widget->window) return;
2934
2935 GdkWindow *source = (GdkWindow *) NULL;
2936 if (m_wxwindow)
2937 source = GTK_PIZZA(m_wxwindow)->bin_window;
2938 else
2939 source = m_widget->window;
2940
2941 int org_x = 0;
2942 int org_y = 0;
2943 gdk_window_get_origin( source, &org_x, &org_y );
2944
2945 if (!m_wxwindow)
2946 {
2947 if (GTK_WIDGET_NO_WINDOW (m_widget))
2948 {
2949 org_x += m_widget->allocation.x;
2950 org_y += m_widget->allocation.y;
2951 }
2952 }
2953
2954
2955 if (x)
2956 {
2957 if (GetLayoutDirection() == wxLayout_RightToLeft)
2958 *x = (GetClientSize().x - *x) + org_x;
2959 else
2960 *x += org_x;
2961 }
2962
2963 if (y) *y += org_y;
2964 }
2965
2966 void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
2967 {
2968 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2969
2970 if (!m_widget->window) return;
2971
2972 GdkWindow *source = (GdkWindow *) NULL;
2973 if (m_wxwindow)
2974 source = GTK_PIZZA(m_wxwindow)->bin_window;
2975 else
2976 source = m_widget->window;
2977
2978 int org_x = 0;
2979 int org_y = 0;
2980 gdk_window_get_origin( source, &org_x, &org_y );
2981
2982 if (!m_wxwindow)
2983 {
2984 if (GTK_WIDGET_NO_WINDOW (m_widget))
2985 {
2986 org_x += m_widget->allocation.x;
2987 org_y += m_widget->allocation.y;
2988 }
2989 }
2990
2991 if (x)
2992 {
2993 if (GetLayoutDirection() == wxLayout_RightToLeft)
2994 *x = (GetClientSize().x - *x) - org_x;
2995 else
2996 *x -= org_x;
2997 }
2998 if (y) *y -= org_y;
2999 }
3000
3001 bool wxWindowGTK::Show( bool show )
3002 {
3003 wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
3004
3005 if (!wxWindowBase::Show(show))
3006 {
3007 // nothing to do
3008 return false;
3009 }
3010
3011 if (show)
3012 {
3013 if (!m_showOnIdle)
3014 {
3015 gtk_widget_show( m_widget );
3016 wxShowEvent eventShow(GetId(), show);
3017 eventShow.SetEventObject(this);
3018 GetEventHandler()->ProcessEvent(eventShow);
3019 }
3020 }
3021 else
3022 {
3023 gtk_widget_hide( m_widget );
3024 wxShowEvent eventShow(GetId(), show);
3025 eventShow.SetEventObject(this);
3026 GetEventHandler()->ProcessEvent(eventShow);
3027 }
3028
3029 return true;
3030 }
3031
3032 void wxWindowGTK::DoEnable( bool enable )
3033 {
3034 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3035
3036 gtk_widget_set_sensitive( m_widget, enable );
3037 if (m_wxwindow && (m_wxwindow != m_widget))
3038 gtk_widget_set_sensitive( m_wxwindow, enable );
3039 }
3040
3041 int wxWindowGTK::GetCharHeight() const
3042 {
3043 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
3044
3045 wxFont font = GetFont();
3046 wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
3047
3048 PangoContext *context = NULL;
3049 if (m_widget)
3050 context = gtk_widget_get_pango_context( m_widget );
3051
3052 if (!context)
3053 return 0;
3054
3055 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
3056 PangoLayout *layout = pango_layout_new(context);
3057 pango_layout_set_font_description(layout, desc);
3058 pango_layout_set_text(layout, "H", 1);
3059 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3060
3061 PangoRectangle rect;
3062 pango_layout_line_get_extents(line, NULL, &rect);
3063
3064 g_object_unref (layout);
3065
3066 return (int) PANGO_PIXELS(rect.height);
3067 }
3068
3069 int wxWindowGTK::GetCharWidth() const
3070 {
3071 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
3072
3073 wxFont font = GetFont();
3074 wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
3075
3076 PangoContext *context = NULL;
3077 if (m_widget)
3078 context = gtk_widget_get_pango_context( m_widget );
3079
3080 if (!context)
3081 return 0;
3082
3083 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
3084 PangoLayout *layout = pango_layout_new(context);
3085 pango_layout_set_font_description(layout, desc);
3086 pango_layout_set_text(layout, "g", 1);
3087 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3088
3089 PangoRectangle rect;
3090 pango_layout_line_get_extents(line, NULL, &rect);
3091
3092 g_object_unref (layout);
3093
3094 return (int) PANGO_PIXELS(rect.width);
3095 }
3096
3097 void wxWindowGTK::GetTextExtent( const wxString& string,
3098 int *x,
3099 int *y,
3100 int *descent,
3101 int *externalLeading,
3102 const wxFont *theFont ) const
3103 {
3104 wxFont fontToUse = theFont ? *theFont : GetFont();
3105
3106 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
3107
3108 if (string.empty())
3109 {
3110 if (x) (*x) = 0;
3111 if (y) (*y) = 0;
3112 return;
3113 }
3114
3115 PangoContext *context = NULL;
3116 if (m_widget)
3117 context = gtk_widget_get_pango_context( m_widget );
3118
3119 if (!context)
3120 {
3121 if (x) (*x) = 0;
3122 if (y) (*y) = 0;
3123 return;
3124 }
3125
3126 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
3127 PangoLayout *layout = pango_layout_new(context);
3128 pango_layout_set_font_description(layout, desc);
3129 {
3130 const wxCharBuffer data = wxGTK_CONV( string );
3131 if ( data )
3132 pango_layout_set_text(layout, data, strlen(data));
3133 }
3134
3135 PangoRectangle rect;
3136 pango_layout_get_extents(layout, NULL, &rect);
3137
3138 if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width);
3139 if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height);
3140 if (descent)
3141 {
3142 PangoLayoutIter *iter = pango_layout_get_iter(layout);
3143 int baseline = pango_layout_iter_get_baseline(iter);
3144 pango_layout_iter_free(iter);
3145 *descent = *y - PANGO_PIXELS(baseline);
3146 }
3147 if (externalLeading) (*externalLeading) = 0; // ??
3148
3149 g_object_unref (layout);
3150 }
3151
3152 bool wxWindowGTK::GTKSetDelayedFocusIfNeeded()
3153 {
3154 if ( g_delayedFocus == this )
3155 {
3156 if ( GTK_WIDGET_REALIZED(m_widget) )
3157 {
3158 gtk_widget_grab_focus(m_widget);
3159 g_delayedFocus = NULL;
3160
3161 return true;
3162 }
3163 }
3164
3165 return false;
3166 }
3167
3168 void wxWindowGTK::SetFocus()
3169 {
3170 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3171 if ( m_hasFocus )
3172 {
3173 // don't do anything if we already have focus
3174 return;
3175 }
3176
3177 if (m_wxwindow)
3178 {
3179 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
3180 {
3181 gtk_widget_grab_focus (m_wxwindow);
3182 }
3183 }
3184 else if (m_widget)
3185 {
3186 if (GTK_IS_CONTAINER(m_widget))
3187 {
3188 #if wxUSE_RADIOBTN
3189 if (IsKindOf(CLASSINFO(wxRadioButton)))
3190 {
3191 gtk_widget_grab_focus (m_widget);
3192 return;
3193 }
3194 #endif // wxUSE_RADIOBTN
3195
3196 gtk_widget_child_focus( m_widget, GTK_DIR_TAB_FORWARD );
3197 }
3198 else
3199 if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
3200 {
3201
3202 if (!GTK_WIDGET_REALIZED(m_widget))
3203 {
3204 // we can't set the focus to the widget now so we remember that
3205 // it should be focused and will do it later, during the idle
3206 // time, as soon as we can
3207 wxLogTrace(TRACE_FOCUS,
3208 _T("Delaying setting focus to %s(%s)"),
3209 GetClassInfo()->GetClassName(), GetLabel().c_str());
3210
3211 g_delayedFocus = this;
3212 }
3213 else
3214 {
3215 wxLogTrace(TRACE_FOCUS,
3216 _T("Setting focus to %s(%s)"),
3217 GetClassInfo()->GetClassName(), GetLabel().c_str());
3218
3219 gtk_widget_grab_focus (m_widget);
3220 }
3221 }
3222 else
3223 {
3224 wxLogTrace(TRACE_FOCUS,
3225 _T("Can't set focus to %s(%s)"),
3226 GetClassInfo()->GetClassName(), GetLabel().c_str());
3227 }
3228 }
3229 }
3230
3231 void wxWindowGTK::SetCanFocus(bool canFocus)
3232 {
3233 if ( canFocus )
3234 GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS);
3235 else
3236 GTK_WIDGET_UNSET_FLAGS(m_widget, GTK_CAN_FOCUS);
3237
3238 if ( m_wxwindow && (m_widget != m_wxwindow) )
3239 {
3240 if ( canFocus )
3241 GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
3242 else
3243 GTK_WIDGET_UNSET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
3244 }
3245 }
3246
3247 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3248 {
3249 wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
3250
3251 wxWindowGTK *oldParent = m_parent,
3252 *newParent = (wxWindowGTK *)newParentBase;
3253
3254 wxASSERT( GTK_IS_WIDGET(m_widget) );
3255
3256 if ( !wxWindowBase::Reparent(newParent) )
3257 return false;
3258
3259 wxASSERT( GTK_IS_WIDGET(m_widget) );
3260
3261 /* prevent GTK from deleting the widget arbitrarily */
3262 gtk_widget_ref( m_widget );
3263
3264 if (oldParent)
3265 {
3266 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
3267 }
3268
3269 wxASSERT( GTK_IS_WIDGET(m_widget) );
3270
3271 if (newParent)
3272 {
3273 if (GTK_WIDGET_VISIBLE (newParent->m_widget))
3274 {
3275 m_showOnIdle = true;
3276 gtk_widget_hide( m_widget );
3277 }
3278
3279 /* insert GTK representation */
3280 (*(newParent->m_insertCallback))(newParent, this);
3281 }
3282
3283 /* reverse: prevent GTK from deleting the widget arbitrarily */
3284 gtk_widget_unref( m_widget );
3285
3286 SetLayoutDirection(wxLayout_Default);
3287
3288 return true;
3289 }
3290
3291 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3292 {
3293 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3294 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3295
3296 /* add to list */
3297 AddChild( child );
3298
3299 /* insert GTK representation */
3300 (*m_insertCallback)(this, child);
3301 }
3302
3303 void wxWindowGTK::AddChild(wxWindowBase *child)
3304 {
3305 wxWindowBase::AddChild(child);
3306 m_dirtyTabOrder = true;
3307 wxTheApp->WakeUpIdle();
3308 }
3309
3310 void wxWindowGTK::RemoveChild(wxWindowBase *child)
3311 {
3312 wxWindowBase::RemoveChild(child);
3313 m_dirtyTabOrder = true;
3314 wxTheApp->WakeUpIdle();
3315 }
3316
3317 /* static */
3318 wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
3319 {
3320 return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL
3321 ? wxLayout_RightToLeft
3322 : wxLayout_LeftToRight;
3323 }
3324
3325 /* static */
3326 void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir)
3327 {
3328 wxASSERT_MSG( dir != wxLayout_Default, _T("invalid layout direction") );
3329
3330 gtk_widget_set_direction(widget,
3331 dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
3332 : GTK_TEXT_DIR_LTR);
3333 }
3334
3335 wxLayoutDirection wxWindowGTK::GetLayoutDirection() const
3336 {
3337 return GTKGetLayout(m_widget);
3338 }
3339
3340 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir)
3341 {
3342 if ( dir == wxLayout_Default )
3343 {
3344 const wxWindow *const parent = GetParent();
3345 if ( parent )
3346 {
3347 // inherit layout from parent.
3348 dir = parent->GetLayoutDirection();
3349 }
3350 else // no parent, use global default layout
3351 {
3352 dir = wxTheApp->GetLayoutDirection();
3353 }
3354 }
3355
3356 if ( dir == wxLayout_Default )
3357 return;
3358
3359 GTKSetLayout(m_widget, dir);
3360
3361 if (m_wxwindow && (m_wxwindow != m_widget))
3362 GTKSetLayout(m_wxwindow, dir);
3363 }
3364
3365 wxCoord
3366 wxWindowGTK::AdjustForLayoutDirection(wxCoord x,
3367 wxCoord WXUNUSED(width),
3368 wxCoord WXUNUSED(widthTotal)) const
3369 {
3370 // We now mirrors the coordinates of RTL windows in GtkPizza
3371 return x;
3372 }
3373
3374 void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, MoveKind move)
3375 {
3376 wxWindowBase::DoMoveInTabOrder(win, move);
3377 m_dirtyTabOrder = true;
3378 wxTheApp->WakeUpIdle();
3379 }
3380
3381 bool wxWindowGTK::DoNavigateIn(int flags)
3382 {
3383 if ( flags & wxNavigationKeyEvent::WinChange )
3384 {
3385 wxFAIL_MSG( _T("not implemented") );
3386
3387 return false;
3388 }
3389 else // navigate inside the container
3390 {
3391 wxWindow *parent = wxGetTopLevelParent(this);
3392 wxCHECK_MSG( parent, false, _T("every window must have a TLW parent") );
3393
3394 GtkDirectionType dir;
3395 dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD
3396 : GTK_DIR_TAB_BACKWARD;
3397
3398 gboolean rc;
3399 g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
3400
3401 return rc == TRUE;
3402 }
3403 }
3404
3405 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3406 {
3407 // none needed by default
3408 return false;
3409 }
3410
3411 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget* WXUNUSED(w))
3412 {
3413 // nothing to do by default since none is needed
3414 }
3415
3416 void wxWindowGTK::RealizeTabOrder()
3417 {
3418 if (m_wxwindow)
3419 {
3420 if ( !m_children.empty() )
3421 {
3422 // we don't only construct the correct focus chain but also use
3423 // this opportunity to update the mnemonic widgets for the widgets
3424 // that need them
3425
3426 GList *chain = NULL;
3427 wxWindowGTK* mnemonicWindow = NULL;
3428
3429 for ( wxWindowList::const_iterator i = m_children.begin();
3430 i != m_children.end();
3431 ++i )
3432 {
3433 wxWindowGTK *win = *i;
3434
3435 if ( mnemonicWindow )
3436 {
3437 if ( win->AcceptsFocusFromKeyboard() )
3438 {
3439 // wxComboBox et al. needs to focus on on a different
3440 // widget than m_widget, so if the main widget isn't
3441 // focusable try the connect widget
3442 GtkWidget* w = win->m_widget;
3443 if ( !GTK_WIDGET_CAN_FOCUS(w) )
3444 {
3445 w = win->GetConnectWidget();
3446 if ( !GTK_WIDGET_CAN_FOCUS(w) )
3447 w = NULL;
3448 }
3449
3450 if ( w )
3451 {
3452 mnemonicWindow->GTKWidgetDoSetMnemonic(w);
3453 mnemonicWindow = NULL;
3454 }
3455 }
3456 }
3457 else if ( win->GTKWidgetNeedsMnemonic() )
3458 {
3459 mnemonicWindow = win;
3460 }
3461
3462 chain = g_list_prepend(chain, win->m_widget);
3463 }
3464
3465 chain = g_list_reverse(chain);
3466
3467 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain);
3468 g_list_free(chain);
3469 }
3470 else // no children
3471 {
3472 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow));
3473 }
3474 }
3475 }
3476
3477 void wxWindowGTK::Raise()
3478 {
3479 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3480
3481 if (m_wxwindow && m_wxwindow->window)
3482 {
3483 gdk_window_raise( m_wxwindow->window );
3484 }
3485 else if (m_widget->window)
3486 {
3487 gdk_window_raise( m_widget->window );
3488 }
3489 }
3490
3491 void wxWindowGTK::Lower()
3492 {
3493 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3494
3495 if (m_wxwindow && m_wxwindow->window)
3496 {
3497 gdk_window_lower( m_wxwindow->window );
3498 }
3499 else if (m_widget->window)
3500 {
3501 gdk_window_lower( m_widget->window );
3502 }
3503 }
3504
3505 bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3506 {
3507 if ( !wxWindowBase::SetCursor(cursor.Ok() ? cursor : *wxSTANDARD_CURSOR) )
3508 return false;
3509
3510 GTKUpdateCursor();
3511
3512 return true;
3513 }
3514
3515 void wxWindowGTK::GTKUpdateCursor()
3516 {
3517 wxCursor cursor(g_globalCursor.Ok() ? g_globalCursor : GetCursor());
3518 if ( cursor.Ok() )
3519 {
3520 wxArrayGdkWindows windowsThis;
3521 GdkWindow * const winThis = GTKGetWindow(windowsThis);
3522 if ( winThis )
3523 {
3524 gdk_window_set_cursor(winThis, cursor.GetCursor());
3525 }
3526 else
3527 {
3528 const size_t count = windowsThis.size();
3529 for ( size_t n = 0; n < count; n++ )
3530 {
3531 GdkWindow *win = windowsThis[n];
3532 if ( !win )
3533 {
3534 wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?"));
3535 continue;
3536 }
3537
3538 gdk_window_set_cursor(win, cursor.GetCursor());
3539 }
3540 }
3541 }
3542 }
3543
3544 void wxWindowGTK::WarpPointer( int x, int y )
3545 {
3546 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3547
3548 // We provide this function ourselves as it is
3549 // missing in GDK (top of this file).
3550
3551 GdkWindow *window = (GdkWindow*) NULL;
3552 if (m_wxwindow)
3553 window = GTK_PIZZA(m_wxwindow)->bin_window;
3554 else
3555 window = GetConnectWidget()->window;
3556
3557 if (window)
3558 gdk_window_warp_pointer( window, x, y );
3559 }
3560
3561 wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const
3562 {
3563 // find the scrollbar which generated the event
3564 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
3565 {
3566 if ( range == m_scrollBar[dir] )
3567 return (ScrollDir)dir;
3568 }
3569
3570 wxFAIL_MSG( _T("event from unknown scrollbar received") );
3571
3572 return ScrollDir_Max;
3573 }
3574
3575 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units)
3576 {
3577 bool changed = false;
3578 GtkRange* range = m_scrollBar[dir];
3579 if ( range && units )
3580 {
3581 GtkAdjustment* adj = range->adjustment;
3582 gdouble inc = unit == ScrollUnit_Line ? adj->step_increment
3583 : adj->page_increment;
3584
3585 const int posOld = int(adj->value + 0.5);
3586 gtk_range_set_value(range, posOld + units*inc);
3587
3588 changed = int(adj->value + 0.5) != posOld;
3589 }
3590
3591 return changed;
3592 }
3593
3594 bool wxWindowGTK::ScrollLines(int lines)
3595 {
3596 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Line, lines);
3597 }
3598
3599 bool wxWindowGTK::ScrollPages(int pages)
3600 {
3601 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages);
3602 }
3603
3604 void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
3605 {
3606 if (!m_widget)
3607 return;
3608 if (!m_widget->window)
3609 return;
3610
3611 if (m_wxwindow)
3612 {
3613 if (!GTK_PIZZA(m_wxwindow)->bin_window) return;
3614
3615 GdkRectangle gdk_rect,
3616 *p;
3617 if (rect)
3618 {
3619 gdk_rect.x = rect->x;
3620 gdk_rect.y = rect->y;
3621 gdk_rect.width = rect->width;
3622 gdk_rect.height = rect->height;
3623 if (GetLayoutDirection() == wxLayout_RightToLeft)
3624 gdk_rect.x = GetClientSize().x - gdk_rect.x - gdk_rect.width;
3625
3626 p = &gdk_rect;
3627 }
3628 else // invalidate everything
3629 {
3630 p = NULL;
3631 }
3632
3633 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, p, TRUE );
3634 }
3635 }
3636
3637 void wxWindowGTK::Update()
3638 {
3639 GtkUpdate();
3640
3641 // when we call Update() we really want to update the window immediately on
3642 // screen, even if it means flushing the entire queue and hence slowing down
3643 // everything -- but it should still be done, it's just that Update() should
3644 // be called very rarely
3645 gdk_flush();
3646 }
3647
3648 void wxWindowGTK::GtkUpdate()
3649 {
3650 if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
3651 gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );
3652 if (m_widget && m_widget->window && (m_wxwindow != m_widget))
3653 gdk_window_process_updates( m_widget->window, FALSE );
3654
3655 // for consistency with other platforms (and also because it's convenient
3656 // to be able to update an entire TLW by calling Update() only once), we
3657 // should also update all our children here
3658 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
3659 node;
3660 node = node->GetNext() )
3661 {
3662 node->GetData()->GtkUpdate();
3663 }
3664 }
3665
3666 bool wxWindowGTK::DoIsExposed( int x, int y ) const
3667 {
3668 return m_updateRegion.Contains(x, y) != wxOutRegion;
3669 }
3670
3671
3672 bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const
3673 {
3674 if (GetLayoutDirection() == wxLayout_RightToLeft)
3675 return m_updateRegion.Contains(x-w, y, w, h) != wxOutRegion;
3676 else
3677 return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
3678 }
3679
3680 void wxWindowGTK::GtkSendPaintEvents()
3681 {
3682 if (!m_wxwindow)
3683 {
3684 m_updateRegion.Clear();
3685 return;
3686 }
3687
3688 // Clip to paint region in wxClientDC
3689 m_clipPaintRegion = true;
3690
3691 m_nativeUpdateRegion = m_updateRegion;
3692
3693 if (GetLayoutDirection() == wxLayout_RightToLeft)
3694 {
3695 // Transform m_updateRegion under RTL
3696 m_updateRegion.Clear();
3697
3698 gint width;
3699 gdk_window_get_geometry( GTK_PIZZA(m_wxwindow)->bin_window,
3700 NULL, NULL, &width, NULL, NULL );
3701
3702 wxRegionIterator upd( m_nativeUpdateRegion );
3703 while (upd)
3704 {
3705 wxRect rect;
3706 rect.x = upd.GetX();
3707 rect.y = upd.GetY();
3708 rect.width = upd.GetWidth();
3709 rect.height = upd.GetHeight();
3710
3711 rect.x = width - rect.x - rect.width;
3712 m_updateRegion.Union( rect );
3713
3714 ++upd;
3715 }
3716 }
3717
3718 // widget to draw on
3719 GtkPizza *pizza = GTK_PIZZA (m_wxwindow);
3720
3721 if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM))
3722 {
3723 // find ancestor from which to steal background
3724 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3725 if (!parent)
3726 parent = (wxWindow*)this;
3727
3728 if (GTK_WIDGET_MAPPED(parent->m_widget))
3729 {
3730 wxRegionIterator upd( m_nativeUpdateRegion );
3731 while (upd)
3732 {
3733 GdkRectangle rect;
3734 rect.x = upd.GetX();
3735 rect.y = upd.GetY();
3736 rect.width = upd.GetWidth();
3737 rect.height = upd.GetHeight();
3738
3739 gtk_paint_flat_box( parent->m_widget->style,
3740 pizza->bin_window,
3741 (GtkStateType)GTK_WIDGET_STATE(m_wxwindow),
3742 GTK_SHADOW_NONE,
3743 &rect,
3744 parent->m_widget,
3745 (char *)"base",
3746 0, 0, -1, -1 );
3747
3748 ++upd;
3749 }
3750 }
3751 }
3752 else
3753 {
3754 wxWindowDC dc( (wxWindow*)this );
3755 dc.SetClippingRegion( m_updateRegion );
3756
3757 wxEraseEvent erase_event( GetId(), &dc );
3758 erase_event.SetEventObject( this );
3759
3760 GetEventHandler()->ProcessEvent(erase_event);
3761 }
3762
3763 wxNcPaintEvent nc_paint_event( GetId() );
3764 nc_paint_event.SetEventObject( this );
3765 GetEventHandler()->ProcessEvent( nc_paint_event );
3766
3767 wxPaintEvent paint_event( GetId() );
3768 paint_event.SetEventObject( this );
3769 GetEventHandler()->ProcessEvent( paint_event );
3770
3771 m_clipPaintRegion = false;
3772
3773 m_updateRegion.Clear();
3774 m_nativeUpdateRegion.Clear();
3775 }
3776
3777 void wxWindowGTK::SetDoubleBuffered( bool on )
3778 {
3779 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3780
3781 if ( m_wxwindow )
3782 gtk_widget_set_double_buffered( m_wxwindow, on );
3783 }
3784
3785 bool wxWindowGTK::IsDoubleBuffered() const
3786 {
3787 return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow );
3788 }
3789
3790 void wxWindowGTK::ClearBackground()
3791 {
3792 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3793 }
3794
3795 #if wxUSE_TOOLTIPS
3796 void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3797 {
3798 wxWindowBase::DoSetToolTip(tip);
3799
3800 if (m_tooltip)
3801 m_tooltip->Apply( (wxWindow *)this );
3802 }
3803
3804 void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const gchar *tip )
3805 {
3806 gtk_tooltips_set_tip(tips, GetConnectWidget(), tip, NULL);
3807 }
3808 #endif // wxUSE_TOOLTIPS
3809
3810 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
3811 {
3812 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3813
3814 if (!wxWindowBase::SetBackgroundColour(colour))
3815 return false;
3816
3817 if (colour.Ok())
3818 {
3819 // We need the pixel value e.g. for background clearing.
3820 m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3821 }
3822
3823 // apply style change (forceStyle=true so that new style is applied
3824 // even if the bg colour changed from valid to wxNullColour)
3825 if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM)
3826 ApplyWidgetStyle(true);
3827
3828 return true;
3829 }
3830
3831 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
3832 {
3833 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3834
3835 if (!wxWindowBase::SetForegroundColour(colour))
3836 {
3837 return false;
3838 }
3839
3840 if (colour.Ok())
3841 {
3842 // We need the pixel value e.g. for background clearing.
3843 m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3844 }
3845
3846 // apply style change (forceStyle=true so that new style is applied
3847 // even if the bg colour changed from valid to wxNullColour):
3848 ApplyWidgetStyle(true);
3849
3850 return true;
3851 }
3852
3853 PangoContext *wxWindowGTK::GtkGetPangoDefaultContext()
3854 {
3855 return gtk_widget_get_pango_context( m_widget );
3856 }
3857
3858 GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle)
3859 {
3860 // do we need to apply any changes at all?
3861 if ( !forceStyle &&
3862 !m_font.Ok() &&
3863 !m_foregroundColour.Ok() && !m_backgroundColour.Ok() )
3864 {
3865 return NULL;
3866 }
3867
3868 GtkRcStyle *style = gtk_rc_style_new();
3869
3870 if ( m_font.Ok() )
3871 {
3872 style->font_desc =
3873 pango_font_description_copy( m_font.GetNativeFontInfo()->description );
3874 }
3875
3876 int flagsNormal = 0,
3877 flagsPrelight = 0,
3878 flagsActive = 0,
3879 flagsInsensitive = 0;
3880
3881 if ( m_foregroundColour.Ok() )
3882 {
3883 const GdkColor *fg = m_foregroundColour.GetColor();
3884
3885 style->fg[GTK_STATE_NORMAL] =
3886 style->text[GTK_STATE_NORMAL] = *fg;
3887 flagsNormal |= GTK_RC_FG | GTK_RC_TEXT;
3888
3889 style->fg[GTK_STATE_PRELIGHT] =
3890 style->text[GTK_STATE_PRELIGHT] = *fg;
3891 flagsPrelight |= GTK_RC_FG | GTK_RC_TEXT;
3892
3893 style->fg[GTK_STATE_ACTIVE] =
3894 style->text[GTK_STATE_ACTIVE] = *fg;
3895 flagsActive |= GTK_RC_FG | GTK_RC_TEXT;
3896 }
3897
3898 if ( m_backgroundColour.Ok() )
3899 {
3900 const GdkColor *bg = m_backgroundColour.GetColor();
3901
3902 style->bg[GTK_STATE_NORMAL] =
3903 style->base[GTK_STATE_NORMAL] = *bg;
3904 flagsNormal |= GTK_RC_BG | GTK_RC_BASE;
3905
3906 style->bg[GTK_STATE_PRELIGHT] =
3907 style->base[GTK_STATE_PRELIGHT] = *bg;
3908 flagsPrelight |= GTK_RC_BG | GTK_RC_BASE;
3909
3910 style->bg[GTK_STATE_ACTIVE] =
3911 style->base[GTK_STATE_ACTIVE] = *bg;
3912 flagsActive |= GTK_RC_BG | GTK_RC_BASE;
3913
3914 style->bg[GTK_STATE_INSENSITIVE] =
3915 style->base[GTK_STATE_INSENSITIVE] = *bg;
3916 flagsInsensitive |= GTK_RC_BG | GTK_RC_BASE;
3917 }
3918
3919 style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)flagsNormal;
3920 style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)flagsPrelight;
3921 style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)flagsActive;
3922 style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)flagsInsensitive;
3923
3924 return style;
3925 }
3926
3927 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle)
3928 {
3929 GtkRcStyle *style = CreateWidgetStyle(forceStyle);
3930 if ( style )
3931 {
3932 DoApplyWidgetStyle(style);
3933 gtk_rc_style_unref(style);
3934 }
3935
3936 // Style change may affect GTK+'s size calculation:
3937 InvalidateBestSize();
3938 }
3939
3940 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
3941 {
3942 if (m_wxwindow)
3943 gtk_widget_modify_style(m_wxwindow, style);
3944 else
3945 gtk_widget_modify_style(m_widget, style);
3946 }
3947
3948 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
3949 {
3950 wxWindowBase::SetBackgroundStyle(style);
3951
3952 if (style == wxBG_STYLE_CUSTOM)
3953 {
3954 GdkWindow *window;
3955 if ( m_wxwindow )
3956 {
3957 window = GTK_PIZZA(m_wxwindow)->bin_window;
3958 }
3959 else
3960 {
3961 GtkWidget * const w = GetConnectWidget();
3962 window = w ? w->window : NULL;
3963 }
3964
3965 if (window)
3966 {
3967 // Make sure GDK/X11 doesn't refresh the window
3968 // automatically.
3969 gdk_window_set_back_pixmap( window, None, False );
3970 #ifdef __X__
3971 Display* display = GDK_WINDOW_DISPLAY(window);
3972 XFlush(display);
3973 #endif
3974 m_needsStyleChange = false;
3975 }
3976 else // window not realized yet
3977 {
3978 // Do in OnIdle, because the window is not yet available
3979 m_needsStyleChange = true;
3980 }
3981
3982 // Don't apply widget style, or we get a grey background
3983 }
3984 else
3985 {
3986 // apply style change (forceStyle=true so that new style is applied
3987 // even if the bg colour changed from valid to wxNullColour):
3988 ApplyWidgetStyle(true);
3989 }
3990 return true;
3991 }
3992
3993 #if wxUSE_DRAG_AND_DROP
3994
3995 void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
3996 {
3997 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3998
3999 GtkWidget *dnd_widget = GetConnectWidget();
4000
4001 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
4002
4003 if (m_dropTarget) delete m_dropTarget;
4004 m_dropTarget = dropTarget;
4005
4006 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
4007 }
4008
4009 #endif // wxUSE_DRAG_AND_DROP
4010
4011 GtkWidget* wxWindowGTK::GetConnectWidget()
4012 {
4013 GtkWidget *connect_widget = m_widget;
4014 if (m_wxwindow) connect_widget = m_wxwindow;
4015
4016 return connect_widget;
4017 }
4018
4019 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const
4020 {
4021 wxArrayGdkWindows windowsThis;
4022 GdkWindow * const winThis = GTKGetWindow(windowsThis);
4023
4024 return winThis ? window == winThis
4025 : windowsThis.Index(window) != wxNOT_FOUND;
4026 }
4027
4028 GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
4029 {
4030 return m_wxwindow ? GTK_PIZZA(m_wxwindow)->bin_window : m_widget->window;
4031 }
4032
4033 bool wxWindowGTK::SetFont( const wxFont &font )
4034 {
4035 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4036
4037 if (!wxWindowBase::SetFont(font))
4038 return false;
4039
4040 // apply style change (forceStyle=true so that new style is applied
4041 // even if the font changed from valid to wxNullFont):
4042 ApplyWidgetStyle(true);
4043
4044 return true;
4045 }
4046
4047 void wxWindowGTK::DoCaptureMouse()
4048 {
4049 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4050
4051 GdkWindow *window = (GdkWindow*) NULL;
4052 if (m_wxwindow)
4053 window = GTK_PIZZA(m_wxwindow)->bin_window;
4054 else
4055 window = GetConnectWidget()->window;
4056
4057 wxCHECK_RET( window, _T("CaptureMouse() failed") );
4058
4059 const wxCursor* cursor = &m_cursor;
4060 if (!cursor->Ok())
4061 cursor = wxSTANDARD_CURSOR;
4062
4063 gdk_pointer_grab( window, FALSE,
4064 (GdkEventMask)
4065 (GDK_BUTTON_PRESS_MASK |
4066 GDK_BUTTON_RELEASE_MASK |
4067 GDK_POINTER_MOTION_HINT_MASK |
4068 GDK_POINTER_MOTION_MASK),
4069 (GdkWindow *) NULL,
4070 cursor->GetCursor(),
4071 (guint32)GDK_CURRENT_TIME );
4072 g_captureWindow = this;
4073 g_captureWindowHasMouse = true;
4074 }
4075
4076 void wxWindowGTK::DoReleaseMouse()
4077 {
4078 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4079
4080 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
4081
4082 g_captureWindow = (wxWindowGTK*) NULL;
4083
4084 GdkWindow *window = (GdkWindow*) NULL;
4085 if (m_wxwindow)
4086 window = GTK_PIZZA(m_wxwindow)->bin_window;
4087 else
4088 window = GetConnectWidget()->window;
4089
4090 if (!window)
4091 return;
4092
4093 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
4094 }
4095
4096 /* static */
4097 wxWindow *wxWindowBase::GetCapture()
4098 {
4099 return (wxWindow *)g_captureWindow;
4100 }
4101
4102 bool wxWindowGTK::IsRetained() const
4103 {
4104 return false;
4105 }
4106
4107 void wxWindowGTK::BlockScrollEvent()
4108 {
4109 wxASSERT(!m_blockScrollEvent);
4110 m_blockScrollEvent = true;
4111 }
4112
4113 void wxWindowGTK::UnblockScrollEvent()
4114 {
4115 wxASSERT(m_blockScrollEvent);
4116 m_blockScrollEvent = false;
4117 }
4118
4119 void wxWindowGTK::SetScrollbar(int orient,
4120 int pos,
4121 int thumbVisible,
4122 int range,
4123 bool WXUNUSED(update))
4124 {
4125 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4126 wxCHECK_RET( sb, _T("this window is not scrollable") );
4127
4128 if (range > 0)
4129 {
4130 m_hasScrolling = true;
4131 }
4132 else
4133 {
4134 // GtkRange requires upper > lower
4135 range =
4136 thumbVisible = 1;
4137 }
4138
4139 if (pos > range - thumbVisible)
4140 pos = range - thumbVisible;
4141 if (pos < 0)
4142 pos = 0;
4143 GtkAdjustment * const adj = sb->adjustment;
4144 adj->step_increment = 1;
4145 adj->page_increment =
4146 adj->page_size = thumbVisible;
4147 adj->upper = range;
4148 SetScrollPos(orient, pos);
4149 gtk_adjustment_changed(adj);
4150 }
4151
4152 void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
4153 {
4154 const int dir = ScrollDirFromOrient(orient);
4155 GtkRange * const sb = m_scrollBar[dir];
4156 wxCHECK_RET( sb, _T("this window is not scrollable") );
4157
4158 // This check is more than an optimization. Without it, the slider
4159 // will not move smoothly while tracking when using wxScrollHelper.
4160 if (GetScrollPos(orient) != pos)
4161 {
4162 GtkAdjustment* adj = sb->adjustment;
4163 const int max = int(adj->upper - adj->page_size);
4164 if (pos > max)
4165 pos = max;
4166 if (pos < 0)
4167 pos = 0;
4168 m_scrollPos[dir] = adj->value = pos;
4169
4170 g_signal_handlers_block_by_func(m_scrollBar[dir],
4171 (gpointer)gtk_scrollbar_value_changed, this);
4172
4173 gtk_adjustment_value_changed(adj);
4174
4175 g_signal_handlers_unblock_by_func(m_scrollBar[dir],
4176 (gpointer)gtk_scrollbar_value_changed, this);
4177 }
4178 }
4179
4180 int wxWindowGTK::GetScrollThumb(int orient) const
4181 {
4182 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4183 wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );
4184
4185 return int(sb->adjustment->page_size);
4186 }
4187
4188 int wxWindowGTK::GetScrollPos( int orient ) const
4189 {
4190 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4191 wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );
4192
4193 return int(sb->adjustment->value + 0.5);
4194 }
4195
4196 int wxWindowGTK::GetScrollRange( int orient ) const
4197 {
4198 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4199 wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );
4200
4201 return int(sb->adjustment->upper);
4202 }
4203
4204 // Determine if increment is the same as +/-x, allowing for some small
4205 // difference due to possible inexactness in floating point arithmetic
4206 static inline bool IsScrollIncrement(double increment, double x)
4207 {
4208 wxASSERT(increment > 0);
4209 const double tolerance = 1.0 / 1024;
4210 return fabs(increment - fabs(x)) < tolerance;
4211 }
4212
4213 wxEventType wxWindowGTK::GetScrollEventType(GtkRange* range)
4214 {
4215 DEBUG_MAIN_THREAD
4216
4217 wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
4218
4219 const int barIndex = range == m_scrollBar[1];
4220 GtkAdjustment* adj = range->adjustment;
4221
4222 const int value = int(adj->value + 0.5);
4223
4224 // save previous position
4225 const double oldPos = m_scrollPos[barIndex];
4226 // update current position
4227 m_scrollPos[barIndex] = adj->value;
4228 // If event should be ignored, or integral position has not changed
4229 if (!m_hasVMT || g_blockEventsOnDrag || value == int(oldPos + 0.5))
4230 {
4231 return wxEVT_NULL;
4232 }
4233
4234 wxEventType eventType = wxEVT_SCROLL_THUMBTRACK;
4235 if (!m_isScrolling)
4236 {
4237 // Difference from last change event
4238 const double diff = adj->value - oldPos;
4239 const bool isDown = diff > 0;
4240
4241 if (IsScrollIncrement(adj->step_increment, diff))
4242 {
4243 eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
4244 }
4245 else if (IsScrollIncrement(adj->page_increment, diff))
4246 {
4247 eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
4248 }
4249 else if (m_mouseButtonDown)
4250 {
4251 // Assume track event
4252 m_isScrolling = true;
4253 }
4254 }
4255 return eventType;
4256 }
4257
4258 void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4259 {
4260 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4261
4262 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4263
4264 // No scrolling requested.
4265 if ((dx == 0) && (dy == 0)) return;
4266
4267 m_clipPaintRegion = true;
4268
4269 if (GetLayoutDirection() == wxLayout_RightToLeft)
4270 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), dx, -dy );
4271 else
4272 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
4273
4274 m_clipPaintRegion = false;
4275
4276 #if wxUSE_CARET
4277 bool restoreCaret = (GetCaret() != NULL && GetCaret()->IsVisible());
4278 if (restoreCaret)
4279 {
4280 wxRect caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4281 if (dx > 0)
4282 caretRect.width += dx;
4283 else
4284 {
4285 caretRect.x += dx; caretRect.width -= dx;
4286 }
4287 if (dy > 0)
4288 caretRect.height += dy;
4289 else
4290 {
4291 caretRect.y += dy; caretRect.height -= dy;
4292 }
4293
4294 RefreshRect(caretRect);
4295 }
4296 #endif // wxUSE_CARET
4297 }
4298
4299 void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
4300 {
4301 //RN: Note that static controls usually have no border on gtk, so maybe
4302 //it makes sense to treat that as simply no border at the wx level
4303 //as well...
4304 if (!(wxstyle & wxNO_BORDER) && !(wxstyle & wxBORDER_STATIC))
4305 {
4306 GtkShadowType gtkstyle;
4307
4308 if(wxstyle & wxBORDER_RAISED)
4309 gtkstyle = GTK_SHADOW_OUT;
4310 else if (wxstyle & wxBORDER_SUNKEN)
4311 gtkstyle = GTK_SHADOW_IN;
4312 else if (wxstyle & wxBORDER_DOUBLE)
4313 gtkstyle = GTK_SHADOW_ETCHED_IN;
4314 else //default
4315 gtkstyle = GTK_SHADOW_IN;
4316
4317 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w),
4318 gtkstyle );
4319 }
4320 }
4321
4322 void wxWindowGTK::SetWindowStyleFlag( long style )
4323 {
4324 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4325 wxWindowBase::SetWindowStyleFlag(style);
4326 }
4327
4328 // Find the wxWindow at the current mouse position, also returning the mouse
4329 // position.
4330 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4331 {
4332 pt = wxGetMousePosition();
4333 wxWindow* found = wxFindWindowAtPoint(pt);
4334 return found;
4335 }
4336
4337 // Get the current mouse position.
4338 wxPoint wxGetMousePosition()
4339 {
4340 /* This crashes when used within wxHelpContext,
4341 so we have to use the X-specific implementation below.
4342 gint x, y;
4343 GdkModifierType *mask;
4344 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4345
4346 return wxPoint(x, y);
4347 */
4348
4349 int x, y;
4350 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4351
4352 Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
4353 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4354 Window rootReturn, childReturn;
4355 int rootX, rootY, winX, winY;
4356 unsigned int maskReturn;
4357
4358 XQueryPointer (display,
4359 rootWindow,
4360 &rootReturn,
4361 &childReturn,
4362 &rootX, &rootY, &winX, &winY, &maskReturn);
4363 return wxPoint(rootX, rootY);
4364
4365 }
4366
4367 // Needed for implementing e.g. combobox on wxGTK within a modal dialog.
4368 void wxAddGrab(wxWindow* window)
4369 {
4370 gtk_grab_add( (GtkWidget*) window->GetHandle() );
4371 }
4372
4373 void wxRemoveGrab(wxWindow* window)
4374 {
4375 gtk_grab_remove( (GtkWidget*) window->GetHandle() );
4376 }