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