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