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