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