]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/window.cpp
projects / wxWidgets.git / blob
? search:


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