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