1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/window.cpp
3 // Purpose: wxWindowGTK implementation
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling, Julian Smart
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
14 #define XWarpPointer XWARPPOINTER
17 #include "wx/window.h"
22 #include "wx/toplevel.h"
23 #include "wx/dcclient.h"
25 #include "wx/settings.h"
26 #include "wx/msgdlg.h"
31 #include "wx/tooltip.h"
33 #include "wx/fontutil.h"
34 #include "wx/sysopt.h"
36 #include "wx/gtk/dc.h"
42 #include "wx/gtk/private.h"
43 #include "wx/gtk/private/gtk2-compat.h"
44 #include "wx/gtk/private/event.h"
45 #include "wx/gtk/private/win_gtk.h"
46 #include "wx/private/textmeasure.h"
47 using namespace wxGTKImpl
;
49 #ifdef GDK_WINDOWING_X11
51 #include "wx/x11/private/wrapxkb.h"
56 #include <gdk/gdkkeysyms.h>
58 #include <gdk/gdkkeysyms-compat.h>
61 // gdk_window_set_composited() is only supported since 2.12
62 #define wxGTK_VERSION_REQUIRED_FOR_COMPOSITING 2,12,0
63 #define wxGTK_HAS_COMPOSITING_SUPPORT GTK_CHECK_VERSION(2,12,0)
65 //-----------------------------------------------------------------------------
66 // documentation on internals
67 //-----------------------------------------------------------------------------
70 I have been asked several times about writing some documentation about
71 the GTK port of wxWidgets, especially its internal structures. Obviously,
72 you cannot understand wxGTK without knowing a little about the GTK, but
73 some more information about what the wxWindow, which is the base class
74 for all other window classes, does seems required as well.
78 What does wxWindow do? It contains the common interface for the following
79 jobs of its descendants:
81 1) Define the rudimentary behaviour common to all window classes, such as
82 resizing, intercepting user input (so as to make it possible to use these
83 events for special purposes in a derived class), window names etc.
85 2) Provide the possibility to contain and manage children, if the derived
86 class is allowed to contain children, which holds true for those window
87 classes which do not display a native GTK widget. To name them, these
88 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
89 work classes are a special case and are handled a bit differently from
90 the rest. The same holds true for the wxNotebook class.
92 3) Provide the possibility to draw into a client area of a window. This,
93 too, only holds true for classes that do not display a native GTK widget
96 4) Provide the entire mechanism for scrolling widgets. This actual inter-
97 face for this is usually in wxScrolledWindow, but the GTK implementation
100 5) A multitude of helper or extra methods for special purposes, such as
101 Drag'n'Drop, managing validators etc.
103 6) Display a border (sunken, raised, simple or none).
105 Normally one might expect, that one wxWidgets window would always correspond
106 to one GTK widget. Under GTK, there is no such all-round widget that has all
107 the functionality. Moreover, the GTK defines a client area as a different
108 widget from the actual widget you are handling. Last but not least some
109 special classes (e.g. wxFrame) handle different categories of widgets and
110 still have the possibility to draw something in the client area.
111 It was therefore required to write a special purpose GTK widget, that would
112 represent a client area in the sense of wxWidgets capable to do the jobs
113 2), 3) and 4). I have written this class and it resides in win_gtk.c of
116 All windows must have a widget, with which they interact with other under-
117 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
118 the wxWindow class has a member variable called m_widget which holds a
119 pointer to this widget. When the window class represents a GTK native widget,
120 this is (in most cases) the only GTK widget the class manages. E.g. the
121 wxStaticText class handles only a GtkLabel widget a pointer to which you
122 can find in m_widget (defined in wxWindow)
124 When the class has a client area for drawing into and for containing children
125 it has to handle the client area widget (of the type wxPizza, defined in
126 win_gtk.cpp), but there could be any number of widgets, handled by a class.
127 The common rule for all windows is only, that the widget that interacts with
128 the rest of GTK must be referenced in m_widget and all other widgets must be
129 children of this widget on the GTK level. The top-most widget, which also
130 represents the client area, must be in the m_wxwindow field and must be of
133 As I said, the window classes that display a GTK native widget only have
134 one widget, so in the case of e.g. the wxButton class m_widget holds a
135 pointer to a GtkButton widget. But windows with client areas (for drawing
136 and children) have a m_widget field that is a pointer to a GtkScrolled-
137 Window and a m_wxwindow field that is pointer to a wxPizza and this
138 one is (in the GTK sense) a child of the GtkScrolledWindow.
140 If the m_wxwindow field is set, then all input to this widget is inter-
141 cepted and sent to the wxWidgets class. If not, all input to the widget
142 that gets pointed to by m_widget gets intercepted and sent to the class.
146 The design of scrolling in wxWidgets is markedly different from that offered
147 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
148 clicking on a scrollbar belonging to scrolled window will inevitably move
149 the window. In wxWidgets, the scrollbar will only emit an event, send this
150 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
151 which actually moves the window and its sub-windows. Note that wxPizza
152 memorizes how much it has been scrolled but that wxWidgets forgets this
153 so that the two coordinates systems have to be kept in synch. This is done
154 in various places using the pizza->m_scroll_x and pizza->m_scroll_y values.
158 Singularly the most broken code in GTK is the code that is supposed to
159 inform subwindows (child windows) about new positions. Very often, duplicate
160 events are sent without changes in size or position, equally often no
161 events are sent at all (All this is due to a bug in the GtkContainer code
162 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
163 GTK's own system and it simply waits for size events for toplevel windows
164 and then iterates down the respective size events to all window. This has
165 the disadvantage that windows might get size events before the GTK widget
166 actually has the reported size. This doesn't normally pose any problem, but
167 the OpenGL drawing routines rely on correct behaviour. Therefore, I have
168 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
169 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
170 window that is used for OpenGL output really has that size (as reported by
175 If someone at some point of time feels the immense desire to have a look at,
176 change or attempt to optimise the Refresh() logic, this person will need an
177 intimate understanding of what "draw" and "expose" events are and what
178 they are used for, in particular when used in connection with GTK's
179 own windowless widgets. Beware.
183 Cursors, too, have been a constant source of pleasure. The main difficulty
184 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
185 for the parent. To prevent this from doing too much harm, SetCursor calls
186 GTKUpdateCursor, which will recursively re-set the cursors of all child windows.
187 Also don't forget that cursors (like much else) are connected to GdkWindows,
188 not GtkWidgets and that the "window" field of a GtkWidget might very well
189 point to the GdkWindow of the parent widget (-> "window-less widget") and
190 that the two obviously have very different meanings.
193 //-----------------------------------------------------------------------------
195 //-----------------------------------------------------------------------------
197 // Don't allow event propagation during drag
198 bool g_blockEventsOnDrag
;
199 // Don't allow mouse event propagation during scroll
200 bool g_blockEventsOnScroll
;
201 extern wxCursor g_globalCursor
;
203 // mouse capture state: the window which has it and if the mouse is currently
205 static wxWindowGTK
*g_captureWindow
= NULL
;
206 static bool g_captureWindowHasMouse
= false;
208 // The window that currently has focus:
209 static wxWindowGTK
*gs_currentFocus
= NULL
;
210 // The window that is scheduled to get focus in the next event loop iteration
211 // or NULL if there's no pending focus change:
212 static wxWindowGTK
*gs_pendingFocus
= NULL
;
214 // the window that has deferred focus-out event pending, if any (see
215 // GTKAddDeferredFocusOut() for details)
216 static wxWindowGTK
*gs_deferredFocusOut
= NULL
;
218 // global variables because GTK+ DnD want to have the
219 // mouse event that caused it
220 GdkEvent
*g_lastMouseEvent
= NULL
;
221 int g_lastButtonNumber
= 0;
223 //-----------------------------------------------------------------------------
225 //-----------------------------------------------------------------------------
227 // the trace mask used for the focus debugging messages
228 #define TRACE_FOCUS wxT("focus")
230 // A handy function to run from under gdb to show information about the given
231 // GtkWidget. Right now it only shows its type, we could enhance it to show
232 // more information later but this is already pretty useful.
233 const char* wxDumpGtkWidget(GtkWidget
* w
)
236 s
.Printf("GtkWidget %p, type \"%s\"", w
, G_OBJECT_TYPE_NAME(w
));
241 //-----------------------------------------------------------------------------
242 // "expose_event"/"draw" from m_wxwindow
243 //-----------------------------------------------------------------------------
247 static gboolean
draw(GtkWidget
*, cairo_t
* cr
, wxWindow
* win
)
249 if (gtk_cairo_should_draw_window(cr
, win
->GTKGetDrawingWindow()))
250 win
->GTKSendPaintEvents(cr
);
255 static gboolean
expose_event(GtkWidget
*, GdkEventExpose
* gdk_event
, wxWindow
* win
)
257 if (gdk_event
->window
== win
->GTKGetDrawingWindow())
258 win
->GTKSendPaintEvents(gdk_event
->region
);
262 #endif // !__WXGTK3__
265 #ifndef __WXUNIVERSAL__
266 //-----------------------------------------------------------------------------
267 // "expose_event"/"draw" from m_wxwindow->parent, for drawing border
268 //-----------------------------------------------------------------------------
273 draw_border(GtkWidget
*, cairo_t
* cr
, wxWindow
* win
)
275 draw_border(GtkWidget
* widget
, GdkEventExpose
* gdk_event
, wxWindow
* win
)
279 if (!gtk_cairo_should_draw_window(cr
, gtk_widget_get_parent_window(win
->m_wxwindow
)))
281 if (gdk_event
->window
!= gtk_widget_get_parent_window(win
->m_wxwindow
))
289 gtk_widget_get_allocation(win
->m_wxwindow
, &alloc
);
290 const int x
= alloc
.x
;
291 const int y
= alloc
.y
;
292 const int w
= alloc
.width
;
293 const int h
= alloc
.height
;
295 if (w
<= 0 || h
<= 0)
298 if (win
->HasFlag(wxBORDER_SIMPLE
))
301 GtkStyleContext
* sc
= gtk_widget_get_style_context(win
->m_wxwindow
);
303 gtk_style_context_get_border_color(sc
, GTK_STATE_FLAG_NORMAL
, &c
);
304 gdk_cairo_set_source_rgba(cr
, &c
);
305 cairo_set_line_width(cr
, 1);
306 cairo_rectangle(cr
, x
+ 0.5, y
+ 0.5, w
- 1, h
- 1);
309 gdk_draw_rectangle(gdk_event
->window
,
310 gtk_widget_get_style(widget
)->black_gc
, false, x
, y
, w
- 1, h
- 1);
313 else if (win
->HasFlag(wxBORDER_RAISED
| wxBORDER_SUNKEN
| wxBORDER_THEME
))
316 //TODO: wxBORDER_RAISED/wxBORDER_SUNKEN
318 if (win
->HasFlag(wxHSCROLL
| wxVSCROLL
))
319 sc
= gtk_widget_get_style_context(wxGTKPrivate
::GetTreeWidget());
321 sc
= gtk_widget_get_style_context(wxGTKPrivate
::GetEntryWidget());
323 gtk_render_frame(sc
, cr
, x
, y
, w
, h
);
325 GtkShadowType shadow
= GTK_SHADOW_IN
;
326 if (win
->HasFlag(wxBORDER_RAISED
))
327 shadow
= GTK_SHADOW_OUT
;
331 if (win
->HasFlag(wxHSCROLL
| wxVSCROLL
))
333 style
= gtk_widget_get_style(wxGTKPrivate
::GetTreeWidget());
338 style
= gtk_widget_get_style(wxGTKPrivate
::GetEntryWidget());
342 // clip rect is required to avoid painting background
343 // over upper left (w,h) of parent window
344 GdkRectangle clipRect
= { x
, y
, w
, h
};
346 style
, gdk_event
->window
, GTK_STATE_NORMAL
,
347 shadow
, &clipRect
, widget
, detail
, x
, y
, w
, h
);
348 #endif // !__WXGTK3__
354 //-----------------------------------------------------------------------------
355 // "parent_set" from m_wxwindow
356 //-----------------------------------------------------------------------------
360 parent_set(GtkWidget
* widget
, GtkWidget
* old_parent
, wxWindow
* win
)
364 g_signal_handlers_disconnect_by_func(
365 old_parent
, (void*)draw_border
, win
);
367 GtkWidget
* parent
= gtk_widget_get_parent(widget
);
371 g_signal_connect_after(parent
, "draw", G_CALLBACK(draw_border
), win
);
373 g_signal_connect_after(parent
, "expose_event", G_CALLBACK(draw_border
), win
);
378 #endif // !__WXUNIVERSAL__
380 //-----------------------------------------------------------------------------
381 // "key_press_event" from any window
382 //-----------------------------------------------------------------------------
384 // set WXTRACE to this to see the key event codes on the console
385 #define TRACE_KEYS wxT("keyevent")
387 // translates an X key symbol to WXK_XXX value
389 // if isChar is true it means that the value returned will be used for EVT_CHAR
390 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
391 // for example, while if it is false it means that the value is going to be
392 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
394 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
400 // Shift, Control and Alt don't generate the CHAR events at all
403 key_code
= isChar ?
0 : WXK_SHIFT
;
407 key_code
= isChar ?
0 : WXK_CONTROL
;
415 key_code
= isChar ?
0 : WXK_ALT
;
418 // neither do the toggle modifies
419 case GDK_Scroll_Lock
:
420 key_code
= isChar ?
0 : WXK_SCROLL
;
424 key_code
= isChar ?
0 : WXK_CAPITAL
;
428 key_code
= isChar ?
0 : WXK_NUMLOCK
;
432 // various other special keys
445 case GDK_ISO_Left_Tab
:
452 key_code
= WXK_RETURN
;
456 key_code
= WXK_CLEAR
;
460 key_code
= WXK_PAUSE
;
464 key_code
= WXK_SELECT
;
468 key_code
= WXK_PRINT
;
472 key_code
= WXK_EXECUTE
;
476 key_code
= WXK_ESCAPE
;
479 // cursor and other extended keyboard keys
481 key_code
= WXK_DELETE
;
497 key_code
= WXK_RIGHT
;
504 case GDK_Prior
: // == GDK_Page_Up
505 key_code
= WXK_PAGEUP
;
508 case GDK_Next
: // == GDK_Page_Down
509 key_code
= WXK_PAGEDOWN
;
521 key_code
= WXK_INSERT
;
536 key_code
= (isChar ?
'0' : int(WXK_NUMPAD0
)) + keysym
- GDK_KP_0
;
540 key_code
= isChar ?
' ' : int(WXK_NUMPAD_SPACE
);
544 key_code
= isChar ? WXK_TAB
: WXK_NUMPAD_TAB
;
548 key_code
= isChar ? WXK_RETURN
: WXK_NUMPAD_ENTER
;
552 key_code
= isChar ? WXK_F1
: WXK_NUMPAD_F1
;
556 key_code
= isChar ? WXK_F2
: WXK_NUMPAD_F2
;
560 key_code
= isChar ? WXK_F3
: WXK_NUMPAD_F3
;
564 key_code
= isChar ? WXK_F4
: WXK_NUMPAD_F4
;
568 key_code
= isChar ? WXK_HOME
: WXK_NUMPAD_HOME
;
572 key_code
= isChar ? WXK_LEFT
: WXK_NUMPAD_LEFT
;
576 key_code
= isChar ? WXK_UP
: WXK_NUMPAD_UP
;
580 key_code
= isChar ? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
584 key_code
= isChar ? WXK_DOWN
: WXK_NUMPAD_DOWN
;
587 case GDK_KP_Prior
: // == GDK_KP_Page_Up
588 key_code
= isChar ? WXK_PAGEUP
: WXK_NUMPAD_PAGEUP
;
591 case GDK_KP_Next
: // == GDK_KP_Page_Down
592 key_code
= isChar ? WXK_PAGEDOWN
: WXK_NUMPAD_PAGEDOWN
;
596 key_code
= isChar ? WXK_END
: WXK_NUMPAD_END
;
600 key_code
= isChar ? WXK_HOME
: WXK_NUMPAD_BEGIN
;
604 key_code
= isChar ? WXK_INSERT
: WXK_NUMPAD_INSERT
;
608 key_code
= isChar ? WXK_DELETE
: WXK_NUMPAD_DELETE
;
612 key_code
= isChar ?
'=' : int(WXK_NUMPAD_EQUAL
);
615 case GDK_KP_Multiply
:
616 key_code
= isChar ?
'*' : int(WXK_NUMPAD_MULTIPLY
);
620 key_code
= isChar ?
'+' : int(WXK_NUMPAD_ADD
);
623 case GDK_KP_Separator
:
624 // FIXME: what is this?
625 key_code
= isChar ?
'.' : int(WXK_NUMPAD_SEPARATOR
);
628 case GDK_KP_Subtract
:
629 key_code
= isChar ?
'-' : int(WXK_NUMPAD_SUBTRACT
);
633 key_code
= isChar ?
'.' : int(WXK_NUMPAD_DECIMAL
);
637 key_code
= isChar ?
'/' : int(WXK_NUMPAD_DIVIDE
);
654 key_code
= WXK_F1
+ keysym
- GDK_F1
;
664 static inline bool wxIsAsciiKeysym(KeySym ks
)
669 static void wxFillOtherKeyEventFields(wxKeyEvent
& event
,
671 GdkEventKey
*gdk_event
)
673 event
.SetTimestamp( gdk_event
->time
);
674 event
.SetId(win
->GetId());
676 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
677 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
678 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
679 event
.m_metaDown
= (gdk_event
->state
& GDK_META_MASK
) != 0;
681 // At least with current Linux systems, MOD5 corresponds to AltGr key and
682 // we represent it, for consistency with Windows, which really allows to
683 // use Ctrl+Alt as a replacement for AltGr if this key is not present, as a
684 // combination of these two modifiers.
685 if ( gdk_event
->state
& GDK_MOD5_MASK
)
687 event
.m_controlDown
=
688 event
.m_altDown
= true;
691 // Normally we take the state of modifiers directly from the low level GDK
692 // event but unfortunately GDK uses a different convention from MSW for the
693 // key events corresponding to the modifier keys themselves: in it, when
694 // e.g. Shift key is pressed, GDK_SHIFT_MASK is not set while it is set
695 // when Shift is released. Under MSW the situation is exactly reversed and
696 // the modifier corresponding to the key is set when it is pressed and
697 // unset when it is released. To ensure consistent behaviour between
698 // platforms (and because it seems to make slightly more sense, although
699 // arguably both behaviours are reasonable) we follow MSW here.
701 // Final notice: we set the flags to the desired value instead of just
702 // inverting them because they are not set correctly (i.e. in the same way
703 // as for the real events generated by the user) for wxUIActionSimulator-
704 // produced events and it seems better to keep that class code the same
705 // among all platforms and fix the discrepancy here instead of adding
706 // wxGTK-specific code to wxUIActionSimulator.
707 const bool isPress
= gdk_event
->type
== GDK_KEY_PRESS
;
708 switch ( gdk_event
->keyval
)
712 event
.m_shiftDown
= isPress
;
717 event
.m_controlDown
= isPress
;
722 event
.m_altDown
= isPress
;
729 event
.m_metaDown
= isPress
;
733 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
734 event
.m_rawFlags
= gdk_event
->hardware_keycode
;
736 event
.SetEventObject( win
);
741 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
743 GdkEventKey
*gdk_event
)
745 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
746 // but only event->keyval which is quite useless to us, so remember
747 // the last character from GDK_KEY_PRESS and reuse it as last resort
749 // NB: should be MT-safe as we're always called from the main thread only
754 } s_lastKeyPress
= { 0, 0 };
756 KeySym keysym
= gdk_event
->keyval
;
758 wxLogTrace(TRACE_KEYS
, wxT("Key %s event: keysym = %ld"),
759 event
.GetEventType() == wxEVT_KEY_UP ?
wxT("release")
763 long key_code
= wxTranslateKeySymToWXKey(keysym
, false /* !isChar */);
767 // do we have the translation or is it a plain ASCII character?
768 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
770 // we should use keysym if it is ASCII as X does some translations
771 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
772 // which we don't want here (but which we do use for OnChar())
773 if ( !wxIsAsciiKeysym(keysym
) )
775 keysym
= (KeySym
)gdk_event
->string
[0];
778 #ifdef GDK_WINDOWING_X11
779 // we want to always get the same key code when the same key is
780 // pressed regardless of the state of the modifiers, i.e. on a
781 // standard US keyboard pressing '5' or '%' ('5' key with
782 // Shift) should result in the same key code in OnKeyDown():
783 // '5' (although OnChar() will get either '5' or '%').
785 // to do it we first translate keysym to keycode (== scan code)
786 // and then back but always using the lower register
787 Display
*dpy
= (Display
*)wxGetDisplay();
788 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
790 wxLogTrace(TRACE_KEYS
, wxT("\t-> keycode %d"), keycode
);
792 #ifdef HAVE_X11_XKBLIB_H
793 KeySym keysymNormalized
= XkbKeycodeToKeysym(dpy
, keycode
, 0, 0);
795 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
798 // use the normalized, i.e. lower register, keysym if we've
800 key_code
= keysymNormalized ? keysymNormalized
: keysym
;
805 // as explained above, we want to have lower register key codes
806 // normally but for the letter keys we want to have the upper ones
808 // NB: don't use XConvertCase() here, we want to do it for letters
810 key_code
= toupper(key_code
);
812 else // non ASCII key, what to do?
814 // by default, ignore it
817 // but if we have cached information from the last KEY_PRESS
818 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
821 if ( keysym
== s_lastKeyPress
.keysym
)
823 key_code
= s_lastKeyPress
.keycode
;
828 if ( gdk_event
->type
== GDK_KEY_PRESS
)
830 // remember it to be reused for KEY_UP event later
831 s_lastKeyPress
.keysym
= keysym
;
832 s_lastKeyPress
.keycode
= key_code
;
836 wxLogTrace(TRACE_KEYS
, wxT("\t-> wxKeyCode %ld"), key_code
);
838 // sending unknown key events doesn't really make sense
842 event
.m_keyCode
= key_code
;
845 event
.m_uniChar
= gdk_keyval_to_unicode(key_code
);
846 if ( !event
.m_uniChar
&& event
.m_keyCode
<= WXK_DELETE
)
848 // Set Unicode key code to the ASCII equivalent for compatibility. E.g.
849 // let RETURN generate the key event with both key and Unicode key
851 event
.m_uniChar
= event
.m_keyCode
;
853 #endif // wxUSE_UNICODE
855 // now fill all the other fields
856 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
864 GtkIMContext
*context
;
865 GdkEventKey
*lastKeyEvent
;
869 context
= gtk_im_multicontext_new();
874 g_object_unref (context
);
881 // Send wxEVT_CHAR_HOOK event to the parent of the window and return true only
882 // if it was processed (and not skipped).
883 bool SendCharHookEvent(const wxKeyEvent
& event
, wxWindow
*win
)
885 // wxEVT_CHAR_HOOK must be sent to allow the parent windows (e.g. a dialog
886 // which typically closes when Esc key is pressed in any of its controls)
887 // to handle key events in all of its children unless the mouse is captured
888 // in which case we consider that the keyboard should be "captured" too.
889 if ( !g_captureWindow
)
891 wxKeyEvent
eventCharHook(wxEVT_CHAR_HOOK
, event
);
892 if ( win
->HandleWindowEvent(eventCharHook
)
893 && !event
.IsNextEventAllowed() )
900 // Adjust wxEVT_CHAR event key code fields. This function takes care of two
902 // (a) Ctrl-letter key presses generate key codes in range 1..26
903 // (b) Unicode key codes are same as key codes for the codes in 1..255 range
904 void AdjustCharEventKeyCodes(wxKeyEvent
& event
)
906 const int code
= event
.m_keyCode
;
908 // Check for (a) above.
909 if ( event
.ControlDown() )
911 // We intentionally don't use isupper/lower() here, we really need
912 // ASCII letters only as it doesn't make sense to translate any other
913 // ones into this range which has only 26 slots.
914 if ( code
>= 'a' && code
<= 'z' )
915 event
.m_keyCode
= code
- 'a' + 1;
916 else if ( code
>= 'A' && code
<= 'Z' )
917 event
.m_keyCode
= code
- 'A' + 1;
920 // Adjust the Unicode equivalent in the same way too.
921 if ( event
.m_keyCode
!= code
)
922 event
.m_uniChar
= event
.m_keyCode
;
923 #endif // wxUSE_UNICODE
927 // Check for (b) from above.
929 // FIXME: Should we do it for key codes up to 255?
930 if ( !event
.m_uniChar
&& code
< WXK_DELETE
)
931 event
.m_uniChar
= code
;
932 #endif // wxUSE_UNICODE
935 } // anonymous namespace
937 // If a widget does not handle a key or mouse event, GTK+ sends it up the
938 // parent chain until it is handled. These events are not supposed to propagate
939 // in wxWidgets, so this code avoids handling them in any parent wxWindow,
940 // while still allowing the event to propagate so things like native keyboard
941 // navigation will work.
942 #define wxPROCESS_EVENT_ONCE(EventType, event) \
943 static EventType eventPrev; \
944 if (memcmp(&eventPrev, event, sizeof(EventType)) == 0) \
950 gtk_window_key_press_callback( GtkWidget
*WXUNUSED(widget
),
951 GdkEventKey
*gdk_event
,
954 if (g_blockEventsOnDrag
)
957 wxPROCESS_EVENT_ONCE(GdkEventKey
, gdk_event
);
959 wxKeyEvent
event( wxEVT_KEY_DOWN
);
961 bool return_after_IM
= false;
963 if( wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
965 // Send the CHAR_HOOK event first
966 if ( SendCharHookEvent(event
, win
) )
968 // Don't do anything at all with this event any more.
972 // Next check for accelerators.
974 wxWindowGTK
*ancestor
= win
;
977 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
980 wxCommandEvent
menu_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
981 ret
= ancestor
->HandleWindowEvent( menu_event
);
985 // if the accelerator wasn't handled as menu event, try
986 // it as button click (for compatibility with other
988 wxCommandEvent
button_event( wxEVT_COMMAND_BUTTON_CLICKED
, command
);
989 ret
= ancestor
->HandleWindowEvent( button_event
);
994 if (ancestor
->IsTopLevel())
996 ancestor
= ancestor
->GetParent();
998 #endif // wxUSE_ACCEL
1000 // If not an accelerator, then emit KEY_DOWN event
1002 ret
= win
->HandleWindowEvent( event
);
1006 // Return after IM processing as we cannot do
1007 // anything with it anyhow.
1008 return_after_IM
= true;
1011 if (!ret
&& win
->m_imData
)
1013 win
->m_imData
->lastKeyEvent
= gdk_event
;
1015 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
1016 // docs, if IM filter returns true, no further processing should be done.
1017 // we should send the key_down event anyway.
1018 bool intercepted_by_IM
=
1019 gtk_im_context_filter_keypress(win
->m_imData
->context
, gdk_event
) != 0;
1020 win
->m_imData
->lastKeyEvent
= NULL
;
1021 if (intercepted_by_IM
)
1023 wxLogTrace(TRACE_KEYS
, wxT("Key event intercepted by IM"));
1028 if (return_after_IM
)
1031 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1032 // will only be sent if it is not in an accelerator table.
1035 KeySym keysym
= gdk_event
->keyval
;
1036 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1037 long key_code
= wxTranslateKeySymToWXKey(keysym
, true /* isChar */);
1040 if ( wxIsAsciiKeysym(keysym
) )
1043 key_code
= (unsigned char)keysym
;
1045 // gdk_event->string is actually deprecated
1046 else if ( gdk_event
->length
== 1 )
1048 key_code
= (unsigned char)gdk_event
->string
[0];
1054 wxKeyEvent
eventChar(wxEVT_CHAR
, event
);
1056 wxLogTrace(TRACE_KEYS
, wxT("Char event: %ld"), key_code
);
1058 eventChar
.m_keyCode
= key_code
;
1060 eventChar
.m_uniChar
= gdk_keyval_to_unicode(key_code
);
1061 #endif // wxUSE_UNICODE
1063 AdjustCharEventKeyCodes(eventChar
);
1065 ret
= win
->HandleWindowEvent(eventChar
);
1075 gtk_wxwindow_commit_cb (GtkIMContext
* WXUNUSED(context
),
1079 wxKeyEvent
event( wxEVT_CHAR
);
1081 // take modifiers, cursor position, timestamp etc. from the last
1082 // key_press_event that was fed into Input Method:
1083 if (window
->m_imData
->lastKeyEvent
)
1085 wxFillOtherKeyEventFields(event
,
1086 window
, window
->m_imData
->lastKeyEvent
);
1090 event
.SetEventObject( window
);
1093 const wxString
data(wxGTK_CONV_BACK_SYS(str
));
1097 for( wxString
::const_iterator pstr
= data
.begin(); pstr
!= data
.end(); ++pstr
)
1100 event
.m_uniChar
= *pstr
;
1101 // Backward compatible for ISO-8859-1
1102 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
1103 wxLogTrace(TRACE_KEYS
, wxT("IM sent character '%c'"), event
.m_uniChar
);
1105 event
.m_keyCode
= (char)*pstr
;
1106 #endif // wxUSE_UNICODE
1108 AdjustCharEventKeyCodes(event
);
1110 window
->HandleWindowEvent(event
);
1116 //-----------------------------------------------------------------------------
1117 // "key_release_event" from any window
1118 //-----------------------------------------------------------------------------
1122 gtk_window_key_release_callback( GtkWidget
* WXUNUSED(widget
),
1123 GdkEventKey
*gdk_event
,
1126 if (g_blockEventsOnDrag
)
1129 wxPROCESS_EVENT_ONCE(GdkEventKey
, gdk_event
);
1131 wxKeyEvent
event( wxEVT_KEY_UP
);
1132 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1134 // unknown key pressed, ignore (the event would be useless anyhow)
1138 return win
->GTKProcessEvent(event
);
1142 // ============================================================================
1144 // ============================================================================
1146 // ----------------------------------------------------------------------------
1147 // mouse event processing helpers
1148 // ----------------------------------------------------------------------------
1150 static void AdjustEventButtonState(wxMouseEvent
& event
)
1152 // GDK reports the old state of the button for a button press event, but
1153 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1154 // for a LEFT_DOWN event, not FALSE, so we will invert
1155 // left/right/middleDown for the corresponding click events
1157 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1158 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1159 (event
.GetEventType() == wxEVT_LEFT_UP
))
1161 event
.m_leftDown
= !event
.m_leftDown
;
1165 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1166 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1167 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1169 event
.m_middleDown
= !event
.m_middleDown
;
1173 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1174 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1175 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1177 event
.m_rightDown
= !event
.m_rightDown
;
1181 if ((event
.GetEventType() == wxEVT_AUX1_DOWN
) ||
1182 (event
.GetEventType() == wxEVT_AUX1_DCLICK
))
1184 event
.m_aux1Down
= true;
1188 if ((event
.GetEventType() == wxEVT_AUX2_DOWN
) ||
1189 (event
.GetEventType() == wxEVT_AUX2_DCLICK
))
1191 event
.m_aux2Down
= true;
1196 // find the window to send the mouse event to
1198 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1203 if (win
->m_wxwindow
)
1205 wxPizza
* pizza
= WX_PIZZA(win
->m_wxwindow
);
1206 xx
+= pizza
->m_scroll_x
;
1207 yy
+= pizza
->m_scroll_y
;
1210 wxWindowList
::compatibility_iterator node
= win
->GetChildren().GetFirst();
1213 wxWindow
* child
= static_cast<wxWindow
*>(node
->GetData());
1215 node
= node
->GetNext();
1216 if (!child
->IsShown())
1219 if (child
->GTKIsTransparentForMouse())
1221 // wxStaticBox is transparent in the box itself
1222 int xx1
= child
->m_x
;
1223 int yy1
= child
->m_y
;
1224 int xx2
= child
->m_x
+ child
->m_width
;
1225 int yy2
= child
->m_y
+ child
->m_height
;
1228 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1230 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1232 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1234 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1245 if ((child
->m_wxwindow
== NULL
) &&
1246 win
->IsClientAreaChild(child
) &&
1247 (child
->m_x
<= xx
) &&
1248 (child
->m_y
<= yy
) &&
1249 (child
->m_x
+child
->m_width
>= xx
) &&
1250 (child
->m_y
+child
->m_height
>= yy
))
1263 // ----------------------------------------------------------------------------
1264 // common event handlers helpers
1265 // ----------------------------------------------------------------------------
1267 bool wxWindowGTK
::GTKProcessEvent(wxEvent
& event
) const
1269 // nothing special at this level
1270 return HandleWindowEvent(event
);
1273 bool wxWindowGTK
::GTKShouldIgnoreEvent() const
1275 return g_blockEventsOnDrag
;
1278 int wxWindowGTK
::GTKCallbackCommonPrologue(GdkEventAny
*event
) const
1280 if (g_blockEventsOnDrag
)
1282 if (g_blockEventsOnScroll
)
1285 if (!GTKIsOwnWindow(event
->window
))
1291 // overloads for all GDK event types we use here: we need to have this as
1292 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1293 // derives from it in the sense that the structs have the same layout
1294 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1295 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1297 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1300 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton
)
1301 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion
)
1302 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing
)
1304 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1306 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1307 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1311 // all event handlers must have C linkage as they're called from GTK+ C code
1315 //-----------------------------------------------------------------------------
1316 // "button_press_event"
1317 //-----------------------------------------------------------------------------
1320 gtk_window_button_press_callback( GtkWidget
* WXUNUSED_IN_GTK3(widget
),
1321 GdkEventButton
*gdk_event
,
1324 wxPROCESS_EVENT_ONCE(GdkEventButton
, gdk_event
);
1326 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1328 g_lastButtonNumber
= gdk_event
->button
;
1330 wxEventType event_type
;
1333 switch (gdk_event
->button
)
1336 down
= wxEVT_LEFT_DOWN
;
1337 dclick
= wxEVT_LEFT_DCLICK
;
1340 down
= wxEVT_MIDDLE_DOWN
;
1341 dclick
= wxEVT_MIDDLE_DCLICK
;
1344 down
= wxEVT_RIGHT_DOWN
;
1345 dclick
= wxEVT_RIGHT_DCLICK
;
1348 down
= wxEVT_AUX1_DOWN
;
1349 dclick
= wxEVT_AUX1_DCLICK
;
1352 down
= wxEVT_AUX2_DOWN
;
1353 dclick
= wxEVT_AUX2_DCLICK
;
1358 switch (gdk_event
->type
)
1360 case GDK_BUTTON_PRESS
:
1362 // GDK sends surplus button down events
1363 // before a double click event. We
1364 // need to filter these out.
1365 if (win
->m_wxwindow
)
1367 GdkEvent
* peek_event
= gdk_event_peek();
1370 const GdkEventType peek_event_type
= peek_event
->type
;
1371 gdk_event_free(peek_event
);
1372 if (peek_event_type
== GDK_2BUTTON_PRESS
||
1373 peek_event_type
== GDK_3BUTTON_PRESS
)
1380 case GDK_2BUTTON_PRESS
:
1381 event_type
= dclick
;
1383 if (gdk_event
->button
>= 1 && gdk_event
->button
<= 3)
1385 // Reset GDK internal timestamp variables in order to disable GDK
1386 // triple click events. GDK will then next time believe no button has
1387 // been clicked just before, and send a normal button click event.
1388 GdkDisplay
* display
= gtk_widget_get_display(widget
);
1389 display
->button_click_time
[1] = 0;
1390 display
->button_click_time
[0] = 0;
1392 #endif // !__WXGTK3__
1394 // we shouldn't get triple clicks at all for GTK2 because we
1395 // suppress them artificially using the code above but we still
1396 // should map them to something for GTK3 and not just ignore them
1397 // as this would lose clicks
1398 case GDK_3BUTTON_PRESS
:
1405 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1407 wxMouseEvent
event( event_type
);
1408 InitMouseEvent( win
, event
, gdk_event
);
1410 AdjustEventButtonState(event
);
1412 // find the correct window to send the event to: it may be a different one
1413 // from the one which got it at GTK+ level because some controls don't have
1414 // their own X window and thus cannot get any events.
1415 if ( !g_captureWindow
)
1416 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1418 // reset the event object and id in case win changed.
1419 event
.SetEventObject( win
);
1420 event
.SetId( win
->GetId() );
1422 bool ret
= win
->GTKProcessEvent( event
);
1423 g_lastMouseEvent
= NULL
;
1427 if ((event_type
== wxEVT_LEFT_DOWN
) && !win
->IsOfStandardClass() &&
1428 (gs_currentFocus
!= win
) /* && win->IsFocusable() */)
1433 if (event_type
== wxEVT_RIGHT_DOWN
)
1435 // generate a "context menu" event: this is similar to right mouse
1436 // click under many GUIs except that it is generated differently
1437 // (right up under MSW, ctrl-click under Mac, right down here) and
1439 // (a) it's a command event and so is propagated to the parent
1440 // (b) under some ports it can be generated from kbd too
1441 // (c) it uses screen coords (because of (a))
1442 wxContextMenuEvent
evtCtx(
1445 win
->ClientToScreen(event
.GetPosition()));
1446 evtCtx
.SetEventObject(win
);
1447 return win
->GTKProcessEvent(evtCtx
);
1453 //-----------------------------------------------------------------------------
1454 // "button_release_event"
1455 //-----------------------------------------------------------------------------
1458 gtk_window_button_release_callback( GtkWidget
*WXUNUSED(widget
),
1459 GdkEventButton
*gdk_event
,
1462 wxPROCESS_EVENT_ONCE(GdkEventButton
, gdk_event
);
1464 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1466 g_lastButtonNumber
= 0;
1468 wxEventType event_type
= wxEVT_NULL
;
1470 switch (gdk_event
->button
)
1473 event_type
= wxEVT_LEFT_UP
;
1477 event_type
= wxEVT_MIDDLE_UP
;
1481 event_type
= wxEVT_RIGHT_UP
;
1485 event_type
= wxEVT_AUX1_UP
;
1489 event_type
= wxEVT_AUX2_UP
;
1493 // unknown button, don't process
1497 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1499 wxMouseEvent
event( event_type
);
1500 InitMouseEvent( win
, event
, gdk_event
);
1502 AdjustEventButtonState(event
);
1504 if ( !g_captureWindow
)
1505 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1507 // reset the event object and id in case win changed.
1508 event
.SetEventObject( win
);
1509 event
.SetId( win
->GetId() );
1511 bool ret
= win
->GTKProcessEvent(event
);
1513 g_lastMouseEvent
= NULL
;
1518 //-----------------------------------------------------------------------------
1519 // "motion_notify_event"
1520 //-----------------------------------------------------------------------------
1523 gtk_window_motion_notify_callback( GtkWidget
* WXUNUSED(widget
),
1524 GdkEventMotion
*gdk_event
,
1527 wxPROCESS_EVENT_ONCE(GdkEventMotion
, gdk_event
);
1529 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1531 if (gdk_event
->is_hint
)
1536 gdk_window_get_device_position(gdk_event
->window
, gdk_event
->device
, &x
, &y
, NULL
);
1538 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, NULL
);
1544 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1546 wxMouseEvent
event( wxEVT_MOTION
);
1547 InitMouseEvent(win
, event
, gdk_event
);
1549 if ( g_captureWindow
)
1551 // synthesise a mouse enter or leave event if needed
1552 GdkWindow
* winUnderMouse
=
1554 gdk_device_get_window_at_position(gdk_event
->device
, NULL
, NULL
);
1556 gdk_window_at_pointer(NULL
, NULL
);
1558 // This seems to be necessary and actually been added to
1559 // GDK itself in version 2.0.X
1562 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1563 if ( hasMouse
!= g_captureWindowHasMouse
)
1565 // the mouse changed window
1566 g_captureWindowHasMouse
= hasMouse
;
1568 wxMouseEvent
eventM(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1569 : wxEVT_LEAVE_WINDOW
);
1570 InitMouseEvent(win
, eventM
, gdk_event
);
1571 eventM
.SetEventObject(win
);
1572 win
->GTKProcessEvent(eventM
);
1577 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1579 // reset the event object and id in case win changed.
1580 event
.SetEventObject( win
);
1581 event
.SetId( win
->GetId() );
1584 if ( !g_captureWindow
)
1586 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1587 if (win
->GTKProcessEvent( cevent
))
1589 win
->SetCursor( cevent
.GetCursor() );
1593 bool ret
= win
->GTKProcessEvent(event
);
1595 g_lastMouseEvent
= NULL
;
1600 //-----------------------------------------------------------------------------
1601 // "scroll_event" (mouse wheel event)
1602 //-----------------------------------------------------------------------------
1605 window_scroll_event_hscrollbar(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1607 if (gdk_event
->direction
!= GDK_SCROLL_LEFT
&&
1608 gdk_event
->direction
!= GDK_SCROLL_RIGHT
)
1613 GtkRange
*range
= win
->m_scrollBar
[wxWindow
::ScrollDir_Horz
];
1615 if (range
&& gtk_widget_get_visible(GTK_WIDGET(range
)))
1617 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
1618 double delta
= gtk_adjustment_get_step_increment(adj
) * 3;
1619 if (gdk_event
->direction
== GDK_SCROLL_LEFT
)
1622 gtk_range_set_value(range
, gtk_adjustment_get_value(adj
) + delta
);
1631 window_scroll_event(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1633 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1634 InitMouseEvent(win
, event
, gdk_event
);
1636 // FIXME: Get these values from GTK or GDK
1637 event
.m_linesPerAction
= 3;
1638 event
.m_wheelDelta
= 120;
1640 // Determine the scroll direction.
1641 switch (gdk_event
->direction
)
1644 case GDK_SCROLL_RIGHT
:
1645 event
.m_wheelRotation
= 120;
1648 case GDK_SCROLL_DOWN
:
1649 case GDK_SCROLL_LEFT
:
1650 event
.m_wheelRotation
= -120;
1652 #if GTK_CHECK_VERSION(3,4,0)
1653 case GDK_SCROLL_SMOOTH
:
1657 return false; // Unknown/unhandled direction
1660 // And the scroll axis.
1661 switch (gdk_event
->direction
)
1664 case GDK_SCROLL_DOWN
:
1665 event
.m_wheelAxis
= wxMOUSE_WHEEL_VERTICAL
;
1668 case GDK_SCROLL_LEFT
:
1669 case GDK_SCROLL_RIGHT
:
1670 event
.m_wheelAxis
= wxMOUSE_WHEEL_HORIZONTAL
;
1672 #if GTK_CHECK_VERSION(3,4,0)
1673 case GDK_SCROLL_SMOOTH
:
1679 if (win
->GTKProcessEvent(event
))
1682 GtkRange
*range
= win
->m_scrollBar
[wxWindow
::ScrollDir_Vert
];
1684 if (range
&& gtk_widget_get_visible(GTK_WIDGET(range
)))
1686 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
1687 double delta
= gtk_adjustment_get_step_increment(adj
) * 3;
1688 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1691 gtk_range_set_value(range
, gtk_adjustment_get_value(adj
) + delta
);
1699 //-----------------------------------------------------------------------------
1701 //-----------------------------------------------------------------------------
1703 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
1705 wxContextMenuEvent
event(wxEVT_CONTEXT_MENU
, win
->GetId(), wxPoint(-1, -1));
1706 event
.SetEventObject(win
);
1707 return win
->GTKProcessEvent(event
);
1710 //-----------------------------------------------------------------------------
1712 //-----------------------------------------------------------------------------
1715 gtk_window_focus_in_callback( GtkWidget
* WXUNUSED(widget
),
1716 GdkEventFocus
*WXUNUSED(event
),
1719 return win
->GTKHandleFocusIn();
1722 //-----------------------------------------------------------------------------
1723 // "focus_out_event"
1724 //-----------------------------------------------------------------------------
1727 gtk_window_focus_out_callback( GtkWidget
* WXUNUSED(widget
),
1728 GdkEventFocus
* WXUNUSED(gdk_event
),
1731 return win
->GTKHandleFocusOut();
1734 //-----------------------------------------------------------------------------
1736 //-----------------------------------------------------------------------------
1739 wx_window_focus_callback(GtkWidget
*widget
,
1740 GtkDirectionType
WXUNUSED(direction
),
1743 // the default handler for focus signal in GtkScrolledWindow sets
1744 // focus to the window itself even if it doesn't accept focus, i.e. has no
1745 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1746 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1747 // any children which might accept focus (we know we don't accept the focus
1748 // ourselves as this signal is only connected in this case)
1749 if ( win
->GetChildren().empty() )
1750 g_signal_stop_emission_by_name(widget
, "focus");
1752 // we didn't change the focus
1756 //-----------------------------------------------------------------------------
1757 // "enter_notify_event"
1758 //-----------------------------------------------------------------------------
1761 gtk_window_enter_callback( GtkWidget
*,
1762 GdkEventCrossing
*gdk_event
,
1765 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1767 // Event was emitted after a grab
1768 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1770 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1771 InitMouseEvent(win
, event
, gdk_event
);
1773 if ( !g_captureWindow
)
1775 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1776 if (win
->GTKProcessEvent( cevent
))
1778 win
->SetCursor( cevent
.GetCursor() );
1782 return win
->GTKProcessEvent(event
);
1785 //-----------------------------------------------------------------------------
1786 // "leave_notify_event"
1787 //-----------------------------------------------------------------------------
1790 gtk_window_leave_callback( GtkWidget
*,
1791 GdkEventCrossing
*gdk_event
,
1794 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1796 // Event was emitted after an ungrab
1797 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1799 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1800 InitMouseEvent(win
, event
, gdk_event
);
1802 return win
->GTKProcessEvent(event
);
1805 //-----------------------------------------------------------------------------
1806 // "value_changed" from scrollbar
1807 //-----------------------------------------------------------------------------
1810 gtk_scrollbar_value_changed(GtkRange
* range
, wxWindow
* win
)
1812 wxEventType eventType
= win
->GTKGetScrollEventType(range
);
1813 if (eventType
!= wxEVT_NULL
)
1815 // Convert scroll event type to scrollwin event type
1816 eventType
+= wxEVT_SCROLLWIN_TOP
- wxEVT_SCROLL_TOP
;
1818 // find the scrollbar which generated the event
1819 wxWindowGTK
::ScrollDir dir
= win
->ScrollDirFromRange(range
);
1821 // generate the corresponding wx event
1822 const int orient
= wxWindow
::OrientFromScrollDir(dir
);
1823 wxScrollWinEvent
event(eventType
, win
->GetScrollPos(orient
), orient
);
1824 event
.SetEventObject(win
);
1826 win
->GTKProcessEvent(event
);
1830 //-----------------------------------------------------------------------------
1831 // "button_press_event" from scrollbar
1832 //-----------------------------------------------------------------------------
1835 gtk_scrollbar_button_press_event(GtkRange
*, GdkEventButton
*, wxWindow
* win
)
1837 g_blockEventsOnScroll
= true;
1838 win
->m_mouseButtonDown
= true;
1843 //-----------------------------------------------------------------------------
1844 // "event_after" from scrollbar
1845 //-----------------------------------------------------------------------------
1848 gtk_scrollbar_event_after(GtkRange
* range
, GdkEvent
* event
, wxWindow
* win
)
1850 if (event
->type
== GDK_BUTTON_RELEASE
)
1852 g_signal_handlers_block_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1854 const int orient
= wxWindow
::OrientFromScrollDir(
1855 win
->ScrollDirFromRange(range
));
1856 wxScrollWinEvent
evt(wxEVT_SCROLLWIN_THUMBRELEASE
,
1857 win
->GetScrollPos(orient
), orient
);
1858 evt
.SetEventObject(win
);
1859 win
->GTKProcessEvent(evt
);
1863 //-----------------------------------------------------------------------------
1864 // "button_release_event" from scrollbar
1865 //-----------------------------------------------------------------------------
1868 gtk_scrollbar_button_release_event(GtkRange
* range
, GdkEventButton
*, wxWindow
* win
)
1870 g_blockEventsOnScroll
= false;
1871 win
->m_mouseButtonDown
= false;
1872 // If thumb tracking
1873 if (win
->m_isScrolling
)
1875 win
->m_isScrolling
= false;
1876 // Hook up handler to send thumb release event after this emission is finished.
1877 // To allow setting scroll position from event handler, sending event must
1878 // be deferred until after the GtkRange handler for this signal has run
1879 g_signal_handlers_unblock_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1885 //-----------------------------------------------------------------------------
1886 // "realize" from m_widget
1887 //-----------------------------------------------------------------------------
1890 gtk_window_realized_callback(GtkWidget
* WXUNUSED(widget
), wxWindowGTK
* win
)
1892 win
->GTKHandleRealized();
1895 //-----------------------------------------------------------------------------
1896 // "size_allocate" from m_wxwindow or m_widget
1897 //-----------------------------------------------------------------------------
1900 size_allocate(GtkWidget
*, GtkAllocation
* alloc
, wxWindow
* win
)
1902 int w
= alloc
->width
;
1903 int h
= alloc
->height
;
1904 if (win
->m_wxwindow
)
1907 WX_PIZZA(win
->m_wxwindow
)->get_border(border
);
1908 w
-= border
.left
+ border
.right
;
1909 h
-= border
.top
+ border
.bottom
;
1913 if (win
->m_oldClientWidth
!= w
|| win
->m_oldClientHeight
!= h
)
1915 win
->m_oldClientWidth
= w
;
1916 win
->m_oldClientHeight
= h
;
1917 // this callback can be connected to m_wxwindow,
1918 // so always get size from m_widget->allocation
1920 gtk_widget_get_allocation(win
->m_widget
, &a
);
1921 win
->m_width
= a
.width
;
1922 win
->m_height
= a
.height
;
1923 if (!win
->m_nativeSizeEvent
)
1925 wxSizeEvent
event(win
->GetSize(), win
->GetId());
1926 event
.SetEventObject(win
);
1927 win
->GTKProcessEvent(event
);
1932 //-----------------------------------------------------------------------------
1934 //-----------------------------------------------------------------------------
1936 #if GTK_CHECK_VERSION(2, 8, 0)
1938 gtk_window_grab_broken( GtkWidget
*,
1939 GdkEventGrabBroken
*event
,
1942 // Mouse capture has been lost involuntarily, notify the application
1943 if(!event
->keyboard
&& wxWindow
::GetCapture() == win
)
1945 wxMouseCaptureLostEvent
evt( win
->GetId() );
1946 evt
.SetEventObject( win
);
1947 win
->HandleWindowEvent( evt
);
1953 //-----------------------------------------------------------------------------
1954 // "style_set"/"style_updated"
1955 //-----------------------------------------------------------------------------
1958 static void style_updated(GtkWidget
*, wxWindow
* win
)
1960 static void style_updated(GtkWidget
*, GtkStyle
*, wxWindow
* win
)
1963 if (win
->IsTopLevel())
1965 wxSysColourChangedEvent event
;
1966 event
.SetEventObject(win
);
1967 win
->GTKProcessEvent(event
);
1971 // Border width could change, which will change client size.
1972 // Make sure size event occurs for this
1973 win
->m_oldClientWidth
= 0;
1977 //-----------------------------------------------------------------------------
1979 //-----------------------------------------------------------------------------
1981 static void unrealize(GtkWidget
*, wxWindow
* win
)
1983 win
->GTKHandleUnrealize();
1988 void wxWindowGTK
::GTKHandleRealized()
1995 gtk_im_context_set_client_window
1998 m_wxwindow ?
GTKGetDrawingWindow()
1999 : gtk_widget_get_window(m_widget
)
2003 // Use composited window if background is transparent, if supported.
2004 if (m_backgroundStyle
== wxBG_STYLE_TRANSPARENT
)
2006 #if wxGTK_HAS_COMPOSITING_SUPPORT
2007 if (IsTransparentBackgroundSupported())
2009 GdkWindow
* const window
= GTKGetDrawingWindow();
2011 gdk_window_set_composited(window
, true);
2014 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
2016 // We revert to erase mode if transparency is not supported
2017 m_backgroundStyle
= wxBG_STYLE_ERASE
;
2022 // We cannot set colours and fonts before the widget
2023 // been realized, so we do this directly after realization
2024 // or otherwise in idle time
2026 if (m_needsStyleChange
)
2028 SetBackgroundStyle(GetBackgroundStyle());
2029 m_needsStyleChange
= false;
2032 wxWindowCreateEvent
event(static_cast<wxWindow
*>(this));
2033 event
.SetEventObject( this );
2034 GTKProcessEvent( event
);
2036 GTKUpdateCursor(true, false);
2039 (IsTopLevel() || HasFlag(wxBORDER_RAISED
| wxBORDER_SUNKEN
| wxBORDER_THEME
)))
2041 // attaching to style changed signal after realization avoids initial
2042 // changes we don't care about
2043 const gchar
*detailed_signal
=
2049 g_signal_connect(m_wxwindow
,
2051 G_CALLBACK(style_updated
), this);
2055 void wxWindowGTK
::GTKHandleUnrealize()
2057 // unrealizing a frozen window seems to have some lingering effect
2058 // preventing updates to the affected area
2065 gtk_im_context_set_client_window(m_imData
->context
, NULL
);
2067 g_signal_handlers_disconnect_by_func(
2068 m_wxwindow
, (void*)style_updated
, this);
2072 // ----------------------------------------------------------------------------
2073 // this wxWindowBase function is implemented here (in platform-specific file)
2074 // because it is static and so couldn't be made virtual
2075 // ----------------------------------------------------------------------------
2077 wxWindow
*wxWindowBase
::DoFindFocus()
2079 // For compatibility with wxMSW, pretend that showing a popup menu doesn't
2080 // change the focus and that it remains on the window showing it, even
2081 // though the real focus does change in GTK.
2082 extern wxMenu
*wxCurrentPopupMenu
;
2083 if ( wxCurrentPopupMenu
)
2084 return wxCurrentPopupMenu
->GetInvokingWindow();
2086 wxWindowGTK
*focus
= gs_pendingFocus ? gs_pendingFocus
: gs_currentFocus
;
2087 // the cast is necessary when we compile in wxUniversal mode
2088 return static_cast<wxWindow
*>(focus
);
2091 void wxWindowGTK
::AddChildGTK(wxWindowGTK
* child
)
2093 wxASSERT_MSG(m_wxwindow
, "Cannot add a child to a window without a client area");
2095 // the window might have been scrolled already, we
2096 // have to adapt the position
2097 wxPizza
* pizza
= WX_PIZZA(m_wxwindow
);
2098 child
->m_x
+= pizza
->m_scroll_x
;
2099 child
->m_y
+= pizza
->m_scroll_y
;
2101 pizza
->put(child
->m_widget
,
2102 child
->m_x
, child
->m_y
, child
->m_width
, child
->m_height
);
2105 //-----------------------------------------------------------------------------
2107 //-----------------------------------------------------------------------------
2109 wxWindow
*wxGetActiveWindow()
2111 return wxWindow
::FindFocus();
2115 // Under Unix this is implemented using X11 functions in utilsx11.cpp but we
2116 // need to have this function under Windows too, so provide at least a stub.
2117 #ifndef GDK_WINDOWING_X11
2118 bool wxGetKeyState(wxKeyCode
WXUNUSED(key
))
2120 wxFAIL_MSG(wxS("Not implemented under Windows"));
2123 #endif // __WINDOWS__
2125 static GdkDisplay
* GetDisplay()
2127 wxWindow
* tlw
= NULL
;
2128 if (!wxTopLevelWindows
.empty())
2129 tlw
= wxTopLevelWindows
.front();
2130 GdkDisplay
* display
;
2131 if (tlw
&& tlw
->m_widget
)
2132 display
= gtk_widget_get_display(tlw
->m_widget
);
2134 display
= gdk_display_get_default();
2138 wxMouseState
wxGetMouseState()
2144 GdkModifierType mask
;
2146 GdkDisplay
* display
= GetDisplay();
2148 GdkDeviceManager
* manager
= gdk_display_get_device_manager(display
);
2149 GdkDevice
* device
= gdk_device_manager_get_client_pointer(manager
);
2151 gdk_device_get_position(device
, &screen
, &x
, &y
);
2152 GdkWindow
* window
= gdk_screen_get_root_window(screen
);
2153 gdk_device_get_state(device
, window
, NULL
, &mask
);
2155 gdk_display_get_pointer(display
, NULL
, &x
, &y
, &mask
);
2160 ms
.SetLeftDown((mask
& GDK_BUTTON1_MASK
) != 0);
2161 ms
.SetMiddleDown((mask
& GDK_BUTTON2_MASK
) != 0);
2162 ms
.SetRightDown((mask
& GDK_BUTTON3_MASK
) != 0);
2163 // see the comment in InitMouseEvent()
2164 ms
.SetAux1Down((mask
& GDK_BUTTON4_MASK
) != 0);
2165 ms
.SetAux2Down((mask
& GDK_BUTTON5_MASK
) != 0);
2167 ms
.SetControlDown((mask
& GDK_CONTROL_MASK
) != 0);
2168 ms
.SetShiftDown((mask
& GDK_SHIFT_MASK
) != 0);
2169 ms
.SetAltDown((mask
& GDK_MOD1_MASK
) != 0);
2170 ms
.SetMetaDown((mask
& GDK_META_MASK
) != 0);
2175 //-----------------------------------------------------------------------------
2177 //-----------------------------------------------------------------------------
2179 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2181 #ifdef __WXUNIVERSAL__
2182 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2183 #endif // __WXUNIVERSAL__
2185 void wxWindowGTK
::Init()
2190 m_focusWidget
= NULL
;
2198 m_showOnIdle
= false;
2201 m_nativeSizeEvent
= false;
2203 m_paintContext
= NULL
;
2204 m_styleProvider
= NULL
;
2207 m_isScrolling
= false;
2208 m_mouseButtonDown
= false;
2210 // initialize scrolling stuff
2211 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2213 m_scrollBar
[dir
] = NULL
;
2214 m_scrollPos
[dir
] = 0;
2218 m_oldClientHeight
= 0;
2220 m_clipPaintRegion
= false;
2222 m_needsStyleChange
= false;
2224 m_cursor
= *wxSTANDARD_CURSOR
;
2227 m_dirtyTabOrder
= false;
2230 wxWindowGTK
::wxWindowGTK()
2235 wxWindowGTK
::wxWindowGTK( wxWindow
*parent
,
2240 const wxString
&name
)
2244 Create( parent
, id
, pos
, size
, style
, name
);
2247 void wxWindowGTK
::GTKCreateScrolledWindowWith(GtkWidget
* view
)
2249 wxASSERT_MSG( HasFlag(wxHSCROLL
) || HasFlag(wxVSCROLL
),
2250 wxS("Must not be called if scrolling is not needed.") );
2252 m_widget
= gtk_scrolled_window_new( NULL
, NULL
);
2254 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2256 // There is a conflict with default bindings at GTK+
2257 // level between scrolled windows and notebooks both of which want to use
2258 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2259 // direction and notebooks for changing pages -- we decide that if we don't
2260 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2261 // means we can get working keyboard navigation in notebooks
2262 if ( !HasFlag(wxHSCROLL
) )
2265 bindings
= gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget
));
2268 gtk_binding_entry_remove(bindings
, GDK_Page_Up
, GDK_CONTROL_MASK
);
2269 gtk_binding_entry_remove(bindings
, GDK_Page_Down
, GDK_CONTROL_MASK
);
2273 // If wx[HV]SCROLL is not given, the corresponding scrollbar is not shown
2274 // at all. Otherwise it may be shown only on demand (default) or always, if
2275 // the wxALWAYS_SHOW_SB is specified.
2276 GtkPolicyType horzPolicy
= HasFlag(wxHSCROLL
)
2277 ?
HasFlag(wxALWAYS_SHOW_SB
)
2279 : GTK_POLICY_AUTOMATIC
2281 GtkPolicyType vertPolicy
= HasFlag(wxVSCROLL
)
2282 ?
HasFlag(wxALWAYS_SHOW_SB
)
2284 : GTK_POLICY_AUTOMATIC
2286 gtk_scrolled_window_set_policy( scrolledWindow
, horzPolicy
, vertPolicy
);
2288 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow
));
2289 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow
));
2290 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2291 gtk_range_set_inverted( m_scrollBar
[ScrollDir_Horz
], TRUE
);
2293 gtk_container_add( GTK_CONTAINER(m_widget
), view
);
2295 // connect various scroll-related events
2296 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2298 // these handlers block mouse events to any window during scrolling
2299 // such as motion events and prevent GTK and wxWidgets from fighting
2300 // over where the slider should be
2301 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2302 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2303 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2304 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2306 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2307 G_CALLBACK(gtk_scrollbar_event_after
), this);
2308 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2310 // these handlers get notified when scrollbar slider moves
2311 g_signal_connect_after(m_scrollBar
[dir
], "value_changed",
2312 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2315 gtk_widget_show( view
);
2318 bool wxWindowGTK
::Create( wxWindow
*parent
,
2323 const wxString
&name
)
2325 // Get default border
2326 wxBorder border
= GetBorder(style
);
2328 style
&= ~wxBORDER_MASK
;
2331 if (!PreCreation( parent
, pos
, size
) ||
2332 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2334 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2338 // We should accept the native look
2340 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2341 scroll_class
->scrollbar_spacing
= 0;
2345 m_wxwindow
= wxPizza
::New(m_windowStyle
);
2346 #ifndef __WXUNIVERSAL__
2347 if (HasFlag(wxPizza
::BORDER_STYLES
))
2349 g_signal_connect(m_wxwindow
, "parent_set",
2350 G_CALLBACK(parent_set
), this);
2353 if (!HasFlag(wxHSCROLL
) && !HasFlag(wxVSCROLL
))
2354 m_widget
= m_wxwindow
;
2356 GTKCreateScrolledWindowWith(m_wxwindow
);
2357 g_object_ref(m_widget
);
2360 m_parent
->DoAddChild( this );
2362 m_focusWidget
= m_wxwindow
;
2364 SetCanFocus(AcceptsFocus());
2371 void wxWindowGTK
::GTKDisconnect(void* instance
)
2373 g_signal_handlers_disconnect_matched(instance
,
2374 GSignalMatchType(G_SIGNAL_MATCH_DATA
), 0, 0, NULL
, NULL
, this);
2377 wxWindowGTK
::~wxWindowGTK()
2381 if (gs_currentFocus
== this)
2382 gs_currentFocus
= NULL
;
2383 if (gs_pendingFocus
== this)
2384 gs_pendingFocus
= NULL
;
2386 if ( gs_deferredFocusOut
== this )
2387 gs_deferredFocusOut
= NULL
;
2389 // Unlike the above cases, which can happen in normal circumstances, a
2390 // window shouldn't be destroyed while it still has capture, so even though
2391 // we still reset the global pointer to avoid leaving it dangling and
2392 // crashing afterwards, also complain about it.
2393 if ( g_captureWindow
== this )
2395 wxFAIL_MSG( wxS("Destroying window with mouse capture") );
2396 g_captureWindow
= NULL
;
2401 GTKDisconnect(m_wxwindow
);
2402 GtkWidget
* parent
= gtk_widget_get_parent(m_wxwindow
);
2404 GTKDisconnect(parent
);
2406 if (m_widget
&& m_widget
!= m_wxwindow
)
2407 GTKDisconnect(m_widget
);
2409 // destroy children before destroying this window itself
2415 // delete before the widgets to avoid a crash on solaris
2419 // avoid problem with GTK+ 2.18 where a frozen window causes the whole
2420 // TLW to be frozen, and if the window is then destroyed, nothing ever
2421 // gets painted again
2426 if (m_styleProvider
)
2427 g_object_unref(m_styleProvider
);
2432 // Note that gtk_widget_destroy() does not destroy the widget, it just
2433 // emits the "destroy" signal. The widget is not actually destroyed
2434 // until its reference count drops to zero.
2435 gtk_widget_destroy(m_widget
);
2436 // Release our reference, should be the last one
2437 g_object_unref(m_widget
);
2443 bool wxWindowGTK
::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2445 if ( GTKNeedsParent() )
2447 wxCHECK_MSG( parent
, false, wxT("Must have non-NULL parent") );
2450 // Use either the given size, or the default if -1 is given.
2451 // See wxWindowBase for these functions.
2452 m_width
= WidthDefault(size
.x
) ;
2453 m_height
= HeightDefault(size
.y
);
2455 if (pos
!= wxDefaultPosition
)
2464 void wxWindowGTK
::PostCreation()
2466 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2468 #if wxGTK_HAS_COMPOSITING_SUPPORT
2469 // Set RGBA visual as soon as possible to minimize the possibility that
2470 // somebody uses the wrong one.
2471 if ( m_backgroundStyle
== wxBG_STYLE_TRANSPARENT
&&
2472 IsTransparentBackgroundSupported() )
2474 GdkScreen
*screen
= gtk_widget_get_screen (m_widget
);
2476 gtk_widget_set_visual(m_widget
, gdk_screen_get_rgba_visual(screen
));
2478 GdkColormap
*rgba_colormap
= gdk_screen_get_rgba_colormap (screen
);
2481 gtk_widget_set_colormap(m_widget
, rgba_colormap
);
2484 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
2490 // these get reported to wxWidgets -> wxPaintEvent
2492 g_signal_connect(m_wxwindow
, "draw", G_CALLBACK(draw
), this);
2494 g_signal_connect(m_wxwindow
, "expose_event", G_CALLBACK(expose_event
), this);
2497 if (GetLayoutDirection() == wxLayout_LeftToRight
)
2498 gtk_widget_set_redraw_on_allocate(m_wxwindow
, HasFlag(wxFULL_REPAINT_ON_RESIZE
));
2501 // Create input method handler
2502 m_imData
= new wxGtkIMData
;
2504 // Cannot handle drawing preedited text yet
2505 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2507 g_signal_connect (m_imData
->context
, "commit",
2508 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2513 if (!GTK_IS_WINDOW(m_widget
))
2515 if (m_focusWidget
== NULL
)
2516 m_focusWidget
= m_widget
;
2520 g_signal_connect (m_focusWidget
, "focus_in_event",
2521 G_CALLBACK (gtk_window_focus_in_callback
), this);
2522 g_signal_connect (m_focusWidget
, "focus_out_event",
2523 G_CALLBACK (gtk_window_focus_out_callback
), this);
2527 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2528 G_CALLBACK (gtk_window_focus_in_callback
), this);
2529 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2530 G_CALLBACK (gtk_window_focus_out_callback
), this);
2534 if ( !AcceptsFocusFromKeyboard() )
2538 g_signal_connect(m_widget
, "focus",
2539 G_CALLBACK(wx_window_focus_callback
), this);
2542 // connect to the various key and mouse handlers
2544 GtkWidget
*connect_widget
= GetConnectWidget();
2546 ConnectWidget( connect_widget
);
2548 // We cannot set colours, fonts and cursors before the widget has been
2549 // realized, so we do this directly after realization -- unless the widget
2550 // was in fact realized already.
2551 if ( gtk_widget_get_realized(connect_widget
) )
2553 GTKHandleRealized();
2557 g_signal_connect (connect_widget
, "realize",
2558 G_CALLBACK (gtk_window_realized_callback
), this);
2560 g_signal_connect(connect_widget
, "unrealize", G_CALLBACK(unrealize
), this);
2564 g_signal_connect(m_wxwindow ? m_wxwindow
: m_widget
, "size_allocate",
2565 G_CALLBACK(size_allocate
), this);
2568 #if GTK_CHECK_VERSION(2, 8, 0)
2570 if ( gtk_check_version(2,8,0) == NULL
)
2573 // Make sure we can notify the app when mouse capture is lost
2576 g_signal_connect (m_wxwindow
, "grab_broken_event",
2577 G_CALLBACK (gtk_window_grab_broken
), this);
2580 if ( connect_widget
!= m_wxwindow
)
2582 g_signal_connect (connect_widget
, "grab_broken_event",
2583 G_CALLBACK (gtk_window_grab_broken
), this);
2586 #endif // GTK+ >= 2.8
2588 if (!WX_IS_PIZZA(gtk_widget_get_parent(m_widget
)) && !GTK_IS_WINDOW(m_widget
))
2589 gtk_widget_set_size_request(m_widget
, m_width
, m_height
);
2591 InheritAttributes();
2593 SetLayoutDirection(wxLayout_Default
);
2595 // unless the window was created initially hidden (i.e. Hide() had been
2596 // called before Create()), we should show it at GTK+ level as well
2598 gtk_widget_show( m_widget
);
2602 wxWindowGTK
::GTKConnectWidget(const char *signal
, wxGTKCallback callback
)
2604 return g_signal_connect(m_widget
, signal
, callback
, this);
2607 void wxWindowGTK
::ConnectWidget( GtkWidget
*widget
)
2609 g_signal_connect (widget
, "key_press_event",
2610 G_CALLBACK (gtk_window_key_press_callback
), this);
2611 g_signal_connect (widget
, "key_release_event",
2612 G_CALLBACK (gtk_window_key_release_callback
), this);
2613 g_signal_connect (widget
, "button_press_event",
2614 G_CALLBACK (gtk_window_button_press_callback
), this);
2615 g_signal_connect (widget
, "button_release_event",
2616 G_CALLBACK (gtk_window_button_release_callback
), this);
2617 g_signal_connect (widget
, "motion_notify_event",
2618 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2620 g_signal_connect (widget
, "scroll_event",
2621 G_CALLBACK (window_scroll_event
), this);
2622 if (m_scrollBar
[ScrollDir_Horz
])
2623 g_signal_connect (m_scrollBar
[ScrollDir_Horz
], "scroll_event",
2624 G_CALLBACK (window_scroll_event_hscrollbar
), this);
2625 if (m_scrollBar
[ScrollDir_Vert
])
2626 g_signal_connect (m_scrollBar
[ScrollDir_Vert
], "scroll_event",
2627 G_CALLBACK (window_scroll_event
), this);
2629 g_signal_connect (widget
, "popup_menu",
2630 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2631 g_signal_connect (widget
, "enter_notify_event",
2632 G_CALLBACK (gtk_window_enter_callback
), this);
2633 g_signal_connect (widget
, "leave_notify_event",
2634 G_CALLBACK (gtk_window_leave_callback
), this);
2637 static GSList
* gs_queueResizeList
;
2640 static gboolean
queue_resize(void*)
2642 gdk_threads_enter();
2643 for (GSList
* p
= gs_queueResizeList
; p
; p
= p
->next
)
2647 gtk_widget_queue_resize(GTK_WIDGET(p
->data
));
2648 g_object_remove_weak_pointer(G_OBJECT(p
->data
), &p
->data
);
2651 g_slist_free(gs_queueResizeList
);
2652 gs_queueResizeList
= NULL
;
2653 gdk_threads_leave();
2658 void wxWindowGTK
::DoMoveWindow(int x
, int y
, int width
, int height
)
2660 gtk_widget_set_size_request(m_widget
, width
, height
);
2661 GtkWidget
* parent
= gtk_widget_get_parent(m_widget
);
2662 if (WX_IS_PIZZA(parent
))
2663 WX_PIZZA(parent
)->move(m_widget
, x
, y
, width
, height
);
2665 // With GTK3, gtk_widget_queue_resize() is ignored while a size-allocate
2666 // is in progress. This situation is common in wxWidgets, since
2667 // size-allocate can generate wxSizeEvent and size event handlers often
2668 // call SetSize(), directly or indirectly. Work around this by deferring
2669 // the queue-resize until after size-allocate processing is finished.
2670 if (g_slist_find(gs_queueResizeList
, m_widget
) == NULL
)
2672 if (gs_queueResizeList
== NULL
)
2673 g_idle_add_full(GTK_PRIORITY_RESIZE
, queue_resize
, NULL
, NULL
);
2674 gs_queueResizeList
= g_slist_prepend(gs_queueResizeList
, m_widget
);
2675 g_object_add_weak_pointer(G_OBJECT(m_widget
), &gs_queueResizeList
->data
);
2679 void wxWindowGTK
::ConstrainSize()
2682 // GPE's window manager doesn't like size hints at all, esp. when the user
2683 // has to use the virtual keyboard, so don't constrain size there
2687 const wxSize minSize
= GetMinSize();
2688 const wxSize maxSize
= GetMaxSize();
2689 if (minSize
.x
> 0 && m_width
< minSize
.x
) m_width
= minSize
.x
;
2690 if (minSize
.y
> 0 && m_height
< minSize
.y
) m_height
= minSize
.y
;
2691 if (maxSize
.x
> 0 && m_width
> maxSize
.x
) m_width
= maxSize
.x
;
2692 if (maxSize
.y
> 0 && m_height
> maxSize
.y
) m_height
= maxSize
.y
;
2696 void wxWindowGTK
::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2698 wxCHECK_RET(m_widget
, "invalid window");
2700 int scrollX
= 0, scrollY
= 0;
2701 GtkWidget
* parent
= gtk_widget_get_parent(m_widget
);
2702 if (WX_IS_PIZZA(parent
))
2704 wxPizza
* pizza
= WX_PIZZA(parent
);
2705 scrollX
= pizza
->m_scroll_x
;
2706 scrollY
= pizza
->m_scroll_y
;
2708 if (x
!= -1 || (sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2712 if (y
!= -1 || (sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2717 // calculate the best size if we should auto size the window
2718 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2719 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2721 const wxSize sizeBest
= GetBestSize();
2722 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2724 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2725 height
= sizeBest
.y
;
2733 const bool sizeChange
= m_width
!= width
|| m_height
!= height
;
2734 if (sizeChange
|| m_x
!= x
|| m_y
!= y
)
2741 /* the default button has a border around it */
2742 if (gtk_widget_get_can_default(m_widget
))
2744 GtkBorder
*default_border
= NULL
;
2745 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2748 x
-= default_border
->left
;
2749 y
-= default_border
->top
;
2750 width
+= default_border
->left
+ default_border
->right
;
2751 height
+= default_border
->top
+ default_border
->bottom
;
2752 gtk_border_free( default_border
);
2756 DoMoveWindow(x
, y
, width
, height
);
2759 if ((sizeChange
&& !m_nativeSizeEvent
) || (sizeFlags
& wxSIZE_FORCE_EVENT
))
2761 // update these variables to keep size_allocate handler
2762 // from sending another size event for this change
2763 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2765 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2766 event
.SetEventObject( this );
2767 HandleWindowEvent( event
);
2771 bool wxWindowGTK
::GTKShowFromOnIdle()
2773 if (IsShown() && m_showOnIdle
&& !gtk_widget_get_visible (m_widget
))
2775 GtkAllocation alloc
;
2778 alloc
.width
= m_width
;
2779 alloc
.height
= m_height
;
2780 gtk_widget_size_allocate( m_widget
, &alloc
);
2781 gtk_widget_show( m_widget
);
2782 wxShowEvent
eventShow(GetId(), true);
2783 eventShow
.SetEventObject(this);
2784 HandleWindowEvent(eventShow
);
2785 m_showOnIdle
= false;
2792 void wxWindowGTK
::OnInternalIdle()
2794 if ( gs_deferredFocusOut
)
2795 GTKHandleDeferredFocusOut();
2797 // Check if we have to show window now
2798 if (GTKShowFromOnIdle()) return;
2800 if ( m_dirtyTabOrder
)
2802 m_dirtyTabOrder
= false;
2806 wxWindowBase
::OnInternalIdle();
2809 void wxWindowGTK
::DoGetSize( int *width
, int *height
) const
2811 if (width
) (*width
) = m_width
;
2812 if (height
) (*height
) = m_height
;
2815 void wxWindowGTK
::DoSetClientSize( int width
, int height
)
2817 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2819 const wxSize size
= GetSize();
2820 const wxSize clientSize
= GetClientSize();
2821 SetSize(width
+ (size
.x
- clientSize
.x
), height
+ (size
.y
- clientSize
.y
));
2824 void wxWindowGTK
::DoGetClientSize( int *width
, int *height
) const
2826 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2833 // if window is scrollable, account for scrollbars
2834 if ( GTK_IS_SCROLLED_WINDOW(m_widget
) )
2836 GtkPolicyType policy
[ScrollDir_Max
];
2837 gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget
),
2838 &policy
[ScrollDir_Horz
],
2839 &policy
[ScrollDir_Vert
]);
2841 // get scrollbar spacing the same way the GTK-private function
2842 // _gtk_scrolled_window_get_scrollbar_spacing() does it
2843 int scrollbar_spacing
=
2844 GTK_SCROLLED_WINDOW_GET_CLASS(m_widget
)->scrollbar_spacing
;
2845 if (scrollbar_spacing
< 0)
2847 gtk_widget_style_get(
2848 m_widget
, "scrollbar-spacing", &scrollbar_spacing
, NULL
);
2851 for ( int i
= 0; i
< ScrollDir_Max
; i
++ )
2853 // don't account for the scrollbars we don't have
2854 GtkRange
* const range
= m_scrollBar
[i
];
2858 // nor for the ones we have but don't current show
2859 switch ( policy
[i
] )
2861 case GTK_POLICY_NEVER
:
2862 // never shown so doesn't take any place
2865 case GTK_POLICY_ALWAYS
:
2866 // no checks necessary
2869 case GTK_POLICY_AUTOMATIC
:
2870 // may be shown or not, check
2871 GtkAdjustment
*adj
= gtk_range_get_adjustment(range
);
2872 if (gtk_adjustment_get_upper(adj
) <= gtk_adjustment_get_page_size(adj
))
2878 GtkWidget
* widget
= GTK_WIDGET(range
);
2879 if (i
== ScrollDir_Horz
)
2883 gtk_widget_get_preferred_height(widget
, NULL
, &req
.height
);
2884 h
-= req
.height
+ scrollbar_spacing
;
2891 gtk_widget_get_preferred_width(widget
, NULL
, &req
.width
);
2892 w
-= req
.width
+ scrollbar_spacing
;
2895 #else // !__WXGTK3__
2896 gtk_widget_size_request(GTK_WIDGET(range
), &req
);
2897 if (i
== ScrollDir_Horz
)
2898 h
-= req
.height
+ scrollbar_spacing
;
2900 w
-= req
.width
+ scrollbar_spacing
;
2901 #endif // !__WXGTK3__
2905 const wxSize sizeBorders
= DoGetBorderSize();
2915 if (width
) *width
= w
;
2916 if (height
) *height
= h
;
2919 wxSize wxWindowGTK
::DoGetBorderSize() const
2922 return wxWindowBase
::DoGetBorderSize();
2925 WX_PIZZA(m_wxwindow
)->get_border(border
);
2926 return wxSize(border
.left
+ border
.right
, border
.top
+ border
.bottom
);
2929 void wxWindowGTK
::DoGetPosition( int *x
, int *y
) const
2933 GtkWidget
* parent
= NULL
;
2935 parent
= gtk_widget_get_parent(m_widget
);
2936 if (WX_IS_PIZZA(parent
))
2938 wxPizza
* pizza
= WX_PIZZA(parent
);
2939 dx
= pizza
->m_scroll_x
;
2940 dy
= pizza
->m_scroll_y
;
2942 if (x
) (*x
) = m_x
- dx
;
2943 if (y
) (*y
) = m_y
- dy
;
2946 void wxWindowGTK
::DoClientToScreen( int *x
, int *y
) const
2948 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2950 if (gtk_widget_get_window(m_widget
) == NULL
) return;
2952 GdkWindow
*source
= NULL
;
2954 source
= gtk_widget_get_window(m_wxwindow
);
2956 source
= gtk_widget_get_window(m_widget
);
2960 gdk_window_get_origin( source
, &org_x
, &org_y
);
2964 if (!gtk_widget_get_has_window(m_widget
))
2967 gtk_widget_get_allocation(m_widget
, &a
);
2976 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2977 *x
= (GetClientSize().x
- *x
) + org_x
;
2985 void wxWindowGTK
::DoScreenToClient( int *x
, int *y
) const
2987 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2989 if (!gtk_widget_get_realized(m_widget
)) return;
2991 GdkWindow
*source
= NULL
;
2993 source
= gtk_widget_get_window(m_wxwindow
);
2995 source
= gtk_widget_get_window(m_widget
);
2999 gdk_window_get_origin( source
, &org_x
, &org_y
);
3003 if (!gtk_widget_get_has_window(m_widget
))
3006 gtk_widget_get_allocation(m_widget
, &a
);
3014 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3015 *x
= (GetClientSize().x
- *x
) - org_x
;
3022 bool wxWindowGTK
::Show( bool show
)
3024 if ( !wxWindowBase
::Show(show
) )
3030 // notice that we may call Hide() before the window is created and this is
3031 // actually useful to create it hidden initially -- but we can't call
3032 // Show() before it is created
3035 wxASSERT_MSG( !show
, "can't show invalid window" );
3043 // defer until later
3047 gtk_widget_show(m_widget
);
3051 gtk_widget_hide(m_widget
);
3054 wxShowEvent
eventShow(GetId(), show
);
3055 eventShow
.SetEventObject(this);
3056 HandleWindowEvent(eventShow
);
3061 void wxWindowGTK
::DoEnable( bool enable
)
3063 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3065 gtk_widget_set_sensitive( m_widget
, enable
);
3066 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3067 gtk_widget_set_sensitive( m_wxwindow
, enable
);
3070 int wxWindowGTK
::GetCharHeight() const
3072 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
3074 wxFont font
= GetFont();
3075 wxCHECK_MSG( font
.IsOk(), 12, wxT("invalid font") );
3077 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
3082 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3083 PangoLayout
*layout
= pango_layout_new(context
);
3084 pango_layout_set_font_description(layout
, desc
);
3085 pango_layout_set_text(layout
, "H", 1);
3086 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3088 PangoRectangle rect
;
3089 pango_layout_line_get_extents(line
, NULL
, &rect
);
3091 g_object_unref (layout
);
3093 return (int) PANGO_PIXELS(rect
.height
);
3096 int wxWindowGTK
::GetCharWidth() const
3098 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
3100 wxFont font
= GetFont();
3101 wxCHECK_MSG( font
.IsOk(), 8, wxT("invalid font") );
3103 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
3108 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3109 PangoLayout
*layout
= pango_layout_new(context
);
3110 pango_layout_set_font_description(layout
, desc
);
3111 pango_layout_set_text(layout
, "g", 1);
3112 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3114 PangoRectangle rect
;
3115 pango_layout_line_get_extents(line
, NULL
, &rect
);
3117 g_object_unref (layout
);
3119 return (int) PANGO_PIXELS(rect
.width
);
3122 void wxWindowGTK
::DoGetTextExtent( const wxString
& string
,
3126 int *externalLeading
,
3127 const wxFont
*theFont
) const
3129 // ensure we work with a valid font
3131 if ( !theFont
|| !theFont
->IsOk() )
3132 fontToUse
= GetFont();
3134 fontToUse
= *theFont
;
3136 wxCHECK_RET( fontToUse
.IsOk(), wxT("invalid font") );
3138 const wxWindow
* win
= static_cast<const wxWindow
*>(this);
3139 wxTextMeasure
txm(win
, &fontToUse
);
3140 txm
.GetTextExtent(string
, x
, y
, descent
, externalLeading
);
3143 void wxWindowGTK
::GTKDisableFocusOutEvent()
3145 g_signal_handlers_block_by_func( m_focusWidget
,
3146 (gpointer
) gtk_window_focus_out_callback
, this);
3149 void wxWindowGTK
::GTKEnableFocusOutEvent()
3151 g_signal_handlers_unblock_by_func( m_focusWidget
,
3152 (gpointer
) gtk_window_focus_out_callback
, this);
3155 bool wxWindowGTK
::GTKHandleFocusIn()
3157 // Disable default focus handling for custom windows since the default GTK+
3158 // handler issues a repaint
3159 const bool retval
= m_wxwindow ?
true : false;
3162 // NB: if there's still unprocessed deferred focus-out event (see
3163 // GTKHandleFocusOut() for explanation), we need to process it first so
3164 // that the order of focus events -- focus-out first, then focus-in
3165 // elsewhere -- is preserved
3166 if ( gs_deferredFocusOut
)
3168 if ( GTKNeedsToFilterSameWindowFocus() &&
3169 gs_deferredFocusOut
== this )
3171 // GTK+ focus changed from this wxWindow back to itself, so don't
3172 // emit any events at all
3173 wxLogTrace(TRACE_FOCUS
,
3174 "filtered out spurious focus change within %s(%p, %s)",
3175 GetClassInfo()->GetClassName(), this, GetLabel());
3176 gs_deferredFocusOut
= NULL
;
3180 // otherwise we need to send focus-out first
3181 wxASSERT_MSG ( gs_deferredFocusOut
!= this,
3182 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
3183 GTKHandleDeferredFocusOut();
3187 wxLogTrace(TRACE_FOCUS
,
3188 "handling focus_in event for %s(%p, %s)",
3189 GetClassInfo()->GetClassName(), this, GetLabel());
3192 gtk_im_context_focus_in(m_imData
->context
);
3194 gs_currentFocus
= this;
3195 gs_pendingFocus
= NULL
;
3198 // caret needs to be informed about focus change
3199 wxCaret
*caret
= GetCaret();
3202 caret
->OnSetFocus();
3204 #endif // wxUSE_CARET
3206 // Notify the parent keeping track of focus for the kbd navigation
3207 // purposes that we got it.
3208 wxChildFocusEvent
eventChildFocus(static_cast<wxWindow
*>(this));
3209 GTKProcessEvent(eventChildFocus
);
3211 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, GetId());
3212 eventFocus
.SetEventObject(this);
3213 GTKProcessEvent(eventFocus
);
3218 bool wxWindowGTK
::GTKHandleFocusOut()
3220 // Disable default focus handling for custom windows since the default GTK+
3221 // handler issues a repaint
3222 const bool retval
= m_wxwindow ?
true : false;
3225 // NB: If a control is composed of several GtkWidgets and when focus
3226 // changes from one of them to another within the same wxWindow, we get
3227 // a focus-out event followed by focus-in for another GtkWidget owned
3228 // by the same wx control. We don't want to generate two spurious
3229 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3230 // from GTKHandleFocusOut() until we know for sure it's not coming back
3231 // (i.e. in GTKHandleFocusIn() or at idle time).
3232 if ( GTKNeedsToFilterSameWindowFocus() )
3234 wxASSERT_MSG( gs_deferredFocusOut
== NULL
,
3235 "deferred focus out event already pending" );
3236 wxLogTrace(TRACE_FOCUS
,
3237 "deferring focus_out event for %s(%p, %s)",
3238 GetClassInfo()->GetClassName(), this, GetLabel());
3239 gs_deferredFocusOut
= this;
3243 GTKHandleFocusOutNoDeferring();
3248 void wxWindowGTK
::GTKHandleFocusOutNoDeferring()
3250 wxLogTrace(TRACE_FOCUS
,
3251 "handling focus_out event for %s(%p, %s)",
3252 GetClassInfo()->GetClassName(), this, GetLabel());
3255 gtk_im_context_focus_out(m_imData
->context
);
3257 if ( gs_currentFocus
!= this )
3259 // Something is terribly wrong, gs_currentFocus is out of sync with the
3260 // real focus. We will reset it to NULL anyway, because after this
3261 // focus-out event is handled, one of the following with happen:
3263 // * either focus will go out of the app altogether, in which case
3264 // gs_currentFocus _should_ be NULL
3266 // * or it goes to another control, in which case focus-in event will
3267 // follow immediately and it will set gs_currentFocus to the right
3269 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3270 GetClassInfo()->GetClassName(), this, GetLabel());
3272 gs_currentFocus
= NULL
;
3275 // caret needs to be informed about focus change
3276 wxCaret
*caret
= GetCaret();
3279 caret
->OnKillFocus();
3281 #endif // wxUSE_CARET
3283 wxFocusEvent
event( wxEVT_KILL_FOCUS
, GetId() );
3284 event
.SetEventObject( this );
3285 event
.SetWindow( FindFocus() );
3286 GTKProcessEvent( event
);
3290 void wxWindowGTK
::GTKHandleDeferredFocusOut()
3292 // NB: See GTKHandleFocusOut() for explanation. This function is called
3293 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3295 if ( gs_deferredFocusOut
)
3297 wxWindowGTK
*win
= gs_deferredFocusOut
;
3298 gs_deferredFocusOut
= NULL
;
3300 wxLogTrace(TRACE_FOCUS
,
3301 "processing deferred focus_out event for %s(%p, %s)",
3302 win
->GetClassInfo()->GetClassName(), win
, win
->GetLabel());
3304 win
->GTKHandleFocusOutNoDeferring();
3308 void wxWindowGTK
::SetFocus()
3310 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3312 // Setting "physical" focus is not immediate in GTK+ and while
3313 // gtk_widget_is_focus ("determines if the widget is the focus widget
3314 // within its toplevel", i.e. returns true for one widget per TLW, not
3315 // globally) returns true immediately after grabbing focus,
3316 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3317 // has focus at the moment) takes effect only after the window is shown
3318 // (if it was hidden at the moment of the call) or at the next event loop
3321 // Because we want to FindFocus() call immediately following
3322 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3324 gs_pendingFocus
= this;
3326 GtkWidget
*widget
= m_wxwindow ? m_wxwindow
: m_focusWidget
;
3328 if ( GTK_IS_CONTAINER(widget
) &&
3329 !gtk_widget_get_can_focus(widget
) )
3331 wxLogTrace(TRACE_FOCUS
,
3332 wxT("Setting focus to a child of %s(%p, %s)"),
3333 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3334 gtk_widget_child_focus(widget
, GTK_DIR_TAB_FORWARD
);
3338 wxLogTrace(TRACE_FOCUS
,
3339 wxT("Setting focus to %s(%p, %s)"),
3340 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3341 gtk_widget_grab_focus(widget
);
3345 void wxWindowGTK
::SetCanFocus(bool canFocus
)
3347 gtk_widget_set_can_focus(m_widget
, canFocus
);
3349 if ( m_wxwindow
&& (m_widget
!= m_wxwindow
) )
3351 gtk_widget_set_can_focus(m_wxwindow
, canFocus
);
3355 bool wxWindowGTK
::Reparent( wxWindowBase
*newParentBase
)
3357 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3359 wxWindowGTK
* const newParent
= (wxWindowGTK
*)newParentBase
;
3361 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3363 if ( !wxWindowBase
::Reparent(newParent
) )
3366 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3368 // Notice that old m_parent pointer might be non-NULL here but the widget
3369 // still not have any parent at GTK level if it's a notebook page that had
3370 // been removed from the notebook so test this at GTK level and not wx one.
3371 if ( GtkWidget
*parentGTK
= gtk_widget_get_parent(m_widget
) )
3372 gtk_container_remove(GTK_CONTAINER(parentGTK
), m_widget
);
3374 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3378 if (gtk_widget_get_visible (newParent
->m_widget
))
3380 m_showOnIdle
= true;
3381 gtk_widget_hide( m_widget
);
3383 /* insert GTK representation */
3384 newParent
->AddChildGTK(this);
3387 SetLayoutDirection(wxLayout_Default
);
3392 void wxWindowGTK
::DoAddChild(wxWindowGTK
*child
)
3394 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3395 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3400 /* insert GTK representation */
3404 void wxWindowGTK
::AddChild(wxWindowBase
*child
)
3406 wxWindowBase
::AddChild(child
);
3407 m_dirtyTabOrder
= true;
3408 wxTheApp
->WakeUpIdle();
3411 void wxWindowGTK
::RemoveChild(wxWindowBase
*child
)
3413 wxWindowBase
::RemoveChild(child
);
3414 m_dirtyTabOrder
= true;
3415 wxTheApp
->WakeUpIdle();
3419 wxLayoutDirection wxWindowGTK
::GTKGetLayout(GtkWidget
*widget
)
3421 return gtk_widget_get_direction(widget
) == GTK_TEXT_DIR_RTL
3422 ? wxLayout_RightToLeft
3423 : wxLayout_LeftToRight
;
3427 void wxWindowGTK
::GTKSetLayout(GtkWidget
*widget
, wxLayoutDirection dir
)
3429 wxASSERT_MSG( dir
!= wxLayout_Default
, wxT("invalid layout direction") );
3431 gtk_widget_set_direction(widget
,
3432 dir
== wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
3433 : GTK_TEXT_DIR_LTR
);
3436 wxLayoutDirection wxWindowGTK
::GetLayoutDirection() const
3438 return GTKGetLayout(m_widget
);
3441 void wxWindowGTK
::SetLayoutDirection(wxLayoutDirection dir
)
3443 if ( dir
== wxLayout_Default
)
3445 const wxWindow
*const parent
= GetParent();
3448 // inherit layout from parent.
3449 dir
= parent
->GetLayoutDirection();
3451 else // no parent, use global default layout
3453 dir
= wxTheApp
->GetLayoutDirection();
3457 if ( dir
== wxLayout_Default
)
3460 GTKSetLayout(m_widget
, dir
);
3462 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3463 GTKSetLayout(m_wxwindow
, dir
);
3467 wxWindowGTK
::AdjustForLayoutDirection(wxCoord x
,
3468 wxCoord
WXUNUSED(width
),
3469 wxCoord
WXUNUSED(widthTotal
)) const
3471 // We now mirror the coordinates of RTL windows in wxPizza
3475 void wxWindowGTK
::DoMoveInTabOrder(wxWindow
*win
, WindowOrder move
)
3477 wxWindowBase
::DoMoveInTabOrder(win
, move
);
3478 m_dirtyTabOrder
= true;
3479 wxTheApp
->WakeUpIdle();
3482 bool wxWindowGTK
::DoNavigateIn(int flags
)
3484 if ( flags
& wxNavigationKeyEvent
::WinChange
)
3486 wxFAIL_MSG( wxT("not implemented") );
3490 else // navigate inside the container
3492 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3493 wxCHECK_MSG( parent
, false, wxT("every window must have a TLW parent") );
3495 GtkDirectionType dir
;
3496 dir
= flags
& wxNavigationKeyEvent
::IsForward ? GTK_DIR_TAB_FORWARD
3497 : GTK_DIR_TAB_BACKWARD
;
3500 g_signal_emit_by_name(parent
->m_widget
, "focus", dir
, &rc
);
3506 bool wxWindowGTK
::GTKWidgetNeedsMnemonic() const
3508 // none needed by default
3512 void wxWindowGTK
::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3514 // nothing to do by default since none is needed
3517 void wxWindowGTK
::RealizeTabOrder()
3521 if ( !m_children
.empty() )
3523 // we don't only construct the correct focus chain but also use
3524 // this opportunity to update the mnemonic widgets for the widgets
3527 GList
*chain
= NULL
;
3528 wxWindowGTK
* mnemonicWindow
= NULL
;
3530 for ( wxWindowList
::const_iterator i
= m_children
.begin();
3531 i
!= m_children
.end();
3534 wxWindowGTK
*win
= *i
;
3536 bool focusableFromKeyboard
= win
->AcceptsFocusFromKeyboard();
3538 if ( mnemonicWindow
)
3540 if ( focusableFromKeyboard
)
3542 // wxComboBox et al. needs to focus on on a different
3543 // widget than m_widget, so if the main widget isn't
3544 // focusable try the connect widget
3545 GtkWidget
* w
= win
->m_widget
;
3546 if ( !gtk_widget_get_can_focus(w
) )
3548 w
= win
->GetConnectWidget();
3549 if ( !gtk_widget_get_can_focus(w
) )
3555 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3556 mnemonicWindow
= NULL
;
3560 else if ( win
->GTKWidgetNeedsMnemonic() )
3562 mnemonicWindow
= win
;
3565 if ( focusableFromKeyboard
)
3566 chain
= g_list_prepend(chain
, win
->m_widget
);
3569 chain
= g_list_reverse(chain
);
3571 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3576 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3581 void wxWindowGTK
::Raise()
3583 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3585 if (m_wxwindow
&& gtk_widget_get_window(m_wxwindow
))
3587 gdk_window_raise(gtk_widget_get_window(m_wxwindow
));
3589 else if (gtk_widget_get_window(m_widget
))
3591 gdk_window_raise(gtk_widget_get_window(m_widget
));
3595 void wxWindowGTK
::Lower()
3597 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3599 if (m_wxwindow
&& gtk_widget_get_window(m_wxwindow
))
3601 gdk_window_lower(gtk_widget_get_window(m_wxwindow
));
3603 else if (gtk_widget_get_window(m_widget
))
3605 gdk_window_lower(gtk_widget_get_window(m_widget
));
3609 bool wxWindowGTK
::SetCursor( const wxCursor
&cursor
)
3611 if ( !wxWindowBase
::SetCursor(cursor
.IsOk() ? cursor
: *wxSTANDARD_CURSOR
) )
3619 void wxWindowGTK
::GTKUpdateCursor(bool update_self
/*=true*/, bool recurse
/*=true*/)
3623 wxCursor
cursor(g_globalCursor
.IsOk() ? g_globalCursor
: GetCursor());
3624 if ( cursor
.IsOk() )
3626 wxArrayGdkWindows windowsThis
;
3627 GdkWindow
* window
= GTKGetWindow(windowsThis
);
3629 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3632 const size_t count
= windowsThis
.size();
3633 for ( size_t n
= 0; n
< count
; n
++ )
3635 GdkWindow
*win
= windowsThis
[n
];
3636 // It can be zero if the window has not been realized yet.
3639 gdk_window_set_cursor(win
, cursor
.GetCursor());
3648 for (wxWindowList
::iterator it
= GetChildren().begin(); it
!= GetChildren().end(); ++it
)
3650 (*it
)->GTKUpdateCursor( true );
3655 void wxWindowGTK
::WarpPointer( int x
, int y
)
3657 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3659 ClientToScreen(&x
, &y
);
3660 GdkDisplay
* display
= gtk_widget_get_display(m_widget
);
3661 GdkScreen
* screen
= gtk_widget_get_screen(m_widget
);
3663 GdkDeviceManager
* manager
= gdk_display_get_device_manager(display
);
3664 gdk_device_warp(gdk_device_manager_get_client_pointer(manager
), screen
, x
, y
);
3666 #ifdef GDK_WINDOWING_X11
3667 XWarpPointer(GDK_DISPLAY_XDISPLAY(display
),
3669 GDK_WINDOW_XID(gdk_screen_get_root_window(screen
)),
3675 wxWindowGTK
::ScrollDir wxWindowGTK
::ScrollDirFromRange(GtkRange
*range
) const
3677 // find the scrollbar which generated the event
3678 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3680 if ( range
== m_scrollBar
[dir
] )
3681 return (ScrollDir
)dir
;
3684 wxFAIL_MSG( wxT("event from unknown scrollbar received") );
3686 return ScrollDir_Max
;
3689 bool wxWindowGTK
::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3691 bool changed
= false;
3692 GtkRange
* range
= m_scrollBar
[dir
];
3693 if ( range
&& units
)
3695 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
3696 double inc
= unit
== ScrollUnit_Line ?
gtk_adjustment_get_step_increment(adj
)
3697 : gtk_adjustment_get_page_increment(adj
);
3699 const int posOld
= wxRound(gtk_adjustment_get_value(adj
));
3700 gtk_range_set_value(range
, posOld
+ units
*inc
);
3702 changed
= wxRound(gtk_adjustment_get_value(adj
)) != posOld
;
3708 bool wxWindowGTK
::ScrollLines(int lines
)
3710 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3713 bool wxWindowGTK
::ScrollPages(int pages
)
3715 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3718 void wxWindowGTK
::Refresh(bool WXUNUSED(eraseBackground
),
3723 if (gtk_widget_get_mapped(m_wxwindow
))
3725 GdkWindow
* window
= gtk_widget_get_window(m_wxwindow
);
3728 GdkRectangle r
= { rect
->x
, rect
->y
, rect
->width
, rect
->height
};
3729 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3730 r
.x
= gdk_window_get_width(window
) - r
.x
- rect
->width
;
3731 gdk_window_invalidate_rect(window
, &r
, true);
3734 gdk_window_invalidate_rect(window
, NULL
, true);
3739 if (gtk_widget_get_mapped(m_widget
))
3742 gtk_widget_queue_draw_area(m_widget
, rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3744 gtk_widget_queue_draw(m_widget
);
3749 void wxWindowGTK
::Update()
3751 if (m_widget
&& gtk_widget_get_mapped(m_widget
))
3753 GdkDisplay
* display
= gtk_widget_get_display(m_widget
);
3754 // Flush everything out to the server, and wait for it to finish.
3755 // This ensures nothing will overwrite the drawing we are about to do.
3756 gdk_display_sync(display
);
3758 GdkWindow
* window
= GTKGetDrawingWindow();
3760 window
= gtk_widget_get_window(m_widget
);
3761 gdk_window_process_updates(window
, true);
3763 // Flush again, but no need to wait for it to finish
3764 gdk_display_flush(display
);
3768 bool wxWindowGTK
::DoIsExposed( int x
, int y
) const
3770 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
3773 bool wxWindowGTK
::DoIsExposed( int x
, int y
, int w
, int h
) const
3775 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3776 return m_updateRegion
.Contains(x
-w
, y
, w
, h
) != wxOutRegion
;
3778 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
3782 void wxWindowGTK
::GTKSendPaintEvents(cairo_t
* cr
)
3784 void wxWindowGTK
::GTKSendPaintEvents(const GdkRegion
* region
)
3788 m_paintContext
= cr
;
3789 double x1
, y1
, x2
, y2
;
3790 cairo_clip_extents(cr
, &x1
, &y1
, &x2
, &y2
);
3791 m_updateRegion
= wxRegion(int(x1
), int(y1
), int(x2
- x1
), int(y2
- y1
));
3792 #else // !__WXGTK3__
3793 m_updateRegion
= wxRegion(region
);
3794 #if wxGTK_HAS_COMPOSITING_SUPPORT
3797 #endif // !__WXGTK3__
3798 // Clip to paint region in wxClientDC
3799 m_clipPaintRegion
= true;
3801 m_nativeUpdateRegion
= m_updateRegion
;
3803 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3805 // Transform m_updateRegion under RTL
3806 m_updateRegion
.Clear();
3808 const int width
= gdk_window_get_width(GTKGetDrawingWindow());
3810 wxRegionIterator
upd( m_nativeUpdateRegion
);
3814 rect
.x
= upd
.GetX();
3815 rect
.y
= upd
.GetY();
3816 rect
.width
= upd
.GetWidth();
3817 rect
.height
= upd
.GetHeight();
3819 rect
.x
= width
- rect
.x
- rect
.width
;
3820 m_updateRegion
.Union( rect
);
3826 switch ( GetBackgroundStyle() )
3828 case wxBG_STYLE_TRANSPARENT
:
3829 #if wxGTK_HAS_COMPOSITING_SUPPORT
3830 if (IsTransparentBackgroundSupported())
3832 // Set a transparent background, so that overlaying in parent
3833 // might indeed let see through where this child did not
3834 // explicitly paint.
3835 // NB: it works also for top level windows (but this is the
3836 // windows manager which then does the compositing job)
3838 cr
= gdk_cairo_create(m_wxwindow
->window
);
3839 gdk_cairo_region(cr
, m_nativeUpdateRegion
.GetRegion());
3842 cairo_set_operator(cr
, CAIRO_OPERATOR_CLEAR
);
3844 cairo_set_operator(cr
, CAIRO_OPERATOR_OVER
);
3846 cairo_surface_flush(cairo_get_target(cr
));
3849 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
3852 case wxBG_STYLE_ERASE
:
3855 wxGTKCairoDC
dc(cr
);
3857 wxWindowDC
dc( (wxWindow
*)this );
3858 dc
.SetDeviceClippingRegion( m_updateRegion
);
3860 // Work around gtk-qt <= 0.60 bug whereby the window colour
3864 GetOptionInt("gtk.window.force-background-colour") )
3866 dc
.SetBackground(GetBackgroundColour());
3869 #endif // !__WXGTK3__
3870 wxEraseEvent
erase_event( GetId(), &dc
);
3871 erase_event
.SetEventObject( this );
3873 if ( HandleWindowEvent(erase_event
) )
3875 // background erased, don't do it again
3881 case wxBG_STYLE_SYSTEM
:
3882 if ( GetThemeEnabled() )
3884 GdkWindow
* gdkWindow
= GTKGetDrawingWindow();
3885 const int w
= gdk_window_get_width(gdkWindow
);
3886 const int h
= gdk_window_get_height(gdkWindow
);
3888 GtkStyleContext
* sc
= gtk_widget_get_style_context(m_wxwindow
);
3889 gtk_render_background(sc
, cr
, 0, 0, w
, h
);
3891 // find ancestor from which to steal background
3892 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3894 parent
= (wxWindow
*)this;
3896 m_nativeUpdateRegion
.GetBox(rect
.x
, rect
.y
, rect
.width
, rect
.height
);
3897 gtk_paint_flat_box(gtk_widget_get_style(parent
->m_widget
),
3899 gtk_widget_get_state(m_wxwindow
),
3905 #endif // !__WXGTK3__
3909 case wxBG_STYLE_PAINT
:
3910 // nothing to do: window will be painted over in EVT_PAINT
3914 wxFAIL_MSG( "unsupported background style" );
3917 wxNcPaintEvent
nc_paint_event( GetId() );
3918 nc_paint_event
.SetEventObject( this );
3919 HandleWindowEvent( nc_paint_event
);
3921 wxPaintEvent
paint_event( GetId() );
3922 paint_event
.SetEventObject( this );
3923 HandleWindowEvent( paint_event
);
3925 #if wxGTK_HAS_COMPOSITING_SUPPORT
3926 if (IsTransparentBackgroundSupported())
3927 { // now composite children which need it
3928 // Overlay all our composite children on top of the painted area
3929 wxWindowList
::compatibility_iterator node
;
3930 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
3932 wxWindow
*compositeChild
= node
->GetData();
3933 if (compositeChild
->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT
)
3938 cr
= gdk_cairo_create(m_wxwindow
->window
);
3939 gdk_cairo_region(cr
, m_nativeUpdateRegion
.GetRegion());
3942 #endif // !__WXGTK3__
3943 GtkWidget
*child
= compositeChild
->m_wxwindow
;
3944 GtkAllocation alloc
;
3945 gtk_widget_get_allocation(child
, &alloc
);
3947 // The source data is the (composited) child
3948 gdk_cairo_set_source_window(
3949 cr
, gtk_widget_get_window(child
), alloc
.x
, alloc
.y
);
3959 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
3961 m_clipPaintRegion
= false;
3963 m_paintContext
= NULL
;
3965 m_updateRegion
.Clear();
3966 m_nativeUpdateRegion
.Clear();
3969 void wxWindowGTK
::SetDoubleBuffered( bool on
)
3971 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3974 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3977 bool wxWindowGTK
::IsDoubleBuffered() const
3979 return gtk_widget_get_double_buffered( m_wxwindow
) != 0;
3982 void wxWindowGTK
::ClearBackground()
3984 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3988 void wxWindowGTK
::DoSetToolTip( wxToolTip
*tip
)
3990 if (m_tooltip
!= tip
)
3992 wxWindowBase
::DoSetToolTip(tip
);
3995 m_tooltip
->GTKSetWindow(static_cast<wxWindow
*>(this));
3997 GTKApplyToolTip(NULL
);
4001 void wxWindowGTK
::GTKApplyToolTip(const char* tip
)
4003 wxToolTip
::GTKApply(GetConnectWidget(), tip
);
4005 #endif // wxUSE_TOOLTIPS
4007 bool wxWindowGTK
::SetBackgroundColour( const wxColour
&colour
)
4009 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4011 if (!wxWindowBase
::SetBackgroundColour(colour
))
4017 // We need the pixel value e.g. for background clearing.
4018 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
4022 // apply style change (forceStyle=true so that new style is applied
4023 // even if the bg colour changed from valid to wxNullColour)
4024 GTKApplyWidgetStyle(true);
4029 bool wxWindowGTK
::SetForegroundColour( const wxColour
&colour
)
4031 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4033 if (!wxWindowBase
::SetForegroundColour(colour
))
4041 // We need the pixel value e.g. for background clearing.
4042 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
4046 // apply style change (forceStyle=true so that new style is applied
4047 // even if the bg colour changed from valid to wxNullColour):
4048 GTKApplyWidgetStyle(true);
4053 PangoContext
*wxWindowGTK
::GTKGetPangoDefaultContext()
4055 return gtk_widget_get_pango_context( m_widget
);
4059 GtkRcStyle
* wxWindowGTK
::GTKCreateWidgetStyle()
4061 GtkRcStyle
*style
= gtk_rc_style_new();
4063 if ( m_font
.IsOk() )
4066 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
4069 int flagsNormal
= 0,
4072 flagsInsensitive
= 0;
4074 if ( m_foregroundColour
.IsOk() )
4076 const GdkColor
*fg
= m_foregroundColour
.GetColor();
4078 style
->fg
[GTK_STATE_NORMAL
] =
4079 style
->text
[GTK_STATE_NORMAL
] = *fg
;
4080 flagsNormal
|= GTK_RC_FG
| GTK_RC_TEXT
;
4082 style
->fg
[GTK_STATE_PRELIGHT
] =
4083 style
->text
[GTK_STATE_PRELIGHT
] = *fg
;
4084 flagsPrelight
|= GTK_RC_FG
| GTK_RC_TEXT
;
4086 style
->fg
[GTK_STATE_ACTIVE
] =
4087 style
->text
[GTK_STATE_ACTIVE
] = *fg
;
4088 flagsActive
|= GTK_RC_FG
| GTK_RC_TEXT
;
4091 if ( m_backgroundColour
.IsOk() )
4093 const GdkColor
*bg
= m_backgroundColour
.GetColor();
4095 style
->bg
[GTK_STATE_NORMAL
] =
4096 style
->base
[GTK_STATE_NORMAL
] = *bg
;
4097 flagsNormal
|= GTK_RC_BG
| GTK_RC_BASE
;
4099 style
->bg
[GTK_STATE_PRELIGHT
] =
4100 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
4101 flagsPrelight
|= GTK_RC_BG
| GTK_RC_BASE
;
4103 style
->bg
[GTK_STATE_ACTIVE
] =
4104 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
4105 flagsActive
|= GTK_RC_BG
| GTK_RC_BASE
;
4107 style
->bg
[GTK_STATE_INSENSITIVE
] =
4108 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
4109 flagsInsensitive
|= GTK_RC_BG
| GTK_RC_BASE
;
4112 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)flagsNormal
;
4113 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)flagsPrelight
;
4114 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)flagsActive
;
4115 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)flagsInsensitive
;
4119 #endif // !__WXGTK3__
4121 void wxWindowGTK
::GTKApplyWidgetStyle(bool forceStyle
)
4123 if (forceStyle
|| m_font
.IsOk() ||
4124 m_foregroundColour
.IsOk() || m_backgroundColour
.IsOk())
4127 if (m_backgroundColour
.IsOk())
4129 // create a GtkStyleProvider to override "background-image"
4130 if (m_styleProvider
== NULL
)
4131 m_styleProvider
= GTK_STYLE_PROVIDER(gtk_css_provider_new());
4133 "*{background-image:-gtk-gradient(linear,0 0,0 1,"
4134 "from(rgba(%u,%u,%u,%g)),to(rgba(%u,%u,%u,%g)))}";
4135 char buf
[sizeof(css
) + 20];
4136 const unsigned r
= m_backgroundColour
.Red();
4137 const unsigned g
= m_backgroundColour
.Green();
4138 const unsigned b
= m_backgroundColour
.Blue();
4139 const double a
= m_backgroundColour
.Alpha() / 255.0;
4140 g_snprintf(buf
, sizeof(buf
), css
, r
, g
, b
, a
, r
, g
, b
, a
);
4141 gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(m_styleProvider
), buf
, -1, NULL
);
4143 DoApplyWidgetStyle(NULL
);
4145 GtkRcStyle
* style
= GTKCreateWidgetStyle();
4146 DoApplyWidgetStyle(style
);
4147 g_object_unref(style
);
4151 // Style change may affect GTK+'s size calculation:
4152 InvalidateBestSize();
4155 void wxWindowGTK
::DoApplyWidgetStyle(GtkRcStyle
*style
)
4157 GtkWidget
* widget
= m_wxwindow ? m_wxwindow
: m_widget
;
4159 // block the signal temporarily to avoid sending
4160 // wxSysColourChangedEvents when we change the colours ourselves
4161 bool unblock
= false;
4162 if (m_wxwindow
&& IsTopLevel())
4165 g_signal_handlers_block_by_func(
4166 m_wxwindow
, (void*)style_updated
, this);
4169 GTKApplyStyle(widget
, style
);
4173 g_signal_handlers_unblock_by_func(
4174 m_wxwindow
, (void*)style_updated
, this);
4178 void wxWindowGTK
::GTKApplyStyle(GtkWidget
* widget
, GtkRcStyle
* WXUNUSED_IN_GTK3(style
))
4181 const PangoFontDescription
* pfd
= NULL
;
4183 pfd
= pango_font_description_copy(m_font
.GetNativeFontInfo()->description
);
4184 gtk_widget_override_font(widget
, pfd
);
4185 gtk_widget_override_color(widget
, GTK_STATE_FLAG_NORMAL
, m_foregroundColour
);
4186 gtk_widget_override_background_color(widget
, GTK_STATE_FLAG_NORMAL
, m_backgroundColour
);
4188 // setting background color has no effect with some themes when the widget style
4189 // has a "background-image" property, so we need to override that as well
4191 GtkStyleContext
* context
= gtk_widget_get_style_context(widget
);
4192 if (m_styleProvider
)
4193 gtk_style_context_remove_provider(context
, m_styleProvider
);
4194 cairo_pattern_t
* pattern
= NULL
;
4195 if (m_backgroundColour
.IsOk())
4197 gtk_style_context_get(context
,
4198 GTK_STATE_FLAG_NORMAL
, "background-image", &pattern
, NULL
);
4202 cairo_pattern_destroy(pattern
);
4203 gtk_style_context_add_provider(context
,
4204 m_styleProvider
, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
);
4207 gtk_widget_modify_style(widget
, style
);
4211 bool wxWindowGTK
::SetBackgroundStyle(wxBackgroundStyle style
)
4213 if (!wxWindowBase
::SetBackgroundStyle(style
))
4220 window
= GTKGetDrawingWindow();
4224 GtkWidget
* const w
= GetConnectWidget();
4225 window
= w ?
gtk_widget_get_window(w
) : NULL
;
4228 bool wantNoBackPixmap
= style
== wxBG_STYLE_PAINT
|| style
== wxBG_STYLE_TRANSPARENT
;
4230 if ( wantNoBackPixmap
)
4234 // Make sure GDK/X11 doesn't refresh the window
4236 gdk_window_set_back_pixmap( window
, NULL
, FALSE
);
4237 m_needsStyleChange
= false;
4239 else // window not realized yet
4241 // Do when window is realized
4242 m_needsStyleChange
= true;
4245 // Don't apply widget style, or we get a grey background
4249 // apply style change (forceStyle=true so that new style is applied
4250 // even if the bg colour changed from valid to wxNullColour):
4251 GTKApplyWidgetStyle(true);
4253 #endif // !__WXGTK3__
4258 bool wxWindowGTK
::IsTransparentBackgroundSupported(wxString
* reason
) const
4260 #if wxGTK_HAS_COMPOSITING_SUPPORT
4262 if (gtk_check_version(wxGTK_VERSION_REQUIRED_FOR_COMPOSITING
) != NULL
)
4266 *reason
= _("GTK+ installed on this machine is too old to "
4267 "support screen compositing, please install "
4268 "GTK+ 2.12 or later.");
4273 #endif // !__WXGTK3__
4275 // NB: We don't check here if the particular kind of widget supports
4276 // transparency, we check only if it would be possible for a generic window
4278 wxCHECK_MSG ( m_widget
, false, "Window must be created first" );
4280 if (!gdk_screen_is_composited(gtk_widget_get_screen(m_widget
)))
4284 *reason
= _("Compositing not supported by this system, "
4285 "please enable it in your Window Manager.");
4295 *reason
= _("This program was compiled with a too old version of GTK+, "
4296 "please rebuild with GTK+ 2.12 or newer.");
4300 #endif // wxGTK_HAS_COMPOSITING_SUPPORT/!wxGTK_HAS_COMPOSITING_SUPPORT
4303 // ----------------------------------------------------------------------------
4304 // Pop-up menu stuff
4305 // ----------------------------------------------------------------------------
4307 #if wxUSE_MENUS_NATIVE
4311 void wxPopupMenuPositionCallback( GtkMenu
*menu
,
4313 gboolean
* WXUNUSED(whatever
),
4314 gpointer user_data
)
4316 // ensure that the menu appears entirely on screen
4319 gtk_widget_get_preferred_size(GTK_WIDGET(menu
), &req
, NULL
);
4321 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
4324 wxSize sizeScreen
= wxGetDisplaySize();
4325 wxPoint
*pos
= (wxPoint
*)user_data
;
4327 gint xmax
= sizeScreen
.x
- req
.width
,
4328 ymax
= sizeScreen
.y
- req
.height
;
4330 *x
= pos
->x
< xmax ? pos
->x
: xmax
;
4331 *y
= pos
->y
< ymax ? pos
->y
: ymax
;
4335 bool wxWindowGTK
::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
4337 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4343 GtkMenuPositionFunc posfunc
;
4344 if ( x
== -1 && y
== -1 )
4346 // use GTK's default positioning algorithm
4352 pos
= ClientToScreen(wxPoint(x
, y
));
4354 posfunc
= wxPopupMenuPositionCallback
;
4357 menu
->m_popupShown
= true;
4359 GTK_MENU(menu
->m_menu
),
4360 NULL
, // parent menu shell
4361 NULL
, // parent menu item
4362 posfunc
, // function to position it
4363 userdata
, // client data
4364 0, // button used to activate it
4365 gtk_get_current_event_time()
4368 while (menu
->m_popupShown
)
4370 gtk_main_iteration();
4376 #endif // wxUSE_MENUS_NATIVE
4378 #if wxUSE_DRAG_AND_DROP
4380 void wxWindowGTK
::SetDropTarget( wxDropTarget
*dropTarget
)
4382 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4384 GtkWidget
*dnd_widget
= GetConnectWidget();
4386 if (m_dropTarget
) m_dropTarget
->GtkUnregisterWidget( dnd_widget
);
4388 if (m_dropTarget
) delete m_dropTarget
;
4389 m_dropTarget
= dropTarget
;
4391 if (m_dropTarget
) m_dropTarget
->GtkRegisterWidget( dnd_widget
);
4394 #endif // wxUSE_DRAG_AND_DROP
4396 GtkWidget
* wxWindowGTK
::GetConnectWidget()
4398 GtkWidget
*connect_widget
= m_widget
;
4399 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4401 return connect_widget
;
4404 bool wxWindowGTK
::GTKIsOwnWindow(GdkWindow
*window
) const
4406 wxArrayGdkWindows windowsThis
;
4407 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
4409 return winThis ? window
== winThis
4410 : windowsThis
.Index(window
) != wxNOT_FOUND
;
4413 GdkWindow
*wxWindowGTK
::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
4415 return m_wxwindow ?
GTKGetDrawingWindow() : gtk_widget_get_window(m_widget
);
4418 bool wxWindowGTK
::SetFont( const wxFont
&font
)
4420 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4422 if (!wxWindowBase
::SetFont(font
))
4425 // apply style change (forceStyle=true so that new style is applied
4426 // even if the font changed from valid to wxNullFont):
4427 GTKApplyWidgetStyle(true);
4432 void wxWindowGTK
::DoCaptureMouse()
4434 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4436 GdkWindow
*window
= NULL
;
4438 window
= GTKGetDrawingWindow();
4440 window
= gtk_widget_get_window(GetConnectWidget());
4442 wxCHECK_RET( window
, wxT("CaptureMouse() failed") );
4444 const wxCursor
* cursor
= &m_cursor
;
4445 if (!cursor
->IsOk())
4446 cursor
= wxSTANDARD_CURSOR
;
4448 const GdkEventMask mask
= GdkEventMask(
4449 GDK_BUTTON_PRESS_MASK
|
4450 GDK_BUTTON_RELEASE_MASK
|
4451 GDK_POINTER_MOTION_HINT_MASK
|
4452 GDK_POINTER_MOTION_MASK
);
4454 GdkDisplay
* display
= gdk_window_get_display(window
);
4455 GdkDeviceManager
* manager
= gdk_display_get_device_manager(display
);
4456 GdkDevice
* device
= gdk_device_manager_get_client_pointer(manager
);
4458 device
, window
, GDK_OWNERSHIP_NONE
, false, mask
,
4459 cursor
->GetCursor(), unsigned(GDK_CURRENT_TIME
));
4461 gdk_pointer_grab( window
, FALSE
,
4464 cursor
->GetCursor(),
4465 (guint32
)GDK_CURRENT_TIME
);
4467 g_captureWindow
= this;
4468 g_captureWindowHasMouse
= true;
4471 void wxWindowGTK
::DoReleaseMouse()
4473 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4475 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4477 g_captureWindow
= NULL
;
4479 GdkWindow
*window
= NULL
;
4481 window
= GTKGetDrawingWindow();
4483 window
= gtk_widget_get_window(GetConnectWidget());
4489 GdkDisplay
* display
= gdk_window_get_display(window
);
4490 GdkDeviceManager
* manager
= gdk_display_get_device_manager(display
);
4491 GdkDevice
* device
= gdk_device_manager_get_client_pointer(manager
);
4492 gdk_device_ungrab(device
, unsigned(GDK_CURRENT_TIME
));
4494 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4498 void wxWindowGTK
::GTKReleaseMouseAndNotify()
4501 wxMouseCaptureLostEvent
evt(GetId());
4502 evt
.SetEventObject( this );
4503 HandleWindowEvent( evt
);
4507 wxWindow
*wxWindowBase
::GetCapture()
4509 return (wxWindow
*)g_captureWindow
;
4512 bool wxWindowGTK
::IsRetained() const
4517 void wxWindowGTK
::SetScrollbar(int orient
,
4521 bool WXUNUSED(update
))
4523 const int dir
= ScrollDirFromOrient(orient
);
4524 GtkRange
* const sb
= m_scrollBar
[dir
];
4525 wxCHECK_RET( sb
, wxT("this window is not scrollable") );
4529 // GtkRange requires upper > lower
4534 g_signal_handlers_block_by_func(
4535 sb
, (void*)gtk_scrollbar_value_changed
, this);
4537 gtk_range_set_increments(sb
, 1, thumbVisible
);
4538 gtk_adjustment_set_page_size(gtk_range_get_adjustment(sb
), thumbVisible
);
4539 gtk_range_set_range(sb
, 0, range
);
4540 gtk_range_set_value(sb
, pos
);
4541 m_scrollPos
[dir
] = gtk_range_get_value(sb
);
4543 g_signal_handlers_unblock_by_func(
4544 sb
, (void*)gtk_scrollbar_value_changed
, this);
4547 void wxWindowGTK
::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4549 const int dir
= ScrollDirFromOrient(orient
);
4550 GtkRange
* const sb
= m_scrollBar
[dir
];
4551 wxCHECK_RET( sb
, wxT("this window is not scrollable") );
4553 // This check is more than an optimization. Without it, the slider
4554 // will not move smoothly while tracking when using wxScrollHelper.
4555 if (GetScrollPos(orient
) != pos
)
4557 g_signal_handlers_block_by_func(
4558 sb
, (void*)gtk_scrollbar_value_changed
, this);
4560 gtk_range_set_value(sb
, pos
);
4561 m_scrollPos
[dir
] = gtk_range_get_value(sb
);
4563 g_signal_handlers_unblock_by_func(
4564 sb
, (void*)gtk_scrollbar_value_changed
, this);
4568 int wxWindowGTK
::GetScrollThumb(int orient
) const
4570 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4571 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4573 return wxRound(gtk_adjustment_get_page_size(gtk_range_get_adjustment(sb
)));
4576 int wxWindowGTK
::GetScrollPos( int orient
) const
4578 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4579 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4581 return wxRound(gtk_range_get_value(sb
));
4584 int wxWindowGTK
::GetScrollRange( int orient
) const
4586 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4587 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4589 return wxRound(gtk_adjustment_get_upper(gtk_range_get_adjustment(sb
)));
4592 // Determine if increment is the same as +/-x, allowing for some small
4593 // difference due to possible inexactness in floating point arithmetic
4594 static inline bool IsScrollIncrement(double increment
, double x
)
4596 wxASSERT(increment
> 0);
4597 const double tolerance
= 1.0 / 1024;
4598 return fabs(increment
- fabs(x
)) < tolerance
;
4601 wxEventType wxWindowGTK
::GTKGetScrollEventType(GtkRange
* range
)
4603 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4605 const int barIndex
= range
== m_scrollBar
[1];
4607 const double value
= gtk_range_get_value(range
);
4609 // save previous position
4610 const double oldPos
= m_scrollPos
[barIndex
];
4611 // update current position
4612 m_scrollPos
[barIndex
] = value
;
4613 // If event should be ignored, or integral position has not changed
4614 if (g_blockEventsOnDrag
|| wxRound(value
) == wxRound(oldPos
))
4619 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4622 // Difference from last change event
4623 const double diff
= value
- oldPos
;
4624 const bool isDown
= diff
> 0;
4626 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
4627 if (IsScrollIncrement(gtk_adjustment_get_step_increment(adj
), diff
))
4629 eventType
= isDown ? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4631 else if (IsScrollIncrement(gtk_adjustment_get_page_increment(adj
), diff
))
4633 eventType
= isDown ? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4635 else if (m_mouseButtonDown
)
4637 // Assume track event
4638 m_isScrolling
= true;
4644 void wxWindowGTK
::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4646 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4648 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4650 // No scrolling requested.
4651 if ((dx
== 0) && (dy
== 0)) return;
4653 m_clipPaintRegion
= true;
4655 WX_PIZZA(m_wxwindow
)->scroll(dx
, dy
);
4657 m_clipPaintRegion
= false;
4660 bool restoreCaret
= (GetCaret() != NULL
&& GetCaret()->IsVisible());
4663 wxRect
caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4665 caretRect
.width
+= dx
;
4668 caretRect
.x
+= dx
; caretRect
.width
-= dx
;
4671 caretRect
.height
+= dy
;
4674 caretRect
.y
+= dy
; caretRect
.height
-= dy
;
4677 RefreshRect(caretRect
);
4679 #endif // wxUSE_CARET
4682 void wxWindowGTK
::GTKScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4684 //RN: Note that static controls usually have no border on gtk, so maybe
4685 //it makes sense to treat that as simply no border at the wx level
4687 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4689 GtkShadowType gtkstyle
;
4691 if(wxstyle
& wxBORDER_RAISED
)
4692 gtkstyle
= GTK_SHADOW_OUT
;
4693 else if ((wxstyle
& wxBORDER_SUNKEN
) || (wxstyle
& wxBORDER_THEME
))
4694 gtkstyle
= GTK_SHADOW_IN
;
4697 else if (wxstyle
& wxBORDER_DOUBLE
)
4698 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4701 gtkstyle
= GTK_SHADOW_IN
;
4703 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4708 // Find the wxWindow at the current mouse position, also returning the mouse
4710 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4712 pt
= wxGetMousePosition();
4713 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4717 // Get the current mouse position.
4718 void wxGetMousePosition(int* x
, int* y
)
4720 GdkDisplay
* display
= GetDisplay();
4722 GdkDeviceManager
* manager
= gdk_display_get_device_manager(display
);
4723 GdkDevice
* device
= gdk_device_manager_get_client_pointer(manager
);
4724 gdk_device_get_position(device
, NULL
, x
, y
);
4726 gdk_display_get_pointer(display
, NULL
, x
, y
, NULL
);
4730 wxPoint
wxGetMousePosition()
4733 wxGetMousePosition(&pt
.x
, &pt
.y
);
4737 GdkWindow
* wxWindowGTK
::GTKGetDrawingWindow() const
4739 GdkWindow
* window
= NULL
;
4741 window
= gtk_widget_get_window(m_wxwindow
);
4745 // ----------------------------------------------------------------------------
4747 // ----------------------------------------------------------------------------
4749 void wxWindowGTK
::GTKFreezeWidget(GtkWidget
* widget
)
4751 if (widget
&& gtk_widget_get_has_window(widget
))
4753 GdkWindow
* window
= gtk_widget_get_window(widget
);
4755 gdk_window_freeze_updates(window
);
4759 void wxWindowGTK
::GTKThawWidget(GtkWidget
* widget
)
4761 if (widget
&& gtk_widget_get_has_window(widget
))
4763 GdkWindow
* window
= gtk_widget_get_window(widget
);
4765 gdk_window_thaw_updates(window
);
4769 void wxWindowGTK
::DoFreeze()
4771 GtkWidget
* widget
= m_wxwindow
;
4774 GTKFreezeWidget(widget
);
4777 void wxWindowGTK
::DoThaw()
4779 GtkWidget
* widget
= m_wxwindow
;
4782 GTKThawWidget(widget
);