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 using namespace wxGTKImpl
;
48 #ifdef GDK_WINDOWING_X11
50 #include "wx/x11/private/wrapxkb.h"
55 #include <gdk/gdkkeysyms.h>
57 #include <gdk/gdkkeysyms-compat.h>
60 // gdk_window_set_composited() is only supported since 2.12
61 #define wxGTK_VERSION_REQUIRED_FOR_COMPOSITING 2,12,0
62 #define wxGTK_HAS_COMPOSITING_SUPPORT GTK_CHECK_VERSION(2,12,0)
64 //-----------------------------------------------------------------------------
65 // documentation on internals
66 //-----------------------------------------------------------------------------
69 I have been asked several times about writing some documentation about
70 the GTK port of wxWidgets, especially its internal structures. Obviously,
71 you cannot understand wxGTK without knowing a little about the GTK, but
72 some more information about what the wxWindow, which is the base class
73 for all other window classes, does seems required as well.
77 What does wxWindow do? It contains the common interface for the following
78 jobs of its descendants:
80 1) Define the rudimentary behaviour common to all window classes, such as
81 resizing, intercepting user input (so as to make it possible to use these
82 events for special purposes in a derived class), window names etc.
84 2) Provide the possibility to contain and manage children, if the derived
85 class is allowed to contain children, which holds true for those window
86 classes which do not display a native GTK widget. To name them, these
87 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
88 work classes are a special case and are handled a bit differently from
89 the rest. The same holds true for the wxNotebook class.
91 3) Provide the possibility to draw into a client area of a window. This,
92 too, only holds true for classes that do not display a native GTK widget
95 4) Provide the entire mechanism for scrolling widgets. This actual inter-
96 face for this is usually in wxScrolledWindow, but the GTK implementation
99 5) A multitude of helper or extra methods for special purposes, such as
100 Drag'n'Drop, managing validators etc.
102 6) Display a border (sunken, raised, simple or none).
104 Normally one might expect, that one wxWidgets window would always correspond
105 to one GTK widget. Under GTK, there is no such all-round widget that has all
106 the functionality. Moreover, the GTK defines a client area as a different
107 widget from the actual widget you are handling. Last but not least some
108 special classes (e.g. wxFrame) handle different categories of widgets and
109 still have the possibility to draw something in the client area.
110 It was therefore required to write a special purpose GTK widget, that would
111 represent a client area in the sense of wxWidgets capable to do the jobs
112 2), 3) and 4). I have written this class and it resides in win_gtk.c of
115 All windows must have a widget, with which they interact with other under-
116 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
117 the wxWindow class has a member variable called m_widget which holds a
118 pointer to this widget. When the window class represents a GTK native widget,
119 this is (in most cases) the only GTK widget the class manages. E.g. the
120 wxStaticText class handles only a GtkLabel widget a pointer to which you
121 can find in m_widget (defined in wxWindow)
123 When the class has a client area for drawing into and for containing children
124 it has to handle the client area widget (of the type wxPizza, defined in
125 win_gtk.cpp), but there could be any number of widgets, handled by a class.
126 The common rule for all windows is only, that the widget that interacts with
127 the rest of GTK must be referenced in m_widget and all other widgets must be
128 children of this widget on the GTK level. The top-most widget, which also
129 represents the client area, must be in the m_wxwindow field and must be of
132 As I said, the window classes that display a GTK native widget only have
133 one widget, so in the case of e.g. the wxButton class m_widget holds a
134 pointer to a GtkButton widget. But windows with client areas (for drawing
135 and children) have a m_widget field that is a pointer to a GtkScrolled-
136 Window and a m_wxwindow field that is pointer to a wxPizza and this
137 one is (in the GTK sense) a child of the GtkScrolledWindow.
139 If the m_wxwindow field is set, then all input to this widget is inter-
140 cepted and sent to the wxWidgets class. If not, all input to the widget
141 that gets pointed to by m_widget gets intercepted and sent to the class.
145 The design of scrolling in wxWidgets is markedly different from that offered
146 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
147 clicking on a scrollbar belonging to scrolled window will inevitably move
148 the window. In wxWidgets, the scrollbar will only emit an event, send this
149 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
150 which actually moves the window and its sub-windows. Note that wxPizza
151 memorizes how much it has been scrolled but that wxWidgets forgets this
152 so that the two coordinates systems have to be kept in synch. This is done
153 in various places using the pizza->m_scroll_x and pizza->m_scroll_y values.
157 Singularly the most broken code in GTK is the code that is supposed to
158 inform subwindows (child windows) about new positions. Very often, duplicate
159 events are sent without changes in size or position, equally often no
160 events are sent at all (All this is due to a bug in the GtkContainer code
161 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
162 GTK's own system and it simply waits for size events for toplevel windows
163 and then iterates down the respective size events to all window. This has
164 the disadvantage that windows might get size events before the GTK widget
165 actually has the reported size. This doesn't normally pose any problem, but
166 the OpenGL drawing routines rely on correct behaviour. Therefore, I have
167 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
168 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
169 window that is used for OpenGL output really has that size (as reported by
174 If someone at some point of time feels the immense desire to have a look at,
175 change or attempt to optimise the Refresh() logic, this person will need an
176 intimate understanding of what "draw" and "expose" events are and what
177 they are used for, in particular when used in connection with GTK's
178 own windowless widgets. Beware.
182 Cursors, too, have been a constant source of pleasure. The main difficulty
183 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
184 for the parent. To prevent this from doing too much harm, SetCursor calls
185 GTKUpdateCursor, which will recursively re-set the cursors of all child windows.
186 Also don't forget that cursors (like much else) are connected to GdkWindows,
187 not GtkWidgets and that the "window" field of a GtkWidget might very well
188 point to the GdkWindow of the parent widget (-> "window-less widget") and
189 that the two obviously have very different meanings.
192 //-----------------------------------------------------------------------------
194 //-----------------------------------------------------------------------------
196 // Don't allow event propagation during drag
197 bool g_blockEventsOnDrag
;
198 // Don't allow mouse event propagation during scroll
199 bool g_blockEventsOnScroll
;
200 extern wxCursor g_globalCursor
;
202 // mouse capture state: the window which has it and if the mouse is currently
204 static wxWindowGTK
*g_captureWindow
= NULL
;
205 static bool g_captureWindowHasMouse
= false;
207 // The window that currently has focus:
208 static wxWindowGTK
*gs_currentFocus
= NULL
;
209 // The window that is scheduled to get focus in the next event loop iteration
210 // or NULL if there's no pending focus change:
211 static wxWindowGTK
*gs_pendingFocus
= NULL
;
213 // the window that has deferred focus-out event pending, if any (see
214 // GTKAddDeferredFocusOut() for details)
215 static wxWindowGTK
*gs_deferredFocusOut
= NULL
;
217 // global variables because GTK+ DnD want to have the
218 // mouse event that caused it
219 GdkEvent
*g_lastMouseEvent
= NULL
;
220 int g_lastButtonNumber
= 0;
222 //-----------------------------------------------------------------------------
224 //-----------------------------------------------------------------------------
226 // the trace mask used for the focus debugging messages
227 #define TRACE_FOCUS wxT("focus")
229 //-----------------------------------------------------------------------------
230 // "expose_event"/"draw" from m_wxwindow
231 //-----------------------------------------------------------------------------
235 static gboolean
draw(GtkWidget
*, cairo_t
* cr
, wxWindow
* win
)
237 if (gtk_cairo_should_draw_window(cr
, win
->GTKGetDrawingWindow()))
238 win
->GTKSendPaintEvents(cr
);
243 static gboolean
expose_event(GtkWidget
*, GdkEventExpose
* gdk_event
, wxWindow
* win
)
245 if (gdk_event
->window
== win
->GTKGetDrawingWindow())
246 win
->GTKSendPaintEvents(gdk_event
->region
);
250 #endif // !__WXGTK3__
253 #ifndef __WXUNIVERSAL__
254 //-----------------------------------------------------------------------------
255 // "expose_event"/"draw" from m_wxwindow->parent, for drawing border
256 //-----------------------------------------------------------------------------
261 draw_border(GtkWidget
*, cairo_t
* cr
, wxWindow
* win
)
263 draw_border(GtkWidget
* widget
, GdkEventExpose
* gdk_event
, wxWindow
* win
)
267 if (!gtk_cairo_should_draw_window(cr
, gtk_widget_get_parent_window(win
->m_wxwindow
)))
269 if (gdk_event
->window
!= gtk_widget_get_parent_window(win
->m_wxwindow
))
277 gtk_widget_get_allocation(win
->m_wxwindow
, &alloc
);
278 const int x
= alloc
.x
;
279 const int y
= alloc
.y
;
280 const int w
= alloc
.width
;
281 const int h
= alloc
.height
;
283 if (w
<= 0 || h
<= 0)
286 if (win
->HasFlag(wxBORDER_SIMPLE
))
289 GtkStyleContext
* sc
= gtk_widget_get_style_context(win
->m_wxwindow
);
291 gtk_style_context_get_border_color(sc
, GTK_STATE_FLAG_NORMAL
, &c
);
292 gdk_cairo_set_source_rgba(cr
, &c
);
293 cairo_set_line_width(cr
, 1);
294 cairo_rectangle(cr
, x
+ 0.5, y
+ 0.5, w
- 1, h
- 1);
297 gdk_draw_rectangle(gdk_event
->window
,
298 gtk_widget_get_style(widget
)->black_gc
, false, x
, y
, w
- 1, h
- 1);
301 else if (win
->HasFlag(wxBORDER_RAISED
| wxBORDER_SUNKEN
| wxBORDER_THEME
))
304 //TODO: wxBORDER_RAISED/wxBORDER_SUNKEN
306 if (win
->HasFlag(wxHSCROLL
| wxVSCROLL
))
307 sc
= gtk_widget_get_style_context(wxGTKPrivate::GetTreeWidget());
309 sc
= gtk_widget_get_style_context(wxGTKPrivate::GetEntryWidget());
311 gtk_render_frame(sc
, cr
, x
, y
, w
, h
);
313 GtkShadowType shadow
= GTK_SHADOW_IN
;
314 if (win
->HasFlag(wxBORDER_RAISED
))
315 shadow
= GTK_SHADOW_OUT
;
319 if (win
->HasFlag(wxHSCROLL
| wxVSCROLL
))
321 style
= gtk_widget_get_style(wxGTKPrivate::GetTreeWidget());
326 style
= gtk_widget_get_style(wxGTKPrivate::GetEntryWidget());
330 // clip rect is required to avoid painting background
331 // over upper left (w,h) of parent window
332 GdkRectangle clipRect
= { x
, y
, w
, h
};
334 style
, gdk_event
->window
, GTK_STATE_NORMAL
,
335 shadow
, &clipRect
, widget
, detail
, x
, y
, w
, h
);
336 #endif // !__WXGTK3__
342 //-----------------------------------------------------------------------------
343 // "parent_set" from m_wxwindow
344 //-----------------------------------------------------------------------------
348 parent_set(GtkWidget
* widget
, GtkWidget
* old_parent
, wxWindow
* win
)
352 g_signal_handlers_disconnect_by_func(
353 old_parent
, (void*)draw_border
, win
);
355 GtkWidget
* parent
= gtk_widget_get_parent(widget
);
359 g_signal_connect_after(parent
, "draw", G_CALLBACK(draw_border
), win
);
361 g_signal_connect_after(parent
, "expose_event", G_CALLBACK(draw_border
), win
);
366 #endif // !__WXUNIVERSAL__
368 //-----------------------------------------------------------------------------
369 // "key_press_event" from any window
370 //-----------------------------------------------------------------------------
372 // set WXTRACE to this to see the key event codes on the console
373 #define TRACE_KEYS wxT("keyevent")
375 // translates an X key symbol to WXK_XXX value
377 // if isChar is true it means that the value returned will be used for EVT_CHAR
378 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
379 // for example, while if it is false it means that the value is going to be
380 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
382 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
388 // Shift, Control and Alt don't generate the CHAR events at all
391 key_code
= isChar
? 0 : WXK_SHIFT
;
395 key_code
= isChar
? 0 : WXK_CONTROL
;
403 key_code
= isChar
? 0 : WXK_ALT
;
406 // neither do the toggle modifies
407 case GDK_Scroll_Lock
:
408 key_code
= isChar
? 0 : WXK_SCROLL
;
412 key_code
= isChar
? 0 : WXK_CAPITAL
;
416 key_code
= isChar
? 0 : WXK_NUMLOCK
;
420 // various other special keys
433 case GDK_ISO_Left_Tab
:
440 key_code
= WXK_RETURN
;
444 key_code
= WXK_CLEAR
;
448 key_code
= WXK_PAUSE
;
452 key_code
= WXK_SELECT
;
456 key_code
= WXK_PRINT
;
460 key_code
= WXK_EXECUTE
;
464 key_code
= WXK_ESCAPE
;
467 // cursor and other extended keyboard keys
469 key_code
= WXK_DELETE
;
485 key_code
= WXK_RIGHT
;
492 case GDK_Prior
: // == GDK_Page_Up
493 key_code
= WXK_PAGEUP
;
496 case GDK_Next
: // == GDK_Page_Down
497 key_code
= WXK_PAGEDOWN
;
509 key_code
= WXK_INSERT
;
524 key_code
= (isChar
? '0' : int(WXK_NUMPAD0
)) + keysym
- GDK_KP_0
;
528 key_code
= isChar
? ' ' : int(WXK_NUMPAD_SPACE
);
532 key_code
= isChar
? WXK_TAB
: WXK_NUMPAD_TAB
;
536 key_code
= isChar
? WXK_RETURN
: WXK_NUMPAD_ENTER
;
540 key_code
= isChar
? WXK_F1
: WXK_NUMPAD_F1
;
544 key_code
= isChar
? WXK_F2
: WXK_NUMPAD_F2
;
548 key_code
= isChar
? WXK_F3
: WXK_NUMPAD_F3
;
552 key_code
= isChar
? WXK_F4
: WXK_NUMPAD_F4
;
556 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_HOME
;
560 key_code
= isChar
? WXK_LEFT
: WXK_NUMPAD_LEFT
;
564 key_code
= isChar
? WXK_UP
: WXK_NUMPAD_UP
;
568 key_code
= isChar
? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
572 key_code
= isChar
? WXK_DOWN
: WXK_NUMPAD_DOWN
;
575 case GDK_KP_Prior
: // == GDK_KP_Page_Up
576 key_code
= isChar
? WXK_PAGEUP
: WXK_NUMPAD_PAGEUP
;
579 case GDK_KP_Next
: // == GDK_KP_Page_Down
580 key_code
= isChar
? WXK_PAGEDOWN
: WXK_NUMPAD_PAGEDOWN
;
584 key_code
= isChar
? WXK_END
: WXK_NUMPAD_END
;
588 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_BEGIN
;
592 key_code
= isChar
? WXK_INSERT
: WXK_NUMPAD_INSERT
;
596 key_code
= isChar
? WXK_DELETE
: WXK_NUMPAD_DELETE
;
600 key_code
= isChar
? '=' : int(WXK_NUMPAD_EQUAL
);
603 case GDK_KP_Multiply
:
604 key_code
= isChar
? '*' : int(WXK_NUMPAD_MULTIPLY
);
608 key_code
= isChar
? '+' : int(WXK_NUMPAD_ADD
);
611 case GDK_KP_Separator
:
612 // FIXME: what is this?
613 key_code
= isChar
? '.' : int(WXK_NUMPAD_SEPARATOR
);
616 case GDK_KP_Subtract
:
617 key_code
= isChar
? '-' : int(WXK_NUMPAD_SUBTRACT
);
621 key_code
= isChar
? '.' : int(WXK_NUMPAD_DECIMAL
);
625 key_code
= isChar
? '/' : int(WXK_NUMPAD_DIVIDE
);
642 key_code
= WXK_F1
+ keysym
- GDK_F1
;
652 static inline bool wxIsAsciiKeysym(KeySym ks
)
657 static void wxFillOtherKeyEventFields(wxKeyEvent
& event
,
659 GdkEventKey
*gdk_event
)
661 event
.SetTimestamp( gdk_event
->time
);
662 event
.SetId(win
->GetId());
664 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
665 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
666 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
667 event
.m_metaDown
= (gdk_event
->state
& GDK_META_MASK
) != 0;
669 // At least with current Linux systems, MOD5 corresponds to AltGr key and
670 // we represent it, for consistency with Windows, which really allows to
671 // use Ctrl+Alt as a replacement for AltGr if this key is not present, as a
672 // combination of these two modifiers.
673 if ( gdk_event
->state
& GDK_MOD5_MASK
)
675 event
.m_controlDown
=
676 event
.m_altDown
= true;
679 // Normally we take the state of modifiers directly from the low level GDK
680 // event but unfortunately GDK uses a different convention from MSW for the
681 // key events corresponding to the modifier keys themselves: in it, when
682 // e.g. Shift key is pressed, GDK_SHIFT_MASK is not set while it is set
683 // when Shift is released. Under MSW the situation is exactly reversed and
684 // the modifier corresponding to the key is set when it is pressed and
685 // unset when it is released. To ensure consistent behaviour between
686 // platforms (and because it seems to make slightly more sense, although
687 // arguably both behaviours are reasonable) we follow MSW here.
689 // Final notice: we set the flags to the desired value instead of just
690 // inverting them because they are not set correctly (i.e. in the same way
691 // as for the real events generated by the user) for wxUIActionSimulator-
692 // produced events and it seems better to keep that class code the same
693 // among all platforms and fix the discrepancy here instead of adding
694 // wxGTK-specific code to wxUIActionSimulator.
695 const bool isPress
= gdk_event
->type
== GDK_KEY_PRESS
;
696 switch ( gdk_event
->keyval
)
700 event
.m_shiftDown
= isPress
;
705 event
.m_controlDown
= isPress
;
710 event
.m_altDown
= isPress
;
717 event
.m_metaDown
= isPress
;
721 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
722 event
.m_rawFlags
= gdk_event
->hardware_keycode
;
724 event
.SetEventObject( win
);
729 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
731 GdkEventKey
*gdk_event
)
733 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
734 // but only event->keyval which is quite useless to us, so remember
735 // the last character from GDK_KEY_PRESS and reuse it as last resort
737 // NB: should be MT-safe as we're always called from the main thread only
742 } s_lastKeyPress
= { 0, 0 };
744 KeySym keysym
= gdk_event
->keyval
;
746 wxLogTrace(TRACE_KEYS
, wxT("Key %s event: keysym = %ld"),
747 event
.GetEventType() == wxEVT_KEY_UP
? wxT("release")
751 long key_code
= wxTranslateKeySymToWXKey(keysym
, false /* !isChar */);
755 // do we have the translation or is it a plain ASCII character?
756 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
758 // we should use keysym if it is ASCII as X does some translations
759 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
760 // which we don't want here (but which we do use for OnChar())
761 if ( !wxIsAsciiKeysym(keysym
) )
763 keysym
= (KeySym
)gdk_event
->string
[0];
766 #ifdef GDK_WINDOWING_X11
767 // we want to always get the same key code when the same key is
768 // pressed regardless of the state of the modifiers, i.e. on a
769 // standard US keyboard pressing '5' or '%' ('5' key with
770 // Shift) should result in the same key code in OnKeyDown():
771 // '5' (although OnChar() will get either '5' or '%').
773 // to do it we first translate keysym to keycode (== scan code)
774 // and then back but always using the lower register
775 Display
*dpy
= (Display
*)wxGetDisplay();
776 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
778 wxLogTrace(TRACE_KEYS
, wxT("\t-> keycode %d"), keycode
);
780 #ifdef HAVE_X11_XKBLIB_H
781 KeySym keysymNormalized
= XkbKeycodeToKeysym(dpy
, keycode
, 0, 0);
783 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
786 // use the normalized, i.e. lower register, keysym if we've
788 key_code
= keysymNormalized
? keysymNormalized
: keysym
;
793 // as explained above, we want to have lower register key codes
794 // normally but for the letter keys we want to have the upper ones
796 // NB: don't use XConvertCase() here, we want to do it for letters
798 key_code
= toupper(key_code
);
800 else // non ASCII key, what to do?
802 // by default, ignore it
805 // but if we have cached information from the last KEY_PRESS
806 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
809 if ( keysym
== s_lastKeyPress
.keysym
)
811 key_code
= s_lastKeyPress
.keycode
;
816 if ( gdk_event
->type
== GDK_KEY_PRESS
)
818 // remember it to be reused for KEY_UP event later
819 s_lastKeyPress
.keysym
= keysym
;
820 s_lastKeyPress
.keycode
= key_code
;
824 wxLogTrace(TRACE_KEYS
, wxT("\t-> wxKeyCode %ld"), key_code
);
826 // sending unknown key events doesn't really make sense
830 event
.m_keyCode
= key_code
;
833 event
.m_uniChar
= gdk_keyval_to_unicode(key_code
? key_code
: keysym
);
834 if ( !event
.m_uniChar
&& event
.m_keyCode
<= WXK_DELETE
)
836 // Set Unicode key code to the ASCII equivalent for compatibility. E.g.
837 // let RETURN generate the key event with both key and Unicode key
839 event
.m_uniChar
= event
.m_keyCode
;
841 #endif // wxUSE_UNICODE
843 // now fill all the other fields
844 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
852 GtkIMContext
*context
;
853 GdkEventKey
*lastKeyEvent
;
857 context
= gtk_im_multicontext_new();
862 g_object_unref (context
);
869 // Send wxEVT_CHAR_HOOK event to the parent of the window and return true only
870 // if it was processed (and not skipped).
871 bool SendCharHookEvent(const wxKeyEvent
& event
, wxWindow
*win
)
873 // wxEVT_CHAR_HOOK must be sent to allow the parent windows (e.g. a dialog
874 // which typically closes when Esc key is pressed in any of its controls)
875 // to handle key events in all of its children unless the mouse is captured
876 // in which case we consider that the keyboard should be "captured" too.
877 if ( !g_captureWindow
)
879 wxKeyEvent
eventCharHook(wxEVT_CHAR_HOOK
, event
);
880 if ( win
->HandleWindowEvent(eventCharHook
)
881 && !event
.IsNextEventAllowed() )
888 // Adjust wxEVT_CHAR event key code fields. This function takes care of two
890 // (a) Ctrl-letter key presses generate key codes in range 1..26
891 // (b) Unicode key codes are same as key codes for the codes in 1..255 range
892 void AdjustCharEventKeyCodes(wxKeyEvent
& event
)
894 const int code
= event
.m_keyCode
;
896 // Check for (a) above.
897 if ( event
.ControlDown() )
899 // We intentionally don't use isupper/lower() here, we really need
900 // ASCII letters only as it doesn't make sense to translate any other
901 // ones into this range which has only 26 slots.
902 if ( code
>= 'a' && code
<= 'z' )
903 event
.m_keyCode
= code
- 'a' + 1;
904 else if ( code
>= 'A' && code
<= 'Z' )
905 event
.m_keyCode
= code
- 'A' + 1;
908 // Adjust the Unicode equivalent in the same way too.
909 if ( event
.m_keyCode
!= code
)
910 event
.m_uniChar
= event
.m_keyCode
;
911 #endif // wxUSE_UNICODE
915 // Check for (b) from above.
917 // FIXME: Should we do it for key codes up to 255?
918 if ( !event
.m_uniChar
&& code
< WXK_DELETE
)
919 event
.m_uniChar
= code
;
920 #endif // wxUSE_UNICODE
923 } // anonymous namespace
925 // If a widget does not handle a key or mouse event, GTK+ sends it up the
926 // parent chain until it is handled. These events are not supposed to propagate
927 // in wxWidgets, so this code avoids handling them in any parent wxWindow,
928 // while still allowing the event to propagate so things like native keyboard
929 // navigation will work.
930 #define wxPROCESS_EVENT_ONCE(EventType, event) \
931 static EventType eventPrev; \
932 if (memcmp(&eventPrev, event, sizeof(EventType)) == 0) \
938 gtk_window_key_press_callback( GtkWidget
*WXUNUSED(widget
),
939 GdkEventKey
*gdk_event
,
944 if (g_blockEventsOnDrag
)
947 wxPROCESS_EVENT_ONCE(GdkEventKey
, gdk_event
);
949 wxKeyEvent
event( wxEVT_KEY_DOWN
);
951 bool return_after_IM
= false;
953 if( wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
955 // Send the CHAR_HOOK event first
956 if ( SendCharHookEvent(event
, win
) )
958 // Don't do anything at all with this event any more.
962 // Next check for accelerators.
964 wxWindowGTK
*ancestor
= win
;
967 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
970 wxCommandEvent
menu_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
971 ret
= ancestor
->HandleWindowEvent( menu_event
);
975 // if the accelerator wasn't handled as menu event, try
976 // it as button click (for compatibility with other
978 wxCommandEvent
button_event( wxEVT_COMMAND_BUTTON_CLICKED
, command
);
979 ret
= ancestor
->HandleWindowEvent( button_event
);
984 if (ancestor
->IsTopLevel())
986 ancestor
= ancestor
->GetParent();
988 #endif // wxUSE_ACCEL
990 // If not an accelerator, then emit KEY_DOWN event
992 ret
= win
->HandleWindowEvent( event
);
996 // Return after IM processing as we cannot do
997 // anything with it anyhow.
998 return_after_IM
= true;
1001 if (!ret
&& win
->m_imData
)
1003 win
->m_imData
->lastKeyEvent
= gdk_event
;
1005 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
1006 // docs, if IM filter returns true, no further processing should be done.
1007 // we should send the key_down event anyway.
1008 bool intercepted_by_IM
=
1009 gtk_im_context_filter_keypress(win
->m_imData
->context
, gdk_event
) != 0;
1010 win
->m_imData
->lastKeyEvent
= NULL
;
1011 if (intercepted_by_IM
)
1013 wxLogTrace(TRACE_KEYS
, wxT("Key event intercepted by IM"));
1018 if (return_after_IM
)
1021 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1022 // will only be sent if it is not in an accelerator table.
1025 KeySym keysym
= gdk_event
->keyval
;
1026 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1027 long key_code
= wxTranslateKeySymToWXKey(keysym
, true /* isChar */);
1030 if ( wxIsAsciiKeysym(keysym
) )
1033 key_code
= (unsigned char)keysym
;
1035 // gdk_event->string is actually deprecated
1036 else if ( gdk_event
->length
== 1 )
1038 key_code
= (unsigned char)gdk_event
->string
[0];
1044 wxKeyEvent
eventChar(wxEVT_CHAR
, event
);
1046 wxLogTrace(TRACE_KEYS
, wxT("Char event: %ld"), key_code
);
1048 eventChar
.m_keyCode
= key_code
;
1050 eventChar
.m_uniChar
= gdk_keyval_to_unicode(key_code
);
1051 #endif // wxUSE_UNICODE
1053 AdjustCharEventKeyCodes(eventChar
);
1055 ret
= win
->HandleWindowEvent(eventChar
);
1065 gtk_wxwindow_commit_cb (GtkIMContext
* WXUNUSED(context
),
1069 wxKeyEvent
event( wxEVT_CHAR
);
1071 // take modifiers, cursor position, timestamp etc. from the last
1072 // key_press_event that was fed into Input Method:
1073 if (window
->m_imData
->lastKeyEvent
)
1075 wxFillOtherKeyEventFields(event
,
1076 window
, window
->m_imData
->lastKeyEvent
);
1080 event
.SetEventObject( window
);
1083 const wxString
data(wxGTK_CONV_BACK_SYS(str
));
1087 for( wxString::const_iterator pstr
= data
.begin(); pstr
!= data
.end(); ++pstr
)
1090 event
.m_uniChar
= *pstr
;
1091 // Backward compatible for ISO-8859-1
1092 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
1093 wxLogTrace(TRACE_KEYS
, wxT("IM sent character '%c'"), event
.m_uniChar
);
1095 event
.m_keyCode
= (char)*pstr
;
1096 #endif // wxUSE_UNICODE
1098 AdjustCharEventKeyCodes(event
);
1100 window
->HandleWindowEvent(event
);
1106 //-----------------------------------------------------------------------------
1107 // "key_release_event" from any window
1108 //-----------------------------------------------------------------------------
1112 gtk_window_key_release_callback( GtkWidget
* WXUNUSED(widget
),
1113 GdkEventKey
*gdk_event
,
1119 if (g_blockEventsOnDrag
)
1122 wxPROCESS_EVENT_ONCE(GdkEventKey
, gdk_event
);
1124 wxKeyEvent
event( wxEVT_KEY_UP
);
1125 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1127 // unknown key pressed, ignore (the event would be useless anyhow)
1131 return win
->GTKProcessEvent(event
);
1135 // ============================================================================
1137 // ============================================================================
1139 // ----------------------------------------------------------------------------
1140 // mouse event processing helpers
1141 // ----------------------------------------------------------------------------
1143 static void AdjustEventButtonState(wxMouseEvent
& event
)
1145 // GDK reports the old state of the button for a button press event, but
1146 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1147 // for a LEFT_DOWN event, not FALSE, so we will invert
1148 // left/right/middleDown for the corresponding click events
1150 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1151 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1152 (event
.GetEventType() == wxEVT_LEFT_UP
))
1154 event
.m_leftDown
= !event
.m_leftDown
;
1158 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1159 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1160 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1162 event
.m_middleDown
= !event
.m_middleDown
;
1166 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1167 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1168 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1170 event
.m_rightDown
= !event
.m_rightDown
;
1174 if ((event
.GetEventType() == wxEVT_AUX1_DOWN
) ||
1175 (event
.GetEventType() == wxEVT_AUX1_DCLICK
))
1177 event
.m_aux1Down
= true;
1181 if ((event
.GetEventType() == wxEVT_AUX2_DOWN
) ||
1182 (event
.GetEventType() == wxEVT_AUX2_DCLICK
))
1184 event
.m_aux2Down
= true;
1189 // find the window to send the mouse event to
1191 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1196 if (win
->m_wxwindow
)
1198 wxPizza
* pizza
= WX_PIZZA(win
->m_wxwindow
);
1199 xx
+= pizza
->m_scroll_x
;
1200 yy
+= pizza
->m_scroll_y
;
1203 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
1206 wxWindow
* child
= static_cast<wxWindow
*>(node
->GetData());
1208 node
= node
->GetNext();
1209 if (!child
->IsShown())
1212 if (child
->GTKIsTransparentForMouse())
1214 // wxStaticBox is transparent in the box itself
1215 int xx1
= child
->m_x
;
1216 int yy1
= child
->m_y
;
1217 int xx2
= child
->m_x
+ child
->m_width
;
1218 int yy2
= child
->m_y
+ child
->m_height
;
1221 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1223 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1225 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1227 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1238 if ((child
->m_wxwindow
== NULL
) &&
1239 win
->IsClientAreaChild(child
) &&
1240 (child
->m_x
<= xx
) &&
1241 (child
->m_y
<= yy
) &&
1242 (child
->m_x
+child
->m_width
>= xx
) &&
1243 (child
->m_y
+child
->m_height
>= yy
))
1256 // ----------------------------------------------------------------------------
1257 // common event handlers helpers
1258 // ----------------------------------------------------------------------------
1260 bool wxWindowGTK::GTKProcessEvent(wxEvent
& event
) const
1262 // nothing special at this level
1263 return HandleWindowEvent(event
);
1266 bool wxWindowGTK::GTKShouldIgnoreEvent() const
1268 return !m_hasVMT
|| g_blockEventsOnDrag
;
1271 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny
*event
) const
1275 if (g_blockEventsOnDrag
)
1277 if (g_blockEventsOnScroll
)
1280 if (!GTKIsOwnWindow(event
->window
))
1286 // overloads for all GDK event types we use here: we need to have this as
1287 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1288 // derives from it in the sense that the structs have the same layout
1289 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1290 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1292 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1295 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton
)
1296 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion
)
1297 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing
)
1299 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1301 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1302 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1306 // all event handlers must have C linkage as they're called from GTK+ C code
1310 //-----------------------------------------------------------------------------
1311 // "button_press_event"
1312 //-----------------------------------------------------------------------------
1315 gtk_window_button_press_callback( GtkWidget
* WXUNUSED_IN_GTK3(widget
),
1316 GdkEventButton
*gdk_event
,
1319 wxPROCESS_EVENT_ONCE(GdkEventButton
, gdk_event
);
1321 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1323 g_lastButtonNumber
= gdk_event
->button
;
1325 wxEventType event_type
;
1328 switch (gdk_event
->button
)
1331 down
= wxEVT_LEFT_DOWN
;
1332 dclick
= wxEVT_LEFT_DCLICK
;
1335 down
= wxEVT_MIDDLE_DOWN
;
1336 dclick
= wxEVT_MIDDLE_DCLICK
;
1339 down
= wxEVT_RIGHT_DOWN
;
1340 dclick
= wxEVT_RIGHT_DCLICK
;
1343 down
= wxEVT_AUX1_DOWN
;
1344 dclick
= wxEVT_AUX1_DCLICK
;
1347 down
= wxEVT_AUX2_DOWN
;
1348 dclick
= wxEVT_AUX2_DCLICK
;
1353 switch (gdk_event
->type
)
1355 case GDK_BUTTON_PRESS
:
1357 // GDK sends surplus button down events
1358 // before a double click event. We
1359 // need to filter these out.
1360 if (win
->m_wxwindow
)
1362 GdkEvent
* peek_event
= gdk_event_peek();
1365 const GdkEventType peek_event_type
= peek_event
->type
;
1366 gdk_event_free(peek_event
);
1367 if (peek_event_type
== GDK_2BUTTON_PRESS
||
1368 peek_event_type
== GDK_3BUTTON_PRESS
)
1375 case GDK_2BUTTON_PRESS
:
1376 event_type
= dclick
;
1378 if (gdk_event
->button
>= 1 && gdk_event
->button
<= 3)
1380 // Reset GDK internal timestamp variables in order to disable GDK
1381 // triple click events. GDK will then next time believe no button has
1382 // been clicked just before, and send a normal button click event.
1383 GdkDisplay
* display
= gtk_widget_get_display(widget
);
1384 display
->button_click_time
[1] = 0;
1385 display
->button_click_time
[0] = 0;
1387 #endif // !__WXGTK3__
1389 // we shouldn't get triple clicks at all for GTK2 because we
1390 // suppress them artificially using the code above but we still
1391 // should map them to something for GTK3 and not just ignore them
1392 // as this would lose clicks
1393 case GDK_3BUTTON_PRESS
:
1400 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1402 wxMouseEvent
event( event_type
);
1403 InitMouseEvent( win
, event
, gdk_event
);
1405 AdjustEventButtonState(event
);
1407 // find the correct window to send the event to: it may be a different one
1408 // from the one which got it at GTK+ level because some controls don't have
1409 // their own X window and thus cannot get any events.
1410 if ( !g_captureWindow
)
1411 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1413 // reset the event object and id in case win changed.
1414 event
.SetEventObject( win
);
1415 event
.SetId( win
->GetId() );
1417 bool ret
= win
->GTKProcessEvent( event
);
1418 g_lastMouseEvent
= NULL
;
1422 if ((event_type
== wxEVT_LEFT_DOWN
) && !win
->IsOfStandardClass() &&
1423 (gs_currentFocus
!= win
) /* && win->IsFocusable() */)
1428 if (event_type
== wxEVT_RIGHT_DOWN
)
1430 // generate a "context menu" event: this is similar to right mouse
1431 // click under many GUIs except that it is generated differently
1432 // (right up under MSW, ctrl-click under Mac, right down here) and
1434 // (a) it's a command event and so is propagated to the parent
1435 // (b) under some ports it can be generated from kbd too
1436 // (c) it uses screen coords (because of (a))
1437 wxContextMenuEvent
evtCtx(
1440 win
->ClientToScreen(event
.GetPosition()));
1441 evtCtx
.SetEventObject(win
);
1442 return win
->GTKProcessEvent(evtCtx
);
1448 //-----------------------------------------------------------------------------
1449 // "button_release_event"
1450 //-----------------------------------------------------------------------------
1453 gtk_window_button_release_callback( GtkWidget
*WXUNUSED(widget
),
1454 GdkEventButton
*gdk_event
,
1457 wxPROCESS_EVENT_ONCE(GdkEventButton
, gdk_event
);
1459 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1461 g_lastButtonNumber
= 0;
1463 wxEventType event_type
= wxEVT_NULL
;
1465 switch (gdk_event
->button
)
1468 event_type
= wxEVT_LEFT_UP
;
1472 event_type
= wxEVT_MIDDLE_UP
;
1476 event_type
= wxEVT_RIGHT_UP
;
1480 event_type
= wxEVT_AUX1_UP
;
1484 event_type
= wxEVT_AUX2_UP
;
1488 // unknown button, don't process
1492 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1494 wxMouseEvent
event( event_type
);
1495 InitMouseEvent( win
, event
, gdk_event
);
1497 AdjustEventButtonState(event
);
1499 if ( !g_captureWindow
)
1500 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1502 // reset the event object and id in case win changed.
1503 event
.SetEventObject( win
);
1504 event
.SetId( win
->GetId() );
1506 bool ret
= win
->GTKProcessEvent(event
);
1508 g_lastMouseEvent
= NULL
;
1513 //-----------------------------------------------------------------------------
1514 // "motion_notify_event"
1515 //-----------------------------------------------------------------------------
1518 gtk_window_motion_notify_callback( GtkWidget
* WXUNUSED(widget
),
1519 GdkEventMotion
*gdk_event
,
1522 wxPROCESS_EVENT_ONCE(GdkEventMotion
, gdk_event
);
1524 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1526 if (gdk_event
->is_hint
)
1530 GdkModifierType state
;
1531 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1536 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1538 wxMouseEvent
event( wxEVT_MOTION
);
1539 InitMouseEvent(win
, event
, gdk_event
);
1541 if ( g_captureWindow
)
1543 // synthesise a mouse enter or leave event if needed
1544 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1545 // This seems to be necessary and actually been added to
1546 // GDK itself in version 2.0.X
1549 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1550 if ( hasMouse
!= g_captureWindowHasMouse
)
1552 // the mouse changed window
1553 g_captureWindowHasMouse
= hasMouse
;
1555 wxMouseEvent
eventM(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1556 : wxEVT_LEAVE_WINDOW
);
1557 InitMouseEvent(win
, eventM
, gdk_event
);
1558 eventM
.SetEventObject(win
);
1559 win
->GTKProcessEvent(eventM
);
1564 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1566 // reset the event object and id in case win changed.
1567 event
.SetEventObject( win
);
1568 event
.SetId( win
->GetId() );
1571 if ( !g_captureWindow
)
1573 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1574 if (win
->GTKProcessEvent( cevent
))
1576 win
->SetCursor( cevent
.GetCursor() );
1580 bool ret
= win
->GTKProcessEvent(event
);
1582 g_lastMouseEvent
= NULL
;
1587 //-----------------------------------------------------------------------------
1588 // "scroll_event" (mouse wheel event)
1589 //-----------------------------------------------------------------------------
1592 window_scroll_event_hscrollbar(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1594 if (gdk_event
->direction
!= GDK_SCROLL_LEFT
&&
1595 gdk_event
->direction
!= GDK_SCROLL_RIGHT
)
1600 GtkRange
*range
= win
->m_scrollBar
[wxWindow::ScrollDir_Horz
];
1602 if (range
&& gtk_widget_get_visible(GTK_WIDGET(range
)))
1604 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
1605 double delta
= gtk_adjustment_get_step_increment(adj
) * 3;
1606 if (gdk_event
->direction
== GDK_SCROLL_LEFT
)
1609 gtk_range_set_value(range
, gtk_adjustment_get_value(adj
) + delta
);
1618 window_scroll_event(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1620 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1621 InitMouseEvent(win
, event
, gdk_event
);
1623 // FIXME: Get these values from GTK or GDK
1624 event
.m_linesPerAction
= 3;
1625 event
.m_wheelDelta
= 120;
1627 // Determine the scroll direction.
1628 switch (gdk_event
->direction
)
1631 case GDK_SCROLL_RIGHT
:
1632 event
.m_wheelRotation
= 120;
1635 case GDK_SCROLL_DOWN
:
1636 case GDK_SCROLL_LEFT
:
1637 event
.m_wheelRotation
= -120;
1641 return false; // Unknown/unhandled direction
1644 // And the scroll axis.
1645 switch (gdk_event
->direction
)
1648 case GDK_SCROLL_DOWN
:
1649 event
.m_wheelAxis
= wxMOUSE_WHEEL_VERTICAL
;
1652 case GDK_SCROLL_LEFT
:
1653 case GDK_SCROLL_RIGHT
:
1654 event
.m_wheelAxis
= wxMOUSE_WHEEL_HORIZONTAL
;
1658 if (win
->GTKProcessEvent(event
))
1661 GtkRange
*range
= win
->m_scrollBar
[wxWindow::ScrollDir_Vert
];
1663 if (range
&& gtk_widget_get_visible(GTK_WIDGET(range
)))
1665 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
1666 double delta
= gtk_adjustment_get_step_increment(adj
) * 3;
1667 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1670 gtk_range_set_value(range
, gtk_adjustment_get_value(adj
) + delta
);
1678 //-----------------------------------------------------------------------------
1680 //-----------------------------------------------------------------------------
1682 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
1684 wxContextMenuEvent
event(wxEVT_CONTEXT_MENU
, win
->GetId(), wxPoint(-1, -1));
1685 event
.SetEventObject(win
);
1686 return win
->GTKProcessEvent(event
);
1689 //-----------------------------------------------------------------------------
1691 //-----------------------------------------------------------------------------
1694 gtk_window_focus_in_callback( GtkWidget
* WXUNUSED(widget
),
1695 GdkEventFocus
*WXUNUSED(event
),
1698 return win
->GTKHandleFocusIn();
1701 //-----------------------------------------------------------------------------
1702 // "focus_out_event"
1703 //-----------------------------------------------------------------------------
1706 gtk_window_focus_out_callback( GtkWidget
* WXUNUSED(widget
),
1707 GdkEventFocus
* WXUNUSED(gdk_event
),
1710 return win
->GTKHandleFocusOut();
1713 //-----------------------------------------------------------------------------
1715 //-----------------------------------------------------------------------------
1718 wx_window_focus_callback(GtkWidget
*widget
,
1719 GtkDirectionType
WXUNUSED(direction
),
1722 // the default handler for focus signal in GtkScrolledWindow sets
1723 // focus to the window itself even if it doesn't accept focus, i.e. has no
1724 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1725 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1726 // any children which might accept focus (we know we don't accept the focus
1727 // ourselves as this signal is only connected in this case)
1728 if ( win
->GetChildren().empty() )
1729 g_signal_stop_emission_by_name(widget
, "focus");
1731 // we didn't change the focus
1735 //-----------------------------------------------------------------------------
1736 // "enter_notify_event"
1737 //-----------------------------------------------------------------------------
1740 gtk_window_enter_callback( GtkWidget
*widget
,
1741 GdkEventCrossing
*gdk_event
,
1744 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1746 // Event was emitted after a grab
1747 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1751 GdkModifierType state
= (GdkModifierType
)0;
1753 gdk_window_get_pointer(gtk_widget_get_window(widget
), &x
, &y
, &state
);
1755 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1756 InitMouseEvent(win
, event
, gdk_event
);
1757 wxPoint pt
= win
->GetClientAreaOrigin();
1758 event
.m_x
= x
+ pt
.x
;
1759 event
.m_y
= y
+ pt
.y
;
1761 if ( !g_captureWindow
)
1763 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1764 if (win
->GTKProcessEvent( cevent
))
1766 win
->SetCursor( cevent
.GetCursor() );
1770 return win
->GTKProcessEvent(event
);
1773 //-----------------------------------------------------------------------------
1774 // "leave_notify_event"
1775 //-----------------------------------------------------------------------------
1778 gtk_window_leave_callback( GtkWidget
*widget
,
1779 GdkEventCrossing
*gdk_event
,
1782 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1784 // Event was emitted after an ungrab
1785 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1787 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1791 GdkModifierType state
= (GdkModifierType
)0;
1793 gdk_window_get_pointer(gtk_widget_get_window(widget
), &x
, &y
, &state
);
1795 InitMouseEvent(win
, event
, gdk_event
);
1797 return win
->GTKProcessEvent(event
);
1800 //-----------------------------------------------------------------------------
1801 // "value_changed" from scrollbar
1802 //-----------------------------------------------------------------------------
1805 gtk_scrollbar_value_changed(GtkRange
* range
, wxWindow
* win
)
1807 wxEventType eventType
= win
->GTKGetScrollEventType(range
);
1808 if (eventType
!= wxEVT_NULL
)
1810 // Convert scroll event type to scrollwin event type
1811 eventType
+= wxEVT_SCROLLWIN_TOP
- wxEVT_SCROLL_TOP
;
1813 // find the scrollbar which generated the event
1814 wxWindowGTK::ScrollDir dir
= win
->ScrollDirFromRange(range
);
1816 // generate the corresponding wx event
1817 const int orient
= wxWindow::OrientFromScrollDir(dir
);
1818 wxScrollWinEvent
event(eventType
, win
->GetScrollPos(orient
), orient
);
1819 event
.SetEventObject(win
);
1821 win
->GTKProcessEvent(event
);
1825 //-----------------------------------------------------------------------------
1826 // "button_press_event" from scrollbar
1827 //-----------------------------------------------------------------------------
1830 gtk_scrollbar_button_press_event(GtkRange
*, GdkEventButton
*, wxWindow
* win
)
1832 g_blockEventsOnScroll
= true;
1833 win
->m_mouseButtonDown
= true;
1838 //-----------------------------------------------------------------------------
1839 // "event_after" from scrollbar
1840 //-----------------------------------------------------------------------------
1843 gtk_scrollbar_event_after(GtkRange
* range
, GdkEvent
* event
, wxWindow
* win
)
1845 if (event
->type
== GDK_BUTTON_RELEASE
)
1847 g_signal_handlers_block_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1849 const int orient
= wxWindow::OrientFromScrollDir(
1850 win
->ScrollDirFromRange(range
));
1851 wxScrollWinEvent
evt(wxEVT_SCROLLWIN_THUMBRELEASE
,
1852 win
->GetScrollPos(orient
), orient
);
1853 evt
.SetEventObject(win
);
1854 win
->GTKProcessEvent(evt
);
1858 //-----------------------------------------------------------------------------
1859 // "button_release_event" from scrollbar
1860 //-----------------------------------------------------------------------------
1863 gtk_scrollbar_button_release_event(GtkRange
* range
, GdkEventButton
*, wxWindow
* win
)
1865 g_blockEventsOnScroll
= false;
1866 win
->m_mouseButtonDown
= false;
1867 // If thumb tracking
1868 if (win
->m_isScrolling
)
1870 win
->m_isScrolling
= false;
1871 // Hook up handler to send thumb release event after this emission is finished.
1872 // To allow setting scroll position from event handler, sending event must
1873 // be deferred until after the GtkRange handler for this signal has run
1874 g_signal_handlers_unblock_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1880 //-----------------------------------------------------------------------------
1881 // "realize" from m_widget
1882 //-----------------------------------------------------------------------------
1885 gtk_window_realized_callback(GtkWidget
* WXUNUSED(widget
), wxWindowGTK
* win
)
1887 win
->GTKHandleRealized();
1890 //-----------------------------------------------------------------------------
1891 // "size_allocate" from m_wxwindow or m_widget
1892 //-----------------------------------------------------------------------------
1895 size_allocate(GtkWidget
*, GtkAllocation
* alloc
, wxWindow
* win
)
1897 int w
= alloc
->width
;
1898 int h
= alloc
->height
;
1899 if (win
->m_wxwindow
)
1902 WX_PIZZA(win
->m_wxwindow
)->get_border(border
);
1903 w
-= border
.left
+ border
.right
;
1904 h
-= border
.top
+ border
.bottom
;
1908 if (win
->m_oldClientWidth
!= w
|| win
->m_oldClientHeight
!= h
)
1910 win
->m_oldClientWidth
= w
;
1911 win
->m_oldClientHeight
= h
;
1912 // this callback can be connected to m_wxwindow,
1913 // so always get size from m_widget->allocation
1915 gtk_widget_get_allocation(win
->m_widget
, &a
);
1916 win
->m_width
= a
.width
;
1917 win
->m_height
= a
.height
;
1918 if (!win
->m_nativeSizeEvent
)
1920 wxSizeEvent
event(win
->GetSize(), win
->GetId());
1921 event
.SetEventObject(win
);
1922 win
->GTKProcessEvent(event
);
1927 //-----------------------------------------------------------------------------
1929 //-----------------------------------------------------------------------------
1931 #if GTK_CHECK_VERSION(2, 8, 0)
1933 gtk_window_grab_broken( GtkWidget
*,
1934 GdkEventGrabBroken
*event
,
1937 // Mouse capture has been lost involuntarily, notify the application
1938 if(!event
->keyboard
&& wxWindow::GetCapture() == win
)
1940 wxMouseCaptureLostEvent
evt( win
->GetId() );
1941 evt
.SetEventObject( win
);
1942 win
->HandleWindowEvent( evt
);
1948 //-----------------------------------------------------------------------------
1949 // "style_set"/"style_updated"
1950 //-----------------------------------------------------------------------------
1953 static void style_updated(GtkWidget
*, wxWindow
* win
)
1955 static void style_updated(GtkWidget
*, GtkStyle
*, wxWindow
* win
)
1958 if (win
->IsTopLevel())
1960 wxSysColourChangedEvent event
;
1961 event
.SetEventObject(win
);
1962 win
->GTKProcessEvent(event
);
1966 // Border width could change, which will change client size.
1967 // Make sure size event occurs for this
1968 win
->m_oldClientWidth
= 0;
1972 //-----------------------------------------------------------------------------
1974 //-----------------------------------------------------------------------------
1976 static void unrealize(GtkWidget
*, wxWindow
* win
)
1978 win
->GTKHandleUnrealize();
1983 void wxWindowGTK::GTKHandleRealized()
1990 gtk_im_context_set_client_window
1993 m_wxwindow
? GTKGetDrawingWindow()
1994 : gtk_widget_get_window(m_widget
)
1998 // Use composited window if background is transparent, if supported.
1999 if (m_backgroundStyle
== wxBG_STYLE_TRANSPARENT
)
2001 #if wxGTK_HAS_COMPOSITING_SUPPORT
2002 if (IsTransparentBackgroundSupported())
2004 GdkWindow
* const window
= GTKGetDrawingWindow();
2006 gdk_window_set_composited(window
, true);
2009 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
2011 // We revert to erase mode if transparency is not supported
2012 m_backgroundStyle
= wxBG_STYLE_ERASE
;
2017 // We cannot set colours and fonts before the widget
2018 // been realized, so we do this directly after realization
2019 // or otherwise in idle time
2021 if (m_needsStyleChange
)
2023 SetBackgroundStyle(GetBackgroundStyle());
2024 m_needsStyleChange
= false;
2027 wxWindowCreateEvent
event(static_cast<wxWindow
*>(this));
2028 event
.SetEventObject( this );
2029 GTKProcessEvent( event
);
2031 GTKUpdateCursor(true, false);
2034 (IsTopLevel() || HasFlag(wxBORDER_RAISED
| wxBORDER_SUNKEN
| wxBORDER_THEME
)))
2036 // attaching to style changed signal after realization avoids initial
2037 // changes we don't care about
2038 const gchar
*detailed_signal
=
2044 g_signal_connect(m_wxwindow
,
2046 G_CALLBACK(style_updated
), this);
2050 void wxWindowGTK::GTKHandleUnrealize()
2052 // unrealizing a frozen window seems to have some lingering effect
2053 // preventing updates to the affected area
2060 gtk_im_context_set_client_window(m_imData
->context
, NULL
);
2062 g_signal_handlers_disconnect_by_func(
2063 m_wxwindow
, (void*)style_updated
, this);
2067 // ----------------------------------------------------------------------------
2068 // this wxWindowBase function is implemented here (in platform-specific file)
2069 // because it is static and so couldn't be made virtual
2070 // ----------------------------------------------------------------------------
2072 wxWindow
*wxWindowBase::DoFindFocus()
2074 // For compatibility with wxMSW, pretend that showing a popup menu doesn't
2075 // change the focus and that it remains on the window showing it, even
2076 // though the real focus does change in GTK.
2077 extern wxMenu
*wxCurrentPopupMenu
;
2078 if ( wxCurrentPopupMenu
)
2079 return wxCurrentPopupMenu
->GetInvokingWindow();
2081 wxWindowGTK
*focus
= gs_pendingFocus
? gs_pendingFocus
: gs_currentFocus
;
2082 // the cast is necessary when we compile in wxUniversal mode
2083 return static_cast<wxWindow
*>(focus
);
2086 void wxWindowGTK::AddChildGTK(wxWindowGTK
* child
)
2088 wxASSERT_MSG(m_wxwindow
, "Cannot add a child to a window without a client area");
2090 // the window might have been scrolled already, we
2091 // have to adapt the position
2092 wxPizza
* pizza
= WX_PIZZA(m_wxwindow
);
2093 child
->m_x
+= pizza
->m_scroll_x
;
2094 child
->m_y
+= pizza
->m_scroll_y
;
2096 pizza
->put(child
->m_widget
,
2097 child
->m_x
, child
->m_y
, child
->m_width
, child
->m_height
);
2100 //-----------------------------------------------------------------------------
2102 //-----------------------------------------------------------------------------
2104 wxWindow
*wxGetActiveWindow()
2106 return wxWindow::FindFocus();
2110 // Under Unix this is implemented using X11 functions in utilsx11.cpp but we
2111 // need to have this function under Windows too, so provide at least a stub.
2112 #ifndef GDK_WINDOWING_X11
2113 bool wxGetKeyState(wxKeyCode
WXUNUSED(key
))
2115 wxFAIL_MSG(wxS("Not implemented under Windows"));
2118 #endif // __WINDOWS__
2120 static void GetMouseState(int& x
, int& y
, GdkModifierType
& mask
)
2122 wxWindow
* tlw
= NULL
;
2123 if (!wxTopLevelWindows
.empty())
2124 tlw
= wxTopLevelWindows
.front();
2125 GdkDisplay
* display
;
2126 if (tlw
&& tlw
->m_widget
)
2127 display
= gtk_widget_get_display(tlw
->m_widget
);
2129 display
= gdk_display_get_default();
2130 gdk_display_get_pointer(display
, NULL
, &x
, &y
, &mask
);
2133 wxMouseState
wxGetMouseState()
2139 GdkModifierType mask
;
2141 GetMouseState(x
, y
, mask
);
2145 ms
.SetLeftDown((mask
& GDK_BUTTON1_MASK
) != 0);
2146 ms
.SetMiddleDown((mask
& GDK_BUTTON2_MASK
) != 0);
2147 ms
.SetRightDown((mask
& GDK_BUTTON3_MASK
) != 0);
2148 // see the comment in InitMouseEvent()
2149 ms
.SetAux1Down((mask
& GDK_BUTTON4_MASK
) != 0);
2150 ms
.SetAux2Down((mask
& GDK_BUTTON5_MASK
) != 0);
2152 ms
.SetControlDown((mask
& GDK_CONTROL_MASK
) != 0);
2153 ms
.SetShiftDown((mask
& GDK_SHIFT_MASK
) != 0);
2154 ms
.SetAltDown((mask
& GDK_MOD1_MASK
) != 0);
2155 ms
.SetMetaDown((mask
& GDK_META_MASK
) != 0);
2160 //-----------------------------------------------------------------------------
2162 //-----------------------------------------------------------------------------
2164 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2166 #ifdef __WXUNIVERSAL__
2167 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2168 #endif // __WXUNIVERSAL__
2170 void wxWindowGTK::Init()
2175 m_focusWidget
= NULL
;
2185 m_showOnIdle
= false;
2188 m_nativeSizeEvent
= false;
2190 m_paintContext
= NULL
;
2193 m_isScrolling
= false;
2194 m_mouseButtonDown
= false;
2196 // initialize scrolling stuff
2197 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2199 m_scrollBar
[dir
] = NULL
;
2200 m_scrollPos
[dir
] = 0;
2204 m_oldClientHeight
= 0;
2206 m_clipPaintRegion
= false;
2208 m_needsStyleChange
= false;
2210 m_cursor
= *wxSTANDARD_CURSOR
;
2213 m_dirtyTabOrder
= false;
2216 wxWindowGTK::wxWindowGTK()
2221 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2226 const wxString
&name
)
2230 Create( parent
, id
, pos
, size
, style
, name
);
2233 void wxWindowGTK::GTKCreateScrolledWindowWith(GtkWidget
* view
)
2235 wxASSERT_MSG( HasFlag(wxHSCROLL
) || HasFlag(wxVSCROLL
),
2236 wxS("Must not be called if scrolling is not needed.") );
2238 m_widget
= gtk_scrolled_window_new( NULL
, NULL
);
2240 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2242 // There is a conflict with default bindings at GTK+
2243 // level between scrolled windows and notebooks both of which want to use
2244 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2245 // direction and notebooks for changing pages -- we decide that if we don't
2246 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2247 // means we can get working keyboard navigation in notebooks
2248 if ( !HasFlag(wxHSCROLL
) )
2251 bindings
= gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget
));
2254 gtk_binding_entry_remove(bindings
, GDK_Page_Up
, GDK_CONTROL_MASK
);
2255 gtk_binding_entry_remove(bindings
, GDK_Page_Down
, GDK_CONTROL_MASK
);
2259 if (HasFlag(wxALWAYS_SHOW_SB
))
2261 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_ALWAYS
, GTK_POLICY_ALWAYS
);
2265 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2268 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow
));
2269 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow
));
2270 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2271 gtk_range_set_inverted( m_scrollBar
[ScrollDir_Horz
], TRUE
);
2273 gtk_container_add( GTK_CONTAINER(m_widget
), view
);
2275 // connect various scroll-related events
2276 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2278 // these handlers block mouse events to any window during scrolling
2279 // such as motion events and prevent GTK and wxWidgets from fighting
2280 // over where the slider should be
2281 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2282 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2283 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2284 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2286 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2287 G_CALLBACK(gtk_scrollbar_event_after
), this);
2288 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2290 // these handlers get notified when scrollbar slider moves
2291 g_signal_connect_after(m_scrollBar
[dir
], "value_changed",
2292 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2295 gtk_widget_show( view
);
2298 bool wxWindowGTK::Create( wxWindow
*parent
,
2303 const wxString
&name
)
2305 // Get default border
2306 wxBorder border
= GetBorder(style
);
2308 style
&= ~wxBORDER_MASK
;
2311 if (!PreCreation( parent
, pos
, size
) ||
2312 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2314 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2318 // We should accept the native look
2320 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2321 scroll_class
->scrollbar_spacing
= 0;
2325 m_wxwindow
= wxPizza::New(m_windowStyle
);
2326 #ifndef __WXUNIVERSAL__
2327 if (HasFlag(wxPizza::BORDER_STYLES
))
2329 g_signal_connect(m_wxwindow
, "parent_set",
2330 G_CALLBACK(parent_set
), this);
2333 if (!HasFlag(wxHSCROLL
) && !HasFlag(wxVSCROLL
))
2334 m_widget
= m_wxwindow
;
2336 GTKCreateScrolledWindowWith(m_wxwindow
);
2337 g_object_ref(m_widget
);
2340 m_parent
->DoAddChild( this );
2342 m_focusWidget
= m_wxwindow
;
2344 SetCanFocus(AcceptsFocus());
2351 wxWindowGTK::~wxWindowGTK()
2355 if (gs_currentFocus
== this)
2356 gs_currentFocus
= NULL
;
2357 if (gs_pendingFocus
== this)
2358 gs_pendingFocus
= NULL
;
2360 if ( gs_deferredFocusOut
== this )
2361 gs_deferredFocusOut
= NULL
;
2365 // destroy children before destroying this window itself
2368 // unhook focus handlers to prevent stray events being
2369 // propagated to this (soon to be) dead object
2370 if (m_focusWidget
!= NULL
)
2372 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2373 (gpointer
) gtk_window_focus_in_callback
,
2375 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2376 (gpointer
) gtk_window_focus_out_callback
,
2383 // delete before the widgets to avoid a crash on solaris
2387 // avoid problem with GTK+ 2.18 where a frozen window causes the whole
2388 // TLW to be frozen, and if the window is then destroyed, nothing ever
2389 // gets painted again
2395 // Note that gtk_widget_destroy() does not destroy the widget, it just
2396 // emits the "destroy" signal. The widget is not actually destroyed
2397 // until its reference count drops to zero.
2398 gtk_widget_destroy(m_widget
);
2399 // Release our reference, should be the last one
2400 g_object_unref(m_widget
);
2406 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2408 if ( GTKNeedsParent() )
2410 wxCHECK_MSG( parent
, false, wxT("Must have non-NULL parent") );
2413 // Use either the given size, or the default if -1 is given.
2414 // See wxWindowBase for these functions.
2415 m_width
= WidthDefault(size
.x
) ;
2416 m_height
= HeightDefault(size
.y
);
2418 if (pos
!= wxDefaultPosition
)
2427 void wxWindowGTK::PostCreation()
2429 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2431 #if wxGTK_HAS_COMPOSITING_SUPPORT
2432 // Set RGBA visual as soon as possible to minimize the possibility that
2433 // somebody uses the wrong one.
2434 if ( m_backgroundStyle
== wxBG_STYLE_TRANSPARENT
&&
2435 IsTransparentBackgroundSupported() )
2437 GdkScreen
*screen
= gtk_widget_get_screen (m_widget
);
2439 gtk_widget_set_visual(m_widget
, gdk_screen_get_rgba_visual(screen
));
2441 GdkColormap
*rgba_colormap
= gdk_screen_get_rgba_colormap (screen
);
2444 gtk_widget_set_colormap(m_widget
, rgba_colormap
);
2447 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
2453 // these get reported to wxWidgets -> wxPaintEvent
2455 g_signal_connect(m_wxwindow
, "draw", G_CALLBACK(draw
), this);
2457 g_signal_connect(m_wxwindow
, "expose_event", G_CALLBACK(expose_event
), this);
2460 if (GetLayoutDirection() == wxLayout_LeftToRight
)
2461 gtk_widget_set_redraw_on_allocate(m_wxwindow
, HasFlag(wxFULL_REPAINT_ON_RESIZE
));
2464 // Create input method handler
2465 m_imData
= new wxGtkIMData
;
2467 // Cannot handle drawing preedited text yet
2468 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2470 g_signal_connect (m_imData
->context
, "commit",
2471 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2476 if (!GTK_IS_WINDOW(m_widget
))
2478 if (m_focusWidget
== NULL
)
2479 m_focusWidget
= m_widget
;
2483 g_signal_connect (m_focusWidget
, "focus_in_event",
2484 G_CALLBACK (gtk_window_focus_in_callback
), this);
2485 g_signal_connect (m_focusWidget
, "focus_out_event",
2486 G_CALLBACK (gtk_window_focus_out_callback
), this);
2490 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2491 G_CALLBACK (gtk_window_focus_in_callback
), this);
2492 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2493 G_CALLBACK (gtk_window_focus_out_callback
), this);
2497 if ( !AcceptsFocusFromKeyboard() )
2501 g_signal_connect(m_widget
, "focus",
2502 G_CALLBACK(wx_window_focus_callback
), this);
2505 // connect to the various key and mouse handlers
2507 GtkWidget
*connect_widget
= GetConnectWidget();
2509 ConnectWidget( connect_widget
);
2511 // We cannot set colours, fonts and cursors before the widget has been
2512 // realized, so we do this directly after realization -- unless the widget
2513 // was in fact realized already.
2514 if ( gtk_widget_get_realized(connect_widget
) )
2516 GTKHandleRealized();
2520 g_signal_connect (connect_widget
, "realize",
2521 G_CALLBACK (gtk_window_realized_callback
), this);
2523 g_signal_connect(connect_widget
, "unrealize", G_CALLBACK(unrealize
), this);
2527 g_signal_connect(m_wxwindow
? m_wxwindow
: m_widget
, "size_allocate",
2528 G_CALLBACK(size_allocate
), this);
2531 #if GTK_CHECK_VERSION(2, 8, 0)
2533 if ( gtk_check_version(2,8,0) == NULL
)
2536 // Make sure we can notify the app when mouse capture is lost
2539 g_signal_connect (m_wxwindow
, "grab_broken_event",
2540 G_CALLBACK (gtk_window_grab_broken
), this);
2543 if ( connect_widget
!= m_wxwindow
)
2545 g_signal_connect (connect_widget
, "grab_broken_event",
2546 G_CALLBACK (gtk_window_grab_broken
), this);
2549 #endif // GTK+ >= 2.8
2551 if (!WX_IS_PIZZA(gtk_widget_get_parent(m_widget
)) && !GTK_IS_WINDOW(m_widget
))
2552 gtk_widget_set_size_request(m_widget
, m_width
, m_height
);
2554 InheritAttributes();
2558 SetLayoutDirection(wxLayout_Default
);
2560 // unless the window was created initially hidden (i.e. Hide() had been
2561 // called before Create()), we should show it at GTK+ level as well
2563 gtk_widget_show( m_widget
);
2567 wxWindowGTK::GTKConnectWidget(const char *signal
, wxGTKCallback callback
)
2569 return g_signal_connect(m_widget
, signal
, callback
, this);
2572 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2574 g_signal_connect (widget
, "key_press_event",
2575 G_CALLBACK (gtk_window_key_press_callback
), this);
2576 g_signal_connect (widget
, "key_release_event",
2577 G_CALLBACK (gtk_window_key_release_callback
), this);
2578 g_signal_connect (widget
, "button_press_event",
2579 G_CALLBACK (gtk_window_button_press_callback
), this);
2580 g_signal_connect (widget
, "button_release_event",
2581 G_CALLBACK (gtk_window_button_release_callback
), this);
2582 g_signal_connect (widget
, "motion_notify_event",
2583 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2585 g_signal_connect (widget
, "scroll_event",
2586 G_CALLBACK (window_scroll_event
), this);
2587 if (m_scrollBar
[ScrollDir_Horz
])
2588 g_signal_connect (m_scrollBar
[ScrollDir_Horz
], "scroll_event",
2589 G_CALLBACK (window_scroll_event_hscrollbar
), this);
2590 if (m_scrollBar
[ScrollDir_Vert
])
2591 g_signal_connect (m_scrollBar
[ScrollDir_Vert
], "scroll_event",
2592 G_CALLBACK (window_scroll_event
), this);
2594 g_signal_connect (widget
, "popup_menu",
2595 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2596 g_signal_connect (widget
, "enter_notify_event",
2597 G_CALLBACK (gtk_window_enter_callback
), this);
2598 g_signal_connect (widget
, "leave_notify_event",
2599 G_CALLBACK (gtk_window_leave_callback
), this);
2602 bool wxWindowGTK::Destroy()
2606 return wxWindowBase::Destroy();
2609 static GSList
* gs_queueResizeList
;
2612 static gboolean
queue_resize(void*)
2614 gdk_threads_enter();
2615 for (GSList
* p
= gs_queueResizeList
; p
; p
= p
->next
)
2619 gtk_widget_queue_resize(GTK_WIDGET(p
->data
));
2620 g_object_remove_weak_pointer(G_OBJECT(p
->data
), &p
->data
);
2623 g_slist_free(gs_queueResizeList
);
2624 gs_queueResizeList
= NULL
;
2625 gdk_threads_leave();
2630 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2632 gtk_widget_set_size_request(m_widget
, width
, height
);
2633 GtkWidget
* parent
= gtk_widget_get_parent(m_widget
);
2634 if (WX_IS_PIZZA(parent
))
2635 WX_PIZZA(parent
)->move(m_widget
, x
, y
, width
, height
);
2637 // With GTK3, gtk_widget_queue_resize() is ignored while a size-allocate
2638 // is in progress. This situation is common in wxWidgets, since
2639 // size-allocate can generate wxSizeEvent and size event handlers often
2640 // call SetSize(), directly or indirectly. Work around this by deferring
2641 // the queue-resize until after size-allocate processing is finished.
2642 if (g_slist_find(gs_queueResizeList
, m_widget
) == NULL
)
2644 if (gs_queueResizeList
== NULL
)
2645 g_idle_add_full(GTK_PRIORITY_RESIZE
, queue_resize
, NULL
, NULL
);
2646 gs_queueResizeList
= g_slist_prepend(gs_queueResizeList
, m_widget
);
2647 g_object_add_weak_pointer(G_OBJECT(m_widget
), &gs_queueResizeList
->data
);
2651 void wxWindowGTK::ConstrainSize()
2654 // GPE's window manager doesn't like size hints at all, esp. when the user
2655 // has to use the virtual keyboard, so don't constrain size there
2659 const wxSize minSize
= GetMinSize();
2660 const wxSize maxSize
= GetMaxSize();
2661 if (minSize
.x
> 0 && m_width
< minSize
.x
) m_width
= minSize
.x
;
2662 if (minSize
.y
> 0 && m_height
< minSize
.y
) m_height
= minSize
.y
;
2663 if (maxSize
.x
> 0 && m_width
> maxSize
.x
) m_width
= maxSize
.x
;
2664 if (maxSize
.y
> 0 && m_height
> maxSize
.y
) m_height
= maxSize
.y
;
2668 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2670 wxCHECK_RET(m_widget
, "invalid window");
2672 int scrollX
= 0, scrollY
= 0;
2673 GtkWidget
* parent
= gtk_widget_get_parent(m_widget
);
2674 if (WX_IS_PIZZA(parent
))
2676 wxPizza
* pizza
= WX_PIZZA(parent
);
2677 scrollX
= pizza
->m_scroll_x
;
2678 scrollY
= pizza
->m_scroll_y
;
2680 if (x
!= -1 || (sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2684 if (y
!= -1 || (sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2689 // calculate the best size if we should auto size the window
2690 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2691 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2693 const wxSize sizeBest
= GetBestSize();
2694 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2696 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2697 height
= sizeBest
.y
;
2705 const bool sizeChange
= m_width
!= width
|| m_height
!= height
;
2706 if (sizeChange
|| m_x
!= x
|| m_y
!= y
)
2713 /* the default button has a border around it */
2714 if (gtk_widget_get_can_default(m_widget
))
2716 GtkBorder
*default_border
= NULL
;
2717 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2720 x
-= default_border
->left
;
2721 y
-= default_border
->top
;
2722 width
+= default_border
->left
+ default_border
->right
;
2723 height
+= default_border
->top
+ default_border
->bottom
;
2724 gtk_border_free( default_border
);
2728 DoMoveWindow(x
, y
, width
, height
);
2731 if ((sizeChange
&& !m_nativeSizeEvent
) || (sizeFlags
& wxSIZE_FORCE_EVENT
))
2733 // update these variables to keep size_allocate handler
2734 // from sending another size event for this change
2735 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2737 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2738 event
.SetEventObject( this );
2739 HandleWindowEvent( event
);
2743 bool wxWindowGTK::GTKShowFromOnIdle()
2745 if (IsShown() && m_showOnIdle
&& !gtk_widget_get_visible (m_widget
))
2747 GtkAllocation alloc
;
2750 alloc
.width
= m_width
;
2751 alloc
.height
= m_height
;
2752 gtk_widget_size_allocate( m_widget
, &alloc
);
2753 gtk_widget_show( m_widget
);
2754 wxShowEvent
eventShow(GetId(), true);
2755 eventShow
.SetEventObject(this);
2756 HandleWindowEvent(eventShow
);
2757 m_showOnIdle
= false;
2764 void wxWindowGTK::OnInternalIdle()
2766 if ( gs_deferredFocusOut
)
2767 GTKHandleDeferredFocusOut();
2769 // Check if we have to show window now
2770 if (GTKShowFromOnIdle()) return;
2772 if ( m_dirtyTabOrder
)
2774 m_dirtyTabOrder
= false;
2778 wxWindowBase::OnInternalIdle();
2781 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
2783 if (width
) (*width
) = m_width
;
2784 if (height
) (*height
) = m_height
;
2787 void wxWindowGTK::DoSetClientSize( int width
, int height
)
2789 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2791 const wxSize size
= GetSize();
2792 const wxSize clientSize
= GetClientSize();
2793 SetSize(width
+ (size
.x
- clientSize
.x
), height
+ (size
.y
- clientSize
.y
));
2796 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
2798 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2805 // if window is scrollable, account for scrollbars
2806 if ( GTK_IS_SCROLLED_WINDOW(m_widget
) )
2808 GtkPolicyType policy
[ScrollDir_Max
];
2809 gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget
),
2810 &policy
[ScrollDir_Horz
],
2811 &policy
[ScrollDir_Vert
]);
2812 const int scrollbar_spacing
=
2813 GTK_SCROLLED_WINDOW_GET_CLASS(m_widget
)->scrollbar_spacing
;
2815 for ( int i
= 0; i
< ScrollDir_Max
; i
++ )
2817 // don't account for the scrollbars we don't have
2818 GtkRange
* const range
= m_scrollBar
[i
];
2822 // nor for the ones we have but don't current show
2823 switch ( policy
[i
] )
2825 case GTK_POLICY_NEVER
:
2826 // never shown so doesn't take any place
2829 case GTK_POLICY_ALWAYS
:
2830 // no checks necessary
2833 case GTK_POLICY_AUTOMATIC
:
2834 // may be shown or not, check
2835 GtkAdjustment
*adj
= gtk_range_get_adjustment(range
);
2836 if (gtk_adjustment_get_upper(adj
) <= gtk_adjustment_get_page_size(adj
))
2842 GtkWidget
* widget
= GTK_WIDGET(range
);
2843 if (i
== ScrollDir_Horz
)
2847 gtk_widget_get_preferred_height(widget
, NULL
, &req
.height
);
2848 h
-= req
.height
+ scrollbar_spacing
;
2855 gtk_widget_get_preferred_width(widget
, NULL
, &req
.width
);
2856 w
-= req
.width
+ scrollbar_spacing
;
2859 #else // !__WXGTK3__
2860 gtk_widget_size_request(GTK_WIDGET(range
), &req
);
2861 if (i
== ScrollDir_Horz
)
2862 h
-= req
.height
+ scrollbar_spacing
;
2864 w
-= req
.width
+ scrollbar_spacing
;
2865 #endif // !__WXGTK3__
2869 const wxSize sizeBorders
= DoGetBorderSize();
2879 if (width
) *width
= w
;
2880 if (height
) *height
= h
;
2883 wxSize
wxWindowGTK::DoGetBorderSize() const
2886 return wxWindowBase::DoGetBorderSize();
2889 WX_PIZZA(m_wxwindow
)->get_border(border
);
2890 return wxSize(border
.left
+ border
.right
, border
.top
+ border
.bottom
);
2893 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
2897 GtkWidget
* parent
= NULL
;
2899 parent
= gtk_widget_get_parent(m_widget
);
2900 if (WX_IS_PIZZA(parent
))
2902 wxPizza
* pizza
= WX_PIZZA(parent
);
2903 dx
= pizza
->m_scroll_x
;
2904 dy
= pizza
->m_scroll_y
;
2906 if (x
) (*x
) = m_x
- dx
;
2907 if (y
) (*y
) = m_y
- dy
;
2910 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
2912 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2914 if (gtk_widget_get_window(m_widget
) == NULL
) return;
2916 GdkWindow
*source
= NULL
;
2918 source
= gtk_widget_get_window(m_wxwindow
);
2920 source
= gtk_widget_get_window(m_widget
);
2924 gdk_window_get_origin( source
, &org_x
, &org_y
);
2928 if (!gtk_widget_get_has_window(m_widget
))
2931 gtk_widget_get_allocation(m_widget
, &a
);
2940 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2941 *x
= (GetClientSize().x
- *x
) + org_x
;
2949 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
2951 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2953 if (!gtk_widget_get_realized(m_widget
)) return;
2955 GdkWindow
*source
= NULL
;
2957 source
= gtk_widget_get_window(m_wxwindow
);
2959 source
= gtk_widget_get_window(m_widget
);
2963 gdk_window_get_origin( source
, &org_x
, &org_y
);
2967 if (!gtk_widget_get_has_window(m_widget
))
2970 gtk_widget_get_allocation(m_widget
, &a
);
2978 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2979 *x
= (GetClientSize().x
- *x
) - org_x
;
2986 bool wxWindowGTK::Show( bool show
)
2988 if ( !wxWindowBase::Show(show
) )
2994 // notice that we may call Hide() before the window is created and this is
2995 // actually useful to create it hidden initially -- but we can't call
2996 // Show() before it is created
2999 wxASSERT_MSG( !show
, "can't show invalid window" );
3007 // defer until later
3011 gtk_widget_show(m_widget
);
3015 gtk_widget_hide(m_widget
);
3018 wxShowEvent
eventShow(GetId(), show
);
3019 eventShow
.SetEventObject(this);
3020 HandleWindowEvent(eventShow
);
3025 void wxWindowGTK::DoEnable( bool enable
)
3027 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3029 gtk_widget_set_sensitive( m_widget
, enable
);
3030 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3031 gtk_widget_set_sensitive( m_wxwindow
, enable
);
3034 int wxWindowGTK::GetCharHeight() const
3036 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
3038 wxFont font
= GetFont();
3039 wxCHECK_MSG( font
.IsOk(), 12, wxT("invalid font") );
3041 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
3046 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3047 PangoLayout
*layout
= pango_layout_new(context
);
3048 pango_layout_set_font_description(layout
, desc
);
3049 pango_layout_set_text(layout
, "H", 1);
3050 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3052 PangoRectangle rect
;
3053 pango_layout_line_get_extents(line
, NULL
, &rect
);
3055 g_object_unref (layout
);
3057 return (int) PANGO_PIXELS(rect
.height
);
3060 int wxWindowGTK::GetCharWidth() const
3062 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
3064 wxFont font
= GetFont();
3065 wxCHECK_MSG( font
.IsOk(), 8, wxT("invalid font") );
3067 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
3072 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3073 PangoLayout
*layout
= pango_layout_new(context
);
3074 pango_layout_set_font_description(layout
, desc
);
3075 pango_layout_set_text(layout
, "g", 1);
3076 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3078 PangoRectangle rect
;
3079 pango_layout_line_get_extents(line
, NULL
, &rect
);
3081 g_object_unref (layout
);
3083 return (int) PANGO_PIXELS(rect
.width
);
3086 void wxWindowGTK::DoGetTextExtent( const wxString
& string
,
3090 int *externalLeading
,
3091 const wxFont
*theFont
) const
3093 wxFont fontToUse
= theFont
? *theFont
: GetFont();
3095 wxCHECK_RET( fontToUse
.IsOk(), wxT("invalid font") );
3104 PangoContext
*context
= NULL
;
3106 context
= gtk_widget_get_pango_context( m_widget
);
3115 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3116 PangoLayout
*layout
= pango_layout_new(context
);
3117 pango_layout_set_font_description(layout
, desc
);
3119 const wxCharBuffer data
= wxGTK_CONV( string
);
3121 pango_layout_set_text(layout
, data
, strlen(data
));
3124 PangoRectangle rect
;
3125 pango_layout_get_extents(layout
, NULL
, &rect
);
3127 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
3128 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
3131 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
3132 int baseline
= pango_layout_iter_get_baseline(iter
);
3133 pango_layout_iter_free(iter
);
3134 *descent
= *y
- PANGO_PIXELS(baseline
);
3136 if (externalLeading
) (*externalLeading
) = 0; // ??
3138 g_object_unref (layout
);
3141 void wxWindowGTK::GTKDisableFocusOutEvent()
3143 g_signal_handlers_block_by_func( m_focusWidget
,
3144 (gpointer
) gtk_window_focus_out_callback
, this);
3147 void wxWindowGTK::GTKEnableFocusOutEvent()
3149 g_signal_handlers_unblock_by_func( m_focusWidget
,
3150 (gpointer
) gtk_window_focus_out_callback
, this);
3153 bool wxWindowGTK::GTKHandleFocusIn()
3155 // Disable default focus handling for custom windows since the default GTK+
3156 // handler issues a repaint
3157 const bool retval
= m_wxwindow
? true : false;
3160 // NB: if there's still unprocessed deferred focus-out event (see
3161 // GTKHandleFocusOut() for explanation), we need to process it first so
3162 // that the order of focus events -- focus-out first, then focus-in
3163 // elsewhere -- is preserved
3164 if ( gs_deferredFocusOut
)
3166 if ( GTKNeedsToFilterSameWindowFocus() &&
3167 gs_deferredFocusOut
== this )
3169 // GTK+ focus changed from this wxWindow back to itself, so don't
3170 // emit any events at all
3171 wxLogTrace(TRACE_FOCUS
,
3172 "filtered out spurious focus change within %s(%p, %s)",
3173 GetClassInfo()->GetClassName(), this, GetLabel());
3174 gs_deferredFocusOut
= NULL
;
3178 // otherwise we need to send focus-out first
3179 wxASSERT_MSG ( gs_deferredFocusOut
!= this,
3180 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
3181 GTKHandleDeferredFocusOut();
3185 wxLogTrace(TRACE_FOCUS
,
3186 "handling focus_in event for %s(%p, %s)",
3187 GetClassInfo()->GetClassName(), this, GetLabel());
3190 gtk_im_context_focus_in(m_imData
->context
);
3192 gs_currentFocus
= this;
3193 gs_pendingFocus
= NULL
;
3196 // caret needs to be informed about focus change
3197 wxCaret
*caret
= GetCaret();
3200 caret
->OnSetFocus();
3202 #endif // wxUSE_CARET
3204 // Notify the parent keeping track of focus for the kbd navigation
3205 // purposes that we got it.
3206 wxChildFocusEvent
eventChildFocus(static_cast<wxWindow
*>(this));
3207 GTKProcessEvent(eventChildFocus
);
3209 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, GetId());
3210 eventFocus
.SetEventObject(this);
3211 GTKProcessEvent(eventFocus
);
3216 bool wxWindowGTK::GTKHandleFocusOut()
3218 // Disable default focus handling for custom windows since the default GTK+
3219 // handler issues a repaint
3220 const bool retval
= m_wxwindow
? true : false;
3223 // NB: If a control is composed of several GtkWidgets and when focus
3224 // changes from one of them to another within the same wxWindow, we get
3225 // a focus-out event followed by focus-in for another GtkWidget owned
3226 // by the same wx control. We don't want to generate two spurious
3227 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3228 // from GTKHandleFocusOut() until we know for sure it's not coming back
3229 // (i.e. in GTKHandleFocusIn() or at idle time).
3230 if ( GTKNeedsToFilterSameWindowFocus() )
3232 wxASSERT_MSG( gs_deferredFocusOut
== NULL
,
3233 "deferred focus out event already pending" );
3234 wxLogTrace(TRACE_FOCUS
,
3235 "deferring focus_out event for %s(%p, %s)",
3236 GetClassInfo()->GetClassName(), this, GetLabel());
3237 gs_deferredFocusOut
= this;
3241 GTKHandleFocusOutNoDeferring();
3246 void wxWindowGTK::GTKHandleFocusOutNoDeferring()
3248 wxLogTrace(TRACE_FOCUS
,
3249 "handling focus_out event for %s(%p, %s)",
3250 GetClassInfo()->GetClassName(), this, GetLabel());
3253 gtk_im_context_focus_out(m_imData
->context
);
3255 if ( gs_currentFocus
!= this )
3257 // Something is terribly wrong, gs_currentFocus is out of sync with the
3258 // real focus. We will reset it to NULL anyway, because after this
3259 // focus-out event is handled, one of the following with happen:
3261 // * either focus will go out of the app altogether, in which case
3262 // gs_currentFocus _should_ be NULL
3264 // * or it goes to another control, in which case focus-in event will
3265 // follow immediately and it will set gs_currentFocus to the right
3267 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3268 GetClassInfo()->GetClassName(), this, GetLabel());
3270 gs_currentFocus
= NULL
;
3273 // caret needs to be informed about focus change
3274 wxCaret
*caret
= GetCaret();
3277 caret
->OnKillFocus();
3279 #endif // wxUSE_CARET
3281 wxFocusEvent
event( wxEVT_KILL_FOCUS
, GetId() );
3282 event
.SetEventObject( this );
3283 event
.SetWindow( FindFocus() );
3284 GTKProcessEvent( event
);
3288 void wxWindowGTK::GTKHandleDeferredFocusOut()
3290 // NB: See GTKHandleFocusOut() for explanation. This function is called
3291 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3293 if ( gs_deferredFocusOut
)
3295 wxWindowGTK
*win
= gs_deferredFocusOut
;
3296 gs_deferredFocusOut
= NULL
;
3298 wxLogTrace(TRACE_FOCUS
,
3299 "processing deferred focus_out event for %s(%p, %s)",
3300 win
->GetClassInfo()->GetClassName(), win
, win
->GetLabel());
3302 win
->GTKHandleFocusOutNoDeferring();
3306 void wxWindowGTK::SetFocus()
3308 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3310 // Setting "physical" focus is not immediate in GTK+ and while
3311 // gtk_widget_is_focus ("determines if the widget is the focus widget
3312 // within its toplevel", i.e. returns true for one widget per TLW, not
3313 // globally) returns true immediately after grabbing focus,
3314 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3315 // has focus at the moment) takes effect only after the window is shown
3316 // (if it was hidden at the moment of the call) or at the next event loop
3319 // Because we want to FindFocus() call immediately following
3320 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3322 gs_pendingFocus
= this;
3324 GtkWidget
*widget
= m_wxwindow
? m_wxwindow
: m_focusWidget
;
3326 if ( GTK_IS_CONTAINER(widget
) &&
3327 !gtk_widget_get_can_focus(widget
) )
3329 wxLogTrace(TRACE_FOCUS
,
3330 wxT("Setting focus to a child of %s(%p, %s)"),
3331 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3332 gtk_widget_child_focus(widget
, GTK_DIR_TAB_FORWARD
);
3336 wxLogTrace(TRACE_FOCUS
,
3337 wxT("Setting focus to %s(%p, %s)"),
3338 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3339 gtk_widget_grab_focus(widget
);
3343 void wxWindowGTK::SetCanFocus(bool canFocus
)
3345 gtk_widget_set_can_focus(m_widget
, canFocus
);
3347 if ( m_wxwindow
&& (m_widget
!= m_wxwindow
) )
3349 gtk_widget_set_can_focus(m_wxwindow
, canFocus
);
3353 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3355 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3357 wxWindowGTK
* const newParent
= (wxWindowGTK
*)newParentBase
;
3359 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3361 if ( !wxWindowBase::Reparent(newParent
) )
3364 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3366 // Notice that old m_parent pointer might be non-NULL here but the widget
3367 // still not have any parent at GTK level if it's a notebook page that had
3368 // been removed from the notebook so test this at GTK level and not wx one.
3369 if ( GtkWidget
*parentGTK
= gtk_widget_get_parent(m_widget
) )
3370 gtk_container_remove(GTK_CONTAINER(parentGTK
), m_widget
);
3372 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3376 if (gtk_widget_get_visible (newParent
->m_widget
))
3378 m_showOnIdle
= true;
3379 gtk_widget_hide( m_widget
);
3381 /* insert GTK representation */
3382 newParent
->AddChildGTK(this);
3385 SetLayoutDirection(wxLayout_Default
);
3390 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3392 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3393 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3398 /* insert GTK representation */
3402 void wxWindowGTK::AddChild(wxWindowBase
*child
)
3404 wxWindowBase::AddChild(child
);
3405 m_dirtyTabOrder
= true;
3406 wxTheApp
->WakeUpIdle();
3409 void wxWindowGTK::RemoveChild(wxWindowBase
*child
)
3411 wxWindowBase::RemoveChild(child
);
3412 m_dirtyTabOrder
= true;
3413 wxTheApp
->WakeUpIdle();
3417 wxLayoutDirection
wxWindowGTK::GTKGetLayout(GtkWidget
*widget
)
3419 return gtk_widget_get_direction(widget
) == GTK_TEXT_DIR_RTL
3420 ? wxLayout_RightToLeft
3421 : wxLayout_LeftToRight
;
3425 void wxWindowGTK::GTKSetLayout(GtkWidget
*widget
, wxLayoutDirection dir
)
3427 wxASSERT_MSG( dir
!= wxLayout_Default
, wxT("invalid layout direction") );
3429 gtk_widget_set_direction(widget
,
3430 dir
== wxLayout_RightToLeft
? GTK_TEXT_DIR_RTL
3431 : GTK_TEXT_DIR_LTR
);
3434 wxLayoutDirection
wxWindowGTK::GetLayoutDirection() const
3436 return GTKGetLayout(m_widget
);
3439 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir
)
3441 if ( dir
== wxLayout_Default
)
3443 const wxWindow
*const parent
= GetParent();
3446 // inherit layout from parent.
3447 dir
= parent
->GetLayoutDirection();
3449 else // no parent, use global default layout
3451 dir
= wxTheApp
->GetLayoutDirection();
3455 if ( dir
== wxLayout_Default
)
3458 GTKSetLayout(m_widget
, dir
);
3460 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3461 GTKSetLayout(m_wxwindow
, dir
);
3465 wxWindowGTK::AdjustForLayoutDirection(wxCoord x
,
3466 wxCoord
WXUNUSED(width
),
3467 wxCoord
WXUNUSED(widthTotal
)) const
3469 // We now mirror the coordinates of RTL windows in wxPizza
3473 void wxWindowGTK::DoMoveInTabOrder(wxWindow
*win
, WindowOrder move
)
3475 wxWindowBase::DoMoveInTabOrder(win
, move
);
3476 m_dirtyTabOrder
= true;
3477 wxTheApp
->WakeUpIdle();
3480 bool wxWindowGTK::DoNavigateIn(int flags
)
3482 if ( flags
& wxNavigationKeyEvent::WinChange
)
3484 wxFAIL_MSG( wxT("not implemented") );
3488 else // navigate inside the container
3490 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3491 wxCHECK_MSG( parent
, false, wxT("every window must have a TLW parent") );
3493 GtkDirectionType dir
;
3494 dir
= flags
& wxNavigationKeyEvent::IsForward
? GTK_DIR_TAB_FORWARD
3495 : GTK_DIR_TAB_BACKWARD
;
3498 g_signal_emit_by_name(parent
->m_widget
, "focus", dir
, &rc
);
3504 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3506 // none needed by default
3510 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3512 // nothing to do by default since none is needed
3515 void wxWindowGTK::RealizeTabOrder()
3519 if ( !m_children
.empty() )
3521 // we don't only construct the correct focus chain but also use
3522 // this opportunity to update the mnemonic widgets for the widgets
3525 GList
*chain
= NULL
;
3526 wxWindowGTK
* mnemonicWindow
= NULL
;
3528 for ( wxWindowList::const_iterator i
= m_children
.begin();
3529 i
!= m_children
.end();
3532 wxWindowGTK
*win
= *i
;
3534 bool focusableFromKeyboard
= win
->AcceptsFocusFromKeyboard();
3536 if ( mnemonicWindow
)
3538 if ( focusableFromKeyboard
)
3540 // wxComboBox et al. needs to focus on on a different
3541 // widget than m_widget, so if the main widget isn't
3542 // focusable try the connect widget
3543 GtkWidget
* w
= win
->m_widget
;
3544 if ( !gtk_widget_get_can_focus(w
) )
3546 w
= win
->GetConnectWidget();
3547 if ( !gtk_widget_get_can_focus(w
) )
3553 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3554 mnemonicWindow
= NULL
;
3558 else if ( win
->GTKWidgetNeedsMnemonic() )
3560 mnemonicWindow
= win
;
3563 if ( focusableFromKeyboard
)
3564 chain
= g_list_prepend(chain
, win
->m_widget
);
3567 chain
= g_list_reverse(chain
);
3569 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3574 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3579 void wxWindowGTK::Raise()
3581 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3583 if (m_wxwindow
&& gtk_widget_get_window(m_wxwindow
))
3585 gdk_window_raise(gtk_widget_get_window(m_wxwindow
));
3587 else if (gtk_widget_get_window(m_widget
))
3589 gdk_window_raise(gtk_widget_get_window(m_widget
));
3593 void wxWindowGTK::Lower()
3595 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3597 if (m_wxwindow
&& gtk_widget_get_window(m_wxwindow
))
3599 gdk_window_lower(gtk_widget_get_window(m_wxwindow
));
3601 else if (gtk_widget_get_window(m_widget
))
3603 gdk_window_lower(gtk_widget_get_window(m_widget
));
3607 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3609 if ( !wxWindowBase::SetCursor(cursor
.IsOk() ? cursor
: *wxSTANDARD_CURSOR
) )
3617 void wxWindowGTK::GTKUpdateCursor(bool update_self
/*=true*/, bool recurse
/*=true*/)
3621 wxCursor
cursor(g_globalCursor
.IsOk() ? g_globalCursor
: GetCursor());
3622 if ( cursor
.IsOk() )
3624 wxArrayGdkWindows windowsThis
;
3625 GdkWindow
* window
= GTKGetWindow(windowsThis
);
3627 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3630 const size_t count
= windowsThis
.size();
3631 for ( size_t n
= 0; n
< count
; n
++ )
3633 GdkWindow
*win
= windowsThis
[n
];
3634 // It can be zero if the window has not been realized yet.
3637 gdk_window_set_cursor(win
, cursor
.GetCursor());
3646 for (wxWindowList::iterator it
= GetChildren().begin(); it
!= GetChildren().end(); ++it
)
3648 (*it
)->GTKUpdateCursor( true );
3653 void wxWindowGTK::WarpPointer( int x
, int y
)
3655 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3657 ClientToScreen(&x
, &y
);
3658 GdkDisplay
* display
= gtk_widget_get_display(m_widget
);
3659 GdkScreen
* screen
= gtk_widget_get_screen(m_widget
);
3661 GdkDeviceManager
* manager
= gdk_display_get_device_manager(display
);
3662 gdk_device_warp(gdk_device_manager_get_client_pointer(manager
), screen
, x
, y
);
3664 #ifdef GDK_WINDOWING_X11
3665 XWarpPointer(GDK_DISPLAY_XDISPLAY(display
),
3667 GDK_WINDOW_XID(gdk_screen_get_root_window(screen
)),
3673 wxWindowGTK::ScrollDir
wxWindowGTK::ScrollDirFromRange(GtkRange
*range
) const
3675 // find the scrollbar which generated the event
3676 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3678 if ( range
== m_scrollBar
[dir
] )
3679 return (ScrollDir
)dir
;
3682 wxFAIL_MSG( wxT("event from unknown scrollbar received") );
3684 return ScrollDir_Max
;
3687 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3689 bool changed
= false;
3690 GtkRange
* range
= m_scrollBar
[dir
];
3691 if ( range
&& units
)
3693 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
3694 double inc
= unit
== ScrollUnit_Line
? gtk_adjustment_get_step_increment(adj
)
3695 : gtk_adjustment_get_page_increment(adj
);
3697 const int posOld
= wxRound(gtk_adjustment_get_value(adj
));
3698 gtk_range_set_value(range
, posOld
+ units
*inc
);
3700 changed
= wxRound(gtk_adjustment_get_value(adj
)) != posOld
;
3706 bool wxWindowGTK::ScrollLines(int lines
)
3708 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3711 bool wxWindowGTK::ScrollPages(int pages
)
3713 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3716 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground
),
3721 if (gtk_widget_get_mapped(m_wxwindow
))
3723 GdkWindow
* window
= gtk_widget_get_window(m_wxwindow
);
3726 GdkRectangle r
= { rect
->x
, rect
->y
, rect
->width
, rect
->height
};
3727 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3728 r
.x
= gdk_window_get_width(window
) - r
.x
- rect
->width
;
3729 gdk_window_invalidate_rect(window
, &r
, true);
3732 gdk_window_invalidate_rect(window
, NULL
, true);
3737 if (gtk_widget_get_mapped(m_widget
))
3740 gtk_widget_queue_draw_area(m_widget
, rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3742 gtk_widget_queue_draw(m_widget
);
3747 void wxWindowGTK::Update()
3749 if (m_widget
&& gtk_widget_get_mapped(m_widget
))
3751 GdkDisplay
* display
= gtk_widget_get_display(m_widget
);
3752 // Flush everything out to the server, and wait for it to finish.
3753 // This ensures nothing will overwrite the drawing we are about to do.
3754 gdk_display_sync(display
);
3756 GdkWindow
* window
= GTKGetDrawingWindow();
3758 window
= gtk_widget_get_window(m_widget
);
3759 gdk_window_process_updates(window
, true);
3761 // Flush again, but no need to wait for it to finish
3762 gdk_display_flush(display
);
3766 bool wxWindowGTK::DoIsExposed( int x
, int y
) const
3768 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
3771 bool wxWindowGTK::DoIsExposed( int x
, int y
, int w
, int h
) const
3773 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3774 return m_updateRegion
.Contains(x
-w
, y
, w
, h
) != wxOutRegion
;
3776 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
3780 void wxWindowGTK::GTKSendPaintEvents(cairo_t
* cr
)
3782 void wxWindowGTK::GTKSendPaintEvents(const GdkRegion
* region
)
3786 m_paintContext
= cr
;
3787 double x1
, y1
, x2
, y2
;
3788 cairo_clip_extents(cr
, &x1
, &y1
, &x2
, &y2
);
3789 m_updateRegion
= wxRegion(int(x1
), int(y1
), int(x2
- x1
), int(y2
- y1
));
3790 #else // !__WXGTK3__
3791 m_updateRegion
= wxRegion(region
);
3792 #if wxGTK_HAS_COMPOSITING_SUPPORT
3795 #endif // !__WXGTK3__
3796 // Clip to paint region in wxClientDC
3797 m_clipPaintRegion
= true;
3799 m_nativeUpdateRegion
= m_updateRegion
;
3801 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3803 // Transform m_updateRegion under RTL
3804 m_updateRegion
.Clear();
3806 const int width
= gdk_window_get_width(GTKGetDrawingWindow());
3808 wxRegionIterator
upd( m_nativeUpdateRegion
);
3812 rect
.x
= upd
.GetX();
3813 rect
.y
= upd
.GetY();
3814 rect
.width
= upd
.GetWidth();
3815 rect
.height
= upd
.GetHeight();
3817 rect
.x
= width
- rect
.x
- rect
.width
;
3818 m_updateRegion
.Union( rect
);
3824 switch ( GetBackgroundStyle() )
3826 case wxBG_STYLE_TRANSPARENT
:
3827 #if wxGTK_HAS_COMPOSITING_SUPPORT
3828 if (IsTransparentBackgroundSupported())
3830 // Set a transparent background, so that overlaying in parent
3831 // might indeed let see through where this child did not
3832 // explicitly paint.
3833 // NB: it works also for top level windows (but this is the
3834 // windows manager which then does the compositing job)
3836 cr
= gdk_cairo_create(m_wxwindow
->window
);
3837 gdk_cairo_region(cr
, m_nativeUpdateRegion
.GetRegion());
3840 cairo_set_operator(cr
, CAIRO_OPERATOR_CLEAR
);
3842 cairo_set_operator(cr
, CAIRO_OPERATOR_OVER
);
3844 cairo_surface_flush(cairo_get_target(cr
));
3847 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
3850 case wxBG_STYLE_ERASE
:
3853 wxGTKCairoDC
dc(cr
);
3855 wxWindowDC
dc( (wxWindow
*)this );
3856 dc
.SetDeviceClippingRegion( m_updateRegion
);
3858 // Work around gtk-qt <= 0.60 bug whereby the window colour
3862 GetOptionInt("gtk.window.force-background-colour") )
3864 dc
.SetBackground(GetBackgroundColour());
3867 #endif // !__WXGTK3__
3868 wxEraseEvent
erase_event( GetId(), &dc
);
3869 erase_event
.SetEventObject( this );
3871 if ( HandleWindowEvent(erase_event
) )
3873 // background erased, don't do it again
3879 case wxBG_STYLE_SYSTEM
:
3880 if ( GetThemeEnabled() )
3882 GdkWindow
* gdkWindow
= GTKGetDrawingWindow();
3883 const int w
= gdk_window_get_width(gdkWindow
);
3884 const int h
= gdk_window_get_height(gdkWindow
);
3886 GtkStyleContext
* sc
= gtk_widget_get_style_context(m_wxwindow
);
3887 gtk_render_background(sc
, cr
, 0, 0, w
, h
);
3889 // find ancestor from which to steal background
3890 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3892 parent
= (wxWindow
*)this;
3894 m_nativeUpdateRegion
.GetBox(rect
.x
, rect
.y
, rect
.width
, rect
.height
);
3895 gtk_paint_flat_box(gtk_widget_get_style(parent
->m_widget
),
3897 gtk_widget_get_state(m_wxwindow
),
3903 #endif // !__WXGTK3__
3907 case wxBG_STYLE_PAINT
:
3908 // nothing to do: window will be painted over in EVT_PAINT
3912 wxFAIL_MSG( "unsupported background style" );
3915 wxNcPaintEvent
nc_paint_event( GetId() );
3916 nc_paint_event
.SetEventObject( this );
3917 HandleWindowEvent( nc_paint_event
);
3919 wxPaintEvent
paint_event( GetId() );
3920 paint_event
.SetEventObject( this );
3921 HandleWindowEvent( paint_event
);
3923 #if wxGTK_HAS_COMPOSITING_SUPPORT
3924 if (IsTransparentBackgroundSupported())
3925 { // now composite children which need it
3926 // Overlay all our composite children on top of the painted area
3927 wxWindowList::compatibility_iterator node
;
3928 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
3930 wxWindow
*compositeChild
= node
->GetData();
3931 if (compositeChild
->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT
)
3936 cr
= gdk_cairo_create(m_wxwindow
->window
);
3937 gdk_cairo_region(cr
, m_nativeUpdateRegion
.GetRegion());
3940 #endif // !__WXGTK3__
3941 GtkWidget
*child
= compositeChild
->m_wxwindow
;
3942 GtkAllocation alloc
;
3943 gtk_widget_get_allocation(child
, &alloc
);
3945 // The source data is the (composited) child
3946 gdk_cairo_set_source_window(
3947 cr
, gtk_widget_get_window(child
), alloc
.x
, alloc
.y
);
3957 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
3959 m_clipPaintRegion
= false;
3961 m_paintContext
= NULL
;
3963 m_updateRegion
.Clear();
3964 m_nativeUpdateRegion
.Clear();
3967 void wxWindowGTK::SetDoubleBuffered( bool on
)
3969 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3972 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3975 bool wxWindowGTK::IsDoubleBuffered() const
3977 return gtk_widget_get_double_buffered( m_wxwindow
) != 0;
3980 void wxWindowGTK::ClearBackground()
3982 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3986 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3988 if (m_tooltip
!= tip
)
3990 wxWindowBase::DoSetToolTip(tip
);
3993 m_tooltip
->GTKSetWindow(static_cast<wxWindow
*>(this));
3995 GTKApplyToolTip(NULL
);
3999 void wxWindowGTK::GTKApplyToolTip(const char* tip
)
4001 wxToolTip::GTKApply(GetConnectWidget(), tip
);
4003 #endif // wxUSE_TOOLTIPS
4005 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
4007 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4009 if (!wxWindowBase::SetBackgroundColour(colour
))
4015 // We need the pixel value e.g. for background clearing.
4016 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
4020 // apply style change (forceStyle=true so that new style is applied
4021 // even if the bg colour changed from valid to wxNullColour)
4022 GTKApplyWidgetStyle(true);
4027 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
4029 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4031 if (!wxWindowBase::SetForegroundColour(colour
))
4039 // We need the pixel value e.g. for background clearing.
4040 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
4044 // apply style change (forceStyle=true so that new style is applied
4045 // even if the bg colour changed from valid to wxNullColour):
4046 GTKApplyWidgetStyle(true);
4051 PangoContext
*wxWindowGTK::GTKGetPangoDefaultContext()
4053 return gtk_widget_get_pango_context( m_widget
);
4057 GtkRcStyle
*wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle
)
4059 // do we need to apply any changes at all?
4062 !m_foregroundColour
.IsOk() && !m_backgroundColour
.IsOk() )
4067 GtkRcStyle
*style
= gtk_rc_style_new();
4069 if ( m_font
.IsOk() )
4072 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
4075 int flagsNormal
= 0,
4078 flagsInsensitive
= 0;
4080 if ( m_foregroundColour
.IsOk() )
4082 const GdkColor
*fg
= m_foregroundColour
.GetColor();
4084 style
->fg
[GTK_STATE_NORMAL
] =
4085 style
->text
[GTK_STATE_NORMAL
] = *fg
;
4086 flagsNormal
|= GTK_RC_FG
| GTK_RC_TEXT
;
4088 style
->fg
[GTK_STATE_PRELIGHT
] =
4089 style
->text
[GTK_STATE_PRELIGHT
] = *fg
;
4090 flagsPrelight
|= GTK_RC_FG
| GTK_RC_TEXT
;
4092 style
->fg
[GTK_STATE_ACTIVE
] =
4093 style
->text
[GTK_STATE_ACTIVE
] = *fg
;
4094 flagsActive
|= GTK_RC_FG
| GTK_RC_TEXT
;
4097 if ( m_backgroundColour
.IsOk() )
4099 const GdkColor
*bg
= m_backgroundColour
.GetColor();
4101 style
->bg
[GTK_STATE_NORMAL
] =
4102 style
->base
[GTK_STATE_NORMAL
] = *bg
;
4103 flagsNormal
|= GTK_RC_BG
| GTK_RC_BASE
;
4105 style
->bg
[GTK_STATE_PRELIGHT
] =
4106 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
4107 flagsPrelight
|= GTK_RC_BG
| GTK_RC_BASE
;
4109 style
->bg
[GTK_STATE_ACTIVE
] =
4110 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
4111 flagsActive
|= GTK_RC_BG
| GTK_RC_BASE
;
4113 style
->bg
[GTK_STATE_INSENSITIVE
] =
4114 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
4115 flagsInsensitive
|= GTK_RC_BG
| GTK_RC_BASE
;
4118 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)flagsNormal
;
4119 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)flagsPrelight
;
4120 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)flagsActive
;
4121 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)flagsInsensitive
;
4125 #endif // !__WXGTK3__
4127 void wxWindowGTK::GTKApplyWidgetStyle(bool WXUNUSED_IN_GTK3(forceStyle
))
4130 DoApplyWidgetStyle(NULL
);
4132 GtkRcStyle
*style
= GTKCreateWidgetStyle(forceStyle
);
4135 DoApplyWidgetStyle(style
);
4136 g_object_unref(style
);
4140 // Style change may affect GTK+'s size calculation:
4141 InvalidateBestSize();
4144 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
4146 GtkWidget
* widget
= m_wxwindow
? m_wxwindow
: m_widget
;
4148 // block the signal temporarily to avoid sending
4149 // wxSysColourChangedEvents when we change the colours ourselves
4150 bool unblock
= false;
4151 if (m_wxwindow
&& IsTopLevel())
4154 g_signal_handlers_block_by_func(
4155 m_wxwindow
, (void*)style_updated
, this);
4158 GTKApplyStyle(widget
, style
);
4162 g_signal_handlers_unblock_by_func(
4163 m_wxwindow
, (void*)style_updated
, this);
4167 void wxWindowGTK::GTKApplyStyle(GtkWidget
* widget
, GtkRcStyle
* WXUNUSED_IN_GTK3(style
))
4170 const PangoFontDescription
* pfd
= NULL
;
4172 pfd
= pango_font_description_copy(m_font
.GetNativeFontInfo()->description
);
4173 gtk_widget_override_font(widget
, pfd
);
4174 gtk_widget_override_color(widget
, GTK_STATE_FLAG_NORMAL
, m_foregroundColour
);
4175 gtk_widget_override_background_color(widget
, GTK_STATE_FLAG_NORMAL
, m_backgroundColour
);
4177 gtk_widget_modify_style(widget
, style
);
4181 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style
)
4183 if (!wxWindowBase::SetBackgroundStyle(style
))
4190 window
= GTKGetDrawingWindow();
4194 GtkWidget
* const w
= GetConnectWidget();
4195 window
= w
? gtk_widget_get_window(w
) : NULL
;
4198 bool wantNoBackPixmap
= style
== wxBG_STYLE_PAINT
|| style
== wxBG_STYLE_TRANSPARENT
;
4200 if ( wantNoBackPixmap
)
4204 // Make sure GDK/X11 doesn't refresh the window
4206 gdk_window_set_back_pixmap( window
, NULL
, FALSE
);
4207 m_needsStyleChange
= false;
4209 else // window not realized yet
4211 // Do when window is realized
4212 m_needsStyleChange
= true;
4215 // Don't apply widget style, or we get a grey background
4219 // apply style change (forceStyle=true so that new style is applied
4220 // even if the bg colour changed from valid to wxNullColour):
4221 GTKApplyWidgetStyle(true);
4223 #endif // !__WXGTK3__
4228 bool wxWindowGTK::IsTransparentBackgroundSupported(wxString
* reason
) const
4230 #if wxGTK_HAS_COMPOSITING_SUPPORT
4232 if (gtk_check_version(wxGTK_VERSION_REQUIRED_FOR_COMPOSITING
) != NULL
)
4236 *reason
= _("GTK+ installed on this machine is too old to "
4237 "support screen compositing, please install "
4238 "GTK+ 2.12 or later.");
4243 #endif // !__WXGTK3__
4245 // NB: We don't check here if the particular kind of widget supports
4246 // transparency, we check only if it would be possible for a generic window
4248 wxCHECK_MSG ( m_widget
, false, "Window must be created first" );
4250 if (!gdk_screen_is_composited(gtk_widget_get_screen(m_widget
)))
4254 *reason
= _("Compositing not supported by this system, "
4255 "please enable it in your Window Manager.");
4265 *reason
= _("This program was compiled with a too old version of GTK+, "
4266 "please rebuild with GTK+ 2.12 or newer.");
4270 #endif // wxGTK_HAS_COMPOSITING_SUPPORT/!wxGTK_HAS_COMPOSITING_SUPPORT
4273 // ----------------------------------------------------------------------------
4274 // Pop-up menu stuff
4275 // ----------------------------------------------------------------------------
4277 #if wxUSE_MENUS_NATIVE
4281 void wxPopupMenuPositionCallback( GtkMenu
*menu
,
4283 gboolean
* WXUNUSED(whatever
),
4284 gpointer user_data
)
4286 // ensure that the menu appears entirely on screen
4288 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
4290 wxSize sizeScreen
= wxGetDisplaySize();
4291 wxPoint
*pos
= (wxPoint
*)user_data
;
4293 gint xmax
= sizeScreen
.x
- req
.width
,
4294 ymax
= sizeScreen
.y
- req
.height
;
4296 *x
= pos
->x
< xmax
? pos
->x
: xmax
;
4297 *y
= pos
->y
< ymax
? pos
->y
: ymax
;
4301 bool wxWindowGTK::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
4303 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4309 GtkMenuPositionFunc posfunc
;
4310 if ( x
== -1 && y
== -1 )
4312 // use GTK's default positioning algorithm
4318 pos
= ClientToScreen(wxPoint(x
, y
));
4320 posfunc
= wxPopupMenuPositionCallback
;
4323 menu
->m_popupShown
= true;
4325 GTK_MENU(menu
->m_menu
),
4326 NULL
, // parent menu shell
4327 NULL
, // parent menu item
4328 posfunc
, // function to position it
4329 userdata
, // client data
4330 0, // button used to activate it
4331 gtk_get_current_event_time()
4334 while (menu
->m_popupShown
)
4336 gtk_main_iteration();
4342 #endif // wxUSE_MENUS_NATIVE
4344 #if wxUSE_DRAG_AND_DROP
4346 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4348 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4350 GtkWidget
*dnd_widget
= GetConnectWidget();
4352 if (m_dropTarget
) m_dropTarget
->GtkUnregisterWidget( dnd_widget
);
4354 if (m_dropTarget
) delete m_dropTarget
;
4355 m_dropTarget
= dropTarget
;
4357 if (m_dropTarget
) m_dropTarget
->GtkRegisterWidget( dnd_widget
);
4360 #endif // wxUSE_DRAG_AND_DROP
4362 GtkWidget
* wxWindowGTK::GetConnectWidget()
4364 GtkWidget
*connect_widget
= m_widget
;
4365 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4367 return connect_widget
;
4370 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow
*window
) const
4372 wxArrayGdkWindows windowsThis
;
4373 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
4375 return winThis
? window
== winThis
4376 : windowsThis
.Index(window
) != wxNOT_FOUND
;
4379 GdkWindow
*wxWindowGTK::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
4381 return m_wxwindow
? GTKGetDrawingWindow() : gtk_widget_get_window(m_widget
);
4384 bool wxWindowGTK::SetFont( const wxFont
&font
)
4386 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4388 if (!wxWindowBase::SetFont(font
))
4391 // apply style change (forceStyle=true so that new style is applied
4392 // even if the font changed from valid to wxNullFont):
4393 GTKApplyWidgetStyle(true);
4398 void wxWindowGTK::DoCaptureMouse()
4400 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4402 GdkWindow
*window
= NULL
;
4404 window
= GTKGetDrawingWindow();
4406 window
= gtk_widget_get_window(GetConnectWidget());
4408 wxCHECK_RET( window
, wxT("CaptureMouse() failed") );
4410 const wxCursor
* cursor
= &m_cursor
;
4411 if (!cursor
->IsOk())
4412 cursor
= wxSTANDARD_CURSOR
;
4414 gdk_pointer_grab( window
, FALSE
,
4416 (GDK_BUTTON_PRESS_MASK
|
4417 GDK_BUTTON_RELEASE_MASK
|
4418 GDK_POINTER_MOTION_HINT_MASK
|
4419 GDK_POINTER_MOTION_MASK
),
4421 cursor
->GetCursor(),
4422 (guint32
)GDK_CURRENT_TIME
);
4423 g_captureWindow
= this;
4424 g_captureWindowHasMouse
= true;
4427 void wxWindowGTK::DoReleaseMouse()
4429 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4431 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4433 g_captureWindow
= NULL
;
4435 GdkWindow
*window
= NULL
;
4437 window
= GTKGetDrawingWindow();
4439 window
= gtk_widget_get_window(GetConnectWidget());
4444 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4447 void wxWindowGTK::GTKReleaseMouseAndNotify()
4450 wxMouseCaptureLostEvent
evt(GetId());
4451 evt
.SetEventObject( this );
4452 HandleWindowEvent( evt
);
4456 wxWindow
*wxWindowBase::GetCapture()
4458 return (wxWindow
*)g_captureWindow
;
4461 bool wxWindowGTK::IsRetained() const
4466 void wxWindowGTK::SetScrollbar(int orient
,
4470 bool WXUNUSED(update
))
4472 const int dir
= ScrollDirFromOrient(orient
);
4473 GtkRange
* const sb
= m_scrollBar
[dir
];
4474 wxCHECK_RET( sb
, wxT("this window is not scrollable") );
4478 // GtkRange requires upper > lower
4483 g_signal_handlers_block_by_func(
4484 sb
, (void*)gtk_scrollbar_value_changed
, this);
4486 gtk_range_set_increments(sb
, 1, thumbVisible
);
4487 gtk_adjustment_set_page_size(gtk_range_get_adjustment(sb
), thumbVisible
);
4488 gtk_range_set_range(sb
, 0, range
);
4489 gtk_range_set_value(sb
, pos
);
4490 m_scrollPos
[dir
] = gtk_range_get_value(sb
);
4492 g_signal_handlers_unblock_by_func(
4493 sb
, (void*)gtk_scrollbar_value_changed
, this);
4496 void wxWindowGTK::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4498 const int dir
= ScrollDirFromOrient(orient
);
4499 GtkRange
* const sb
= m_scrollBar
[dir
];
4500 wxCHECK_RET( sb
, wxT("this window is not scrollable") );
4502 // This check is more than an optimization. Without it, the slider
4503 // will not move smoothly while tracking when using wxScrollHelper.
4504 if (GetScrollPos(orient
) != pos
)
4506 g_signal_handlers_block_by_func(
4507 sb
, (void*)gtk_scrollbar_value_changed
, this);
4509 gtk_range_set_value(sb
, pos
);
4510 m_scrollPos
[dir
] = gtk_range_get_value(sb
);
4512 g_signal_handlers_unblock_by_func(
4513 sb
, (void*)gtk_scrollbar_value_changed
, this);
4517 int wxWindowGTK::GetScrollThumb(int orient
) const
4519 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4520 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4522 return wxRound(gtk_adjustment_get_page_size(gtk_range_get_adjustment(sb
)));
4525 int wxWindowGTK::GetScrollPos( int orient
) const
4527 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4528 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4530 return wxRound(gtk_range_get_value(sb
));
4533 int wxWindowGTK::GetScrollRange( int orient
) const
4535 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4536 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4538 return wxRound(gtk_adjustment_get_upper(gtk_range_get_adjustment(sb
)));
4541 // Determine if increment is the same as +/-x, allowing for some small
4542 // difference due to possible inexactness in floating point arithmetic
4543 static inline bool IsScrollIncrement(double increment
, double x
)
4545 wxASSERT(increment
> 0);
4546 const double tolerance
= 1.0 / 1024;
4547 return fabs(increment
- fabs(x
)) < tolerance
;
4550 wxEventType
wxWindowGTK::GTKGetScrollEventType(GtkRange
* range
)
4552 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4554 const int barIndex
= range
== m_scrollBar
[1];
4556 const double value
= gtk_range_get_value(range
);
4558 // save previous position
4559 const double oldPos
= m_scrollPos
[barIndex
];
4560 // update current position
4561 m_scrollPos
[barIndex
] = value
;
4562 // If event should be ignored, or integral position has not changed
4563 if (!m_hasVMT
|| g_blockEventsOnDrag
|| wxRound(value
) == wxRound(oldPos
))
4568 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4571 // Difference from last change event
4572 const double diff
= value
- oldPos
;
4573 const bool isDown
= diff
> 0;
4575 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
4576 if (IsScrollIncrement(gtk_adjustment_get_step_increment(adj
), diff
))
4578 eventType
= isDown
? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4580 else if (IsScrollIncrement(gtk_adjustment_get_page_increment(adj
), diff
))
4582 eventType
= isDown
? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4584 else if (m_mouseButtonDown
)
4586 // Assume track event
4587 m_isScrolling
= true;
4593 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4595 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4597 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4599 // No scrolling requested.
4600 if ((dx
== 0) && (dy
== 0)) return;
4602 m_clipPaintRegion
= true;
4604 WX_PIZZA(m_wxwindow
)->scroll(dx
, dy
);
4606 m_clipPaintRegion
= false;
4609 bool restoreCaret
= (GetCaret() != NULL
&& GetCaret()->IsVisible());
4612 wxRect
caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4614 caretRect
.width
+= dx
;
4617 caretRect
.x
+= dx
; caretRect
.width
-= dx
;
4620 caretRect
.height
+= dy
;
4623 caretRect
.y
+= dy
; caretRect
.height
-= dy
;
4626 RefreshRect(caretRect
);
4628 #endif // wxUSE_CARET
4631 void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4633 //RN: Note that static controls usually have no border on gtk, so maybe
4634 //it makes sense to treat that as simply no border at the wx level
4636 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4638 GtkShadowType gtkstyle
;
4640 if(wxstyle
& wxBORDER_RAISED
)
4641 gtkstyle
= GTK_SHADOW_OUT
;
4642 else if ((wxstyle
& wxBORDER_SUNKEN
) || (wxstyle
& wxBORDER_THEME
))
4643 gtkstyle
= GTK_SHADOW_IN
;
4646 else if (wxstyle
& wxBORDER_DOUBLE
)
4647 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4650 gtkstyle
= GTK_SHADOW_IN
;
4652 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4657 // Find the wxWindow at the current mouse position, also returning the mouse
4659 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4661 pt
= wxGetMousePosition();
4662 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4666 // Get the current mouse position.
4667 wxPoint
wxGetMousePosition()
4670 GdkModifierType unused
;
4671 GetMouseState(x
, y
, unused
);
4672 return wxPoint(x
, y
);
4675 GdkWindow
* wxWindowGTK::GTKGetDrawingWindow() const
4677 GdkWindow
* window
= NULL
;
4679 window
= gtk_widget_get_window(m_wxwindow
);
4683 // ----------------------------------------------------------------------------
4685 // ----------------------------------------------------------------------------
4687 void wxWindowGTK::GTKFreezeWidget(GtkWidget
* widget
)
4689 if (widget
&& gtk_widget_get_has_window(widget
))
4691 GdkWindow
* window
= gtk_widget_get_window(widget
);
4693 gdk_window_freeze_updates(window
);
4697 void wxWindowGTK::GTKThawWidget(GtkWidget
* widget
)
4699 if (widget
&& gtk_widget_get_has_window(widget
))
4701 GdkWindow
* window
= gtk_widget_get_window(widget
);
4703 gdk_window_thaw_updates(window
);
4707 void wxWindowGTK::DoFreeze()
4709 GtkWidget
* widget
= m_wxwindow
;
4712 GTKFreezeWidget(widget
);
4715 void wxWindowGTK::DoThaw()
4717 GtkWidget
* widget
= m_wxwindow
;
4720 GTKThawWidget(widget
);