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