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


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