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


931b5e816774e9965820048340053dbac2134701
[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, GtkWidget* 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 //-----------------------------------------------------------------------------
1897 // "size_allocate" from m_wxwindow or m_widget
1898 //-----------------------------------------------------------------------------
1899
1900 static void
1901 size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win)
1902 {
1903 int w = alloc->width;
1904 int h = alloc->height;
1905 if (win->m_wxwindow)
1906 {
1907 int border_x, border_y;
1908 WX_PIZZA(win->m_wxwindow)->get_border_widths(border_x, border_y);
1909 w -= 2 * border_x;
1910 h -= 2 * border_y;
1911 if (w < 0) w = 0;
1912 if (h < 0) h = 0;
1913 }
1914 if (win->m_oldClientWidth != w || win->m_oldClientHeight != h)
1915 {
1916 win->m_oldClientWidth = w;
1917 win->m_oldClientHeight = h;
1918 // this callback can be connected to m_wxwindow,
1919 // so always get size from m_widget->allocation
1920 GtkAllocation a;
1921 gtk_widget_get_allocation(win->m_widget, &a);
1922 win->m_width = a.width;
1923 win->m_height = a.height;
1924 if (!win->m_nativeSizeEvent)
1925 {
1926 wxSizeEvent event(win->GetSize(), win->GetId());
1927 event.SetEventObject(win);
1928 win->GTKProcessEvent(event);
1929 }
1930 }
1931 }
1932
1933 //-----------------------------------------------------------------------------
1934 // "grab_broken"
1935 //-----------------------------------------------------------------------------
1936
1937 #if GTK_CHECK_VERSION(2, 8, 0)
1938 static gboolean
1939 gtk_window_grab_broken( GtkWidget*,
1940 GdkEventGrabBroken *event,
1941 wxWindow *win )
1942 {
1943 // Mouse capture has been lost involuntarily, notify the application
1944 if(!event->keyboard && wxWindow::GetCapture() == win)
1945 {
1946 wxMouseCaptureLostEvent evt( win->GetId() );
1947 evt.SetEventObject( win );
1948 win->HandleWindowEvent( evt );
1949 }
1950 return false;
1951 }
1952 #endif
1953
1954 //-----------------------------------------------------------------------------
1955 // "style_set"
1956 //-----------------------------------------------------------------------------
1957
1958 static
1959 void gtk_window_style_set_callback( GtkWidget *WXUNUSED(widget),
1960 GtkStyle *previous_style,
1961 wxWindow* win )
1962 {
1963 if (win && previous_style)
1964 {
1965 wxSysColourChangedEvent event;
1966 event.SetEventObject(win);
1967
1968 win->GTKProcessEvent( event );
1969 }
1970 }
1971
1972 } // extern "C"
1973
1974 void wxWindowGTK::GTKHandleRealized()
1975 {
1976 if (m_imData)
1977 {
1978 gtk_im_context_set_client_window
1979 (
1980 m_imData->context,
1981 m_wxwindow ? GTKGetDrawingWindow()
1982 : gtk_widget_get_window(m_widget)
1983 );
1984 }
1985
1986 // We cannot set colours and fonts before the widget
1987 // been realized, so we do this directly after realization
1988 // or otherwise in idle time
1989
1990 if (m_needsStyleChange)
1991 {
1992 SetBackgroundStyle(GetBackgroundStyle());
1993 m_needsStyleChange = false;
1994 }
1995
1996 wxWindowCreateEvent event( this );
1997 event.SetEventObject( this );
1998 GTKProcessEvent( event );
1999
2000 GTKUpdateCursor(true, false);
2001 }
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
2448 wxWindowGTK::GTKConnectWidget(const char *signal, wxGTKCallback callback)
2449 {
2450 return g_signal_connect(m_widget, signal, callback, this);
2451 }
2452
2453 void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2454 {
2455 g_signal_connect (widget, "key_press_event",
2456 G_CALLBACK (gtk_window_key_press_callback), this);
2457 g_signal_connect (widget, "key_release_event",
2458 G_CALLBACK (gtk_window_key_release_callback), this);
2459 g_signal_connect (widget, "button_press_event",
2460 G_CALLBACK (gtk_window_button_press_callback), this);
2461 g_signal_connect (widget, "button_release_event",
2462 G_CALLBACK (gtk_window_button_release_callback), this);
2463 g_signal_connect (widget, "motion_notify_event",
2464 G_CALLBACK (gtk_window_motion_notify_callback), this);
2465
2466 g_signal_connect (widget, "scroll_event",
2467 G_CALLBACK (window_scroll_event), this);
2468 if (m_scrollBar[ScrollDir_Horz])
2469 g_signal_connect (m_scrollBar[ScrollDir_Horz], "scroll_event",
2470 G_CALLBACK (window_scroll_event_hscrollbar), this);
2471 if (m_scrollBar[ScrollDir_Vert])
2472 g_signal_connect (m_scrollBar[ScrollDir_Vert], "scroll_event",
2473 G_CALLBACK (window_scroll_event), this);
2474
2475 g_signal_connect (widget, "popup_menu",
2476 G_CALLBACK (wxgtk_window_popup_menu_callback), this);
2477 g_signal_connect (widget, "enter_notify_event",
2478 G_CALLBACK (gtk_window_enter_callback), this);
2479 g_signal_connect (widget, "leave_notify_event",
2480 G_CALLBACK (gtk_window_leave_callback), this);
2481
2482 if (IsTopLevel() && m_wxwindow)
2483 g_signal_connect (m_wxwindow, "style_set",
2484 G_CALLBACK (gtk_window_style_set_callback), this);
2485 }
2486
2487 bool wxWindowGTK::Destroy()
2488 {
2489 m_hasVMT = false;
2490
2491 return wxWindowBase::Destroy();
2492 }
2493
2494 void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
2495 {
2496 gtk_widget_set_size_request(m_widget, width, height);
2497
2498 // inform the parent to perform the move
2499 wxASSERT_MSG(m_parent && m_parent->m_wxwindow,
2500 "the parent window has no client area?");
2501 WX_PIZZA(m_parent->m_wxwindow)->move(m_widget, x, y);
2502 }
2503
2504 void wxWindowGTK::ConstrainSize()
2505 {
2506 #ifdef __WXGPE__
2507 // GPE's window manager doesn't like size hints at all, esp. when the user
2508 // has to use the virtual keyboard, so don't constrain size there
2509 if (!IsTopLevel())
2510 #endif
2511 {
2512 const wxSize minSize = GetMinSize();
2513 const wxSize maxSize = GetMaxSize();
2514 if (minSize.x > 0 && m_width < minSize.x) m_width = minSize.x;
2515 if (minSize.y > 0 && m_height < minSize.y) m_height = minSize.y;
2516 if (maxSize.x > 0 && m_width > maxSize.x) m_width = maxSize.x;
2517 if (maxSize.y > 0 && m_height > maxSize.y) m_height = maxSize.y;
2518 }
2519 }
2520
2521 void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2522 {
2523 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2524 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
2525
2526 int currentX, currentY;
2527 GetPosition(&currentX, &currentY);
2528 if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2529 x = currentX;
2530 if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2531 y = currentY;
2532 AdjustForParentClientOrigin(x, y, sizeFlags);
2533
2534 // calculate the best size if we should auto size the window
2535 if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
2536 ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
2537 {
2538 const wxSize sizeBest = GetBestSize();
2539 if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
2540 width = sizeBest.x;
2541 if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
2542 height = sizeBest.y;
2543 }
2544
2545 const wxSize oldSize(m_width, m_height);
2546 if (width != -1)
2547 m_width = width;
2548 if (height != -1)
2549 m_height = height;
2550
2551 if (m_parent->m_wxwindow)
2552 {
2553 wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
2554 m_x = x + pizza->m_scroll_x;
2555 m_y = y + pizza->m_scroll_y;
2556
2557 int left_border = 0;
2558 int right_border = 0;
2559 int top_border = 0;
2560 int bottom_border = 0;
2561
2562 /* the default button has a border around it */
2563 if (gtk_widget_get_can_default(m_widget))
2564 {
2565 GtkBorder *default_border = NULL;
2566 gtk_widget_style_get( m_widget, "default_border", &default_border, NULL );
2567 if (default_border)
2568 {
2569 left_border += default_border->left;
2570 right_border += default_border->right;
2571 top_border += default_border->top;
2572 bottom_border += default_border->bottom;
2573 gtk_border_free( default_border );
2574 }
2575 }
2576
2577 DoMoveWindow( m_x - left_border,
2578 m_y - top_border,
2579 m_width+left_border+right_border,
2580 m_height+top_border+bottom_border );
2581 }
2582
2583 if (m_width != oldSize.x || m_height != oldSize.y)
2584 {
2585 // update these variables to keep size_allocate handler
2586 // from sending another size event for this change
2587 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
2588
2589 gtk_widget_queue_resize(m_widget);
2590 if (!m_nativeSizeEvent)
2591 {
2592 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2593 event.SetEventObject( this );
2594 HandleWindowEvent( event );
2595 }
2596 } else
2597 if (sizeFlags & wxSIZE_FORCE_EVENT)
2598 {
2599 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2600 event.SetEventObject( this );
2601 HandleWindowEvent( event );
2602 }
2603 }
2604
2605 bool wxWindowGTK::GTKShowFromOnIdle()
2606 {
2607 if (IsShown() && m_showOnIdle && !gtk_widget_get_visible (m_widget))
2608 {
2609 GtkAllocation alloc;
2610 alloc.x = m_x;
2611 alloc.y = m_y;
2612 alloc.width = m_width;
2613 alloc.height = m_height;
2614 gtk_widget_size_allocate( m_widget, &alloc );
2615 gtk_widget_show( m_widget );
2616 wxShowEvent eventShow(GetId(), true);
2617 eventShow.SetEventObject(this);
2618 HandleWindowEvent(eventShow);
2619 m_showOnIdle = false;
2620 return true;
2621 }
2622
2623 return false;
2624 }
2625
2626 void wxWindowGTK::OnInternalIdle()
2627 {
2628 if ( gs_deferredFocusOut )
2629 GTKHandleDeferredFocusOut();
2630
2631 // Check if we have to show window now
2632 if (GTKShowFromOnIdle()) return;
2633
2634 if ( m_dirtyTabOrder )
2635 {
2636 m_dirtyTabOrder = false;
2637 RealizeTabOrder();
2638 }
2639
2640 // Update style if the window was not yet realized when
2641 // SetBackgroundStyle() was called
2642 if (m_needsStyleChange)
2643 {
2644 SetBackgroundStyle(GetBackgroundStyle());
2645 m_needsStyleChange = false;
2646 }
2647
2648 wxWindowBase::OnInternalIdle();
2649 }
2650
2651 void wxWindowGTK::DoGetSize( int *width, int *height ) const
2652 {
2653 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2654
2655 if (width) (*width) = m_width;
2656 if (height) (*height) = m_height;
2657 }
2658
2659 void wxWindowGTK::DoSetClientSize( int width, int height )
2660 {
2661 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2662
2663 const wxSize size = GetSize();
2664 const wxSize clientSize = GetClientSize();
2665 SetSize(width + (size.x - clientSize.x), height + (size.y - clientSize.y));
2666 }
2667
2668 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
2669 {
2670 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2671
2672 int w = m_width;
2673 int h = m_height;
2674
2675 if ( m_wxwindow )
2676 {
2677 // if window is scrollable, account for scrollbars
2678 if ( GTK_IS_SCROLLED_WINDOW(m_widget) )
2679 {
2680 GtkPolicyType policy[ScrollDir_Max];
2681 gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget),
2682 &policy[ScrollDir_Horz],
2683 &policy[ScrollDir_Vert]);
2684
2685 for ( int i = 0; i < ScrollDir_Max; i++ )
2686 {
2687 // don't account for the scrollbars we don't have
2688 GtkRange * const range = m_scrollBar[i];
2689 if ( !range )
2690 continue;
2691
2692 // nor for the ones we have but don't current show
2693 switch ( policy[i] )
2694 {
2695 case GTK_POLICY_NEVER:
2696 // never shown so doesn't take any place
2697 continue;
2698
2699 case GTK_POLICY_ALWAYS:
2700 // no checks necessary
2701 break;
2702
2703 case GTK_POLICY_AUTOMATIC:
2704 // may be shown or not, check
2705 GtkAdjustment *adj = gtk_range_get_adjustment(range);
2706 if (gtk_adjustment_get_upper(adj) <= gtk_adjustment_get_page_size(adj))
2707 continue;
2708 }
2709
2710 GtkScrolledWindowClass *scroll_class =
2711 GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2712
2713 GtkRequisition req;
2714 gtk_widget_size_request(GTK_WIDGET(range), &req);
2715 if (i == ScrollDir_Horz)
2716 h -= req.height + scroll_class->scrollbar_spacing;
2717 else
2718 w -= req.width + scroll_class->scrollbar_spacing;
2719 }
2720 }
2721
2722 const wxSize sizeBorders = DoGetBorderSize();
2723 w -= sizeBorders.x;
2724 h -= sizeBorders.y;
2725
2726 if (w < 0)
2727 w = 0;
2728 if (h < 0)
2729 h = 0;
2730 }
2731
2732 if (width) *width = w;
2733 if (height) *height = h;
2734 }
2735
2736 wxSize wxWindowGTK::DoGetBorderSize() const
2737 {
2738 if ( !m_wxwindow )
2739 return wxWindowBase::DoGetBorderSize();
2740
2741 int x, y;
2742 WX_PIZZA(m_wxwindow)->get_border_widths(x, y);
2743
2744 return 2*wxSize(x, y);
2745 }
2746
2747 void wxWindowGTK::DoGetPosition( int *x, int *y ) const
2748 {
2749 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2750
2751 int dx = 0;
2752 int dy = 0;
2753 if (!IsTopLevel() && m_parent && m_parent->m_wxwindow)
2754 {
2755 wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
2756 dx = pizza->m_scroll_x;
2757 dy = pizza->m_scroll_y;
2758 }
2759
2760 if (m_x == -1 && m_y == -1)
2761 {
2762 GdkWindow *source = NULL;
2763 if (m_wxwindow)
2764 source = gtk_widget_get_window(m_wxwindow);
2765 else
2766 source = gtk_widget_get_window(m_widget);
2767
2768 if (source)
2769 {
2770 int org_x = 0;
2771 int org_y = 0;
2772 gdk_window_get_origin( source, &org_x, &org_y );
2773
2774 if (m_parent)
2775 m_parent->ScreenToClient(&org_x, &org_y);
2776
2777 const_cast<wxWindowGTK*>(this)->m_x = org_x;
2778 const_cast<wxWindowGTK*>(this)->m_y = org_y;
2779 }
2780 }
2781
2782 if (x) (*x) = m_x - dx;
2783 if (y) (*y) = m_y - dy;
2784 }
2785
2786 void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
2787 {
2788 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2789
2790 if (gtk_widget_get_window(m_widget) == NULL) return;
2791
2792 GdkWindow *source = NULL;
2793 if (m_wxwindow)
2794 source = gtk_widget_get_window(m_wxwindow);
2795 else
2796 source = gtk_widget_get_window(m_widget);
2797
2798 int org_x = 0;
2799 int org_y = 0;
2800 gdk_window_get_origin( source, &org_x, &org_y );
2801
2802 if (!m_wxwindow)
2803 {
2804 if (!gtk_widget_get_has_window(m_widget))
2805 {
2806 GtkAllocation a;
2807 gtk_widget_get_allocation(m_widget, &a);
2808 org_x += a.x;
2809 org_y += a.y;
2810 }
2811 }
2812
2813
2814 if (x)
2815 {
2816 if (GetLayoutDirection() == wxLayout_RightToLeft)
2817 *x = (GetClientSize().x - *x) + org_x;
2818 else
2819 *x += org_x;
2820 }
2821
2822 if (y) *y += org_y;
2823 }
2824
2825 void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
2826 {
2827 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2828
2829 if (!gtk_widget_get_realized(m_widget)) return;
2830
2831 GdkWindow *source = NULL;
2832 if (m_wxwindow)
2833 source = gtk_widget_get_window(m_wxwindow);
2834 else
2835 source = gtk_widget_get_window(m_widget);
2836
2837 int org_x = 0;
2838 int org_y = 0;
2839 gdk_window_get_origin( source, &org_x, &org_y );
2840
2841 if (!m_wxwindow)
2842 {
2843 if (!gtk_widget_get_has_window(m_widget))
2844 {
2845 GtkAllocation a;
2846 gtk_widget_get_allocation(m_widget, &a);
2847 org_x += a.x;
2848 org_y += a.y;
2849 }
2850 }
2851
2852 if (x)
2853 {
2854 if (GetLayoutDirection() == wxLayout_RightToLeft)
2855 *x = (GetClientSize().x - *x) - org_x;
2856 else
2857 *x -= org_x;
2858 }
2859 if (y) *y -= org_y;
2860 }
2861
2862 bool wxWindowGTK::Show( bool show )
2863 {
2864 if ( !wxWindowBase::Show(show) )
2865 {
2866 // nothing to do
2867 return false;
2868 }
2869
2870 // notice that we may call Hide() before the window is created and this is
2871 // actually useful to create it hidden initially -- but we can't call
2872 // Show() before it is created
2873 if ( !m_widget )
2874 {
2875 wxASSERT_MSG( !show, "can't show invalid window" );
2876 return true;
2877 }
2878
2879 if ( show )
2880 {
2881 if ( m_showOnIdle )
2882 {
2883 // defer until later
2884 return true;
2885 }
2886
2887 gtk_widget_show(m_widget);
2888 }
2889 else // hide
2890 {
2891 gtk_widget_hide(m_widget);
2892 }
2893
2894 wxShowEvent eventShow(GetId(), show);
2895 eventShow.SetEventObject(this);
2896 HandleWindowEvent(eventShow);
2897
2898 return true;
2899 }
2900
2901 void wxWindowGTK::DoEnable( bool enable )
2902 {
2903 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2904
2905 gtk_widget_set_sensitive( m_widget, enable );
2906 if (m_wxwindow && (m_wxwindow != m_widget))
2907 gtk_widget_set_sensitive( m_wxwindow, enable );
2908 }
2909
2910 int wxWindowGTK::GetCharHeight() const
2911 {
2912 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
2913
2914 wxFont font = GetFont();
2915 wxCHECK_MSG( font.IsOk(), 12, wxT("invalid font") );
2916
2917 PangoContext* context = gtk_widget_get_pango_context(m_widget);
2918
2919 if (!context)
2920 return 0;
2921
2922 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
2923 PangoLayout *layout = pango_layout_new(context);
2924 pango_layout_set_font_description(layout, desc);
2925 pango_layout_set_text(layout, "H", 1);
2926 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2927
2928 PangoRectangle rect;
2929 pango_layout_line_get_extents(line, NULL, &rect);
2930
2931 g_object_unref (layout);
2932
2933 return (int) PANGO_PIXELS(rect.height);
2934 }
2935
2936 int wxWindowGTK::GetCharWidth() const
2937 {
2938 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
2939
2940 wxFont font = GetFont();
2941 wxCHECK_MSG( font.IsOk(), 8, wxT("invalid font") );
2942
2943 PangoContext* context = gtk_widget_get_pango_context(m_widget);
2944
2945 if (!context)
2946 return 0;
2947
2948 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
2949 PangoLayout *layout = pango_layout_new(context);
2950 pango_layout_set_font_description(layout, desc);
2951 pango_layout_set_text(layout, "g", 1);
2952 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2953
2954 PangoRectangle rect;
2955 pango_layout_line_get_extents(line, NULL, &rect);
2956
2957 g_object_unref (layout);
2958
2959 return (int) PANGO_PIXELS(rect.width);
2960 }
2961
2962 void wxWindowGTK::DoGetTextExtent( const wxString& string,
2963 int *x,
2964 int *y,
2965 int *descent,
2966 int *externalLeading,
2967 const wxFont *theFont ) const
2968 {
2969 wxFont fontToUse = theFont ? *theFont : GetFont();
2970
2971 wxCHECK_RET( fontToUse.IsOk(), wxT("invalid font") );
2972
2973 if (string.empty())
2974 {
2975 if (x) (*x) = 0;
2976 if (y) (*y) = 0;
2977 return;
2978 }
2979
2980 PangoContext *context = NULL;
2981 if (m_widget)
2982 context = gtk_widget_get_pango_context( m_widget );
2983
2984 if (!context)
2985 {
2986 if (x) (*x) = 0;
2987 if (y) (*y) = 0;
2988 return;
2989 }
2990
2991 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
2992 PangoLayout *layout = pango_layout_new(context);
2993 pango_layout_set_font_description(layout, desc);
2994 {
2995 const wxCharBuffer data = wxGTK_CONV( string );
2996 if ( data )
2997 pango_layout_set_text(layout, data, strlen(data));
2998 }
2999
3000 PangoRectangle rect;
3001 pango_layout_get_extents(layout, NULL, &rect);
3002
3003 if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width);
3004 if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height);
3005 if (descent)
3006 {
3007 PangoLayoutIter *iter = pango_layout_get_iter(layout);
3008 int baseline = pango_layout_iter_get_baseline(iter);
3009 pango_layout_iter_free(iter);
3010 *descent = *y - PANGO_PIXELS(baseline);
3011 }
3012 if (externalLeading) (*externalLeading) = 0; // ??
3013
3014 g_object_unref (layout);
3015 }
3016
3017 void wxWindowGTK::GTKDisableFocusOutEvent()
3018 {
3019 g_signal_handlers_block_by_func( m_focusWidget,
3020 (gpointer) gtk_window_focus_out_callback, this);
3021 }
3022
3023 void wxWindowGTK::GTKEnableFocusOutEvent()
3024 {
3025 g_signal_handlers_unblock_by_func( m_focusWidget,
3026 (gpointer) gtk_window_focus_out_callback, this);
3027 }
3028
3029 bool wxWindowGTK::GTKHandleFocusIn()
3030 {
3031 // Disable default focus handling for custom windows since the default GTK+
3032 // handler issues a repaint
3033 const bool retval = m_wxwindow ? true : false;
3034
3035
3036 // NB: if there's still unprocessed deferred focus-out event (see
3037 // GTKHandleFocusOut() for explanation), we need to process it first so
3038 // that the order of focus events -- focus-out first, then focus-in
3039 // elsewhere -- is preserved
3040 if ( gs_deferredFocusOut )
3041 {
3042 if ( GTKNeedsToFilterSameWindowFocus() &&
3043 gs_deferredFocusOut == this )
3044 {
3045 // GTK+ focus changed from this wxWindow back to itself, so don't
3046 // emit any events at all
3047 wxLogTrace(TRACE_FOCUS,
3048 "filtered out spurious focus change within %s(%p, %s)",
3049 GetClassInfo()->GetClassName(), this, GetLabel());
3050 gs_deferredFocusOut = NULL;
3051 return retval;
3052 }
3053
3054 // otherwise we need to send focus-out first
3055 wxASSERT_MSG ( gs_deferredFocusOut != this,
3056 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
3057 GTKHandleDeferredFocusOut();
3058 }
3059
3060
3061 wxLogTrace(TRACE_FOCUS,
3062 "handling focus_in event for %s(%p, %s)",
3063 GetClassInfo()->GetClassName(), this, GetLabel());
3064
3065 if (m_imData)
3066 gtk_im_context_focus_in(m_imData->context);
3067
3068 gs_currentFocus = this;
3069 gs_pendingFocus = NULL;
3070
3071 #if wxUSE_CARET
3072 // caret needs to be informed about focus change
3073 wxCaret *caret = GetCaret();
3074 if ( caret )
3075 {
3076 caret->OnSetFocus();
3077 }
3078 #endif // wxUSE_CARET
3079
3080 // Notify the parent keeping track of focus for the kbd navigation
3081 // purposes that we got it.
3082 wxChildFocusEvent eventChildFocus(static_cast<wxWindow*>(this));
3083 GTKProcessEvent(eventChildFocus);
3084
3085 wxFocusEvent eventFocus(wxEVT_SET_FOCUS, GetId());
3086 eventFocus.SetEventObject(this);
3087 GTKProcessEvent(eventFocus);
3088
3089 return retval;
3090 }
3091
3092 bool wxWindowGTK::GTKHandleFocusOut()
3093 {
3094 // Disable default focus handling for custom windows since the default GTK+
3095 // handler issues a repaint
3096 const bool retval = m_wxwindow ? true : false;
3097
3098
3099 // NB: If a control is composed of several GtkWidgets and when focus
3100 // changes from one of them to another within the same wxWindow, we get
3101 // a focus-out event followed by focus-in for another GtkWidget owned
3102 // by the same wx control. We don't want to generate two spurious
3103 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3104 // from GTKHandleFocusOut() until we know for sure it's not coming back
3105 // (i.e. in GTKHandleFocusIn() or at idle time).
3106 if ( GTKNeedsToFilterSameWindowFocus() )
3107 {
3108 wxASSERT_MSG( gs_deferredFocusOut == NULL,
3109 "deferred focus out event already pending" );
3110 wxLogTrace(TRACE_FOCUS,
3111 "deferring focus_out event for %s(%p, %s)",
3112 GetClassInfo()->GetClassName(), this, GetLabel());
3113 gs_deferredFocusOut = this;
3114 return retval;
3115 }
3116
3117 GTKHandleFocusOutNoDeferring();
3118
3119 return retval;
3120 }
3121
3122 void wxWindowGTK::GTKHandleFocusOutNoDeferring()
3123 {
3124 wxLogTrace(TRACE_FOCUS,
3125 "handling focus_out event for %s(%p, %s)",
3126 GetClassInfo()->GetClassName(), this, GetLabel());
3127
3128 if (m_imData)
3129 gtk_im_context_focus_out(m_imData->context);
3130
3131 if ( gs_currentFocus != this )
3132 {
3133 // Something is terribly wrong, gs_currentFocus is out of sync with the
3134 // real focus. We will reset it to NULL anyway, because after this
3135 // focus-out event is handled, one of the following with happen:
3136 //
3137 // * either focus will go out of the app altogether, in which case
3138 // gs_currentFocus _should_ be NULL
3139 //
3140 // * or it goes to another control, in which case focus-in event will
3141 // follow immediately and it will set gs_currentFocus to the right
3142 // value
3143 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3144 GetClassInfo()->GetClassName(), this, GetLabel());
3145 }
3146 gs_currentFocus = NULL;
3147
3148 #if wxUSE_CARET
3149 // caret needs to be informed about focus change
3150 wxCaret *caret = GetCaret();
3151 if ( caret )
3152 {
3153 caret->OnKillFocus();
3154 }
3155 #endif // wxUSE_CARET
3156
3157 wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
3158 event.SetEventObject( this );
3159 event.SetWindow( FindFocus() );
3160 GTKProcessEvent( event );
3161 }
3162
3163 /*static*/
3164 void wxWindowGTK::GTKHandleDeferredFocusOut()
3165 {
3166 // NB: See GTKHandleFocusOut() for explanation. This function is called
3167 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3168 // deferred event.
3169 if ( gs_deferredFocusOut )
3170 {
3171 wxWindowGTK *win = gs_deferredFocusOut;
3172 gs_deferredFocusOut = NULL;
3173
3174 wxLogTrace(TRACE_FOCUS,
3175 "processing deferred focus_out event for %s(%p, %s)",
3176 win->GetClassInfo()->GetClassName(), win, win->GetLabel());
3177
3178 win->GTKHandleFocusOutNoDeferring();
3179 }
3180 }
3181
3182 void wxWindowGTK::SetFocus()
3183 {
3184 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3185
3186 // Setting "physical" focus is not immediate in GTK+ and while
3187 // gtk_widget_is_focus ("determines if the widget is the focus widget
3188 // within its toplevel", i.e. returns true for one widget per TLW, not
3189 // globally) returns true immediately after grabbing focus,
3190 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3191 // has focus at the moment) takes effect only after the window is shown
3192 // (if it was hidden at the moment of the call) or at the next event loop
3193 // iteration.
3194 //
3195 // Because we want to FindFocus() call immediately following
3196 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3197 // ourselves.
3198 gs_pendingFocus = this;
3199
3200 GtkWidget *widget = m_wxwindow ? m_wxwindow : m_focusWidget;
3201
3202 if ( GTK_IS_CONTAINER(widget) &&
3203 !gtk_widget_get_can_focus(widget) )
3204 {
3205 wxLogTrace(TRACE_FOCUS,
3206 wxT("Setting focus to a child of %s(%p, %s)"),
3207 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3208 gtk_widget_child_focus(widget, GTK_DIR_TAB_FORWARD);
3209 }
3210 else
3211 {
3212 wxLogTrace(TRACE_FOCUS,
3213 wxT("Setting focus to %s(%p, %s)"),
3214 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3215 gtk_widget_grab_focus(widget);
3216 }
3217 }
3218
3219 void wxWindowGTK::SetCanFocus(bool canFocus)
3220 {
3221 gtk_widget_set_can_focus(m_widget, canFocus);
3222
3223 if ( m_wxwindow && (m_widget != m_wxwindow) )
3224 {
3225 gtk_widget_set_can_focus(m_wxwindow, canFocus);
3226 }
3227 }
3228
3229 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3230 {
3231 wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
3232
3233 wxWindowGTK * const newParent = (wxWindowGTK *)newParentBase;
3234
3235 wxASSERT( GTK_IS_WIDGET(m_widget) );
3236
3237 if ( !wxWindowBase::Reparent(newParent) )
3238 return false;
3239
3240 wxASSERT( GTK_IS_WIDGET(m_widget) );
3241
3242 // Notice that old m_parent pointer might be non-NULL here but the widget
3243 // still not have any parent at GTK level if it's a notebook page that had
3244 // been removed from the notebook so test this at GTK level and not wx one.
3245 if ( GtkWidget *parentGTK = gtk_widget_get_parent(m_widget) )
3246 gtk_container_remove(GTK_CONTAINER(parentGTK), m_widget);
3247
3248 wxASSERT( GTK_IS_WIDGET(m_widget) );
3249
3250 if (newParent)
3251 {
3252 if (gtk_widget_get_visible (newParent->m_widget))
3253 {
3254 m_showOnIdle = true;
3255 gtk_widget_hide( m_widget );
3256 }
3257 /* insert GTK representation */
3258 newParent->AddChildGTK(this);
3259 }
3260
3261 SetLayoutDirection(wxLayout_Default);
3262
3263 return true;
3264 }
3265
3266 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3267 {
3268 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3269 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3270
3271 /* add to list */
3272 AddChild( child );
3273
3274 /* insert GTK representation */
3275 AddChildGTK(child);
3276 }
3277
3278 void wxWindowGTK::AddChild(wxWindowBase *child)
3279 {
3280 wxWindowBase::AddChild(child);
3281 m_dirtyTabOrder = true;
3282 wxTheApp->WakeUpIdle();
3283 }
3284
3285 void wxWindowGTK::RemoveChild(wxWindowBase *child)
3286 {
3287 wxWindowBase::RemoveChild(child);
3288 m_dirtyTabOrder = true;
3289 wxTheApp->WakeUpIdle();
3290 }
3291
3292 /* static */
3293 wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
3294 {
3295 return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL
3296 ? wxLayout_RightToLeft
3297 : wxLayout_LeftToRight;
3298 }
3299
3300 /* static */
3301 void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir)
3302 {
3303 wxASSERT_MSG( dir != wxLayout_Default, wxT("invalid layout direction") );
3304
3305 gtk_widget_set_direction(widget,
3306 dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
3307 : GTK_TEXT_DIR_LTR);
3308 }
3309
3310 wxLayoutDirection wxWindowGTK::GetLayoutDirection() const
3311 {
3312 return GTKGetLayout(m_widget);
3313 }
3314
3315 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir)
3316 {
3317 if ( dir == wxLayout_Default )
3318 {
3319 const wxWindow *const parent = GetParent();
3320 if ( parent )
3321 {
3322 // inherit layout from parent.
3323 dir = parent->GetLayoutDirection();
3324 }
3325 else // no parent, use global default layout
3326 {
3327 dir = wxTheApp->GetLayoutDirection();
3328 }
3329 }
3330
3331 if ( dir == wxLayout_Default )
3332 return;
3333
3334 GTKSetLayout(m_widget, dir);
3335
3336 if (m_wxwindow && (m_wxwindow != m_widget))
3337 GTKSetLayout(m_wxwindow, dir);
3338 }
3339
3340 wxCoord
3341 wxWindowGTK::AdjustForLayoutDirection(wxCoord x,
3342 wxCoord WXUNUSED(width),
3343 wxCoord WXUNUSED(widthTotal)) const
3344 {
3345 // We now mirror the coordinates of RTL windows in wxPizza
3346 return x;
3347 }
3348
3349 void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, WindowOrder move)
3350 {
3351 wxWindowBase::DoMoveInTabOrder(win, move);
3352 m_dirtyTabOrder = true;
3353 wxTheApp->WakeUpIdle();
3354 }
3355
3356 bool wxWindowGTK::DoNavigateIn(int flags)
3357 {
3358 if ( flags & wxNavigationKeyEvent::WinChange )
3359 {
3360 wxFAIL_MSG( wxT("not implemented") );
3361
3362 return false;
3363 }
3364 else // navigate inside the container
3365 {
3366 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3367 wxCHECK_MSG( parent, false, wxT("every window must have a TLW parent") );
3368
3369 GtkDirectionType dir;
3370 dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD
3371 : GTK_DIR_TAB_BACKWARD;
3372
3373 gboolean rc;
3374 g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
3375
3376 return rc == TRUE;
3377 }
3378 }
3379
3380 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3381 {
3382 // none needed by default
3383 return false;
3384 }
3385
3386 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget* WXUNUSED(w))
3387 {
3388 // nothing to do by default since none is needed
3389 }
3390
3391 void wxWindowGTK::RealizeTabOrder()
3392 {
3393 if (m_wxwindow)
3394 {
3395 if ( !m_children.empty() )
3396 {
3397 // we don't only construct the correct focus chain but also use
3398 // this opportunity to update the mnemonic widgets for the widgets
3399 // that need them
3400
3401 GList *chain = NULL;
3402 wxWindowGTK* mnemonicWindow = NULL;
3403
3404 for ( wxWindowList::const_iterator i = m_children.begin();
3405 i != m_children.end();
3406 ++i )
3407 {
3408 wxWindowGTK *win = *i;
3409
3410 bool focusableFromKeyboard = win->AcceptsFocusFromKeyboard();
3411
3412 if ( mnemonicWindow )
3413 {
3414 if ( focusableFromKeyboard )
3415 {
3416 // wxComboBox et al. needs to focus on on a different
3417 // widget than m_widget, so if the main widget isn't
3418 // focusable try the connect widget
3419 GtkWidget* w = win->m_widget;
3420 if ( !gtk_widget_get_can_focus(w) )
3421 {
3422 w = win->GetConnectWidget();
3423 if ( !gtk_widget_get_can_focus(w) )
3424 w = NULL;
3425 }
3426
3427 if ( w )
3428 {
3429 mnemonicWindow->GTKWidgetDoSetMnemonic(w);
3430 mnemonicWindow = NULL;
3431 }
3432 }
3433 }
3434 else if ( win->GTKWidgetNeedsMnemonic() )
3435 {
3436 mnemonicWindow = win;
3437 }
3438
3439 if ( focusableFromKeyboard )
3440 chain = g_list_prepend(chain, win->m_widget);
3441 }
3442
3443 chain = g_list_reverse(chain);
3444
3445 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain);
3446 g_list_free(chain);
3447 }
3448 else // no children
3449 {
3450 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow));
3451 }
3452 }
3453 }
3454
3455 void wxWindowGTK::Raise()
3456 {
3457 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3458
3459 if (m_wxwindow && gtk_widget_get_window(m_wxwindow))
3460 {
3461 gdk_window_raise(gtk_widget_get_window(m_wxwindow));
3462 }
3463 else if (gtk_widget_get_window(m_widget))
3464 {
3465 gdk_window_raise(gtk_widget_get_window(m_widget));
3466 }
3467 }
3468
3469 void wxWindowGTK::Lower()
3470 {
3471 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3472
3473 if (m_wxwindow && gtk_widget_get_window(m_wxwindow))
3474 {
3475 gdk_window_lower(gtk_widget_get_window(m_wxwindow));
3476 }
3477 else if (gtk_widget_get_window(m_widget))
3478 {
3479 gdk_window_lower(gtk_widget_get_window(m_widget));
3480 }
3481 }
3482
3483 bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3484 {
3485 if ( !wxWindowBase::SetCursor(cursor.IsOk() ? cursor : *wxSTANDARD_CURSOR) )
3486 return false;
3487
3488 GTKUpdateCursor();
3489
3490 return true;
3491 }
3492
3493 void wxWindowGTK::GTKUpdateCursor(bool update_self /*=true*/, bool recurse /*=true*/)
3494 {
3495 if (update_self)
3496 {
3497 wxCursor cursor(g_globalCursor.IsOk() ? g_globalCursor : GetCursor());
3498 if ( cursor.IsOk() )
3499 {
3500 wxArrayGdkWindows windowsThis;
3501 GdkWindow* window = GTKGetWindow(windowsThis);
3502 if (window)
3503 gdk_window_set_cursor( window, cursor.GetCursor() );
3504 else
3505 {
3506 const size_t count = windowsThis.size();
3507 for ( size_t n = 0; n < count; n++ )
3508 {
3509 GdkWindow *win = windowsThis[n];
3510 // It can be zero if the window has not been realized yet.
3511 if ( win )
3512 {
3513 gdk_window_set_cursor(win, cursor.GetCursor());
3514 }
3515 }
3516 }
3517 }
3518 }
3519
3520 if (recurse)
3521 {
3522 for (wxWindowList::iterator it = GetChildren().begin(); it != GetChildren().end(); ++it)
3523 {
3524 (*it)->GTKUpdateCursor( true );
3525 }
3526 }
3527 }
3528
3529 void wxWindowGTK::WarpPointer( int x, int y )
3530 {
3531 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3532
3533 ClientToScreen(&x, &y);
3534 GdkDisplay* display = gtk_widget_get_display(m_widget);
3535 GdkScreen* screen = gtk_widget_get_screen(m_widget);
3536 #ifdef __WXGTK30__
3537 GdkDeviceManager* manager = gdk_display_get_device_manager(display);
3538 gdk_device_warp(gdk_device_manager_get_client_pointer(manager), screen, x, y);
3539 #else
3540 XWarpPointer(GDK_DISPLAY_XDISPLAY(display),
3541 None,
3542 GDK_WINDOW_XID(gdk_screen_get_root_window(screen)),
3543 0, 0, 0, 0, x, y);
3544 #endif
3545 }
3546
3547 wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const
3548 {
3549 // find the scrollbar which generated the event
3550 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
3551 {
3552 if ( range == m_scrollBar[dir] )
3553 return (ScrollDir)dir;
3554 }
3555
3556 wxFAIL_MSG( wxT("event from unknown scrollbar received") );
3557
3558 return ScrollDir_Max;
3559 }
3560
3561 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units)
3562 {
3563 bool changed = false;
3564 GtkRange* range = m_scrollBar[dir];
3565 if ( range && units )
3566 {
3567 GtkAdjustment* adj = gtk_range_get_adjustment(range);
3568 double inc = unit == ScrollUnit_Line ? gtk_adjustment_get_step_increment(adj)
3569 : gtk_adjustment_get_page_increment(adj);
3570
3571 const int posOld = wxRound(gtk_adjustment_get_value(adj));
3572 gtk_range_set_value(range, posOld + units*inc);
3573
3574 changed = wxRound(gtk_adjustment_get_value(adj)) != posOld;
3575 }
3576
3577 return changed;
3578 }
3579
3580 bool wxWindowGTK::ScrollLines(int lines)
3581 {
3582 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Line, lines);
3583 }
3584
3585 bool wxWindowGTK::ScrollPages(int pages)
3586 {
3587 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages);
3588 }
3589
3590 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground),
3591 const wxRect *rect)
3592 {
3593 if ( !m_widget )
3594 {
3595 // it is valid to call Refresh() for a window which hasn't been created
3596 // yet, it simply doesn't do anything in this case
3597 return;
3598 }
3599
3600 if (!m_wxwindow)
3601 {
3602 if (rect)
3603 gtk_widget_queue_draw_area( m_widget, rect->x, rect->y, rect->width, rect->height );
3604 else
3605 gtk_widget_queue_draw( m_widget );
3606 }
3607 else
3608 {
3609 // Just return if the widget or one of its ancestors isn't mapped
3610 GtkWidget *w;
3611 for (w = m_wxwindow; w != NULL; w = gtk_widget_get_parent(w))
3612 if (!gtk_widget_get_mapped (w))
3613 return;
3614
3615 GdkWindow* window = GTKGetDrawingWindow();
3616 if (rect)
3617 {
3618 int x = rect->x;
3619 if (GetLayoutDirection() == wxLayout_RightToLeft)
3620 x = GetClientSize().x - x - rect->width;
3621 GdkRectangle r;
3622 r.x = rect->x;
3623 r.y = rect->y;
3624 r.width = rect->width;
3625 r.height = rect->height;
3626 gdk_window_invalidate_rect(window, &r, true);
3627 }
3628 else
3629 gdk_window_invalidate_rect(window, NULL, true);
3630 }
3631 }
3632
3633 void wxWindowGTK::Update()
3634 {
3635 if (m_widget && gtk_widget_get_mapped(m_widget))
3636 {
3637 GdkDisplay* display = gtk_widget_get_display(m_widget);
3638 // Flush everything out to the server, and wait for it to finish.
3639 // This ensures nothing will overwrite the drawing we are about to do.
3640 gdk_display_sync(display);
3641
3642 GdkWindow* window = GTKGetDrawingWindow();
3643 if (window == NULL)
3644 window = gtk_widget_get_window(m_widget);
3645 gdk_window_process_updates(window, true);
3646
3647 // Flush again, but no need to wait for it to finish
3648 gdk_display_flush(display);
3649 }
3650 }
3651
3652 bool wxWindowGTK::DoIsExposed( int x, int y ) const
3653 {
3654 return m_updateRegion.Contains(x, y) != wxOutRegion;
3655 }
3656
3657 bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const
3658 {
3659 if (GetLayoutDirection() == wxLayout_RightToLeft)
3660 return m_updateRegion.Contains(x-w, y, w, h) != wxOutRegion;
3661 else
3662 return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
3663 }
3664
3665 void wxWindowGTK::GtkSendPaintEvents()
3666 {
3667 if (!m_wxwindow)
3668 {
3669 m_updateRegion.Clear();
3670 return;
3671 }
3672
3673 // Clip to paint region in wxClientDC
3674 m_clipPaintRegion = true;
3675
3676 m_nativeUpdateRegion = m_updateRegion;
3677
3678 if (GetLayoutDirection() == wxLayout_RightToLeft)
3679 {
3680 // Transform m_updateRegion under RTL
3681 m_updateRegion.Clear();
3682
3683 gint width;
3684 gdk_drawable_get_size(gtk_widget_get_window(m_wxwindow), &width, NULL);
3685
3686 wxRegionIterator upd( m_nativeUpdateRegion );
3687 while (upd)
3688 {
3689 wxRect rect;
3690 rect.x = upd.GetX();
3691 rect.y = upd.GetY();
3692 rect.width = upd.GetWidth();
3693 rect.height = upd.GetHeight();
3694
3695 rect.x = width - rect.x - rect.width;
3696 m_updateRegion.Union( rect );
3697
3698 ++upd;
3699 }
3700 }
3701
3702 switch ( GetBackgroundStyle() )
3703 {
3704 case wxBG_STYLE_ERASE:
3705 {
3706 wxWindowDC dc( (wxWindow*)this );
3707 dc.SetDeviceClippingRegion( m_updateRegion );
3708
3709 // Work around gtk-qt <= 0.60 bug whereby the window colour
3710 // remains grey
3711 if ( UseBgCol() &&
3712 wxSystemOptions::
3713 GetOptionInt("gtk.window.force-background-colour") )
3714 {
3715 dc.SetBackground(GetBackgroundColour());
3716 dc.Clear();
3717 }
3718
3719 wxEraseEvent erase_event( GetId(), &dc );
3720 erase_event.SetEventObject( this );
3721
3722 if ( HandleWindowEvent(erase_event) )
3723 {
3724 // background erased, don't do it again
3725 break;
3726 }
3727 }
3728 // fall through
3729
3730 case wxBG_STYLE_SYSTEM:
3731 if ( GetThemeEnabled() )
3732 {
3733 // find ancestor from which to steal background
3734 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3735 if (!parent)
3736 parent = (wxWindow*)this;
3737
3738 if (gtk_widget_get_mapped(parent->m_widget))
3739 {
3740 wxRegionIterator upd( m_nativeUpdateRegion );
3741 while (upd)
3742 {
3743 GdkRectangle rect;
3744 rect.x = upd.GetX();
3745 rect.y = upd.GetY();
3746 rect.width = upd.GetWidth();
3747 rect.height = upd.GetHeight();
3748
3749 gtk_paint_flat_box(gtk_widget_get_style(parent->m_widget),
3750 GTKGetDrawingWindow(),
3751 gtk_widget_get_state(m_wxwindow),
3752 GTK_SHADOW_NONE,
3753 &rect,
3754 parent->m_widget,
3755 (char *)"base",
3756 0, 0, -1, -1 );
3757
3758 ++upd;
3759 }
3760 }
3761 }
3762 break;
3763
3764 case wxBG_STYLE_PAINT:
3765 // nothing to do: window will be painted over in EVT_PAINT
3766 break;
3767
3768 default:
3769 wxFAIL_MSG( "unsupported background style" );
3770 }
3771
3772 wxNcPaintEvent nc_paint_event( GetId() );
3773 nc_paint_event.SetEventObject( this );
3774 HandleWindowEvent( nc_paint_event );
3775
3776 wxPaintEvent paint_event( GetId() );
3777 paint_event.SetEventObject( this );
3778 HandleWindowEvent( paint_event );
3779
3780 m_clipPaintRegion = false;
3781
3782 m_updateRegion.Clear();
3783 m_nativeUpdateRegion.Clear();
3784 }
3785
3786 void wxWindowGTK::SetDoubleBuffered( bool on )
3787 {
3788 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3789
3790 if ( m_wxwindow )
3791 gtk_widget_set_double_buffered( m_wxwindow, on );
3792 }
3793
3794 bool wxWindowGTK::IsDoubleBuffered() const
3795 {
3796 return gtk_widget_get_double_buffered( m_wxwindow );
3797 }
3798
3799 void wxWindowGTK::ClearBackground()
3800 {
3801 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3802 }
3803
3804 #if wxUSE_TOOLTIPS
3805 void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3806 {
3807 if (m_tooltip != tip)
3808 {
3809 wxWindowBase::DoSetToolTip(tip);
3810
3811 if (m_tooltip)
3812 m_tooltip->GTKSetWindow(static_cast<wxWindow*>(this));
3813 else
3814 GTKApplyToolTip(NULL);
3815 }
3816 }
3817
3818 void wxWindowGTK::GTKApplyToolTip(const char* tip)
3819 {
3820 wxToolTip::GTKApply(GetConnectWidget(), tip);
3821 }
3822 #endif // wxUSE_TOOLTIPS
3823
3824 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
3825 {
3826 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3827
3828 if (!wxWindowBase::SetBackgroundColour(colour))
3829 return false;
3830
3831 if (colour.IsOk())
3832 {
3833 // We need the pixel value e.g. for background clearing.
3834 m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3835 }
3836
3837 // apply style change (forceStyle=true so that new style is applied
3838 // even if the bg colour changed from valid to wxNullColour)
3839 GTKApplyWidgetStyle(true);
3840
3841 return true;
3842 }
3843
3844 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
3845 {
3846 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3847
3848 if (!wxWindowBase::SetForegroundColour(colour))
3849 {
3850 return false;
3851 }
3852
3853 if (colour.IsOk())
3854 {
3855 // We need the pixel value e.g. for background clearing.
3856 m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3857 }
3858
3859 // apply style change (forceStyle=true so that new style is applied
3860 // even if the bg colour changed from valid to wxNullColour):
3861 GTKApplyWidgetStyle(true);
3862
3863 return true;
3864 }
3865
3866 PangoContext *wxWindowGTK::GTKGetPangoDefaultContext()
3867 {
3868 return gtk_widget_get_pango_context( m_widget );
3869 }
3870
3871 GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle)
3872 {
3873 // do we need to apply any changes at all?
3874 if ( !forceStyle &&
3875 !m_font.IsOk() &&
3876 !m_foregroundColour.IsOk() && !m_backgroundColour.IsOk() )
3877 {
3878 return NULL;
3879 }
3880
3881 GtkRcStyle *style = gtk_rc_style_new();
3882
3883 if ( m_font.IsOk() )
3884 {
3885 style->font_desc =
3886 pango_font_description_copy( m_font.GetNativeFontInfo()->description );
3887 }
3888
3889 int flagsNormal = 0,
3890 flagsPrelight = 0,
3891 flagsActive = 0,
3892 flagsInsensitive = 0;
3893
3894 if ( m_foregroundColour.IsOk() )
3895 {
3896 const GdkColor *fg = m_foregroundColour.GetColor();
3897
3898 style->fg[GTK_STATE_NORMAL] =
3899 style->text[GTK_STATE_NORMAL] = *fg;
3900 flagsNormal |= GTK_RC_FG | GTK_RC_TEXT;
3901
3902 style->fg[GTK_STATE_PRELIGHT] =
3903 style->text[GTK_STATE_PRELIGHT] = *fg;
3904 flagsPrelight |= GTK_RC_FG | GTK_RC_TEXT;
3905
3906 style->fg[GTK_STATE_ACTIVE] =
3907 style->text[GTK_STATE_ACTIVE] = *fg;
3908 flagsActive |= GTK_RC_FG | GTK_RC_TEXT;
3909 }
3910
3911 if ( m_backgroundColour.IsOk() )
3912 {
3913 const GdkColor *bg = m_backgroundColour.GetColor();
3914
3915 style->bg[GTK_STATE_NORMAL] =
3916 style->base[GTK_STATE_NORMAL] = *bg;
3917 flagsNormal |= GTK_RC_BG | GTK_RC_BASE;
3918
3919 style->bg[GTK_STATE_PRELIGHT] =
3920 style->base[GTK_STATE_PRELIGHT] = *bg;
3921 flagsPrelight |= GTK_RC_BG | GTK_RC_BASE;
3922
3923 style->bg[GTK_STATE_ACTIVE] =
3924 style->base[GTK_STATE_ACTIVE] = *bg;
3925 flagsActive |= GTK_RC_BG | GTK_RC_BASE;
3926
3927 style->bg[GTK_STATE_INSENSITIVE] =
3928 style->base[GTK_STATE_INSENSITIVE] = *bg;
3929 flagsInsensitive |= GTK_RC_BG | GTK_RC_BASE;
3930 }
3931
3932 style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)flagsNormal;
3933 style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)flagsPrelight;
3934 style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)flagsActive;
3935 style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)flagsInsensitive;
3936
3937 return style;
3938 }
3939
3940 void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle)
3941 {
3942 GtkRcStyle *style = GTKCreateWidgetStyle(forceStyle);
3943 if ( style )
3944 {
3945 DoApplyWidgetStyle(style);
3946 g_object_unref(style);
3947 }
3948
3949 // Style change may affect GTK+'s size calculation:
3950 InvalidateBestSize();
3951 }
3952
3953 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
3954 {
3955 if ( m_wxwindow )
3956 {
3957 // block the signal temporarily to avoid sending
3958 // wxSysColourChangedEvents when we change the colours ourselves
3959 bool unblock = false;
3960 if ( IsTopLevel() )
3961 {
3962 unblock = true;
3963 g_signal_handlers_block_by_func(
3964 m_wxwindow, (void *)gtk_window_style_set_callback, this);
3965 }
3966
3967 gtk_widget_modify_style(m_wxwindow, style);
3968
3969 if ( unblock )
3970 {
3971 g_signal_handlers_unblock_by_func(
3972 m_wxwindow, (void *)gtk_window_style_set_callback, this);
3973 }
3974 }
3975 else
3976 {
3977 gtk_widget_modify_style(m_widget, style);
3978 }
3979 }
3980
3981 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
3982 {
3983 wxWindowBase::SetBackgroundStyle(style);
3984
3985 if ( style == wxBG_STYLE_PAINT )
3986 {
3987 GdkWindow *window;
3988 if ( m_wxwindow )
3989 {
3990 window = GTKGetDrawingWindow();
3991 }
3992 else
3993 {
3994 GtkWidget * const w = GetConnectWidget();
3995 window = w ? gtk_widget_get_window(w) : NULL;
3996 }
3997
3998 if (window)
3999 {
4000 // Make sure GDK/X11 doesn't refresh the window
4001 // automatically.
4002 gdk_window_set_back_pixmap( window, None, False );
4003 #ifdef __X__
4004 Display* display = GDK_WINDOW_DISPLAY(window);
4005 XFlush(display);
4006 #endif
4007 m_needsStyleChange = false;
4008 }
4009 else // window not realized yet
4010 {
4011 // Do in OnIdle, because the window is not yet available
4012 m_needsStyleChange = true;
4013 }
4014
4015 // Don't apply widget style, or we get a grey background
4016 }
4017 else
4018 {
4019 // apply style change (forceStyle=true so that new style is applied
4020 // even if the bg colour changed from valid to wxNullColour):
4021 GTKApplyWidgetStyle(true);
4022 }
4023
4024 return true;
4025 }
4026
4027 // ----------------------------------------------------------------------------
4028 // Pop-up menu stuff
4029 // ----------------------------------------------------------------------------
4030
4031 #if wxUSE_MENUS_NATIVE
4032
4033 extern "C" {
4034 static
4035 void wxPopupMenuPositionCallback( GtkMenu *menu,
4036 gint *x, gint *y,
4037 gboolean * WXUNUSED(whatever),
4038 gpointer user_data )
4039 {
4040 // ensure that the menu appears entirely on screen
4041 GtkRequisition req;
4042 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
4043
4044 wxSize sizeScreen = wxGetDisplaySize();
4045 wxPoint *pos = (wxPoint*)user_data;
4046
4047 gint xmax = sizeScreen.x - req.width,
4048 ymax = sizeScreen.y - req.height;
4049
4050 *x = pos->x < xmax ? pos->x : xmax;
4051 *y = pos->y < ymax ? pos->y : ymax;
4052 }
4053 }
4054
4055 bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
4056 {
4057 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4058
4059 menu->UpdateUI();
4060
4061 wxPoint pos;
4062 gpointer userdata;
4063 GtkMenuPositionFunc posfunc;
4064 if ( x == -1 && y == -1 )
4065 {
4066 // use GTK's default positioning algorithm
4067 userdata = NULL;
4068 posfunc = NULL;
4069 }
4070 else
4071 {
4072 pos = ClientToScreen(wxPoint(x, y));
4073 userdata = &pos;
4074 posfunc = wxPopupMenuPositionCallback;
4075 }
4076
4077 menu->m_popupShown = true;
4078 gtk_menu_popup(
4079 GTK_MENU(menu->m_menu),
4080 NULL, // parent menu shell
4081 NULL, // parent menu item
4082 posfunc, // function to position it
4083 userdata, // client data
4084 0, // button used to activate it
4085 gtk_get_current_event_time()
4086 );
4087
4088 while (menu->m_popupShown)
4089 {
4090 gtk_main_iteration();
4091 }
4092
4093 return true;
4094 }
4095
4096 #endif // wxUSE_MENUS_NATIVE
4097
4098 #if wxUSE_DRAG_AND_DROP
4099
4100 void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
4101 {
4102 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4103
4104 GtkWidget *dnd_widget = GetConnectWidget();
4105
4106 if (m_dropTarget) m_dropTarget->GtkUnregisterWidget( dnd_widget );
4107
4108 if (m_dropTarget) delete m_dropTarget;
4109 m_dropTarget = dropTarget;
4110
4111 if (m_dropTarget) m_dropTarget->GtkRegisterWidget( dnd_widget );
4112 }
4113
4114 #endif // wxUSE_DRAG_AND_DROP
4115
4116 GtkWidget* wxWindowGTK::GetConnectWidget()
4117 {
4118 GtkWidget *connect_widget = m_widget;
4119 if (m_wxwindow) connect_widget = m_wxwindow;
4120
4121 return connect_widget;
4122 }
4123
4124 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const
4125 {
4126 wxArrayGdkWindows windowsThis;
4127 GdkWindow * const winThis = GTKGetWindow(windowsThis);
4128
4129 return winThis ? window == winThis
4130 : windowsThis.Index(window) != wxNOT_FOUND;
4131 }
4132
4133 GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
4134 {
4135 return m_wxwindow ? GTKGetDrawingWindow() : gtk_widget_get_window(m_widget);
4136 }
4137
4138 bool wxWindowGTK::SetFont( const wxFont &font )
4139 {
4140 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4141
4142 if (!wxWindowBase::SetFont(font))
4143 return false;
4144
4145 // apply style change (forceStyle=true so that new style is applied
4146 // even if the font changed from valid to wxNullFont):
4147 GTKApplyWidgetStyle(true);
4148
4149 return true;
4150 }
4151
4152 void wxWindowGTK::DoCaptureMouse()
4153 {
4154 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4155
4156 GdkWindow *window = NULL;
4157 if (m_wxwindow)
4158 window = GTKGetDrawingWindow();
4159 else
4160 window = gtk_widget_get_window(GetConnectWidget());
4161
4162 wxCHECK_RET( window, wxT("CaptureMouse() failed") );
4163
4164 const wxCursor* cursor = &m_cursor;
4165 if (!cursor->IsOk())
4166 cursor = wxSTANDARD_CURSOR;
4167
4168 gdk_pointer_grab( window, FALSE,
4169 (GdkEventMask)
4170 (GDK_BUTTON_PRESS_MASK |
4171 GDK_BUTTON_RELEASE_MASK |
4172 GDK_POINTER_MOTION_HINT_MASK |
4173 GDK_POINTER_MOTION_MASK),
4174 NULL,
4175 cursor->GetCursor(),
4176 (guint32)GDK_CURRENT_TIME );
4177 g_captureWindow = this;
4178 g_captureWindowHasMouse = true;
4179 }
4180
4181 void wxWindowGTK::DoReleaseMouse()
4182 {
4183 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4184
4185 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
4186
4187 g_captureWindow = NULL;
4188
4189 GdkWindow *window = NULL;
4190 if (m_wxwindow)
4191 window = GTKGetDrawingWindow();
4192 else
4193 window = gtk_widget_get_window(GetConnectWidget());
4194
4195 if (!window)
4196 return;
4197
4198 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
4199 }
4200
4201 void wxWindowGTK::GTKReleaseMouseAndNotify()
4202 {
4203 DoReleaseMouse();
4204 wxMouseCaptureLostEvent evt(GetId());
4205 evt.SetEventObject( this );
4206 HandleWindowEvent( evt );
4207 }
4208
4209 /* static */
4210 wxWindow *wxWindowBase::GetCapture()
4211 {
4212 return (wxWindow *)g_captureWindow;
4213 }
4214
4215 bool wxWindowGTK::IsRetained() const
4216 {
4217 return false;
4218 }
4219
4220 void wxWindowGTK::SetScrollbar(int orient,
4221 int pos,
4222 int thumbVisible,
4223 int range,
4224 bool WXUNUSED(update))
4225 {
4226 const int dir = ScrollDirFromOrient(orient);
4227 GtkRange* const sb = m_scrollBar[dir];
4228 wxCHECK_RET( sb, wxT("this window is not scrollable") );
4229
4230 if (range <= 0)
4231 {
4232 // GtkRange requires upper > lower
4233 range =
4234 thumbVisible = 1;
4235 }
4236
4237 g_signal_handlers_block_by_func(
4238 sb, (void*)gtk_scrollbar_value_changed, this);
4239
4240 gtk_range_set_increments(sb, 1, thumbVisible);
4241 gtk_adjustment_set_page_size(gtk_range_get_adjustment(sb), thumbVisible);
4242 gtk_range_set_range(sb, 0, range);
4243 gtk_range_set_value(sb, pos);
4244 m_scrollPos[dir] = gtk_range_get_value(sb);
4245
4246 g_signal_handlers_unblock_by_func(
4247 sb, (void*)gtk_scrollbar_value_changed, this);
4248 }
4249
4250 void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
4251 {
4252 const int dir = ScrollDirFromOrient(orient);
4253 GtkRange * const sb = m_scrollBar[dir];
4254 wxCHECK_RET( sb, wxT("this window is not scrollable") );
4255
4256 // This check is more than an optimization. Without it, the slider
4257 // will not move smoothly while tracking when using wxScrollHelper.
4258 if (GetScrollPos(orient) != pos)
4259 {
4260 g_signal_handlers_block_by_func(
4261 sb, (void*)gtk_scrollbar_value_changed, this);
4262
4263 gtk_range_set_value(sb, pos);
4264 m_scrollPos[dir] = gtk_range_get_value(sb);
4265
4266 g_signal_handlers_unblock_by_func(
4267 sb, (void*)gtk_scrollbar_value_changed, this);
4268 }
4269 }
4270
4271 int wxWindowGTK::GetScrollThumb(int orient) const
4272 {
4273 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4274 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4275
4276 return wxRound(gtk_adjustment_get_page_size(gtk_range_get_adjustment(sb)));
4277 }
4278
4279 int wxWindowGTK::GetScrollPos( int orient ) const
4280 {
4281 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4282 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4283
4284 return wxRound(gtk_range_get_value(sb));
4285 }
4286
4287 int wxWindowGTK::GetScrollRange( int orient ) const
4288 {
4289 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4290 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4291
4292 return wxRound(gtk_adjustment_get_upper(gtk_range_get_adjustment(sb)));
4293 }
4294
4295 // Determine if increment is the same as +/-x, allowing for some small
4296 // difference due to possible inexactness in floating point arithmetic
4297 static inline bool IsScrollIncrement(double increment, double x)
4298 {
4299 wxASSERT(increment > 0);
4300 const double tolerance = 1.0 / 1024;
4301 return fabs(increment - fabs(x)) < tolerance;
4302 }
4303
4304 wxEventType wxWindowGTK::GTKGetScrollEventType(GtkRange* range)
4305 {
4306 wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
4307
4308 const int barIndex = range == m_scrollBar[1];
4309
4310 const double value = gtk_range_get_value(range);
4311
4312 // save previous position
4313 const double oldPos = m_scrollPos[barIndex];
4314 // update current position
4315 m_scrollPos[barIndex] = value;
4316 // If event should be ignored, or integral position has not changed
4317 if (!m_hasVMT || g_blockEventsOnDrag || wxRound(value) == wxRound(oldPos))
4318 {
4319 return wxEVT_NULL;
4320 }
4321
4322 wxEventType eventType = wxEVT_SCROLL_THUMBTRACK;
4323 if (!m_isScrolling)
4324 {
4325 // Difference from last change event
4326 const double diff = value - oldPos;
4327 const bool isDown = diff > 0;
4328
4329 GtkAdjustment* adj = gtk_range_get_adjustment(range);
4330 if (IsScrollIncrement(gtk_adjustment_get_step_increment(adj), diff))
4331 {
4332 eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
4333 }
4334 else if (IsScrollIncrement(gtk_adjustment_get_page_increment(adj), diff))
4335 {
4336 eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
4337 }
4338 else if (m_mouseButtonDown)
4339 {
4340 // Assume track event
4341 m_isScrolling = true;
4342 }
4343 }
4344 return eventType;
4345 }
4346
4347 void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4348 {
4349 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4350
4351 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4352
4353 // No scrolling requested.
4354 if ((dx == 0) && (dy == 0)) return;
4355
4356 m_clipPaintRegion = true;
4357
4358 WX_PIZZA(m_wxwindow)->scroll(dx, dy);
4359
4360 m_clipPaintRegion = false;
4361
4362 #if wxUSE_CARET
4363 bool restoreCaret = (GetCaret() != NULL && GetCaret()->IsVisible());
4364 if (restoreCaret)
4365 {
4366 wxRect caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4367 if (dx > 0)
4368 caretRect.width += dx;
4369 else
4370 {
4371 caretRect.x += dx; caretRect.width -= dx;
4372 }
4373 if (dy > 0)
4374 caretRect.height += dy;
4375 else
4376 {
4377 caretRect.y += dy; caretRect.height -= dy;
4378 }
4379
4380 RefreshRect(caretRect);
4381 }
4382 #endif // wxUSE_CARET
4383 }
4384
4385 void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
4386 {
4387 //RN: Note that static controls usually have no border on gtk, so maybe
4388 //it makes sense to treat that as simply no border at the wx level
4389 //as well...
4390 if (!(wxstyle & wxNO_BORDER) && !(wxstyle & wxBORDER_STATIC))
4391 {
4392 GtkShadowType gtkstyle;
4393
4394 if(wxstyle & wxBORDER_RAISED)
4395 gtkstyle = GTK_SHADOW_OUT;
4396 else if ((wxstyle & wxBORDER_SUNKEN) || (wxstyle & wxBORDER_THEME))
4397 gtkstyle = GTK_SHADOW_IN;
4398 #if 0
4399 // Now obsolete
4400 else if (wxstyle & wxBORDER_DOUBLE)
4401 gtkstyle = GTK_SHADOW_ETCHED_IN;
4402 #endif
4403 else //default
4404 gtkstyle = GTK_SHADOW_IN;
4405
4406 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w),
4407 gtkstyle );
4408 }
4409 }
4410
4411 void wxWindowGTK::SetWindowStyleFlag( long style )
4412 {
4413 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4414 wxWindowBase::SetWindowStyleFlag(style);
4415 }
4416
4417 // Find the wxWindow at the current mouse position, also returning the mouse
4418 // position.
4419 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4420 {
4421 pt = wxGetMousePosition();
4422 wxWindow* found = wxFindWindowAtPoint(pt);
4423 return found;
4424 }
4425
4426 // Get the current mouse position.
4427 wxPoint wxGetMousePosition()
4428 {
4429 /* This crashes when used within wxHelpContext,
4430 so we have to use the X-specific implementation below.
4431 gint x, y;
4432 GdkModifierType *mask;
4433 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4434
4435 return wxPoint(x, y);
4436 */
4437
4438 int x, y;
4439 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4440
4441 Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
4442 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4443 Window rootReturn, childReturn;
4444 int rootX, rootY, winX, winY;
4445 unsigned int maskReturn;
4446
4447 XQueryPointer (display,
4448 rootWindow,
4449 &rootReturn,
4450 &childReturn,
4451 &rootX, &rootY, &winX, &winY, &maskReturn);
4452 return wxPoint(rootX, rootY);
4453
4454 }
4455
4456 GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
4457 {
4458 GdkWindow* window = NULL;
4459 if (m_wxwindow)
4460 window = gtk_widget_get_window(m_wxwindow);
4461 return window;
4462 }
4463
4464 // ----------------------------------------------------------------------------
4465 // freeze/thaw
4466 // ----------------------------------------------------------------------------
4467
4468 extern "C"
4469 {
4470
4471 // this is called if we attempted to freeze unrealized widget when it finally
4472 // is realized (and so can be frozen):
4473 static void wx_frozen_widget_realize(GtkWidget* w, wxWindowGTK* win)
4474 {
4475 wxASSERT( w && gtk_widget_get_has_window(w) );
4476 wxASSERT( gtk_widget_get_realized(w) );
4477
4478 g_signal_handlers_disconnect_by_func
4479 (
4480 w,
4481 (void*)wx_frozen_widget_realize,
4482 win
4483 );
4484
4485 GdkWindow* window;
4486 if (w == win->m_wxwindow)
4487 window = win->GTKGetDrawingWindow();
4488 else
4489 window = gtk_widget_get_window(w);
4490 gdk_window_freeze_updates(window);
4491 }
4492
4493 } // extern "C"
4494
4495 void wxWindowGTK::GTKFreezeWidget(GtkWidget *w)
4496 {
4497 if ( !w || !gtk_widget_get_has_window(w) )
4498 return; // window-less widget, cannot be frozen
4499
4500 GdkWindow* window = gtk_widget_get_window(w);
4501 if (window == NULL)
4502 {
4503 // we can't thaw unrealized widgets because they don't have GdkWindow,
4504 // so set it up to be done immediately after realization:
4505 g_signal_connect_after
4506 (
4507 w,
4508 "realize",
4509 G_CALLBACK(wx_frozen_widget_realize),
4510 this
4511 );
4512 return;
4513 }
4514
4515 if (w == m_wxwindow)
4516 window = GTKGetDrawingWindow();
4517 gdk_window_freeze_updates(window);
4518 }
4519
4520 void wxWindowGTK::GTKThawWidget(GtkWidget *w)
4521 {
4522 if ( !w || !gtk_widget_get_has_window(w) )
4523 return; // window-less widget, cannot be frozen
4524
4525 GdkWindow* window = gtk_widget_get_window(w);
4526 if (window == NULL)
4527 {
4528 // the widget wasn't realized yet, no need to thaw
4529 g_signal_handlers_disconnect_by_func
4530 (
4531 w,
4532 (void*)wx_frozen_widget_realize,
4533 this
4534 );
4535 return;
4536 }
4537
4538 if (w == m_wxwindow)
4539 window = GTKGetDrawingWindow();
4540 gdk_window_thaw_updates(window);
4541 }
4542
4543 void wxWindowGTK::DoFreeze()
4544 {
4545 GTKFreezeWidget(m_widget);
4546 if ( m_wxwindow && m_widget != m_wxwindow )
4547 GTKFreezeWidget(m_wxwindow);
4548 }
4549
4550 void wxWindowGTK::DoThaw()
4551 {
4552 GTKThawWidget(m_widget);
4553 if ( m_wxwindow && m_widget != m_wxwindow )
4554 GTKThawWidget(m_wxwindow);
4555 }
wxWidgets (Impactor)