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