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