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