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