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