projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
remove wxWindow::m_needParent and use GTKNeedsParent() which can be overridden in...
[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::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2629 {
2630 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2631 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
2632
2633 if (m_resizing) return; /* I don't like recursions */
2634 m_resizing = true;
2635
2636 int currentX, currentY;
2637 GetPosition(&currentX, &currentY);
2638 if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2639 x = currentX;
2640 if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2641 y = currentY;
2642 AdjustForParentClientOrigin(x, y, sizeFlags);
2643
2644 // calculate the best size if we should auto size the window
2645 if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
2646 ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
2647 {
2648 const wxSize sizeBest = GetBestSize();
2649 if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
2650 width = sizeBest.x;
2651 if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
2652 height = sizeBest.y;
2653 }
2654
2655 if (width != -1)
2656 m_width = width;
2657 if (height != -1)
2658 m_height = height;
2659
2660 int minWidth = GetMinWidth(),
2661 minHeight = GetMinHeight(),
2662 maxWidth = GetMaxWidth(),
2663 maxHeight = GetMaxHeight();
2664
2665 if ((minWidth != -1) && (m_width < minWidth )) m_width = minWidth;
2666 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
2667 if ((maxWidth != -1) && (m_width > maxWidth )) m_width = maxWidth;
2668 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
2669
2670 #if wxUSE_TOOLBAR_NATIVE
2671 if (wxDynamicCast(GetParent(), wxToolBar))
2672 {
2673 // don't take the x,y values, they're wrong because toolbar sets them
2674 GtkWidget *widget = m_widget;
2675 gtk_widget_set_size_request (widget, m_width, m_height);
2676 }
2677 else
2678 #endif
2679 if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook
2680 {
2681 // don't set the size for children of wxNotebook, just take the values.
2682 m_x = x;
2683 m_y = y;
2684 m_width = width;
2685 m_height = height;
2686 }
2687 else
2688 {
2689 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2690 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
2691 {
2692 if (x != -1) m_x = x + gtk_pizza_get_xoffset( pizza );
2693 if (y != -1) m_y = y + gtk_pizza_get_yoffset( pizza );
2694 }
2695 else
2696 {
2697 m_x = x + gtk_pizza_get_xoffset( pizza );
2698 m_y = y + gtk_pizza_get_yoffset( pizza );
2699 }
2700
2701 int left_border = 0;
2702 int right_border = 0;
2703 int top_border = 0;
2704 int bottom_border = 0;
2705
2706 /* the default button has a border around it */
2707 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
2708 {
2709 GtkBorder *default_border = NULL;
2710 gtk_widget_style_get( m_widget, "default_border", &default_border, NULL );
2711 if (default_border)
2712 {
2713 left_border += default_border->left;
2714 right_border += default_border->right;
2715 top_border += default_border->top;
2716 bottom_border += default_border->bottom;
2717 g_free( default_border );
2718 }
2719 }
2720
2721 DoMoveWindow( m_x-top_border,
2722 m_y-left_border,
2723 m_width+left_border+right_border,
2724 m_height+top_border+bottom_border );
2725 }
2726
2727 if (m_hasScrolling)
2728 {
2729 /* Sometimes the client area changes size without the
2730 whole windows's size changing, but if the whole
2731 windows's size doesn't change, no wxSizeEvent will
2732 normally be sent. Here we add an extra test if
2733 the client test has been changed and this will
2734 be used then. */
2735 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
2736 }
2737
2738 /*
2739 wxPrintf( "OnSize sent from " );
2740 if (GetClassInfo() && GetClassInfo()->GetClassName())
2741 wxPrintf( GetClassInfo()->GetClassName() );
2742 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2743 */
2744
2745 if (!m_nativeSizeEvent)
2746 {
2747 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2748 event.SetEventObject( this );
2749 GetEventHandler()->ProcessEvent( event );
2750 }
2751
2752 m_resizing = false;
2753 }
2754
2755 bool wxWindowGTK::GtkShowFromOnIdle()
2756 {
2757 if (IsShown() && m_showOnIdle && !GTK_WIDGET_VISIBLE (m_widget))
2758 {
2759 GtkAllocation alloc;
2760 alloc.x = m_x;
2761 alloc.y = m_y;
2762 alloc.width = m_width;
2763 alloc.height = m_height;
2764 gtk_widget_size_allocate( m_widget, &alloc );
2765 gtk_widget_show( m_widget );
2766 wxShowEvent eventShow(GetId(), true);
2767 eventShow.SetEventObject(this);
2768 GetEventHandler()->ProcessEvent(eventShow);
2769 m_showOnIdle = false;
2770 return true;
2771 }
2772
2773 return false;
2774 }
2775
2776 void wxWindowGTK::OnInternalIdle()
2777 {
2778 // Check if we have to show window now
2779 if (GtkShowFromOnIdle()) return;
2780
2781 if ( m_dirtyTabOrder )
2782 {
2783 m_dirtyTabOrder = false;
2784 RealizeTabOrder();
2785 }
2786
2787 // Update style if the window was not yet realized
2788 // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
2789 if (m_needsStyleChange)
2790 {
2791 SetBackgroundStyle(GetBackgroundStyle());
2792 m_needsStyleChange = false;
2793 }
2794
2795 wxCursor cursor = m_cursor;
2796 if (g_globalCursor.Ok()) cursor = g_globalCursor;
2797
2798 if (cursor.Ok())
2799 {
2800 /* I now set the cursor anew in every OnInternalIdle call
2801 as setting the cursor in a parent window also effects the
2802 windows above so that checking for the current cursor is
2803 not possible. */
2804
2805 if (m_wxwindow && (m_wxwindow != m_widget))
2806 {
2807 GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
2808 if (window)
2809 gdk_window_set_cursor( window, cursor.GetCursor() );
2810
2811 if (!g_globalCursor.Ok())
2812 cursor = *wxSTANDARD_CURSOR;
2813
2814 window = m_widget->window;
2815 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2816 gdk_window_set_cursor( window, cursor.GetCursor() );
2817
2818 }
2819 else if ( m_widget )
2820 {
2821 GdkWindow *window = m_widget->window;
2822 if ( window && !GTK_WIDGET_NO_WINDOW(m_widget) )
2823 gdk_window_set_cursor( window, cursor.GetCursor() );
2824 }
2825 }
2826
2827 if (wxUpdateUIEvent::CanUpdate(this))
2828 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
2829 }
2830
2831 void wxWindowGTK::DoGetSize( int *width, int *height ) const
2832 {
2833 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2834
2835 if (width) (*width) = m_width;
2836 if (height) (*height) = m_height;
2837 }
2838
2839 void wxWindowGTK::DoSetClientSize( int width, int height )
2840 {
2841 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2842
2843 if (m_wxwindow)
2844 {
2845 int dw = 0;
2846 int dh = 0;
2847
2848 if (m_hasScrolling)
2849 {
2850 GetScrollbarWidth(m_widget, dw, dh);
2851 }
2852
2853 const int border = GTK_CONTAINER(m_wxwindow)->border_width;
2854 dw += 2 * border;
2855 dh += 2 * border;
2856
2857 width += dw;
2858 height += dh;
2859 }
2860
2861 SetSize(width, height);
2862 }
2863
2864 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
2865 {
2866 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2867
2868 int w = m_width;
2869 int h = m_height;
2870
2871 if (m_wxwindow)
2872 {
2873 int dw = 0;
2874 int dh = 0;
2875
2876 if (m_hasScrolling)
2877 GetScrollbarWidth(m_widget, dw, dh);
2878
2879 const int border = GTK_CONTAINER(m_wxwindow)->border_width;
2880 dw += 2 * border;
2881 dh += 2 * border;
2882
2883 w -= dw;
2884 h -= dh;
2885 if (w < 0)
2886 w = 0;
2887 if (h < 0)
2888 h = 0;
2889 }
2890
2891 if (width) *width = w;
2892 if (height) *height = h;
2893 }
2894
2895 void wxWindowGTK::DoGetPosition( int *x, int *y ) const
2896 {
2897 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2898
2899 int dx = 0;
2900 int dy = 0;
2901 if (m_parent && m_parent->m_wxwindow)
2902 {
2903 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2904 dx = gtk_pizza_get_xoffset( pizza );
2905 dy = gtk_pizza_get_yoffset( pizza );
2906 }
2907
2908 if (m_x == -1 && m_y == -1)
2909 {
2910 GdkWindow *source = (GdkWindow *) NULL;
2911 if (m_wxwindow)
2912 source = GTK_PIZZA(m_wxwindow)->bin_window;
2913 else
2914 source = m_widget->window;
2915
2916 if (source)
2917 {
2918 int org_x = 0;
2919 int org_y = 0;
2920 gdk_window_get_origin( source, &org_x, &org_y );
2921
2922 if (m_parent)
2923 m_parent->ScreenToClient(&org_x, &org_y);
2924
2925 wx_const_cast(wxWindowGTK*, this)->m_x = org_x;
2926 wx_const_cast(wxWindowGTK*, this)->m_y = org_y;
2927 }
2928 }
2929
2930 if (x) (*x) = m_x - dx;
2931 if (y) (*y) = m_y - dy;
2932 }
2933
2934 void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
2935 {
2936 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2937
2938 if (!m_widget->window) return;
2939
2940 GdkWindow *source = (GdkWindow *) NULL;
2941 if (m_wxwindow)
2942 source = GTK_PIZZA(m_wxwindow)->bin_window;
2943 else
2944 source = m_widget->window;
2945
2946 int org_x = 0;
2947 int org_y = 0;
2948 gdk_window_get_origin( source, &org_x, &org_y );
2949
2950 if (!m_wxwindow)
2951 {
2952 if (GTK_WIDGET_NO_WINDOW (m_widget))
2953 {
2954 org_x += m_widget->allocation.x;
2955 org_y += m_widget->allocation.y;
2956 }
2957 }
2958
2959
2960 if (x)
2961 {
2962 if (GetLayoutDirection() == wxLayout_RightToLeft)
2963 *x = (GetClientSize().x - *x) + org_x;
2964 else
2965 *x += org_x;
2966 }
2967
2968 if (y) *y += org_y;
2969 }
2970
2971 void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
2972 {
2973 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2974
2975 if (!m_widget->window) return;
2976
2977 GdkWindow *source = (GdkWindow *) NULL;
2978 if (m_wxwindow)
2979 source = GTK_PIZZA(m_wxwindow)->bin_window;
2980 else
2981 source = m_widget->window;
2982
2983 int org_x = 0;
2984 int org_y = 0;
2985 gdk_window_get_origin( source, &org_x, &org_y );
2986
2987 if (!m_wxwindow)
2988 {
2989 if (GTK_WIDGET_NO_WINDOW (m_widget))
2990 {
2991 org_x += m_widget->allocation.x;
2992 org_y += m_widget->allocation.y;
2993 }
2994 }
2995
2996 if (x)
2997 {
2998 if (GetLayoutDirection() == wxLayout_RightToLeft)
2999 *x = (GetClientSize().x - *x) - org_x;
3000 else
3001 *x -= org_x;
3002 }
3003 if (y) *y -= org_y;
3004 }
3005
3006 bool wxWindowGTK::Show( bool show )
3007 {
3008 wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
3009
3010 if (!wxWindowBase::Show(show))
3011 {
3012 // nothing to do
3013 return false;
3014 }
3015
3016 if (show)
3017 {
3018 if (!m_showOnIdle)
3019 {
3020 gtk_widget_show( m_widget );
3021 wxShowEvent eventShow(GetId(), show);
3022 eventShow.SetEventObject(this);
3023 GetEventHandler()->ProcessEvent(eventShow);
3024 }
3025 }
3026 else
3027 {
3028 gtk_widget_hide( m_widget );
3029 wxShowEvent eventShow(GetId(), show);
3030 eventShow.SetEventObject(this);
3031 GetEventHandler()->ProcessEvent(eventShow);
3032 }
3033
3034 return true;
3035 }
3036
3037 void wxWindowGTK::DoEnable( bool enable )
3038 {
3039 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3040
3041 gtk_widget_set_sensitive( m_widget, enable );
3042 if (m_wxwindow && (m_wxwindow != m_widget))
3043 gtk_widget_set_sensitive( m_wxwindow, enable );
3044 }
3045
3046 int wxWindowGTK::GetCharHeight() const
3047 {
3048 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
3049
3050 wxFont font = GetFont();
3051 wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
3052
3053 PangoContext *context = NULL;
3054 if (m_widget)
3055 context = gtk_widget_get_pango_context( m_widget );
3056
3057 if (!context)
3058 return 0;
3059
3060 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
3061 PangoLayout *layout = pango_layout_new(context);
3062 pango_layout_set_font_description(layout, desc);
3063 pango_layout_set_text(layout, "H", 1);
3064 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3065
3066 PangoRectangle rect;
3067 pango_layout_line_get_extents(line, NULL, &rect);
3068
3069 g_object_unref (layout);
3070
3071 return (int) PANGO_PIXELS(rect.height);
3072 }
3073
3074 int wxWindowGTK::GetCharWidth() const
3075 {
3076 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
3077
3078 wxFont font = GetFont();
3079 wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
3080
3081 PangoContext *context = NULL;
3082 if (m_widget)
3083 context = gtk_widget_get_pango_context( m_widget );
3084
3085 if (!context)
3086 return 0;
3087
3088 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
3089 PangoLayout *layout = pango_layout_new(context);
3090 pango_layout_set_font_description(layout, desc);
3091 pango_layout_set_text(layout, "g", 1);
3092 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3093
3094 PangoRectangle rect;
3095 pango_layout_line_get_extents(line, NULL, &rect);
3096
3097 g_object_unref (layout);
3098
3099 return (int) PANGO_PIXELS(rect.width);
3100 }
3101
3102 void wxWindowGTK::GetTextExtent( const wxString& string,
3103 int *x,
3104 int *y,
3105 int *descent,
3106 int *externalLeading,
3107 const wxFont *theFont ) const
3108 {
3109 wxFont fontToUse = theFont ? *theFont : GetFont();
3110
3111 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
3112
3113 if (string.empty())
3114 {
3115 if (x) (*x) = 0;
3116 if (y) (*y) = 0;
3117 return;
3118 }
3119
3120 PangoContext *context = NULL;
3121 if (m_widget)
3122 context = gtk_widget_get_pango_context( m_widget );
3123
3124 if (!context)
3125 {
3126 if (x) (*x) = 0;
3127 if (y) (*y) = 0;
3128 return;
3129 }
3130
3131 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
3132 PangoLayout *layout = pango_layout_new(context);
3133 pango_layout_set_font_description(layout, desc);
3134 {
3135 const wxCharBuffer data = wxGTK_CONV( string );
3136 if ( data )
3137 pango_layout_set_text(layout, data, strlen(data));
3138 }
3139
3140 PangoRectangle rect;
3141 pango_layout_get_extents(layout, NULL, &rect);
3142
3143 if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width);
3144 if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height);
3145 if (descent)
3146 {
3147 PangoLayoutIter *iter = pango_layout_get_iter(layout);
3148 int baseline = pango_layout_iter_get_baseline(iter);
3149 pango_layout_iter_free(iter);
3150 *descent = *y - PANGO_PIXELS(baseline);
3151 }
3152 if (externalLeading) (*externalLeading) = 0; // ??
3153
3154 g_object_unref (layout);
3155 }
3156
3157 bool wxWindowGTK::GTKSetDelayedFocusIfNeeded()
3158 {
3159 if ( g_delayedFocus == this )
3160 {
3161 if ( GTK_WIDGET_REALIZED(m_widget) )
3162 {
3163 gtk_widget_grab_focus(m_widget);
3164 g_delayedFocus = NULL;
3165
3166 return true;
3167 }
3168 }
3169
3170 return false;
3171 }
3172
3173 void wxWindowGTK::SetFocus()
3174 {
3175 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3176 if ( m_hasFocus )
3177 {
3178 // don't do anything if we already have focus
3179 return;
3180 }
3181
3182 if (m_wxwindow)
3183 {
3184 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
3185 {
3186 gtk_widget_grab_focus (m_wxwindow);
3187 }
3188 }
3189 else if (m_widget)
3190 {
3191 if (GTK_IS_CONTAINER(m_widget))
3192 {
3193 if (IsKindOf(CLASSINFO(wxRadioButton)))
3194 {
3195 gtk_widget_grab_focus (m_widget);
3196 return;
3197 }
3198
3199 gtk_widget_child_focus( m_widget, GTK_DIR_TAB_FORWARD );
3200 }
3201 else
3202 if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
3203 {
3204
3205 if (!GTK_WIDGET_REALIZED(m_widget))
3206 {
3207 // we can't set the focus to the widget now so we remember that
3208 // it should be focused and will do it later, during the idle
3209 // time, as soon as we can
3210 wxLogTrace(TRACE_FOCUS,
3211 _T("Delaying setting focus to %s(%s)"),
3212 GetClassInfo()->GetClassName(), GetLabel().c_str());
3213
3214 g_delayedFocus = this;
3215 }
3216 else
3217 {
3218 wxLogTrace(TRACE_FOCUS,
3219 _T("Setting focus to %s(%s)"),
3220 GetClassInfo()->GetClassName(), GetLabel().c_str());
3221
3222 gtk_widget_grab_focus (m_widget);
3223 }
3224 }
3225 else
3226 {
3227 wxLogTrace(TRACE_FOCUS,
3228 _T("Can't set focus to %s(%s)"),
3229 GetClassInfo()->GetClassName(), GetLabel().c_str());
3230 }
3231 }
3232 }
3233
3234 void wxWindowGTK::SetCanFocus(bool canFocus)
3235 {
3236 if ( canFocus )
3237 GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS);
3238 else
3239 GTK_WIDGET_UNSET_FLAGS(m_widget, GTK_CAN_FOCUS);
3240
3241 if ( m_wxwindow && (m_widget != m_wxwindow) )
3242 {
3243 if ( canFocus )
3244 GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
3245 else
3246 GTK_WIDGET_UNSET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
3247 }
3248 }
3249
3250 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3251 {
3252 wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
3253
3254 wxWindowGTK *oldParent = m_parent,
3255 *newParent = (wxWindowGTK *)newParentBase;
3256
3257 wxASSERT( GTK_IS_WIDGET(m_widget) );
3258
3259 if ( !wxWindowBase::Reparent(newParent) )
3260 return false;
3261
3262 wxASSERT( GTK_IS_WIDGET(m_widget) );
3263
3264 /* prevent GTK from deleting the widget arbitrarily */
3265 gtk_widget_ref( m_widget );
3266
3267 if (oldParent)
3268 {
3269 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
3270 }
3271
3272 wxASSERT( GTK_IS_WIDGET(m_widget) );
3273
3274 if (newParent)
3275 {
3276 if (GTK_WIDGET_VISIBLE (newParent->m_widget))
3277 {
3278 m_showOnIdle = true;
3279 gtk_widget_hide( m_widget );
3280 }
3281
3282 /* insert GTK representation */
3283 (*(newParent->m_insertCallback))(newParent, this);
3284 }
3285
3286 /* reverse: prevent GTK from deleting the widget arbitrarily */
3287 gtk_widget_unref( m_widget );
3288
3289 SetLayoutDirection(wxLayout_Default);
3290
3291 return true;
3292 }
3293
3294 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3295 {
3296 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3297
3298 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3299
3300 wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
3301
3302 /* add to list */
3303 AddChild( child );
3304
3305 /* insert GTK representation */
3306 (*m_insertCallback)(this, child);
3307 }
3308
3309 void wxWindowGTK::AddChild(wxWindowBase *child)
3310 {
3311 wxWindowBase::AddChild(child);
3312 m_dirtyTabOrder = true;
3313 wxTheApp->WakeUpIdle();
3314 }
3315
3316 void wxWindowGTK::RemoveChild(wxWindowBase *child)
3317 {
3318 wxWindowBase::RemoveChild(child);
3319 m_dirtyTabOrder = true;
3320 wxTheApp->WakeUpIdle();
3321 }
3322
3323 /* static */
3324 wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
3325 {
3326 return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL
3327 ? wxLayout_RightToLeft
3328 : wxLayout_LeftToRight;
3329 }
3330
3331 /* static */
3332 void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir)
3333 {
3334 wxASSERT_MSG( dir != wxLayout_Default, _T("invalid layout direction") );
3335
3336 gtk_widget_set_direction(widget,
3337 dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
3338 : GTK_TEXT_DIR_LTR);
3339 }
3340
3341 wxLayoutDirection wxWindowGTK::GetLayoutDirection() const
3342 {
3343 return GTKGetLayout(m_widget);
3344 }
3345
3346 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir)
3347 {
3348 if ( dir == wxLayout_Default )
3349 {
3350 const wxWindow *const parent = GetParent();
3351 if ( parent )
3352 {
3353 // inherit layout from parent.
3354 dir = parent->GetLayoutDirection();
3355 }
3356 else // no parent, use global default layout
3357 {
3358 dir = wxTheApp->GetLayoutDirection();
3359 }
3360 }
3361
3362 if ( dir == wxLayout_Default )
3363 return;
3364
3365 GTKSetLayout(m_widget, dir);
3366
3367 if (m_wxwindow && (m_wxwindow != m_widget))
3368 GTKSetLayout(m_wxwindow, dir);
3369 }
3370
3371 wxCoord
3372 wxWindowGTK::AdjustForLayoutDirection(wxCoord x,
3373 wxCoord WXUNUSED(width),
3374 wxCoord WXUNUSED(widthTotal)) const
3375 {
3376 // We now mirrors the coordinates of RTL windows in GtkPizza
3377 return x;
3378 }
3379
3380 void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, MoveKind move)
3381 {
3382 wxWindowBase::DoMoveInTabOrder(win, move);
3383 m_dirtyTabOrder = true;
3384 wxTheApp->WakeUpIdle();
3385 }
3386
3387 bool wxWindowGTK::DoNavigateIn(int flags)
3388 {
3389 if ( flags & wxNavigationKeyEvent::WinChange )
3390 {
3391 wxFAIL_MSG( _T("not implemented") );
3392
3393 return false;
3394 }
3395 else // navigate inside the container
3396 {
3397 wxWindow *parent = wxGetTopLevelParent(this);
3398 wxCHECK_MSG( parent, false, _T("every window must have a TLW parent") );
3399
3400 GtkDirectionType dir;
3401 dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD
3402 : GTK_DIR_TAB_BACKWARD;
3403
3404 gboolean rc;
3405 g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
3406
3407 return rc == TRUE;
3408 }
3409 }
3410
3411 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3412 {
3413 // none needed by default
3414 return false;
3415 }
3416
3417 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget* WXUNUSED(w))
3418 {
3419 // nothing to do by default since none is needed
3420 }
3421
3422 void wxWindowGTK::RealizeTabOrder()
3423 {
3424 if (m_wxwindow)
3425 {
3426 if ( !m_children.empty() )
3427 {
3428 // we don't only construct the correct focus chain but also use
3429 // this opportunity to update the mnemonic widgets for the widgets
3430 // that need them
3431
3432 GList *chain = NULL;
3433 wxWindowGTK* mnemonicWindow = NULL;
3434
3435 for ( wxWindowList::const_iterator i = m_children.begin();
3436 i != m_children.end();
3437 ++i )
3438 {
3439 wxWindowGTK *win = *i;
3440
3441 if ( mnemonicWindow )
3442 {
3443 if ( win->AcceptsFocusFromKeyboard() )
3444 {
3445 // wxComboBox et al. needs to focus on on a different
3446 // widget than m_widget, so if the main widget isn't
3447 // focusable try the connect widget
3448 GtkWidget* w = win->m_widget;
3449 if ( !GTK_WIDGET_CAN_FOCUS(w) )
3450 {
3451 w = win->GetConnectWidget();
3452 if ( !GTK_WIDGET_CAN_FOCUS(w) )
3453 w = NULL;
3454 }
3455
3456 if ( w )
3457 {
3458 mnemonicWindow->GTKWidgetDoSetMnemonic(w);
3459 mnemonicWindow = NULL;
3460 }
3461 }
3462 }
3463 else if ( win->GTKWidgetNeedsMnemonic() )
3464 {
3465 mnemonicWindow = win;
3466 }
3467
3468 chain = g_list_prepend(chain, win->m_widget);
3469 }
3470
3471 chain = g_list_reverse(chain);
3472
3473 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain);
3474 g_list_free(chain);
3475 }
3476 else // no children
3477 {
3478 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow));
3479 }
3480 }
3481 }
3482
3483 void wxWindowGTK::Raise()
3484 {
3485 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3486
3487 if (m_wxwindow && m_wxwindow->window)
3488 {
3489 gdk_window_raise( m_wxwindow->window );
3490 }
3491 else if (m_widget->window)
3492 {
3493 gdk_window_raise( m_widget->window );
3494 }
3495 }
3496
3497 void wxWindowGTK::Lower()
3498 {
3499 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3500
3501 if (m_wxwindow && m_wxwindow->window)
3502 {
3503 gdk_window_lower( m_wxwindow->window );
3504 }
3505 else if (m_widget->window)
3506 {
3507 gdk_window_lower( m_widget->window );
3508 }
3509 }
3510
3511 bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3512 {
3513 if ( !wxWindowBase::SetCursor(cursor.Ok() ? cursor : *wxSTANDARD_CURSOR) )
3514 return false;
3515
3516 GTKUpdateCursor();
3517
3518 return true;
3519 }
3520
3521 void wxWindowGTK::GTKUpdateCursor()
3522 {
3523 wxCursor cursor(g_globalCursor.Ok() ? g_globalCursor : GetCursor());
3524 if ( cursor.Ok() )
3525 {
3526 wxArrayGdkWindows windowsThis;
3527 GdkWindow * const winThis = GTKGetWindow(windowsThis);
3528 if ( winThis )
3529 {
3530 gdk_window_set_cursor(winThis, cursor.GetCursor());
3531 }
3532 else
3533 {
3534 const size_t count = windowsThis.size();
3535 for ( size_t n = 0; n < count; n++ )
3536 {
3537 GdkWindow *win = windowsThis[n];
3538 if ( !win )
3539 {
3540 wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?"));
3541 continue;
3542 }
3543
3544 gdk_window_set_cursor(win, cursor.GetCursor());
3545 }
3546 }
3547 }
3548 }
3549
3550 void wxWindowGTK::WarpPointer( int x, int y )
3551 {
3552 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3553
3554 // We provide this function ourselves as it is
3555 // missing in GDK (top of this file).
3556
3557 GdkWindow *window = (GdkWindow*) NULL;
3558 if (m_wxwindow)
3559 window = GTK_PIZZA(m_wxwindow)->bin_window;
3560 else
3561 window = GetConnectWidget()->window;
3562
3563 if (window)
3564 gdk_window_warp_pointer( window, x, y );
3565 }
3566
3567 wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const
3568 {
3569 // find the scrollbar which generated the event
3570 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
3571 {
3572 if ( range == m_scrollBar[dir] )
3573 return (ScrollDir)dir;
3574 }
3575
3576 wxFAIL_MSG( _T("event from unknown scrollbar received") );
3577
3578 return ScrollDir_Max;
3579 }
3580
3581 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units)
3582 {
3583 bool changed = false;
3584 GtkRange* range = m_scrollBar[dir];
3585 if ( range && units )
3586 {
3587 GtkAdjustment* adj = range->adjustment;
3588 gdouble inc = unit == ScrollUnit_Line ? adj->step_increment
3589 : adj->page_increment;
3590
3591 const int posOld = int(adj->value + 0.5);
3592 gtk_range_set_value(range, posOld + units*inc);
3593
3594 changed = int(adj->value + 0.5) != posOld;
3595 }
3596
3597 return changed;
3598 }
3599
3600 bool wxWindowGTK::ScrollLines(int lines)
3601 {
3602 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Line, lines);
3603 }
3604
3605 bool wxWindowGTK::ScrollPages(int pages)
3606 {
3607 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages);
3608 }
3609
3610 void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
3611 {
3612 if (!m_widget)
3613 return;
3614 if (!m_widget->window)
3615 return;
3616
3617 if (m_wxwindow)
3618 {
3619 if (!GTK_PIZZA(m_wxwindow)->bin_window) return;
3620
3621 GdkRectangle gdk_rect,
3622 *p;
3623 if (rect)
3624 {
3625 gdk_rect.x = rect->x;
3626 gdk_rect.y = rect->y;
3627 gdk_rect.width = rect->width;
3628 gdk_rect.height = rect->height;
3629 if (GetLayoutDirection() == wxLayout_RightToLeft)
3630 gdk_rect.x = GetClientSize().x - gdk_rect.x - gdk_rect.width;
3631
3632 p = &gdk_rect;
3633 }
3634 else // invalidate everything
3635 {
3636 p = NULL;
3637 }
3638
3639 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, p, TRUE );
3640 }
3641 }
3642
3643 void wxWindowGTK::Update()
3644 {
3645 GtkUpdate();
3646
3647 // when we call Update() we really want to update the window immediately on
3648 // screen, even if it means flushing the entire queue and hence slowing down
3649 // everything -- but it should still be done, it's just that Update() should
3650 // be called very rarely
3651 gdk_flush();
3652 }
3653
3654 void wxWindowGTK::GtkUpdate()
3655 {
3656 if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
3657 gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );
3658 if (m_widget && m_widget->window && (m_wxwindow != m_widget))
3659 gdk_window_process_updates( m_widget->window, FALSE );
3660
3661 // for consistency with other platforms (and also because it's convenient
3662 // to be able to update an entire TLW by calling Update() only once), we
3663 // should also update all our children here
3664 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
3665 node;
3666 node = node->GetNext() )
3667 {
3668 node->GetData()->GtkUpdate();
3669 }
3670 }
3671
3672 bool wxWindowGTK::DoIsExposed( int x, int y ) const
3673 {
3674 return m_updateRegion.Contains(x, y) != wxOutRegion;
3675 }
3676
3677
3678 bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const
3679 {
3680 if (GetLayoutDirection() == wxLayout_RightToLeft)
3681 return m_updateRegion.Contains(x-w, y, w, h) != wxOutRegion;
3682 else
3683 return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
3684 }
3685
3686 void wxWindowGTK::GtkSendPaintEvents()
3687 {
3688 if (!m_wxwindow)
3689 {
3690 m_updateRegion.Clear();
3691 return;
3692 }
3693
3694 // Clip to paint region in wxClientDC
3695 m_clipPaintRegion = true;
3696
3697 m_nativeUpdateRegion = m_updateRegion;
3698
3699 if (GetLayoutDirection() == wxLayout_RightToLeft)
3700 {
3701 // Transform m_updateRegion under RTL
3702 m_updateRegion.Clear();
3703
3704 gint width;
3705 gdk_window_get_geometry( GTK_PIZZA(m_wxwindow)->bin_window,
3706 NULL, NULL, &width, NULL, NULL );
3707
3708 wxRegionIterator upd( m_nativeUpdateRegion );
3709 while (upd)
3710 {
3711 wxRect rect;
3712 rect.x = upd.GetX();
3713 rect.y = upd.GetY();
3714 rect.width = upd.GetWidth();
3715 rect.height = upd.GetHeight();
3716
3717 rect.x = width - rect.x - rect.width;
3718 m_updateRegion.Union( rect );
3719
3720 ++upd;
3721 }
3722 }
3723
3724 // widget to draw on
3725 GtkPizza *pizza = GTK_PIZZA (m_wxwindow);
3726
3727 if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM))
3728 {
3729 // find ancestor from which to steal background
3730 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3731 if (!parent)
3732 parent = (wxWindow*)this;
3733
3734 if (GTK_WIDGET_MAPPED(parent->m_widget))
3735 {
3736 wxRegionIterator upd( m_nativeUpdateRegion );
3737 while (upd)
3738 {
3739 GdkRectangle rect;
3740 rect.x = upd.GetX();
3741 rect.y = upd.GetY();
3742 rect.width = upd.GetWidth();
3743 rect.height = upd.GetHeight();
3744
3745 gtk_paint_flat_box( parent->m_widget->style,
3746 pizza->bin_window,
3747 (GtkStateType)GTK_WIDGET_STATE(m_wxwindow),
3748 GTK_SHADOW_NONE,
3749 &rect,
3750 parent->m_widget,
3751 (char *)"base",
3752 0, 0, -1, -1 );
3753
3754 ++upd;
3755 }
3756 }
3757 }
3758 else
3759 {
3760 wxWindowDC dc( (wxWindow*)this );
3761 dc.SetClippingRegion( m_updateRegion );
3762
3763 wxEraseEvent erase_event( GetId(), &dc );
3764 erase_event.SetEventObject( this );
3765
3766 GetEventHandler()->ProcessEvent(erase_event);
3767 }
3768
3769 wxNcPaintEvent nc_paint_event( GetId() );
3770 nc_paint_event.SetEventObject( this );
3771 GetEventHandler()->ProcessEvent( nc_paint_event );
3772
3773 wxPaintEvent paint_event( GetId() );
3774 paint_event.SetEventObject( this );
3775 GetEventHandler()->ProcessEvent( paint_event );
3776
3777 m_clipPaintRegion = false;
3778
3779 m_updateRegion.Clear();
3780 m_nativeUpdateRegion.Clear();
3781 }
3782
3783 void wxWindowGTK::SetDoubleBuffered( bool on )
3784 {
3785 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3786
3787 if ( m_wxwindow )
3788 gtk_widget_set_double_buffered( m_wxwindow, on );
3789 }
3790
3791 bool wxWindowGTK::IsDoubleBuffered() const
3792 {
3793 return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow );
3794 }
3795
3796 void wxWindowGTK::ClearBackground()
3797 {
3798 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3799 }
3800
3801 #if wxUSE_TOOLTIPS
3802 void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3803 {
3804 wxWindowBase::DoSetToolTip(tip);
3805
3806 if (m_tooltip)
3807 m_tooltip->Apply( (wxWindow *)this );
3808 }
3809
3810 void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
3811 {
3812 if (tip)
3813 {
3814 wxString tmp( tip );
3815 gtk_tooltips_set_tip( tips, GetConnectWidget(), wxGTK_CONV(tmp), (gchar*) NULL );
3816 }
3817 else
3818 {
3819 gtk_tooltips_set_tip( tips, GetConnectWidget(), NULL, NULL);
3820 }
3821 }
3822 #endif // wxUSE_TOOLTIPS
3823
3824 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
3825 {
3826 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3827
3828 if (!wxWindowBase::SetBackgroundColour(colour))
3829 return false;
3830
3831 if (colour.Ok())
3832 {
3833 // We need the pixel value e.g. for background clearing.
3834 m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3835 }
3836
3837 // apply style change (forceStyle=true so that new style is applied
3838 // even if the bg colour changed from valid to wxNullColour)
3839 if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM)
3840 ApplyWidgetStyle(true);
3841
3842 return true;
3843 }
3844
3845 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
3846 {
3847 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3848
3849 if (!wxWindowBase::SetForegroundColour(colour))
3850 {
3851 return false;
3852 }
3853
3854 if (colour.Ok())
3855 {
3856 // We need the pixel value e.g. for background clearing.
3857 m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3858 }
3859
3860 // apply style change (forceStyle=true so that new style is applied
3861 // even if the bg colour changed from valid to wxNullColour):
3862 ApplyWidgetStyle(true);
3863
3864 return true;
3865 }
3866
3867 PangoContext *wxWindowGTK::GtkGetPangoDefaultContext()
3868 {
3869 return gtk_widget_get_pango_context( m_widget );
3870 }
3871
3872 GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle)
3873 {
3874 // do we need to apply any changes at all?
3875 if ( !forceStyle &&
3876 !m_font.Ok() &&
3877 !m_foregroundColour.Ok() && !m_backgroundColour.Ok() )
3878 {
3879 return NULL;
3880 }
3881
3882 GtkRcStyle *style = gtk_rc_style_new();
3883
3884 if ( m_font.Ok() )
3885 {
3886 style->font_desc =
3887 pango_font_description_copy( m_font.GetNativeFontInfo()->description );
3888 }
3889
3890 int flagsNormal = 0,
3891 flagsPrelight = 0,
3892 flagsActive = 0,
3893 flagsInsensitive = 0;
3894
3895 if ( m_foregroundColour.Ok() )
3896 {
3897 const GdkColor *fg = m_foregroundColour.GetColor();
3898
3899 style->fg[GTK_STATE_NORMAL] =
3900 style->text[GTK_STATE_NORMAL] = *fg;
3901 flagsNormal |= GTK_RC_FG | GTK_RC_TEXT;
3902
3903 style->fg[GTK_STATE_PRELIGHT] =
3904 style->text[GTK_STATE_PRELIGHT] = *fg;
3905 flagsPrelight |= GTK_RC_FG | GTK_RC_TEXT;
3906
3907 style->fg[GTK_STATE_ACTIVE] =
3908 style->text[GTK_STATE_ACTIVE] = *fg;
3909 flagsActive |= GTK_RC_FG | GTK_RC_TEXT;
3910 }
3911
3912 if ( m_backgroundColour.Ok() )
3913 {
3914 const GdkColor *bg = m_backgroundColour.GetColor();
3915
3916 style->bg[GTK_STATE_NORMAL] =
3917 style->base[GTK_STATE_NORMAL] = *bg;
3918 flagsNormal |= GTK_RC_BG | GTK_RC_BASE;
3919
3920 style->bg[GTK_STATE_PRELIGHT] =
3921 style->base[GTK_STATE_PRELIGHT] = *bg;
3922 flagsPrelight |= GTK_RC_BG | GTK_RC_BASE;
3923
3924 style->bg[GTK_STATE_ACTIVE] =
3925 style->base[GTK_STATE_ACTIVE] = *bg;
3926 flagsActive |= GTK_RC_BG | GTK_RC_BASE;
3927
3928 style->bg[GTK_STATE_INSENSITIVE] =
3929 style->base[GTK_STATE_INSENSITIVE] = *bg;
3930 flagsInsensitive |= GTK_RC_BG | GTK_RC_BASE;
3931 }
3932
3933 style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)flagsNormal;
3934 style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)flagsPrelight;
3935 style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)flagsActive;
3936 style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)flagsInsensitive;
3937
3938 return style;
3939 }
3940
3941 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle)
3942 {
3943 GtkRcStyle *style = CreateWidgetStyle(forceStyle);
3944 if ( style )
3945 {
3946 DoApplyWidgetStyle(style);
3947 gtk_rc_style_unref(style);
3948 }
3949
3950 // Style change may affect GTK+'s size calculation:
3951 InvalidateBestSize();
3952 }
3953
3954 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
3955 {
3956 if (m_wxwindow)
3957 gtk_widget_modify_style(m_wxwindow, style);
3958 else
3959 gtk_widget_modify_style(m_widget, style);
3960 }
3961
3962 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
3963 {
3964 wxWindowBase::SetBackgroundStyle(style);
3965
3966 if (style == wxBG_STYLE_CUSTOM)
3967 {
3968 GdkWindow *window = (GdkWindow*) NULL;
3969 if (m_wxwindow)
3970 window = GTK_PIZZA(m_wxwindow)->bin_window;
3971 else
3972 window = GetConnectWidget()->window;
3973
3974 if (window)
3975 {
3976 // Make sure GDK/X11 doesn't refresh the window
3977 // automatically.
3978 gdk_window_set_back_pixmap( window, None, False );
3979 #ifdef __X__
3980 Display* display = GDK_WINDOW_DISPLAY(window);
3981 XFlush(display);
3982 #endif
3983 m_needsStyleChange = false;
3984 }
3985 else
3986 // Do in OnIdle, because the window is not yet available
3987 m_needsStyleChange = true;
3988
3989 // Don't apply widget style, or we get a grey background
3990 }
3991 else
3992 {
3993 // apply style change (forceStyle=true so that new style is applied
3994 // even if the bg colour changed from valid to wxNullColour):
3995 ApplyWidgetStyle(true);
3996 }
3997 return true;
3998 }
3999
4000 #if wxUSE_DRAG_AND_DROP
4001
4002 void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
4003 {
4004 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4005
4006 GtkWidget *dnd_widget = GetConnectWidget();
4007
4008 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
4009
4010 if (m_dropTarget) delete m_dropTarget;
4011 m_dropTarget = dropTarget;
4012
4013 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
4014 }
4015
4016 #endif // wxUSE_DRAG_AND_DROP
4017
4018 GtkWidget* wxWindowGTK::GetConnectWidget()
4019 {
4020 GtkWidget *connect_widget = m_widget;
4021 if (m_wxwindow) connect_widget = m_wxwindow;
4022
4023 return connect_widget;
4024 }
4025
4026 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const
4027 {
4028 wxArrayGdkWindows windowsThis;
4029 GdkWindow * const winThis = GTKGetWindow(windowsThis);
4030
4031 return winThis ? window == winThis
4032 : windowsThis.Index(window) != wxNOT_FOUND;
4033 }
4034
4035 GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
4036 {
4037 return m_wxwindow ? GTK_PIZZA(m_wxwindow)->bin_window : m_widget->window;
4038 }
4039
4040 bool wxWindowGTK::SetFont( const wxFont &font )
4041 {
4042 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4043
4044 if (!wxWindowBase::SetFont(font))
4045 return false;
4046
4047 // apply style change (forceStyle=true so that new style is applied
4048 // even if the font changed from valid to wxNullFont):
4049 ApplyWidgetStyle(true);
4050
4051 return true;
4052 }
4053
4054 void wxWindowGTK::DoCaptureMouse()
4055 {
4056 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4057
4058 GdkWindow *window = (GdkWindow*) NULL;
4059 if (m_wxwindow)
4060 window = GTK_PIZZA(m_wxwindow)->bin_window;
4061 else
4062 window = GetConnectWidget()->window;
4063
4064 wxCHECK_RET( window, _T("CaptureMouse() failed") );
4065
4066 const wxCursor* cursor = &m_cursor;
4067 if (!cursor->Ok())
4068 cursor = wxSTANDARD_CURSOR;
4069
4070 gdk_pointer_grab( window, FALSE,
4071 (GdkEventMask)
4072 (GDK_BUTTON_PRESS_MASK |
4073 GDK_BUTTON_RELEASE_MASK |
4074 GDK_POINTER_MOTION_HINT_MASK |
4075 GDK_POINTER_MOTION_MASK),
4076 (GdkWindow *) NULL,
4077 cursor->GetCursor(),
4078 (guint32)GDK_CURRENT_TIME );
4079 g_captureWindow = this;
4080 g_captureWindowHasMouse = true;
4081 }
4082
4083 void wxWindowGTK::DoReleaseMouse()
4084 {
4085 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4086
4087 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
4088
4089 g_captureWindow = (wxWindowGTK*) NULL;
4090
4091 GdkWindow *window = (GdkWindow*) NULL;
4092 if (m_wxwindow)
4093 window = GTK_PIZZA(m_wxwindow)->bin_window;
4094 else
4095 window = GetConnectWidget()->window;
4096
4097 if (!window)
4098 return;
4099
4100 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
4101 }
4102
4103 /* static */
4104 wxWindow *wxWindowBase::GetCapture()
4105 {
4106 return (wxWindow *)g_captureWindow;
4107 }
4108
4109 bool wxWindowGTK::IsRetained() const
4110 {
4111 return false;
4112 }
4113
4114 void wxWindowGTK::BlockScrollEvent()
4115 {
4116 wxASSERT(!m_blockScrollEvent);
4117 m_blockScrollEvent = true;
4118 }
4119
4120 void wxWindowGTK::UnblockScrollEvent()
4121 {
4122 wxASSERT(m_blockScrollEvent);
4123 m_blockScrollEvent = false;
4124 }
4125
4126 void wxWindowGTK::SetScrollbar(int orient,
4127 int pos,
4128 int thumbVisible,
4129 int range,
4130 bool WXUNUSED(update))
4131 {
4132 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4133 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4134 wxCHECK_RET( m_wxwindow != m_widget, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") );
4135
4136 if (range > 0)
4137 {
4138 m_hasScrolling = true;
4139 }
4140 else
4141 {
4142 // GtkRange requires upper > lower
4143 range =
4144 thumbVisible = 1;
4145 }
4146
4147 if (pos > range - thumbVisible)
4148 pos = range - thumbVisible;
4149 if (pos < 0)
4150 pos = 0;
4151 GtkAdjustment* adj = m_scrollBar[ScrollDirFromOrient(orient)]->adjustment;
4152 adj->step_increment = 1;
4153 adj->page_increment =
4154 adj->page_size = thumbVisible;
4155 adj->upper = range;
4156 SetScrollPos(orient, pos);
4157 gtk_adjustment_changed(adj);
4158 }
4159
4160 void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
4161 {
4162 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4163 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4164 wxCHECK_RET( m_wxwindow != m_widget, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") );
4165
4166 // This check is more than an optimization. Without it, the slider
4167 // will not move smoothly while tracking when using wxScrollHelper.
4168 if (GetScrollPos(orient) != pos)
4169 {
4170 const int dir = ScrollDirFromOrient(orient);
4171 GtkAdjustment* adj = m_scrollBar[dir]->adjustment;
4172 const int max = int(adj->upper - adj->page_size);
4173 if (pos > max)
4174 pos = max;
4175 if (pos < 0)
4176 pos = 0;
4177 m_scrollPos[dir] = adj->value = pos;
4178
4179 // If a "value_changed" signal emission is not already in progress
4180 if (!m_blockValueChanged[dir])
4181 {
4182 gtk_adjustment_value_changed(adj);
4183 }
4184 }
4185 }
4186
4187 int wxWindowGTK::GetScrollThumb(int orient) const
4188 {
4189 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4190 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4191 wxCHECK_MSG( m_wxwindow != m_widget, 0, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") );
4192
4193 return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->page_size);
4194 }
4195
4196 int wxWindowGTK::GetScrollPos( 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->value + 0.5);
4203 }
4204
4205 int wxWindowGTK::GetScrollRange( 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->upper);
4212 }
4213
4214 // Determine if increment is the same as +/-x, allowing for some small
4215 // difference due to possible inexactness in floating point arithmetic
4216 static inline bool IsScrollIncrement(double increment, double x)
4217 {
4218 wxASSERT(increment > 0);
4219 const double tolerance = 1.0 / 1024;
4220 return fabs(increment - fabs(x)) < tolerance;
4221 }
4222
4223 wxEventType wxWindowGTK::GetScrollEventType(GtkRange* range)
4224 {
4225 DEBUG_MAIN_THREAD
4226
4227 wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
4228
4229 const int barIndex = range == m_scrollBar[1];
4230 GtkAdjustment* adj = range->adjustment;
4231
4232 const int value = int(adj->value + 0.5);
4233
4234 // save previous position
4235 const double oldPos = m_scrollPos[barIndex];
4236 // update current position
4237 m_scrollPos[barIndex] = adj->value;
4238 // If event should be ignored, or integral position has not changed
4239 if (!m_hasVMT || g_blockEventsOnDrag || value == int(oldPos + 0.5))
4240 {
4241 return wxEVT_NULL;
4242 }
4243
4244 wxEventType eventType = wxEVT_SCROLL_THUMBTRACK;
4245 if (!m_isScrolling)
4246 {
4247 // Difference from last change event
4248 const double diff = adj->value - oldPos;
4249 const bool isDown = diff > 0;
4250
4251 if (IsScrollIncrement(adj->step_increment, diff))
4252 {
4253 eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
4254 }
4255 else if (IsScrollIncrement(adj->page_increment, diff))
4256 {
4257 eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
4258 }
4259 else if (m_mouseButtonDown)
4260 {
4261 // Assume track event
4262 m_isScrolling = true;
4263 }
4264 }
4265 return eventType;
4266 }
4267
4268 void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4269 {
4270 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4271
4272 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4273
4274 // No scrolling requested.
4275 if ((dx == 0) && (dy == 0)) return;
4276
4277 m_clipPaintRegion = true;
4278
4279 if (GetLayoutDirection() == wxLayout_RightToLeft)
4280 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), dx, -dy );
4281 else
4282 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
4283
4284 m_clipPaintRegion = false;
4285
4286 #if wxUSE_CARET
4287 bool restoreCaret = (GetCaret() != NULL && GetCaret()->IsVisible());
4288 if (restoreCaret)
4289 {
4290 wxRect caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4291 if (dx > 0)
4292 caretRect.width += dx;
4293 else
4294 {
4295 caretRect.x += dx; caretRect.width -= dx;
4296 }
4297 if (dy > 0)
4298 caretRect.height += dy;
4299 else
4300 {
4301 caretRect.y += dy; caretRect.height -= dy;
4302 }
4303
4304 RefreshRect(caretRect);
4305 }
4306 #endif // wxUSE_CARET
4307 }
4308
4309 void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
4310 {
4311 //RN: Note that static controls usually have no border on gtk, so maybe
4312 //it makes sense to treat that as simply no border at the wx level
4313 //as well...
4314 if (!(wxstyle & wxNO_BORDER) && !(wxstyle & wxBORDER_STATIC))
4315 {
4316 GtkShadowType gtkstyle;
4317
4318 if(wxstyle & wxBORDER_RAISED)
4319 gtkstyle = GTK_SHADOW_OUT;
4320 else if (wxstyle & wxBORDER_SUNKEN)
4321 gtkstyle = GTK_SHADOW_IN;
4322 else if (wxstyle & wxBORDER_DOUBLE)
4323 gtkstyle = GTK_SHADOW_ETCHED_IN;
4324 else //default
4325 gtkstyle = GTK_SHADOW_IN;
4326
4327 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w),
4328 gtkstyle );
4329 }
4330 }
4331
4332 void wxWindowGTK::SetWindowStyleFlag( long style )
4333 {
4334 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4335 wxWindowBase::SetWindowStyleFlag(style);
4336 }
4337
4338 // Find the wxWindow at the current mouse position, also returning the mouse
4339 // position.
4340 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4341 {
4342 pt = wxGetMousePosition();
4343 wxWindow* found = wxFindWindowAtPoint(pt);
4344 return found;
4345 }
4346
4347 // Get the current mouse position.
4348 wxPoint wxGetMousePosition()
4349 {
4350 /* This crashes when used within wxHelpContext,
4351 so we have to use the X-specific implementation below.
4352 gint x, y;
4353 GdkModifierType *mask;
4354 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4355
4356 return wxPoint(x, y);
4357 */
4358
4359 int x, y;
4360 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4361
4362 Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
4363 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4364 Window rootReturn, childReturn;
4365 int rootX, rootY, winX, winY;
4366 unsigned int maskReturn;
4367
4368 XQueryPointer (display,
4369 rootWindow,
4370 &rootReturn,
4371 &childReturn,
4372 &rootX, &rootY, &winX, &winY, &maskReturn);
4373 return wxPoint(rootX, rootY);
4374
4375 }
4376
4377 // Needed for implementing e.g. combobox on wxGTK within a modal dialog.
4378 void wxAddGrab(wxWindow* window)
4379 {
4380 gtk_grab_add( (GtkWidget*) window->GetHandle() );
4381 }
4382
4383 void wxRemoveGrab(wxWindow* window)
4384 {
4385 gtk_grab_remove( (GtkWidget*) window->GetHandle() );
4386 }
wxWidgets (Impactor)