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 // Normally we take the state of modifiers directly from the low level GDK
670 // event but unfortunately GDK uses a different convention from MSW for the
671 // key events corresponding to the modifier keys themselves: in it, when
672 // e.g. Shift key is pressed, GDK_SHIFT_MASK is not set while it is set
673 // when Shift is released. Under MSW the situation is exactly reversed and
674 // the modifier corresponding to the key is set when it is pressed and
675 // unset when it is released. To ensure consistent behaviour between
676 // platforms (and because it seems to make slightly more sense, although
677 // arguably both behaviours are reasonable) we follow MSW here.
679 // Final notice: we set the flags to the desired value instead of just
680 // inverting them because they are not set correctly (i.e. in the same way
681 // as for the real events generated by the user) for wxUIActionSimulator-
682 // produced events and it seems better to keep that class code the same
683 // among all platforms and fix the discrepancy here instead of adding
684 // wxGTK-specific code to wxUIActionSimulator.
685 const bool isPress
= gdk_event
->type
== GDK_KEY_PRESS
;
686 switch ( gdk_event
->keyval
)
690 event
.m_shiftDown
= isPress
;
695 event
.m_controlDown
= isPress
;
700 event
.m_altDown
= isPress
;
707 event
.m_metaDown
= isPress
;
711 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
712 event
.m_rawFlags
= gdk_event
->hardware_keycode
;
714 wxGetMousePosition(&event
.m_x
, &event
.m_y
);
715 win
->ScreenToClient(&event
.m_x
, &event
.m_y
);
716 event
.SetEventObject( win
);
721 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
723 GdkEventKey
*gdk_event
)
725 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
726 // but only event->keyval which is quite useless to us, so remember
727 // the last character from GDK_KEY_PRESS and reuse it as last resort
729 // NB: should be MT-safe as we're always called from the main thread only
734 } s_lastKeyPress
= { 0, 0 };
736 KeySym keysym
= gdk_event
->keyval
;
738 wxLogTrace(TRACE_KEYS
, wxT("Key %s event: keysym = %ld"),
739 event
.GetEventType() == wxEVT_KEY_UP
? wxT("release")
743 long key_code
= wxTranslateKeySymToWXKey(keysym
, false /* !isChar */);
747 // do we have the translation or is it a plain ASCII character?
748 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
750 // we should use keysym if it is ASCII as X does some translations
751 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
752 // which we don't want here (but which we do use for OnChar())
753 if ( !wxIsAsciiKeysym(keysym
) )
755 keysym
= (KeySym
)gdk_event
->string
[0];
758 #ifdef GDK_WINDOWING_X11
759 // we want to always get the same key code when the same key is
760 // pressed regardless of the state of the modifiers, i.e. on a
761 // standard US keyboard pressing '5' or '%' ('5' key with
762 // Shift) should result in the same key code in OnKeyDown():
763 // '5' (although OnChar() will get either '5' or '%').
765 // to do it we first translate keysym to keycode (== scan code)
766 // and then back but always using the lower register
767 Display
*dpy
= (Display
*)wxGetDisplay();
768 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
770 wxLogTrace(TRACE_KEYS
, wxT("\t-> keycode %d"), keycode
);
772 #ifdef HAVE_X11_XKBLIB_H
773 KeySym keysymNormalized
= XkbKeycodeToKeysym(dpy
, keycode
, 0, 0);
775 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
778 // use the normalized, i.e. lower register, keysym if we've
780 key_code
= keysymNormalized
? keysymNormalized
: keysym
;
785 // as explained above, we want to have lower register key codes
786 // normally but for the letter keys we want to have the upper ones
788 // NB: don't use XConvertCase() here, we want to do it for letters
790 key_code
= toupper(key_code
);
792 else // non ASCII key, what to do?
794 // by default, ignore it
797 // but if we have cached information from the last KEY_PRESS
798 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
801 if ( keysym
== s_lastKeyPress
.keysym
)
803 key_code
= s_lastKeyPress
.keycode
;
808 if ( gdk_event
->type
== GDK_KEY_PRESS
)
810 // remember it to be reused for KEY_UP event later
811 s_lastKeyPress
.keysym
= keysym
;
812 s_lastKeyPress
.keycode
= key_code
;
816 wxLogTrace(TRACE_KEYS
, wxT("\t-> wxKeyCode %ld"), key_code
);
818 // sending unknown key events doesn't really make sense
822 event
.m_keyCode
= key_code
;
825 event
.m_uniChar
= gdk_keyval_to_unicode(key_code
? key_code
: keysym
);
826 if ( !event
.m_uniChar
&& event
.m_keyCode
<= WXK_DELETE
)
828 // Set Unicode key code to the ASCII equivalent for compatibility. E.g.
829 // let RETURN generate the key event with both key and Unicode key
831 event
.m_uniChar
= event
.m_keyCode
;
833 #endif // wxUSE_UNICODE
835 // now fill all the other fields
836 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
844 GtkIMContext
*context
;
845 GdkEventKey
*lastKeyEvent
;
849 context
= gtk_im_multicontext_new();
854 g_object_unref (context
);
861 // Send wxEVT_CHAR_HOOK event to the parent of the window and return true only
862 // if it was processed (and not skipped).
863 bool SendCharHookEvent(const wxKeyEvent
& event
, wxWindow
*win
)
865 // wxEVT_CHAR_HOOK must be sent to allow the parent windows (e.g. a dialog
866 // which typically closes when Esc key is pressed in any of its controls)
867 // to handle key events in all of its children unless the mouse is captured
868 // in which case we consider that the keyboard should be "captured" too.
869 if ( !g_captureWindow
)
871 wxKeyEvent
eventCharHook(wxEVT_CHAR_HOOK
, event
);
872 if ( win
->HandleWindowEvent(eventCharHook
)
873 && !event
.IsNextEventAllowed() )
880 // Adjust wxEVT_CHAR event key code fields. This function takes care of two
882 // (a) Ctrl-letter key presses generate key codes in range 1..26
883 // (b) Unicode key codes are same as key codes for the codes in 1..255 range
884 void AdjustCharEventKeyCodes(wxKeyEvent
& event
)
886 const int code
= event
.m_keyCode
;
888 // Check for (a) above.
889 if ( event
.ControlDown() )
891 // We intentionally don't use isupper/lower() here, we really need
892 // ASCII letters only as it doesn't make sense to translate any other
893 // ones into this range which has only 26 slots.
894 if ( code
>= 'a' && code
<= 'z' )
895 event
.m_keyCode
= code
- 'a' + 1;
896 else if ( code
>= 'A' && code
<= 'Z' )
897 event
.m_keyCode
= code
- 'A' + 1;
900 // Adjust the Unicode equivalent in the same way too.
901 if ( event
.m_keyCode
!= code
)
902 event
.m_uniChar
= event
.m_keyCode
;
903 #endif // wxUSE_UNICODE
907 // Check for (b) from above.
909 // FIXME: Should we do it for key codes up to 255?
910 if ( !event
.m_uniChar
&& code
< WXK_DELETE
)
911 event
.m_uniChar
= code
;
912 #endif // wxUSE_UNICODE
915 } // anonymous namespace
917 // If a widget does not handle a key or mouse event, GTK+ sends it up the
918 // parent chain until it is handled. These events are not supposed to propagate
919 // in wxWidgets, so this code avoids handling them in any parent wxWindow,
920 // while still allowing the event to propagate so things like native keyboard
921 // navigation will work.
922 #define wxPROCESS_EVENT_ONCE(EventType, event) \
923 static EventType eventPrev; \
924 if (memcmp(&eventPrev, event, sizeof(EventType)) == 0) \
930 gtk_window_key_press_callback( GtkWidget
*WXUNUSED(widget
),
931 GdkEventKey
*gdk_event
,
936 if (g_blockEventsOnDrag
)
939 wxPROCESS_EVENT_ONCE(GdkEventKey
, gdk_event
);
941 wxKeyEvent
event( wxEVT_KEY_DOWN
);
943 bool return_after_IM
= false;
945 if( wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
947 // Send the CHAR_HOOK event first
948 if ( SendCharHookEvent(event
, win
) )
950 // Don't do anything at all with this event any more.
954 // Emit KEY_DOWN event
955 ret
= win
->HandleWindowEvent( event
);
959 // Return after IM processing as we cannot do
960 // anything with it anyhow.
961 return_after_IM
= true;
964 if (!ret
&& win
->m_imData
)
966 win
->m_imData
->lastKeyEvent
= gdk_event
;
968 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
969 // docs, if IM filter returns true, no further processing should be done.
970 // we should send the key_down event anyway.
971 bool intercepted_by_IM
=
972 gtk_im_context_filter_keypress(win
->m_imData
->context
, gdk_event
) != 0;
973 win
->m_imData
->lastKeyEvent
= NULL
;
974 if (intercepted_by_IM
)
976 wxLogTrace(TRACE_KEYS
, wxT("Key event intercepted by IM"));
987 wxWindowGTK
*ancestor
= win
;
990 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
993 wxCommandEvent
menu_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
994 ret
= ancestor
->HandleWindowEvent( menu_event
);
998 // if the accelerator wasn't handled as menu event, try
999 // it as button click (for compatibility with other
1001 wxCommandEvent
button_event( wxEVT_COMMAND_BUTTON_CLICKED
, command
);
1002 ret
= ancestor
->HandleWindowEvent( button_event
);
1007 if (ancestor
->IsTopLevel())
1009 ancestor
= ancestor
->GetParent();
1012 #endif // wxUSE_ACCEL
1014 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1015 // will only be sent if it is not in an accelerator table.
1019 KeySym keysym
= gdk_event
->keyval
;
1020 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1021 key_code
= wxTranslateKeySymToWXKey(keysym
, true /* isChar */);
1024 if ( wxIsAsciiKeysym(keysym
) )
1027 key_code
= (unsigned char)keysym
;
1029 // gdk_event->string is actually deprecated
1030 else if ( gdk_event
->length
== 1 )
1032 key_code
= (unsigned char)gdk_event
->string
[0];
1038 wxKeyEvent
eventChar(wxEVT_CHAR
, event
);
1040 wxLogTrace(TRACE_KEYS
, wxT("Char event: %ld"), key_code
);
1042 eventChar
.m_keyCode
= key_code
;
1044 AdjustCharEventKeyCodes(eventChar
);
1046 ret
= win
->HandleWindowEvent(eventChar
);
1056 gtk_wxwindow_commit_cb (GtkIMContext
* WXUNUSED(context
),
1060 wxKeyEvent
event( wxEVT_CHAR
);
1062 // take modifiers, cursor position, timestamp etc. from the last
1063 // key_press_event that was fed into Input Method:
1064 if (window
->m_imData
->lastKeyEvent
)
1066 wxFillOtherKeyEventFields(event
,
1067 window
, window
->m_imData
->lastKeyEvent
);
1071 event
.SetEventObject( window
);
1074 const wxString
data(wxGTK_CONV_BACK_SYS(str
));
1078 for( wxString::const_iterator pstr
= data
.begin(); pstr
!= data
.end(); ++pstr
)
1081 event
.m_uniChar
= *pstr
;
1082 // Backward compatible for ISO-8859-1
1083 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
1084 wxLogTrace(TRACE_KEYS
, wxT("IM sent character '%c'"), event
.m_uniChar
);
1086 event
.m_keyCode
= (char)*pstr
;
1087 #endif // wxUSE_UNICODE
1089 AdjustCharEventKeyCodes(event
);
1091 window
->HandleWindowEvent(event
);
1097 //-----------------------------------------------------------------------------
1098 // "key_release_event" from any window
1099 //-----------------------------------------------------------------------------
1103 gtk_window_key_release_callback( GtkWidget
* WXUNUSED(widget
),
1104 GdkEventKey
*gdk_event
,
1110 if (g_blockEventsOnDrag
)
1113 wxPROCESS_EVENT_ONCE(GdkEventKey
, gdk_event
);
1115 wxKeyEvent
event( wxEVT_KEY_UP
);
1116 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1118 // unknown key pressed, ignore (the event would be useless anyhow)
1122 return win
->GTKProcessEvent(event
);
1126 // ============================================================================
1128 // ============================================================================
1130 // ----------------------------------------------------------------------------
1131 // mouse event processing helpers
1132 // ----------------------------------------------------------------------------
1134 static void AdjustEventButtonState(wxMouseEvent
& event
)
1136 // GDK reports the old state of the button for a button press event, but
1137 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1138 // for a LEFT_DOWN event, not FALSE, so we will invert
1139 // left/right/middleDown for the corresponding click events
1141 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1142 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1143 (event
.GetEventType() == wxEVT_LEFT_UP
))
1145 event
.m_leftDown
= !event
.m_leftDown
;
1149 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1150 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1151 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1153 event
.m_middleDown
= !event
.m_middleDown
;
1157 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1158 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1159 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1161 event
.m_rightDown
= !event
.m_rightDown
;
1165 if ((event
.GetEventType() == wxEVT_AUX1_DOWN
) ||
1166 (event
.GetEventType() == wxEVT_AUX1_DCLICK
))
1168 event
.m_aux1Down
= true;
1172 if ((event
.GetEventType() == wxEVT_AUX2_DOWN
) ||
1173 (event
.GetEventType() == wxEVT_AUX2_DCLICK
))
1175 event
.m_aux2Down
= true;
1180 // find the window to send the mouse event to
1182 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1187 if (win
->m_wxwindow
)
1189 wxPizza
* pizza
= WX_PIZZA(win
->m_wxwindow
);
1190 xx
+= pizza
->m_scroll_x
;
1191 yy
+= pizza
->m_scroll_y
;
1194 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
1197 wxWindow
* child
= static_cast<wxWindow
*>(node
->GetData());
1199 node
= node
->GetNext();
1200 if (!child
->IsShown())
1203 if (child
->GTKIsTransparentForMouse())
1205 // wxStaticBox is transparent in the box itself
1206 int xx1
= child
->m_x
;
1207 int yy1
= child
->m_y
;
1208 int xx2
= child
->m_x
+ child
->m_width
;
1209 int yy2
= child
->m_y
+ child
->m_height
;
1212 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1214 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1216 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1218 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1229 if ((child
->m_wxwindow
== NULL
) &&
1230 win
->IsClientAreaChild(child
) &&
1231 (child
->m_x
<= xx
) &&
1232 (child
->m_y
<= yy
) &&
1233 (child
->m_x
+child
->m_width
>= xx
) &&
1234 (child
->m_y
+child
->m_height
>= yy
))
1247 // ----------------------------------------------------------------------------
1248 // common event handlers helpers
1249 // ----------------------------------------------------------------------------
1251 bool wxWindowGTK::GTKProcessEvent(wxEvent
& event
) const
1253 // nothing special at this level
1254 return HandleWindowEvent(event
);
1257 bool wxWindowGTK::GTKShouldIgnoreEvent() const
1259 return !m_hasVMT
|| g_blockEventsOnDrag
;
1262 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny
*event
) const
1266 if (g_blockEventsOnDrag
)
1268 if (g_blockEventsOnScroll
)
1271 if (!GTKIsOwnWindow(event
->window
))
1277 // overloads for all GDK event types we use here: we need to have this as
1278 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1279 // derives from it in the sense that the structs have the same layout
1280 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1281 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1283 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1286 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton
)
1287 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion
)
1288 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing
)
1290 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1292 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1293 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1297 // all event handlers must have C linkage as they're called from GTK+ C code
1301 //-----------------------------------------------------------------------------
1302 // "button_press_event"
1303 //-----------------------------------------------------------------------------
1306 gtk_window_button_press_callback( GtkWidget
* WXUNUSED_IN_GTK3(widget
),
1307 GdkEventButton
*gdk_event
,
1310 wxPROCESS_EVENT_ONCE(GdkEventButton
, gdk_event
);
1312 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1314 g_lastButtonNumber
= gdk_event
->button
;
1316 wxEventType event_type
;
1319 switch (gdk_event
->button
)
1322 down
= wxEVT_LEFT_DOWN
;
1323 dclick
= wxEVT_LEFT_DCLICK
;
1326 down
= wxEVT_MIDDLE_DOWN
;
1327 dclick
= wxEVT_MIDDLE_DCLICK
;
1330 down
= wxEVT_RIGHT_DOWN
;
1331 dclick
= wxEVT_RIGHT_DCLICK
;
1334 down
= wxEVT_AUX1_DOWN
;
1335 dclick
= wxEVT_AUX1_DCLICK
;
1338 down
= wxEVT_AUX2_DOWN
;
1339 dclick
= wxEVT_AUX2_DCLICK
;
1344 switch (gdk_event
->type
)
1346 case GDK_BUTTON_PRESS
:
1348 // GDK sends surplus button down events
1349 // before a double click event. We
1350 // need to filter these out.
1351 if (win
->m_wxwindow
)
1353 GdkEvent
* peek_event
= gdk_event_peek();
1356 const GdkEventType peek_event_type
= peek_event
->type
;
1357 gdk_event_free(peek_event
);
1358 if (peek_event_type
== GDK_2BUTTON_PRESS
||
1359 peek_event_type
== GDK_3BUTTON_PRESS
)
1366 case GDK_2BUTTON_PRESS
:
1367 event_type
= dclick
;
1369 if (gdk_event
->button
>= 1 && gdk_event
->button
<= 3)
1371 // Reset GDK internal timestamp variables in order to disable GDK
1372 // triple click events. GDK will then next time believe no button has
1373 // been clicked just before, and send a normal button click event.
1374 GdkDisplay
* display
= gtk_widget_get_display(widget
);
1375 display
->button_click_time
[1] = 0;
1376 display
->button_click_time
[0] = 0;
1378 #endif // !__WXGTK3__
1380 // we shouldn't get triple clicks at all for GTK2 because we
1381 // suppress them artificially using the code above but we still
1382 // should map them to something for GTK3 and not just ignore them
1383 // as this would lose clicks
1384 case GDK_3BUTTON_PRESS
:
1391 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1393 wxMouseEvent
event( event_type
);
1394 InitMouseEvent( win
, event
, gdk_event
);
1396 AdjustEventButtonState(event
);
1398 // find the correct window to send the event to: it may be a different one
1399 // from the one which got it at GTK+ level because some controls don't have
1400 // their own X window and thus cannot get any events.
1401 if ( !g_captureWindow
)
1402 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1404 // reset the event object and id in case win changed.
1405 event
.SetEventObject( win
);
1406 event
.SetId( win
->GetId() );
1408 bool ret
= win
->GTKProcessEvent( event
);
1409 g_lastMouseEvent
= NULL
;
1413 if ((event_type
== wxEVT_LEFT_DOWN
) && !win
->IsOfStandardClass() &&
1414 (gs_currentFocus
!= win
) /* && win->IsFocusable() */)
1419 if (event_type
== wxEVT_RIGHT_DOWN
)
1421 // generate a "context menu" event: this is similar to right mouse
1422 // click under many GUIs except that it is generated differently
1423 // (right up under MSW, ctrl-click under Mac, right down here) and
1425 // (a) it's a command event and so is propagated to the parent
1426 // (b) under some ports it can be generated from kbd too
1427 // (c) it uses screen coords (because of (a))
1428 wxContextMenuEvent
evtCtx(
1431 win
->ClientToScreen(event
.GetPosition()));
1432 evtCtx
.SetEventObject(win
);
1433 return win
->GTKProcessEvent(evtCtx
);
1439 //-----------------------------------------------------------------------------
1440 // "button_release_event"
1441 //-----------------------------------------------------------------------------
1444 gtk_window_button_release_callback( GtkWidget
*WXUNUSED(widget
),
1445 GdkEventButton
*gdk_event
,
1448 wxPROCESS_EVENT_ONCE(GdkEventButton
, gdk_event
);
1450 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1452 g_lastButtonNumber
= 0;
1454 wxEventType event_type
= wxEVT_NULL
;
1456 switch (gdk_event
->button
)
1459 event_type
= wxEVT_LEFT_UP
;
1463 event_type
= wxEVT_MIDDLE_UP
;
1467 event_type
= wxEVT_RIGHT_UP
;
1471 event_type
= wxEVT_AUX1_UP
;
1475 event_type
= wxEVT_AUX2_UP
;
1479 // unknown button, don't process
1483 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1485 wxMouseEvent
event( event_type
);
1486 InitMouseEvent( win
, event
, gdk_event
);
1488 AdjustEventButtonState(event
);
1490 if ( !g_captureWindow
)
1491 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1493 // reset the event object and id in case win changed.
1494 event
.SetEventObject( win
);
1495 event
.SetId( win
->GetId() );
1497 bool ret
= win
->GTKProcessEvent(event
);
1499 g_lastMouseEvent
= NULL
;
1504 //-----------------------------------------------------------------------------
1505 // "motion_notify_event"
1506 //-----------------------------------------------------------------------------
1509 gtk_window_motion_notify_callback( GtkWidget
* WXUNUSED(widget
),
1510 GdkEventMotion
*gdk_event
,
1513 wxPROCESS_EVENT_ONCE(GdkEventMotion
, gdk_event
);
1515 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1517 if (gdk_event
->is_hint
)
1521 GdkModifierType state
;
1522 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1527 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1529 wxMouseEvent
event( wxEVT_MOTION
);
1530 InitMouseEvent(win
, event
, gdk_event
);
1532 if ( g_captureWindow
)
1534 // synthesise a mouse enter or leave event if needed
1535 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1536 // This seems to be necessary and actually been added to
1537 // GDK itself in version 2.0.X
1540 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1541 if ( hasMouse
!= g_captureWindowHasMouse
)
1543 // the mouse changed window
1544 g_captureWindowHasMouse
= hasMouse
;
1546 wxMouseEvent
eventM(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1547 : wxEVT_LEAVE_WINDOW
);
1548 InitMouseEvent(win
, eventM
, gdk_event
);
1549 eventM
.SetEventObject(win
);
1550 win
->GTKProcessEvent(eventM
);
1555 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1557 // reset the event object and id in case win changed.
1558 event
.SetEventObject( win
);
1559 event
.SetId( win
->GetId() );
1562 if ( !g_captureWindow
)
1564 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1565 if (win
->GTKProcessEvent( cevent
))
1567 win
->SetCursor( cevent
.GetCursor() );
1571 bool ret
= win
->GTKProcessEvent(event
);
1573 g_lastMouseEvent
= NULL
;
1578 //-----------------------------------------------------------------------------
1579 // "scroll_event" (mouse wheel event)
1580 //-----------------------------------------------------------------------------
1583 window_scroll_event_hscrollbar(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1585 if (gdk_event
->direction
!= GDK_SCROLL_LEFT
&&
1586 gdk_event
->direction
!= GDK_SCROLL_RIGHT
)
1591 GtkRange
*range
= win
->m_scrollBar
[wxWindow::ScrollDir_Horz
];
1593 if (range
&& gtk_widget_get_visible(GTK_WIDGET(range
)))
1595 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
1596 double delta
= gtk_adjustment_get_step_increment(adj
) * 3;
1597 if (gdk_event
->direction
== GDK_SCROLL_LEFT
)
1600 gtk_range_set_value(range
, gtk_adjustment_get_value(adj
) + delta
);
1609 window_scroll_event(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1611 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1612 InitMouseEvent(win
, event
, gdk_event
);
1614 // FIXME: Get these values from GTK or GDK
1615 event
.m_linesPerAction
= 3;
1616 event
.m_wheelDelta
= 120;
1618 // Determine the scroll direction.
1619 switch (gdk_event
->direction
)
1622 case GDK_SCROLL_RIGHT
:
1623 event
.m_wheelRotation
= 120;
1626 case GDK_SCROLL_DOWN
:
1627 case GDK_SCROLL_LEFT
:
1628 event
.m_wheelRotation
= -120;
1632 return false; // Unknown/unhandled direction
1635 // And the scroll axis.
1636 switch (gdk_event
->direction
)
1639 case GDK_SCROLL_DOWN
:
1640 event
.m_wheelAxis
= wxMOUSE_WHEEL_VERTICAL
;
1643 case GDK_SCROLL_LEFT
:
1644 case GDK_SCROLL_RIGHT
:
1645 event
.m_wheelAxis
= wxMOUSE_WHEEL_HORIZONTAL
;
1649 if (win
->GTKProcessEvent(event
))
1652 GtkRange
*range
= win
->m_scrollBar
[wxWindow::ScrollDir_Vert
];
1654 if (range
&& gtk_widget_get_visible(GTK_WIDGET(range
)))
1656 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
1657 double delta
= gtk_adjustment_get_step_increment(adj
) * 3;
1658 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1661 gtk_range_set_value(range
, gtk_adjustment_get_value(adj
) + delta
);
1669 //-----------------------------------------------------------------------------
1671 //-----------------------------------------------------------------------------
1673 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
1675 wxContextMenuEvent
event(wxEVT_CONTEXT_MENU
, win
->GetId(), wxPoint(-1, -1));
1676 event
.SetEventObject(win
);
1677 return win
->GTKProcessEvent(event
);
1680 //-----------------------------------------------------------------------------
1682 //-----------------------------------------------------------------------------
1685 gtk_window_focus_in_callback( GtkWidget
* WXUNUSED(widget
),
1686 GdkEventFocus
*WXUNUSED(event
),
1689 return win
->GTKHandleFocusIn();
1692 //-----------------------------------------------------------------------------
1693 // "focus_out_event"
1694 //-----------------------------------------------------------------------------
1697 gtk_window_focus_out_callback( GtkWidget
* WXUNUSED(widget
),
1698 GdkEventFocus
* WXUNUSED(gdk_event
),
1701 return win
->GTKHandleFocusOut();
1704 //-----------------------------------------------------------------------------
1706 //-----------------------------------------------------------------------------
1709 wx_window_focus_callback(GtkWidget
*widget
,
1710 GtkDirectionType
WXUNUSED(direction
),
1713 // the default handler for focus signal in GtkScrolledWindow sets
1714 // focus to the window itself even if it doesn't accept focus, i.e. has no
1715 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1716 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1717 // any children which might accept focus (we know we don't accept the focus
1718 // ourselves as this signal is only connected in this case)
1719 if ( win
->GetChildren().empty() )
1720 g_signal_stop_emission_by_name(widget
, "focus");
1722 // we didn't change the focus
1726 //-----------------------------------------------------------------------------
1727 // "enter_notify_event"
1728 //-----------------------------------------------------------------------------
1731 gtk_window_enter_callback( GtkWidget
*widget
,
1732 GdkEventCrossing
*gdk_event
,
1735 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1737 // Event was emitted after a grab
1738 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1742 GdkModifierType state
= (GdkModifierType
)0;
1744 gdk_window_get_pointer(gtk_widget_get_window(widget
), &x
, &y
, &state
);
1746 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1747 InitMouseEvent(win
, event
, gdk_event
);
1748 wxPoint pt
= win
->GetClientAreaOrigin();
1749 event
.m_x
= x
+ pt
.x
;
1750 event
.m_y
= y
+ pt
.y
;
1752 if ( !g_captureWindow
)
1754 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1755 if (win
->GTKProcessEvent( cevent
))
1757 win
->SetCursor( cevent
.GetCursor() );
1761 return win
->GTKProcessEvent(event
);
1764 //-----------------------------------------------------------------------------
1765 // "leave_notify_event"
1766 //-----------------------------------------------------------------------------
1769 gtk_window_leave_callback( GtkWidget
*widget
,
1770 GdkEventCrossing
*gdk_event
,
1773 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1775 // Event was emitted after an ungrab
1776 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1778 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1782 GdkModifierType state
= (GdkModifierType
)0;
1784 gdk_window_get_pointer(gtk_widget_get_window(widget
), &x
, &y
, &state
);
1786 InitMouseEvent(win
, event
, gdk_event
);
1788 return win
->GTKProcessEvent(event
);
1791 //-----------------------------------------------------------------------------
1792 // "value_changed" from scrollbar
1793 //-----------------------------------------------------------------------------
1796 gtk_scrollbar_value_changed(GtkRange
* range
, wxWindow
* win
)
1798 wxEventType eventType
= win
->GTKGetScrollEventType(range
);
1799 if (eventType
!= wxEVT_NULL
)
1801 // Convert scroll event type to scrollwin event type
1802 eventType
+= wxEVT_SCROLLWIN_TOP
- wxEVT_SCROLL_TOP
;
1804 // find the scrollbar which generated the event
1805 wxWindowGTK::ScrollDir dir
= win
->ScrollDirFromRange(range
);
1807 // generate the corresponding wx event
1808 const int orient
= wxWindow::OrientFromScrollDir(dir
);
1809 wxScrollWinEvent
event(eventType
, win
->GetScrollPos(orient
), orient
);
1810 event
.SetEventObject(win
);
1812 win
->GTKProcessEvent(event
);
1816 //-----------------------------------------------------------------------------
1817 // "button_press_event" from scrollbar
1818 //-----------------------------------------------------------------------------
1821 gtk_scrollbar_button_press_event(GtkRange
*, GdkEventButton
*, wxWindow
* win
)
1823 g_blockEventsOnScroll
= true;
1824 win
->m_mouseButtonDown
= true;
1829 //-----------------------------------------------------------------------------
1830 // "event_after" from scrollbar
1831 //-----------------------------------------------------------------------------
1834 gtk_scrollbar_event_after(GtkRange
* range
, GdkEvent
* event
, wxWindow
* win
)
1836 if (event
->type
== GDK_BUTTON_RELEASE
)
1838 g_signal_handlers_block_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1840 const int orient
= wxWindow::OrientFromScrollDir(
1841 win
->ScrollDirFromRange(range
));
1842 wxScrollWinEvent
evt(wxEVT_SCROLLWIN_THUMBRELEASE
,
1843 win
->GetScrollPos(orient
), orient
);
1844 evt
.SetEventObject(win
);
1845 win
->GTKProcessEvent(evt
);
1849 //-----------------------------------------------------------------------------
1850 // "button_release_event" from scrollbar
1851 //-----------------------------------------------------------------------------
1854 gtk_scrollbar_button_release_event(GtkRange
* range
, GdkEventButton
*, wxWindow
* win
)
1856 g_blockEventsOnScroll
= false;
1857 win
->m_mouseButtonDown
= false;
1858 // If thumb tracking
1859 if (win
->m_isScrolling
)
1861 win
->m_isScrolling
= false;
1862 // Hook up handler to send thumb release event after this emission is finished.
1863 // To allow setting scroll position from event handler, sending event must
1864 // be deferred until after the GtkRange handler for this signal has run
1865 g_signal_handlers_unblock_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1871 //-----------------------------------------------------------------------------
1872 // "realize" from m_widget
1873 //-----------------------------------------------------------------------------
1876 gtk_window_realized_callback(GtkWidget
* WXUNUSED(widget
), wxWindowGTK
* win
)
1878 win
->GTKHandleRealized();
1881 //-----------------------------------------------------------------------------
1882 // "size_allocate" from m_wxwindow or m_widget
1883 //-----------------------------------------------------------------------------
1886 size_allocate(GtkWidget
*, GtkAllocation
* alloc
, wxWindow
* win
)
1888 int w
= alloc
->width
;
1889 int h
= alloc
->height
;
1890 if (win
->m_wxwindow
)
1893 WX_PIZZA(win
->m_wxwindow
)->get_border(border
);
1894 w
-= border
.left
+ border
.right
;
1895 h
-= border
.top
+ border
.bottom
;
1899 if (win
->m_oldClientWidth
!= w
|| win
->m_oldClientHeight
!= h
)
1901 win
->m_oldClientWidth
= w
;
1902 win
->m_oldClientHeight
= h
;
1903 // this callback can be connected to m_wxwindow,
1904 // so always get size from m_widget->allocation
1906 gtk_widget_get_allocation(win
->m_widget
, &a
);
1907 win
->m_width
= a
.width
;
1908 win
->m_height
= a
.height
;
1909 if (!win
->m_nativeSizeEvent
)
1911 wxSizeEvent
event(win
->GetSize(), win
->GetId());
1912 event
.SetEventObject(win
);
1913 win
->GTKProcessEvent(event
);
1918 //-----------------------------------------------------------------------------
1920 //-----------------------------------------------------------------------------
1922 #if GTK_CHECK_VERSION(2, 8, 0)
1924 gtk_window_grab_broken( GtkWidget
*,
1925 GdkEventGrabBroken
*event
,
1928 // Mouse capture has been lost involuntarily, notify the application
1929 if(!event
->keyboard
&& wxWindow::GetCapture() == win
)
1931 wxMouseCaptureLostEvent
evt( win
->GetId() );
1932 evt
.SetEventObject( win
);
1933 win
->HandleWindowEvent( evt
);
1939 //-----------------------------------------------------------------------------
1940 // "style_set"/"style_updated"
1941 //-----------------------------------------------------------------------------
1944 static void style_updated(GtkWidget
*, wxWindow
* win
)
1946 static void style_updated(GtkWidget
*, GtkStyle
*, wxWindow
* win
)
1949 if (win
->IsTopLevel())
1951 wxSysColourChangedEvent event
;
1952 event
.SetEventObject(win
);
1953 win
->GTKProcessEvent(event
);
1957 // Border width could change, which will change client size.
1958 // Make sure size event occurs for this
1959 win
->m_oldClientWidth
= 0;
1963 //-----------------------------------------------------------------------------
1964 // "unrealize" from m_wxwindow
1965 //-----------------------------------------------------------------------------
1967 static void unrealize(GtkWidget
*, wxWindow
* win
)
1970 gtk_im_context_set_client_window(win
->m_imData
->context
, NULL
);
1972 g_signal_handlers_disconnect_by_func(
1973 win
->m_wxwindow
, (void*)style_updated
, win
);
1978 void wxWindowGTK::GTKHandleRealized()
1982 gtk_im_context_set_client_window
1985 m_wxwindow
? GTKGetDrawingWindow()
1986 : gtk_widget_get_window(m_widget
)
1990 // Use composited window if background is transparent, if supported.
1991 if (m_backgroundStyle
== wxBG_STYLE_TRANSPARENT
)
1993 #if wxGTK_HAS_COMPOSITING_SUPPORT
1994 if (IsTransparentBackgroundSupported())
1996 GdkWindow
* const window
= GTKGetDrawingWindow();
1998 gdk_window_set_composited(window
, true);
2001 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
2003 // We revert to erase mode if transparency is not supported
2004 m_backgroundStyle
= wxBG_STYLE_ERASE
;
2009 // We cannot set colours and fonts before the widget
2010 // been realized, so we do this directly after realization
2011 // or otherwise in idle time
2013 if (m_needsStyleChange
)
2015 SetBackgroundStyle(GetBackgroundStyle());
2016 m_needsStyleChange
= false;
2019 wxWindowCreateEvent
event(static_cast<wxWindow
*>(this));
2020 event
.SetEventObject( this );
2021 GTKProcessEvent( event
);
2023 GTKUpdateCursor(true, false);
2026 (IsTopLevel() || HasFlag(wxBORDER_RAISED
| wxBORDER_SUNKEN
| wxBORDER_THEME
)))
2028 // attaching to style changed signal after realization avoids initial
2029 // changes we don't care about
2030 const gchar
*detailed_signal
=
2036 g_signal_connect(m_wxwindow
,
2038 G_CALLBACK(style_updated
), this);
2042 // ----------------------------------------------------------------------------
2043 // this wxWindowBase function is implemented here (in platform-specific file)
2044 // because it is static and so couldn't be made virtual
2045 // ----------------------------------------------------------------------------
2047 wxWindow
*wxWindowBase::DoFindFocus()
2049 // For compatibility with wxMSW, pretend that showing a popup menu doesn't
2050 // change the focus and that it remains on the window showing it, even
2051 // though the real focus does change in GTK.
2052 extern wxMenu
*wxCurrentPopupMenu
;
2053 if ( wxCurrentPopupMenu
)
2054 return wxCurrentPopupMenu
->GetInvokingWindow();
2056 wxWindowGTK
*focus
= gs_pendingFocus
? gs_pendingFocus
: gs_currentFocus
;
2057 // the cast is necessary when we compile in wxUniversal mode
2058 return static_cast<wxWindow
*>(focus
);
2061 void wxWindowGTK::AddChildGTK(wxWindowGTK
* child
)
2063 wxASSERT_MSG(m_wxwindow
, "Cannot add a child to a window without a client area");
2065 // the window might have been scrolled already, we
2066 // have to adapt the position
2067 wxPizza
* pizza
= WX_PIZZA(m_wxwindow
);
2068 child
->m_x
+= pizza
->m_scroll_x
;
2069 child
->m_y
+= pizza
->m_scroll_y
;
2071 pizza
->put(child
->m_widget
,
2072 child
->m_x
, child
->m_y
, child
->m_width
, child
->m_height
);
2075 //-----------------------------------------------------------------------------
2077 //-----------------------------------------------------------------------------
2079 wxWindow
*wxGetActiveWindow()
2081 return wxWindow::FindFocus();
2085 // Under Unix this is implemented using X11 functions in utilsx11.cpp but we
2086 // need to have this function under Windows too, so provide at least a stub.
2087 #ifndef GDK_WINDOWING_X11
2088 bool wxGetKeyState(wxKeyCode
WXUNUSED(key
))
2090 wxFAIL_MSG(wxS("Not implemented under Windows"));
2093 #endif // __WINDOWS__
2095 static void GetMouseState(int& x
, int& y
, GdkModifierType
& mask
)
2097 wxWindow
* tlw
= NULL
;
2098 if (!wxTopLevelWindows
.empty())
2099 tlw
= wxTopLevelWindows
.front();
2100 GdkDisplay
* display
;
2101 if (tlw
&& tlw
->m_widget
)
2102 display
= gtk_widget_get_display(tlw
->m_widget
);
2104 display
= gdk_display_get_default();
2105 gdk_display_get_pointer(display
, NULL
, &x
, &y
, &mask
);
2108 wxMouseState
wxGetMouseState()
2114 GdkModifierType mask
;
2116 GetMouseState(x
, y
, mask
);
2120 ms
.SetLeftDown((mask
& GDK_BUTTON1_MASK
) != 0);
2121 ms
.SetMiddleDown((mask
& GDK_BUTTON2_MASK
) != 0);
2122 ms
.SetRightDown((mask
& GDK_BUTTON3_MASK
) != 0);
2123 // see the comment in InitMouseEvent()
2124 ms
.SetAux1Down((mask
& GDK_BUTTON4_MASK
) != 0);
2125 ms
.SetAux2Down((mask
& GDK_BUTTON5_MASK
) != 0);
2127 ms
.SetControlDown((mask
& GDK_CONTROL_MASK
) != 0);
2128 ms
.SetShiftDown((mask
& GDK_SHIFT_MASK
) != 0);
2129 ms
.SetAltDown((mask
& GDK_MOD1_MASK
) != 0);
2130 ms
.SetMetaDown((mask
& GDK_META_MASK
) != 0);
2135 //-----------------------------------------------------------------------------
2137 //-----------------------------------------------------------------------------
2139 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2141 #ifdef __WXUNIVERSAL__
2142 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2143 #endif // __WXUNIVERSAL__
2145 void wxWindowGTK::Init()
2150 m_focusWidget
= NULL
;
2160 m_showOnIdle
= false;
2163 m_nativeSizeEvent
= false;
2165 m_paintContext
= NULL
;
2168 m_isScrolling
= false;
2169 m_mouseButtonDown
= false;
2171 // initialize scrolling stuff
2172 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2174 m_scrollBar
[dir
] = NULL
;
2175 m_scrollPos
[dir
] = 0;
2179 m_oldClientHeight
= 0;
2181 m_clipPaintRegion
= false;
2183 m_needsStyleChange
= false;
2185 m_cursor
= *wxSTANDARD_CURSOR
;
2188 m_dirtyTabOrder
= false;
2191 wxWindowGTK::wxWindowGTK()
2196 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2201 const wxString
&name
)
2205 Create( parent
, id
, pos
, size
, style
, name
);
2208 bool wxWindowGTK::Create( wxWindow
*parent
,
2213 const wxString
&name
)
2215 // Get default border
2216 wxBorder border
= GetBorder(style
);
2218 style
&= ~wxBORDER_MASK
;
2221 if (!PreCreation( parent
, pos
, size
) ||
2222 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2224 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2228 // We should accept the native look
2230 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2231 scroll_class
->scrollbar_spacing
= 0;
2235 m_wxwindow
= wxPizza::New(m_windowStyle
);
2236 #ifndef __WXUNIVERSAL__
2237 if (HasFlag(wxPizza::BORDER_STYLES
))
2239 g_signal_connect(m_wxwindow
, "parent_set",
2240 G_CALLBACK(parent_set
), this);
2243 if (!HasFlag(wxHSCROLL
) && !HasFlag(wxVSCROLL
))
2244 m_widget
= m_wxwindow
;
2247 m_widget
= gtk_scrolled_window_new( NULL
, NULL
);
2249 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2251 // There is a conflict with default bindings at GTK+
2252 // level between scrolled windows and notebooks both of which want to use
2253 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2254 // direction and notebooks for changing pages -- we decide that if we don't
2255 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2256 // means we can get working keyboard navigation in notebooks
2257 if ( !HasFlag(wxHSCROLL
) )
2260 bindings
= gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget
));
2263 gtk_binding_entry_remove(bindings
, GDK_Page_Up
, GDK_CONTROL_MASK
);
2264 gtk_binding_entry_remove(bindings
, GDK_Page_Down
, GDK_CONTROL_MASK
);
2268 if (HasFlag(wxALWAYS_SHOW_SB
))
2270 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_ALWAYS
, GTK_POLICY_ALWAYS
);
2274 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2277 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow
));
2278 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow
));
2279 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2280 gtk_range_set_inverted( m_scrollBar
[ScrollDir_Horz
], TRUE
);
2282 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2284 // connect various scroll-related events
2285 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2287 // these handlers block mouse events to any window during scrolling
2288 // such as motion events and prevent GTK and wxWidgets from fighting
2289 // over where the slider should be
2290 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2291 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2292 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2293 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2295 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2296 G_CALLBACK(gtk_scrollbar_event_after
), this);
2297 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2299 // these handlers get notified when scrollbar slider moves
2300 g_signal_connect_after(m_scrollBar
[dir
], "value_changed",
2301 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2304 gtk_widget_show( m_wxwindow
);
2306 g_object_ref(m_widget
);
2309 m_parent
->DoAddChild( this );
2311 m_focusWidget
= m_wxwindow
;
2313 SetCanFocus(AcceptsFocus());
2320 wxWindowGTK::~wxWindowGTK()
2324 if (gs_currentFocus
== this)
2325 gs_currentFocus
= NULL
;
2326 if (gs_pendingFocus
== this)
2327 gs_pendingFocus
= NULL
;
2329 if ( gs_deferredFocusOut
== this )
2330 gs_deferredFocusOut
= NULL
;
2334 // destroy children before destroying this window itself
2337 // unhook focus handlers to prevent stray events being
2338 // propagated to this (soon to be) dead object
2339 if (m_focusWidget
!= NULL
)
2341 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2342 (gpointer
) gtk_window_focus_in_callback
,
2344 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2345 (gpointer
) gtk_window_focus_out_callback
,
2352 // delete before the widgets to avoid a crash on solaris
2356 // avoid problem with GTK+ 2.18 where a frozen window causes the whole
2357 // TLW to be frozen, and if the window is then destroyed, nothing ever
2358 // gets painted again
2364 // Note that gtk_widget_destroy() does not destroy the widget, it just
2365 // emits the "destroy" signal. The widget is not actually destroyed
2366 // until its reference count drops to zero.
2367 gtk_widget_destroy(m_widget
);
2368 // Release our reference, should be the last one
2369 g_object_unref(m_widget
);
2375 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2377 if ( GTKNeedsParent() )
2379 wxCHECK_MSG( parent
, false, wxT("Must have non-NULL parent") );
2382 // Use either the given size, or the default if -1 is given.
2383 // See wxWindowBase for these functions.
2384 m_width
= WidthDefault(size
.x
) ;
2385 m_height
= HeightDefault(size
.y
);
2387 if (pos
!= wxDefaultPosition
)
2396 void wxWindowGTK::PostCreation()
2398 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2400 #if wxGTK_HAS_COMPOSITING_SUPPORT
2401 // Set RGBA visual as soon as possible to minimize the possibility that
2402 // somebody uses the wrong one.
2403 if ( m_backgroundStyle
== wxBG_STYLE_TRANSPARENT
&&
2404 IsTransparentBackgroundSupported() )
2406 GdkScreen
*screen
= gtk_widget_get_screen (m_widget
);
2408 gtk_widget_set_visual(m_widget
, gdk_screen_get_rgba_visual(screen
));
2410 GdkColormap
*rgba_colormap
= gdk_screen_get_rgba_colormap (screen
);
2413 gtk_widget_set_colormap(m_widget
, rgba_colormap
);
2416 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
2422 // these get reported to wxWidgets -> wxPaintEvent
2424 g_signal_connect(m_wxwindow
, "draw", G_CALLBACK(draw
), this);
2426 g_signal_connect(m_wxwindow
, "expose_event", G_CALLBACK(expose_event
), this);
2429 if (GetLayoutDirection() == wxLayout_LeftToRight
)
2430 gtk_widget_set_redraw_on_allocate(m_wxwindow
, HasFlag(wxFULL_REPAINT_ON_RESIZE
));
2433 // Create input method handler
2434 m_imData
= new wxGtkIMData
;
2436 // Cannot handle drawing preedited text yet
2437 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2439 g_signal_connect (m_imData
->context
, "commit",
2440 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2441 g_signal_connect(m_wxwindow
, "unrealize", G_CALLBACK(unrealize
), this);
2446 if (!GTK_IS_WINDOW(m_widget
))
2448 if (m_focusWidget
== NULL
)
2449 m_focusWidget
= m_widget
;
2453 g_signal_connect (m_focusWidget
, "focus_in_event",
2454 G_CALLBACK (gtk_window_focus_in_callback
), this);
2455 g_signal_connect (m_focusWidget
, "focus_out_event",
2456 G_CALLBACK (gtk_window_focus_out_callback
), this);
2460 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2461 G_CALLBACK (gtk_window_focus_in_callback
), this);
2462 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2463 G_CALLBACK (gtk_window_focus_out_callback
), this);
2467 if ( !AcceptsFocusFromKeyboard() )
2471 g_signal_connect(m_widget
, "focus",
2472 G_CALLBACK(wx_window_focus_callback
), this);
2475 // connect to the various key and mouse handlers
2477 GtkWidget
*connect_widget
= GetConnectWidget();
2479 ConnectWidget( connect_widget
);
2481 // We cannot set colours, fonts and cursors before the widget has been
2482 // realized, so we do this directly after realization -- unless the widget
2483 // was in fact realized already.
2484 if ( gtk_widget_get_realized(connect_widget
) )
2486 gtk_window_realized_callback(connect_widget
, this);
2490 g_signal_connect (connect_widget
, "realize",
2491 G_CALLBACK (gtk_window_realized_callback
), this);
2496 g_signal_connect(m_wxwindow
? m_wxwindow
: m_widget
, "size_allocate",
2497 G_CALLBACK(size_allocate
), this);
2500 #if GTK_CHECK_VERSION(2, 8, 0)
2502 if ( gtk_check_version(2,8,0) == NULL
)
2505 // Make sure we can notify the app when mouse capture is lost
2508 g_signal_connect (m_wxwindow
, "grab_broken_event",
2509 G_CALLBACK (gtk_window_grab_broken
), this);
2512 if ( connect_widget
!= m_wxwindow
)
2514 g_signal_connect (connect_widget
, "grab_broken_event",
2515 G_CALLBACK (gtk_window_grab_broken
), this);
2518 #endif // GTK+ >= 2.8
2520 if (!WX_IS_PIZZA(gtk_widget_get_parent(m_widget
)) && !GTK_IS_WINDOW(m_widget
))
2521 gtk_widget_set_size_request(m_widget
, m_width
, m_height
);
2523 InheritAttributes();
2527 SetLayoutDirection(wxLayout_Default
);
2529 // unless the window was created initially hidden (i.e. Hide() had been
2530 // called before Create()), we should show it at GTK+ level as well
2532 gtk_widget_show( m_widget
);
2536 wxWindowGTK::GTKConnectWidget(const char *signal
, wxGTKCallback callback
)
2538 return g_signal_connect(m_widget
, signal
, callback
, this);
2541 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2543 g_signal_connect (widget
, "key_press_event",
2544 G_CALLBACK (gtk_window_key_press_callback
), this);
2545 g_signal_connect (widget
, "key_release_event",
2546 G_CALLBACK (gtk_window_key_release_callback
), this);
2547 g_signal_connect (widget
, "button_press_event",
2548 G_CALLBACK (gtk_window_button_press_callback
), this);
2549 g_signal_connect (widget
, "button_release_event",
2550 G_CALLBACK (gtk_window_button_release_callback
), this);
2551 g_signal_connect (widget
, "motion_notify_event",
2552 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2554 g_signal_connect (widget
, "scroll_event",
2555 G_CALLBACK (window_scroll_event
), this);
2556 if (m_scrollBar
[ScrollDir_Horz
])
2557 g_signal_connect (m_scrollBar
[ScrollDir_Horz
], "scroll_event",
2558 G_CALLBACK (window_scroll_event_hscrollbar
), this);
2559 if (m_scrollBar
[ScrollDir_Vert
])
2560 g_signal_connect (m_scrollBar
[ScrollDir_Vert
], "scroll_event",
2561 G_CALLBACK (window_scroll_event
), this);
2563 g_signal_connect (widget
, "popup_menu",
2564 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2565 g_signal_connect (widget
, "enter_notify_event",
2566 G_CALLBACK (gtk_window_enter_callback
), this);
2567 g_signal_connect (widget
, "leave_notify_event",
2568 G_CALLBACK (gtk_window_leave_callback
), this);
2571 bool wxWindowGTK::Destroy()
2575 return wxWindowBase::Destroy();
2578 static GSList
* gs_queueResizeList
;
2581 static gboolean
queue_resize(void*)
2583 gdk_threads_enter();
2584 for (GSList
* p
= gs_queueResizeList
; p
; p
= p
->next
)
2588 gtk_widget_queue_resize(GTK_WIDGET(p
->data
));
2589 g_object_remove_weak_pointer(G_OBJECT(p
->data
), &p
->data
);
2592 g_slist_free(gs_queueResizeList
);
2593 gs_queueResizeList
= NULL
;
2594 gdk_threads_leave();
2599 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2601 gtk_widget_set_size_request(m_widget
, width
, height
);
2602 GtkWidget
* parent
= gtk_widget_get_parent(m_widget
);
2603 if (WX_IS_PIZZA(parent
))
2604 WX_PIZZA(parent
)->move(m_widget
, x
, y
, width
, height
);
2606 // With GTK3, gtk_widget_queue_resize() is ignored while a size-allocate
2607 // is in progress. This situation is common in wxWidgets, since
2608 // size-allocate can generate wxSizeEvent and size event handlers often
2609 // call SetSize(), directly or indirectly. Work around this by deferring
2610 // the queue-resize until after size-allocate processing is finished.
2611 if (g_slist_find(gs_queueResizeList
, m_widget
) == NULL
)
2613 if (gs_queueResizeList
== NULL
)
2614 g_idle_add_full(GTK_PRIORITY_RESIZE
, queue_resize
, NULL
, NULL
);
2615 gs_queueResizeList
= g_slist_prepend(gs_queueResizeList
, m_widget
);
2616 g_object_add_weak_pointer(G_OBJECT(m_widget
), &gs_queueResizeList
->data
);
2620 void wxWindowGTK::ConstrainSize()
2623 // GPE's window manager doesn't like size hints at all, esp. when the user
2624 // has to use the virtual keyboard, so don't constrain size there
2628 const wxSize minSize
= GetMinSize();
2629 const wxSize maxSize
= GetMaxSize();
2630 if (minSize
.x
> 0 && m_width
< minSize
.x
) m_width
= minSize
.x
;
2631 if (minSize
.y
> 0 && m_height
< minSize
.y
) m_height
= minSize
.y
;
2632 if (maxSize
.x
> 0 && m_width
> maxSize
.x
) m_width
= maxSize
.x
;
2633 if (maxSize
.y
> 0 && m_height
> maxSize
.y
) m_height
= maxSize
.y
;
2637 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2639 wxCHECK_RET(m_widget
, "invalid window");
2641 int scrollX
= 0, scrollY
= 0;
2642 GtkWidget
* parent
= gtk_widget_get_parent(m_widget
);
2643 if (WX_IS_PIZZA(parent
))
2645 wxPizza
* pizza
= WX_PIZZA(parent
);
2646 scrollX
= pizza
->m_scroll_x
;
2647 scrollY
= pizza
->m_scroll_y
;
2649 if (x
!= -1 || (sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2653 if (y
!= -1 || (sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2658 // calculate the best size if we should auto size the window
2659 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2660 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2662 const wxSize sizeBest
= GetBestSize();
2663 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2665 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2666 height
= sizeBest
.y
;
2674 const bool sizeChange
= m_width
!= width
|| m_height
!= height
;
2675 if (sizeChange
|| m_x
!= x
|| m_y
!= y
)
2682 /* the default button has a border around it */
2683 if (gtk_widget_get_can_default(m_widget
))
2685 GtkBorder
*default_border
= NULL
;
2686 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2689 x
-= default_border
->left
;
2690 y
-= default_border
->top
;
2691 width
+= default_border
->left
+ default_border
->right
;
2692 height
+= default_border
->top
+ default_border
->bottom
;
2693 gtk_border_free( default_border
);
2697 DoMoveWindow(x
, y
, width
, height
);
2700 if ((sizeChange
&& !m_nativeSizeEvent
) || (sizeFlags
& wxSIZE_FORCE_EVENT
))
2702 // update these variables to keep size_allocate handler
2703 // from sending another size event for this change
2704 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2706 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2707 event
.SetEventObject( this );
2708 HandleWindowEvent( event
);
2712 bool wxWindowGTK::GTKShowFromOnIdle()
2714 if (IsShown() && m_showOnIdle
&& !gtk_widget_get_visible (m_widget
))
2716 GtkAllocation alloc
;
2719 alloc
.width
= m_width
;
2720 alloc
.height
= m_height
;
2721 gtk_widget_size_allocate( m_widget
, &alloc
);
2722 gtk_widget_show( m_widget
);
2723 wxShowEvent
eventShow(GetId(), true);
2724 eventShow
.SetEventObject(this);
2725 HandleWindowEvent(eventShow
);
2726 m_showOnIdle
= false;
2733 void wxWindowGTK::OnInternalIdle()
2735 if ( gs_deferredFocusOut
)
2736 GTKHandleDeferredFocusOut();
2738 // Check if we have to show window now
2739 if (GTKShowFromOnIdle()) return;
2741 if ( m_dirtyTabOrder
)
2743 m_dirtyTabOrder
= false;
2747 wxWindowBase::OnInternalIdle();
2750 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
2752 if (width
) (*width
) = m_width
;
2753 if (height
) (*height
) = m_height
;
2756 void wxWindowGTK::DoSetClientSize( int width
, int height
)
2758 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2760 const wxSize size
= GetSize();
2761 const wxSize clientSize
= GetClientSize();
2762 SetSize(width
+ (size
.x
- clientSize
.x
), height
+ (size
.y
- clientSize
.y
));
2765 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
2767 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2774 // if window is scrollable, account for scrollbars
2775 if ( GTK_IS_SCROLLED_WINDOW(m_widget
) )
2777 GtkPolicyType policy
[ScrollDir_Max
];
2778 gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget
),
2779 &policy
[ScrollDir_Horz
],
2780 &policy
[ScrollDir_Vert
]);
2781 const int scrollbar_spacing
=
2782 GTK_SCROLLED_WINDOW_GET_CLASS(m_widget
)->scrollbar_spacing
;
2784 for ( int i
= 0; i
< ScrollDir_Max
; i
++ )
2786 // don't account for the scrollbars we don't have
2787 GtkRange
* const range
= m_scrollBar
[i
];
2791 // nor for the ones we have but don't current show
2792 switch ( policy
[i
] )
2794 case GTK_POLICY_NEVER
:
2795 // never shown so doesn't take any place
2798 case GTK_POLICY_ALWAYS
:
2799 // no checks necessary
2802 case GTK_POLICY_AUTOMATIC
:
2803 // may be shown or not, check
2804 GtkAdjustment
*adj
= gtk_range_get_adjustment(range
);
2805 if (gtk_adjustment_get_upper(adj
) <= gtk_adjustment_get_page_size(adj
))
2811 GtkWidget
* widget
= GTK_WIDGET(range
);
2812 if (i
== ScrollDir_Horz
)
2816 gtk_widget_get_preferred_height(widget
, NULL
, &req
.height
);
2817 h
-= req
.height
+ scrollbar_spacing
;
2824 gtk_widget_get_preferred_width(widget
, NULL
, &req
.width
);
2825 w
-= req
.width
+ scrollbar_spacing
;
2828 #else // !__WXGTK3__
2829 gtk_widget_size_request(GTK_WIDGET(range
), &req
);
2830 if (i
== ScrollDir_Horz
)
2831 h
-= req
.height
+ scrollbar_spacing
;
2833 w
-= req
.width
+ scrollbar_spacing
;
2834 #endif // !__WXGTK3__
2838 const wxSize sizeBorders
= DoGetBorderSize();
2848 if (width
) *width
= w
;
2849 if (height
) *height
= h
;
2852 wxSize
wxWindowGTK::DoGetBorderSize() const
2855 return wxWindowBase::DoGetBorderSize();
2858 WX_PIZZA(m_wxwindow
)->get_border(border
);
2859 return wxSize(border
.left
+ border
.right
, border
.top
+ border
.bottom
);
2862 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
2866 GtkWidget
* parent
= NULL
;
2868 parent
= gtk_widget_get_parent(m_widget
);
2869 if (WX_IS_PIZZA(parent
))
2871 wxPizza
* pizza
= WX_PIZZA(parent
);
2872 dx
= pizza
->m_scroll_x
;
2873 dy
= pizza
->m_scroll_y
;
2875 if (x
) (*x
) = m_x
- dx
;
2876 if (y
) (*y
) = m_y
- dy
;
2879 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
2881 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2883 if (gtk_widget_get_window(m_widget
) == NULL
) return;
2885 GdkWindow
*source
= NULL
;
2887 source
= gtk_widget_get_window(m_wxwindow
);
2889 source
= gtk_widget_get_window(m_widget
);
2893 gdk_window_get_origin( source
, &org_x
, &org_y
);
2897 if (!gtk_widget_get_has_window(m_widget
))
2900 gtk_widget_get_allocation(m_widget
, &a
);
2909 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2910 *x
= (GetClientSize().x
- *x
) + org_x
;
2918 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
2920 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2922 if (!gtk_widget_get_realized(m_widget
)) return;
2924 GdkWindow
*source
= NULL
;
2926 source
= gtk_widget_get_window(m_wxwindow
);
2928 source
= gtk_widget_get_window(m_widget
);
2932 gdk_window_get_origin( source
, &org_x
, &org_y
);
2936 if (!gtk_widget_get_has_window(m_widget
))
2939 gtk_widget_get_allocation(m_widget
, &a
);
2947 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2948 *x
= (GetClientSize().x
- *x
) - org_x
;
2955 bool wxWindowGTK::Show( bool show
)
2957 if ( !wxWindowBase::Show(show
) )
2963 // notice that we may call Hide() before the window is created and this is
2964 // actually useful to create it hidden initially -- but we can't call
2965 // Show() before it is created
2968 wxASSERT_MSG( !show
, "can't show invalid window" );
2976 // defer until later
2980 gtk_widget_show(m_widget
);
2984 gtk_widget_hide(m_widget
);
2987 wxShowEvent
eventShow(GetId(), show
);
2988 eventShow
.SetEventObject(this);
2989 HandleWindowEvent(eventShow
);
2994 void wxWindowGTK::DoEnable( bool enable
)
2996 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2998 gtk_widget_set_sensitive( m_widget
, enable
);
2999 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3000 gtk_widget_set_sensitive( m_wxwindow
, enable
);
3003 int wxWindowGTK::GetCharHeight() const
3005 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
3007 wxFont font
= GetFont();
3008 wxCHECK_MSG( font
.IsOk(), 12, wxT("invalid font") );
3010 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
3015 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3016 PangoLayout
*layout
= pango_layout_new(context
);
3017 pango_layout_set_font_description(layout
, desc
);
3018 pango_layout_set_text(layout
, "H", 1);
3019 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3021 PangoRectangle rect
;
3022 pango_layout_line_get_extents(line
, NULL
, &rect
);
3024 g_object_unref (layout
);
3026 return (int) PANGO_PIXELS(rect
.height
);
3029 int wxWindowGTK::GetCharWidth() const
3031 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
3033 wxFont font
= GetFont();
3034 wxCHECK_MSG( font
.IsOk(), 8, wxT("invalid font") );
3036 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
3041 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3042 PangoLayout
*layout
= pango_layout_new(context
);
3043 pango_layout_set_font_description(layout
, desc
);
3044 pango_layout_set_text(layout
, "g", 1);
3045 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3047 PangoRectangle rect
;
3048 pango_layout_line_get_extents(line
, NULL
, &rect
);
3050 g_object_unref (layout
);
3052 return (int) PANGO_PIXELS(rect
.width
);
3055 void wxWindowGTK::DoGetTextExtent( const wxString
& string
,
3059 int *externalLeading
,
3060 const wxFont
*theFont
) const
3062 wxFont fontToUse
= theFont
? *theFont
: GetFont();
3064 wxCHECK_RET( fontToUse
.IsOk(), wxT("invalid font") );
3073 PangoContext
*context
= NULL
;
3075 context
= gtk_widget_get_pango_context( m_widget
);
3084 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3085 PangoLayout
*layout
= pango_layout_new(context
);
3086 pango_layout_set_font_description(layout
, desc
);
3088 const wxCharBuffer data
= wxGTK_CONV( string
);
3090 pango_layout_set_text(layout
, data
, strlen(data
));
3093 PangoRectangle rect
;
3094 pango_layout_get_extents(layout
, NULL
, &rect
);
3096 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
3097 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
3100 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
3101 int baseline
= pango_layout_iter_get_baseline(iter
);
3102 pango_layout_iter_free(iter
);
3103 *descent
= *y
- PANGO_PIXELS(baseline
);
3105 if (externalLeading
) (*externalLeading
) = 0; // ??
3107 g_object_unref (layout
);
3110 void wxWindowGTK::GTKDisableFocusOutEvent()
3112 g_signal_handlers_block_by_func( m_focusWidget
,
3113 (gpointer
) gtk_window_focus_out_callback
, this);
3116 void wxWindowGTK::GTKEnableFocusOutEvent()
3118 g_signal_handlers_unblock_by_func( m_focusWidget
,
3119 (gpointer
) gtk_window_focus_out_callback
, this);
3122 bool wxWindowGTK::GTKHandleFocusIn()
3124 // Disable default focus handling for custom windows since the default GTK+
3125 // handler issues a repaint
3126 const bool retval
= m_wxwindow
? true : false;
3129 // NB: if there's still unprocessed deferred focus-out event (see
3130 // GTKHandleFocusOut() for explanation), we need to process it first so
3131 // that the order of focus events -- focus-out first, then focus-in
3132 // elsewhere -- is preserved
3133 if ( gs_deferredFocusOut
)
3135 if ( GTKNeedsToFilterSameWindowFocus() &&
3136 gs_deferredFocusOut
== this )
3138 // GTK+ focus changed from this wxWindow back to itself, so don't
3139 // emit any events at all
3140 wxLogTrace(TRACE_FOCUS
,
3141 "filtered out spurious focus change within %s(%p, %s)",
3142 GetClassInfo()->GetClassName(), this, GetLabel());
3143 gs_deferredFocusOut
= NULL
;
3147 // otherwise we need to send focus-out first
3148 wxASSERT_MSG ( gs_deferredFocusOut
!= this,
3149 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
3150 GTKHandleDeferredFocusOut();
3154 wxLogTrace(TRACE_FOCUS
,
3155 "handling focus_in event for %s(%p, %s)",
3156 GetClassInfo()->GetClassName(), this, GetLabel());
3159 gtk_im_context_focus_in(m_imData
->context
);
3161 gs_currentFocus
= this;
3162 gs_pendingFocus
= NULL
;
3165 // caret needs to be informed about focus change
3166 wxCaret
*caret
= GetCaret();
3169 caret
->OnSetFocus();
3171 #endif // wxUSE_CARET
3173 // Notify the parent keeping track of focus for the kbd navigation
3174 // purposes that we got it.
3175 wxChildFocusEvent
eventChildFocus(static_cast<wxWindow
*>(this));
3176 GTKProcessEvent(eventChildFocus
);
3178 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, GetId());
3179 eventFocus
.SetEventObject(this);
3180 GTKProcessEvent(eventFocus
);
3185 bool wxWindowGTK::GTKHandleFocusOut()
3187 // Disable default focus handling for custom windows since the default GTK+
3188 // handler issues a repaint
3189 const bool retval
= m_wxwindow
? true : false;
3192 // NB: If a control is composed of several GtkWidgets and when focus
3193 // changes from one of them to another within the same wxWindow, we get
3194 // a focus-out event followed by focus-in for another GtkWidget owned
3195 // by the same wx control. We don't want to generate two spurious
3196 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3197 // from GTKHandleFocusOut() until we know for sure it's not coming back
3198 // (i.e. in GTKHandleFocusIn() or at idle time).
3199 if ( GTKNeedsToFilterSameWindowFocus() )
3201 wxASSERT_MSG( gs_deferredFocusOut
== NULL
,
3202 "deferred focus out event already pending" );
3203 wxLogTrace(TRACE_FOCUS
,
3204 "deferring focus_out event for %s(%p, %s)",
3205 GetClassInfo()->GetClassName(), this, GetLabel());
3206 gs_deferredFocusOut
= this;
3210 GTKHandleFocusOutNoDeferring();
3215 void wxWindowGTK::GTKHandleFocusOutNoDeferring()
3217 wxLogTrace(TRACE_FOCUS
,
3218 "handling focus_out event for %s(%p, %s)",
3219 GetClassInfo()->GetClassName(), this, GetLabel());
3222 gtk_im_context_focus_out(m_imData
->context
);
3224 if ( gs_currentFocus
!= this )
3226 // Something is terribly wrong, gs_currentFocus is out of sync with the
3227 // real focus. We will reset it to NULL anyway, because after this
3228 // focus-out event is handled, one of the following with happen:
3230 // * either focus will go out of the app altogether, in which case
3231 // gs_currentFocus _should_ be NULL
3233 // * or it goes to another control, in which case focus-in event will
3234 // follow immediately and it will set gs_currentFocus to the right
3236 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3237 GetClassInfo()->GetClassName(), this, GetLabel());
3239 gs_currentFocus
= NULL
;
3242 // caret needs to be informed about focus change
3243 wxCaret
*caret
= GetCaret();
3246 caret
->OnKillFocus();
3248 #endif // wxUSE_CARET
3250 wxFocusEvent
event( wxEVT_KILL_FOCUS
, GetId() );
3251 event
.SetEventObject( this );
3252 event
.SetWindow( FindFocus() );
3253 GTKProcessEvent( event
);
3257 void wxWindowGTK::GTKHandleDeferredFocusOut()
3259 // NB: See GTKHandleFocusOut() for explanation. This function is called
3260 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3262 if ( gs_deferredFocusOut
)
3264 wxWindowGTK
*win
= gs_deferredFocusOut
;
3265 gs_deferredFocusOut
= NULL
;
3267 wxLogTrace(TRACE_FOCUS
,
3268 "processing deferred focus_out event for %s(%p, %s)",
3269 win
->GetClassInfo()->GetClassName(), win
, win
->GetLabel());
3271 win
->GTKHandleFocusOutNoDeferring();
3275 void wxWindowGTK::SetFocus()
3277 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3279 // Setting "physical" focus is not immediate in GTK+ and while
3280 // gtk_widget_is_focus ("determines if the widget is the focus widget
3281 // within its toplevel", i.e. returns true for one widget per TLW, not
3282 // globally) returns true immediately after grabbing focus,
3283 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3284 // has focus at the moment) takes effect only after the window is shown
3285 // (if it was hidden at the moment of the call) or at the next event loop
3288 // Because we want to FindFocus() call immediately following
3289 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3291 gs_pendingFocus
= this;
3293 GtkWidget
*widget
= m_wxwindow
? m_wxwindow
: m_focusWidget
;
3295 if ( GTK_IS_CONTAINER(widget
) &&
3296 !gtk_widget_get_can_focus(widget
) )
3298 wxLogTrace(TRACE_FOCUS
,
3299 wxT("Setting focus to a child of %s(%p, %s)"),
3300 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3301 gtk_widget_child_focus(widget
, GTK_DIR_TAB_FORWARD
);
3305 wxLogTrace(TRACE_FOCUS
,
3306 wxT("Setting focus to %s(%p, %s)"),
3307 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3308 gtk_widget_grab_focus(widget
);
3312 void wxWindowGTK::SetCanFocus(bool canFocus
)
3314 gtk_widget_set_can_focus(m_widget
, canFocus
);
3316 if ( m_wxwindow
&& (m_widget
!= m_wxwindow
) )
3318 gtk_widget_set_can_focus(m_wxwindow
, canFocus
);
3322 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3324 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3326 wxWindowGTK
* const newParent
= (wxWindowGTK
*)newParentBase
;
3328 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3330 if ( !wxWindowBase::Reparent(newParent
) )
3333 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3335 // Notice that old m_parent pointer might be non-NULL here but the widget
3336 // still not have any parent at GTK level if it's a notebook page that had
3337 // been removed from the notebook so test this at GTK level and not wx one.
3338 if ( GtkWidget
*parentGTK
= gtk_widget_get_parent(m_widget
) )
3339 gtk_container_remove(GTK_CONTAINER(parentGTK
), m_widget
);
3341 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3345 if (gtk_widget_get_visible (newParent
->m_widget
))
3347 m_showOnIdle
= true;
3348 gtk_widget_hide( m_widget
);
3350 /* insert GTK representation */
3351 newParent
->AddChildGTK(this);
3354 SetLayoutDirection(wxLayout_Default
);
3359 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3361 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3362 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3367 /* insert GTK representation */
3371 void wxWindowGTK::AddChild(wxWindowBase
*child
)
3373 wxWindowBase::AddChild(child
);
3374 m_dirtyTabOrder
= true;
3375 wxTheApp
->WakeUpIdle();
3378 void wxWindowGTK::RemoveChild(wxWindowBase
*child
)
3380 wxWindowBase::RemoveChild(child
);
3381 m_dirtyTabOrder
= true;
3382 wxTheApp
->WakeUpIdle();
3386 wxLayoutDirection
wxWindowGTK::GTKGetLayout(GtkWidget
*widget
)
3388 return gtk_widget_get_direction(widget
) == GTK_TEXT_DIR_RTL
3389 ? wxLayout_RightToLeft
3390 : wxLayout_LeftToRight
;
3394 void wxWindowGTK::GTKSetLayout(GtkWidget
*widget
, wxLayoutDirection dir
)
3396 wxASSERT_MSG( dir
!= wxLayout_Default
, wxT("invalid layout direction") );
3398 gtk_widget_set_direction(widget
,
3399 dir
== wxLayout_RightToLeft
? GTK_TEXT_DIR_RTL
3400 : GTK_TEXT_DIR_LTR
);
3403 wxLayoutDirection
wxWindowGTK::GetLayoutDirection() const
3405 return GTKGetLayout(m_widget
);
3408 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir
)
3410 if ( dir
== wxLayout_Default
)
3412 const wxWindow
*const parent
= GetParent();
3415 // inherit layout from parent.
3416 dir
= parent
->GetLayoutDirection();
3418 else // no parent, use global default layout
3420 dir
= wxTheApp
->GetLayoutDirection();
3424 if ( dir
== wxLayout_Default
)
3427 GTKSetLayout(m_widget
, dir
);
3429 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3430 GTKSetLayout(m_wxwindow
, dir
);
3434 wxWindowGTK::AdjustForLayoutDirection(wxCoord x
,
3435 wxCoord
WXUNUSED(width
),
3436 wxCoord
WXUNUSED(widthTotal
)) const
3438 // We now mirror the coordinates of RTL windows in wxPizza
3442 void wxWindowGTK::DoMoveInTabOrder(wxWindow
*win
, WindowOrder move
)
3444 wxWindowBase::DoMoveInTabOrder(win
, move
);
3445 m_dirtyTabOrder
= true;
3446 wxTheApp
->WakeUpIdle();
3449 bool wxWindowGTK::DoNavigateIn(int flags
)
3451 if ( flags
& wxNavigationKeyEvent::WinChange
)
3453 wxFAIL_MSG( wxT("not implemented") );
3457 else // navigate inside the container
3459 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3460 wxCHECK_MSG( parent
, false, wxT("every window must have a TLW parent") );
3462 GtkDirectionType dir
;
3463 dir
= flags
& wxNavigationKeyEvent::IsForward
? GTK_DIR_TAB_FORWARD
3464 : GTK_DIR_TAB_BACKWARD
;
3467 g_signal_emit_by_name(parent
->m_widget
, "focus", dir
, &rc
);
3473 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3475 // none needed by default
3479 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3481 // nothing to do by default since none is needed
3484 void wxWindowGTK::RealizeTabOrder()
3488 if ( !m_children
.empty() )
3490 // we don't only construct the correct focus chain but also use
3491 // this opportunity to update the mnemonic widgets for the widgets
3494 GList
*chain
= NULL
;
3495 wxWindowGTK
* mnemonicWindow
= NULL
;
3497 for ( wxWindowList::const_iterator i
= m_children
.begin();
3498 i
!= m_children
.end();
3501 wxWindowGTK
*win
= *i
;
3503 bool focusableFromKeyboard
= win
->AcceptsFocusFromKeyboard();
3505 if ( mnemonicWindow
)
3507 if ( focusableFromKeyboard
)
3509 // wxComboBox et al. needs to focus on on a different
3510 // widget than m_widget, so if the main widget isn't
3511 // focusable try the connect widget
3512 GtkWidget
* w
= win
->m_widget
;
3513 if ( !gtk_widget_get_can_focus(w
) )
3515 w
= win
->GetConnectWidget();
3516 if ( !gtk_widget_get_can_focus(w
) )
3522 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3523 mnemonicWindow
= NULL
;
3527 else if ( win
->GTKWidgetNeedsMnemonic() )
3529 mnemonicWindow
= win
;
3532 if ( focusableFromKeyboard
)
3533 chain
= g_list_prepend(chain
, win
->m_widget
);
3536 chain
= g_list_reverse(chain
);
3538 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3543 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3548 void wxWindowGTK::Raise()
3550 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3552 if (m_wxwindow
&& gtk_widget_get_window(m_wxwindow
))
3554 gdk_window_raise(gtk_widget_get_window(m_wxwindow
));
3556 else if (gtk_widget_get_window(m_widget
))
3558 gdk_window_raise(gtk_widget_get_window(m_widget
));
3562 void wxWindowGTK::Lower()
3564 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3566 if (m_wxwindow
&& gtk_widget_get_window(m_wxwindow
))
3568 gdk_window_lower(gtk_widget_get_window(m_wxwindow
));
3570 else if (gtk_widget_get_window(m_widget
))
3572 gdk_window_lower(gtk_widget_get_window(m_widget
));
3576 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3578 if ( !wxWindowBase::SetCursor(cursor
.IsOk() ? cursor
: *wxSTANDARD_CURSOR
) )
3586 void wxWindowGTK::GTKUpdateCursor(bool update_self
/*=true*/, bool recurse
/*=true*/)
3590 wxCursor
cursor(g_globalCursor
.IsOk() ? g_globalCursor
: GetCursor());
3591 if ( cursor
.IsOk() )
3593 wxArrayGdkWindows windowsThis
;
3594 GdkWindow
* window
= GTKGetWindow(windowsThis
);
3596 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3599 const size_t count
= windowsThis
.size();
3600 for ( size_t n
= 0; n
< count
; n
++ )
3602 GdkWindow
*win
= windowsThis
[n
];
3603 // It can be zero if the window has not been realized yet.
3606 gdk_window_set_cursor(win
, cursor
.GetCursor());
3615 for (wxWindowList::iterator it
= GetChildren().begin(); it
!= GetChildren().end(); ++it
)
3617 (*it
)->GTKUpdateCursor( true );
3622 void wxWindowGTK::WarpPointer( int x
, int y
)
3624 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3626 ClientToScreen(&x
, &y
);
3627 GdkDisplay
* display
= gtk_widget_get_display(m_widget
);
3628 GdkScreen
* screen
= gtk_widget_get_screen(m_widget
);
3630 GdkDeviceManager
* manager
= gdk_display_get_device_manager(display
);
3631 gdk_device_warp(gdk_device_manager_get_client_pointer(manager
), screen
, x
, y
);
3633 #ifdef GDK_WINDOWING_X11
3634 XWarpPointer(GDK_DISPLAY_XDISPLAY(display
),
3636 GDK_WINDOW_XID(gdk_screen_get_root_window(screen
)),
3642 wxWindowGTK::ScrollDir
wxWindowGTK::ScrollDirFromRange(GtkRange
*range
) const
3644 // find the scrollbar which generated the event
3645 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3647 if ( range
== m_scrollBar
[dir
] )
3648 return (ScrollDir
)dir
;
3651 wxFAIL_MSG( wxT("event from unknown scrollbar received") );
3653 return ScrollDir_Max
;
3656 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3658 bool changed
= false;
3659 GtkRange
* range
= m_scrollBar
[dir
];
3660 if ( range
&& units
)
3662 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
3663 double inc
= unit
== ScrollUnit_Line
? gtk_adjustment_get_step_increment(adj
)
3664 : gtk_adjustment_get_page_increment(adj
);
3666 const int posOld
= wxRound(gtk_adjustment_get_value(adj
));
3667 gtk_range_set_value(range
, posOld
+ units
*inc
);
3669 changed
= wxRound(gtk_adjustment_get_value(adj
)) != posOld
;
3675 bool wxWindowGTK::ScrollLines(int lines
)
3677 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3680 bool wxWindowGTK::ScrollPages(int pages
)
3682 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3685 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground
),
3690 if (gtk_widget_get_mapped(m_wxwindow
))
3692 GdkWindow
* window
= gtk_widget_get_window(m_wxwindow
);
3695 GdkRectangle r
= { rect
->x
, rect
->y
, rect
->width
, rect
->height
};
3696 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3697 r
.x
= gdk_window_get_width(window
) - r
.x
- rect
->width
;
3698 gdk_window_invalidate_rect(window
, &r
, true);
3701 gdk_window_invalidate_rect(window
, NULL
, true);
3706 if (gtk_widget_get_mapped(m_widget
))
3709 gtk_widget_queue_draw_area(m_widget
, rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3711 gtk_widget_queue_draw(m_widget
);
3716 void wxWindowGTK::Update()
3718 if (m_widget
&& gtk_widget_get_mapped(m_widget
))
3720 GdkDisplay
* display
= gtk_widget_get_display(m_widget
);
3721 // Flush everything out to the server, and wait for it to finish.
3722 // This ensures nothing will overwrite the drawing we are about to do.
3723 gdk_display_sync(display
);
3725 GdkWindow
* window
= GTKGetDrawingWindow();
3727 window
= gtk_widget_get_window(m_widget
);
3728 gdk_window_process_updates(window
, true);
3730 // Flush again, but no need to wait for it to finish
3731 gdk_display_flush(display
);
3735 bool wxWindowGTK::DoIsExposed( int x
, int y
) const
3737 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
3740 bool wxWindowGTK::DoIsExposed( int x
, int y
, int w
, int h
) const
3742 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3743 return m_updateRegion
.Contains(x
-w
, y
, w
, h
) != wxOutRegion
;
3745 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
3749 void wxWindowGTK::GTKSendPaintEvents(cairo_t
* cr
)
3751 void wxWindowGTK::GTKSendPaintEvents(const GdkRegion
* region
)
3755 m_paintContext
= cr
;
3756 double x1
, y1
, x2
, y2
;
3757 cairo_clip_extents(cr
, &x1
, &y1
, &x2
, &y2
);
3758 m_updateRegion
= wxRegion(int(x1
), int(y1
), int(x2
- x1
), int(y2
- y1
));
3759 #else // !__WXGTK3__
3760 m_updateRegion
= wxRegion(region
);
3761 #if wxGTK_HAS_COMPOSITING_SUPPORT
3764 #endif // !__WXGTK3__
3765 // Clip to paint region in wxClientDC
3766 m_clipPaintRegion
= true;
3768 m_nativeUpdateRegion
= m_updateRegion
;
3770 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3772 // Transform m_updateRegion under RTL
3773 m_updateRegion
.Clear();
3775 const int width
= gdk_window_get_width(GTKGetDrawingWindow());
3777 wxRegionIterator
upd( m_nativeUpdateRegion
);
3781 rect
.x
= upd
.GetX();
3782 rect
.y
= upd
.GetY();
3783 rect
.width
= upd
.GetWidth();
3784 rect
.height
= upd
.GetHeight();
3786 rect
.x
= width
- rect
.x
- rect
.width
;
3787 m_updateRegion
.Union( rect
);
3793 switch ( GetBackgroundStyle() )
3795 case wxBG_STYLE_TRANSPARENT
:
3796 #if wxGTK_HAS_COMPOSITING_SUPPORT
3797 if (IsTransparentBackgroundSupported())
3799 // Set a transparent background, so that overlaying in parent
3800 // might indeed let see through where this child did not
3801 // explicitly paint.
3802 // NB: it works also for top level windows (but this is the
3803 // windows manager which then does the compositing job)
3805 cr
= gdk_cairo_create(m_wxwindow
->window
);
3806 gdk_cairo_region(cr
, m_nativeUpdateRegion
.GetRegion());
3809 cairo_set_operator(cr
, CAIRO_OPERATOR_CLEAR
);
3811 cairo_set_operator(cr
, CAIRO_OPERATOR_OVER
);
3813 cairo_surface_flush(cairo_get_target(cr
));
3816 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
3819 case wxBG_STYLE_ERASE
:
3822 wxGTKCairoDC
dc(cr
);
3824 wxWindowDC
dc( (wxWindow
*)this );
3825 dc
.SetDeviceClippingRegion( m_updateRegion
);
3827 // Work around gtk-qt <= 0.60 bug whereby the window colour
3831 GetOptionInt("gtk.window.force-background-colour") )
3833 dc
.SetBackground(GetBackgroundColour());
3836 #endif // !__WXGTK3__
3837 wxEraseEvent
erase_event( GetId(), &dc
);
3838 erase_event
.SetEventObject( this );
3840 if ( HandleWindowEvent(erase_event
) )
3842 // background erased, don't do it again
3848 case wxBG_STYLE_SYSTEM
:
3849 if ( GetThemeEnabled() )
3851 GdkWindow
* gdkWindow
= GTKGetDrawingWindow();
3852 const int w
= gdk_window_get_width(gdkWindow
);
3853 const int h
= gdk_window_get_height(gdkWindow
);
3855 GtkStyleContext
* sc
= gtk_widget_get_style_context(m_wxwindow
);
3856 gtk_render_background(sc
, cr
, 0, 0, w
, h
);
3858 // find ancestor from which to steal background
3859 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3861 parent
= (wxWindow
*)this;
3863 m_nativeUpdateRegion
.GetBox(rect
.x
, rect
.y
, rect
.width
, rect
.height
);
3864 gtk_paint_flat_box(gtk_widget_get_style(parent
->m_widget
),
3866 gtk_widget_get_state(m_wxwindow
),
3872 #endif // !__WXGTK3__
3876 case wxBG_STYLE_PAINT
:
3877 // nothing to do: window will be painted over in EVT_PAINT
3881 wxFAIL_MSG( "unsupported background style" );
3884 wxNcPaintEvent
nc_paint_event( GetId() );
3885 nc_paint_event
.SetEventObject( this );
3886 HandleWindowEvent( nc_paint_event
);
3888 wxPaintEvent
paint_event( GetId() );
3889 paint_event
.SetEventObject( this );
3890 HandleWindowEvent( paint_event
);
3892 #if wxGTK_HAS_COMPOSITING_SUPPORT
3893 if (IsTransparentBackgroundSupported())
3894 { // now composite children which need it
3895 // Overlay all our composite children on top of the painted area
3896 wxWindowList::compatibility_iterator node
;
3897 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
3899 wxWindow
*compositeChild
= node
->GetData();
3900 if (compositeChild
->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT
)
3905 cr
= gdk_cairo_create(m_wxwindow
->window
);
3906 gdk_cairo_region(cr
, m_nativeUpdateRegion
.GetRegion());
3909 #endif // !__WXGTK3__
3910 GtkWidget
*child
= compositeChild
->m_wxwindow
;
3911 GtkAllocation alloc
;
3912 gtk_widget_get_allocation(child
, &alloc
);
3914 // The source data is the (composited) child
3915 gdk_cairo_set_source_window(
3916 cr
, gtk_widget_get_window(child
), alloc
.x
, alloc
.y
);
3926 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
3928 m_clipPaintRegion
= false;
3930 m_paintContext
= NULL
;
3932 m_updateRegion
.Clear();
3933 m_nativeUpdateRegion
.Clear();
3936 void wxWindowGTK::SetDoubleBuffered( bool on
)
3938 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3941 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3944 bool wxWindowGTK::IsDoubleBuffered() const
3946 return gtk_widget_get_double_buffered( m_wxwindow
) != 0;
3949 void wxWindowGTK::ClearBackground()
3951 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3955 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3957 if (m_tooltip
!= tip
)
3959 wxWindowBase::DoSetToolTip(tip
);
3962 m_tooltip
->GTKSetWindow(static_cast<wxWindow
*>(this));
3964 GTKApplyToolTip(NULL
);
3968 void wxWindowGTK::GTKApplyToolTip(const char* tip
)
3970 wxToolTip::GTKApply(GetConnectWidget(), tip
);
3972 #endif // wxUSE_TOOLTIPS
3974 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
3976 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3978 if (!wxWindowBase::SetBackgroundColour(colour
))
3984 // We need the pixel value e.g. for background clearing.
3985 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3989 // apply style change (forceStyle=true so that new style is applied
3990 // even if the bg colour changed from valid to wxNullColour)
3991 GTKApplyWidgetStyle(true);
3996 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
3998 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4000 if (!wxWindowBase::SetForegroundColour(colour
))
4008 // We need the pixel value e.g. for background clearing.
4009 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
4013 // apply style change (forceStyle=true so that new style is applied
4014 // even if the bg colour changed from valid to wxNullColour):
4015 GTKApplyWidgetStyle(true);
4020 PangoContext
*wxWindowGTK::GTKGetPangoDefaultContext()
4022 return gtk_widget_get_pango_context( m_widget
);
4026 GtkRcStyle
*wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle
)
4028 // do we need to apply any changes at all?
4031 !m_foregroundColour
.IsOk() && !m_backgroundColour
.IsOk() )
4036 GtkRcStyle
*style
= gtk_rc_style_new();
4038 if ( m_font
.IsOk() )
4041 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
4044 int flagsNormal
= 0,
4047 flagsInsensitive
= 0;
4049 if ( m_foregroundColour
.IsOk() )
4051 const GdkColor
*fg
= m_foregroundColour
.GetColor();
4053 style
->fg
[GTK_STATE_NORMAL
] =
4054 style
->text
[GTK_STATE_NORMAL
] = *fg
;
4055 flagsNormal
|= GTK_RC_FG
| GTK_RC_TEXT
;
4057 style
->fg
[GTK_STATE_PRELIGHT
] =
4058 style
->text
[GTK_STATE_PRELIGHT
] = *fg
;
4059 flagsPrelight
|= GTK_RC_FG
| GTK_RC_TEXT
;
4061 style
->fg
[GTK_STATE_ACTIVE
] =
4062 style
->text
[GTK_STATE_ACTIVE
] = *fg
;
4063 flagsActive
|= GTK_RC_FG
| GTK_RC_TEXT
;
4066 if ( m_backgroundColour
.IsOk() )
4068 const GdkColor
*bg
= m_backgroundColour
.GetColor();
4070 style
->bg
[GTK_STATE_NORMAL
] =
4071 style
->base
[GTK_STATE_NORMAL
] = *bg
;
4072 flagsNormal
|= GTK_RC_BG
| GTK_RC_BASE
;
4074 style
->bg
[GTK_STATE_PRELIGHT
] =
4075 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
4076 flagsPrelight
|= GTK_RC_BG
| GTK_RC_BASE
;
4078 style
->bg
[GTK_STATE_ACTIVE
] =
4079 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
4080 flagsActive
|= GTK_RC_BG
| GTK_RC_BASE
;
4082 style
->bg
[GTK_STATE_INSENSITIVE
] =
4083 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
4084 flagsInsensitive
|= GTK_RC_BG
| GTK_RC_BASE
;
4087 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)flagsNormal
;
4088 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)flagsPrelight
;
4089 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)flagsActive
;
4090 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)flagsInsensitive
;
4094 #endif // !__WXGTK3__
4096 void wxWindowGTK::GTKApplyWidgetStyle(bool WXUNUSED_IN_GTK3(forceStyle
))
4099 DoApplyWidgetStyle(NULL
);
4101 GtkRcStyle
*style
= GTKCreateWidgetStyle(forceStyle
);
4104 DoApplyWidgetStyle(style
);
4105 g_object_unref(style
);
4109 // Style change may affect GTK+'s size calculation:
4110 InvalidateBestSize();
4113 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
4115 GtkWidget
* widget
= m_wxwindow
? m_wxwindow
: m_widget
;
4117 // block the signal temporarily to avoid sending
4118 // wxSysColourChangedEvents when we change the colours ourselves
4119 bool unblock
= false;
4120 if (m_wxwindow
&& IsTopLevel())
4123 g_signal_handlers_block_by_func(
4124 m_wxwindow
, (void*)style_updated
, this);
4127 GTKApplyStyle(widget
, style
);
4131 g_signal_handlers_unblock_by_func(
4132 m_wxwindow
, (void*)style_updated
, this);
4136 void wxWindowGTK::GTKApplyStyle(GtkWidget
* widget
, GtkRcStyle
* WXUNUSED_IN_GTK3(style
))
4139 const PangoFontDescription
* pfd
= NULL
;
4141 pfd
= pango_font_description_copy(m_font
.GetNativeFontInfo()->description
);
4142 gtk_widget_override_font(widget
, pfd
);
4143 gtk_widget_override_color(widget
, GTK_STATE_FLAG_NORMAL
, m_foregroundColour
);
4144 gtk_widget_override_background_color(widget
, GTK_STATE_FLAG_NORMAL
, m_backgroundColour
);
4146 gtk_widget_modify_style(widget
, style
);
4150 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style
)
4152 if (!wxWindowBase::SetBackgroundStyle(style
))
4159 window
= GTKGetDrawingWindow();
4163 GtkWidget
* const w
= GetConnectWidget();
4164 window
= w
? gtk_widget_get_window(w
) : NULL
;
4167 bool wantNoBackPixmap
= style
== wxBG_STYLE_PAINT
|| style
== wxBG_STYLE_TRANSPARENT
;
4169 if ( wantNoBackPixmap
)
4173 // Make sure GDK/X11 doesn't refresh the window
4175 gdk_window_set_back_pixmap( window
, NULL
, FALSE
);
4176 m_needsStyleChange
= false;
4178 else // window not realized yet
4180 // Do when window is realized
4181 m_needsStyleChange
= true;
4184 // Don't apply widget style, or we get a grey background
4188 // apply style change (forceStyle=true so that new style is applied
4189 // even if the bg colour changed from valid to wxNullColour):
4190 GTKApplyWidgetStyle(true);
4192 #endif // !__WXGTK3__
4197 bool wxWindowGTK::IsTransparentBackgroundSupported(wxString
* reason
) const
4199 #if wxGTK_HAS_COMPOSITING_SUPPORT
4201 if (gtk_check_version(wxGTK_VERSION_REQUIRED_FOR_COMPOSITING
) != NULL
)
4205 *reason
= _("GTK+ installed on this machine is too old to "
4206 "support screen compositing, please install "
4207 "GTK+ 2.12 or later.");
4212 #endif // !__WXGTK3__
4214 // NB: We don't check here if the particular kind of widget supports
4215 // transparency, we check only if it would be possible for a generic window
4217 wxCHECK_MSG ( m_widget
, false, "Window must be created first" );
4219 if (!gdk_screen_is_composited(gtk_widget_get_screen(m_widget
)))
4223 *reason
= _("Compositing not supported by this system, "
4224 "please enable it in your Window Manager.");
4234 *reason
= _("This program was compiled with a too old version of GTK+, "
4235 "please rebuild with GTK+ 2.12 or newer.");
4239 #endif // wxGTK_HAS_COMPOSITING_SUPPORT/!wxGTK_HAS_COMPOSITING_SUPPORT
4242 // ----------------------------------------------------------------------------
4243 // Pop-up menu stuff
4244 // ----------------------------------------------------------------------------
4246 #if wxUSE_MENUS_NATIVE
4250 void wxPopupMenuPositionCallback( GtkMenu
*menu
,
4252 gboolean
* WXUNUSED(whatever
),
4253 gpointer user_data
)
4255 // ensure that the menu appears entirely on screen
4257 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
4259 wxSize sizeScreen
= wxGetDisplaySize();
4260 wxPoint
*pos
= (wxPoint
*)user_data
;
4262 gint xmax
= sizeScreen
.x
- req
.width
,
4263 ymax
= sizeScreen
.y
- req
.height
;
4265 *x
= pos
->x
< xmax
? pos
->x
: xmax
;
4266 *y
= pos
->y
< ymax
? pos
->y
: ymax
;
4270 bool wxWindowGTK::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
4272 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4278 GtkMenuPositionFunc posfunc
;
4279 if ( x
== -1 && y
== -1 )
4281 // use GTK's default positioning algorithm
4287 pos
= ClientToScreen(wxPoint(x
, y
));
4289 posfunc
= wxPopupMenuPositionCallback
;
4292 menu
->m_popupShown
= true;
4294 GTK_MENU(menu
->m_menu
),
4295 NULL
, // parent menu shell
4296 NULL
, // parent menu item
4297 posfunc
, // function to position it
4298 userdata
, // client data
4299 0, // button used to activate it
4300 gtk_get_current_event_time()
4303 while (menu
->m_popupShown
)
4305 gtk_main_iteration();
4311 #endif // wxUSE_MENUS_NATIVE
4313 #if wxUSE_DRAG_AND_DROP
4315 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4317 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4319 GtkWidget
*dnd_widget
= GetConnectWidget();
4321 if (m_dropTarget
) m_dropTarget
->GtkUnregisterWidget( dnd_widget
);
4323 if (m_dropTarget
) delete m_dropTarget
;
4324 m_dropTarget
= dropTarget
;
4326 if (m_dropTarget
) m_dropTarget
->GtkRegisterWidget( dnd_widget
);
4329 #endif // wxUSE_DRAG_AND_DROP
4331 GtkWidget
* wxWindowGTK::GetConnectWidget()
4333 GtkWidget
*connect_widget
= m_widget
;
4334 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4336 return connect_widget
;
4339 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow
*window
) const
4341 wxArrayGdkWindows windowsThis
;
4342 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
4344 return winThis
? window
== winThis
4345 : windowsThis
.Index(window
) != wxNOT_FOUND
;
4348 GdkWindow
*wxWindowGTK::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
4350 return m_wxwindow
? GTKGetDrawingWindow() : gtk_widget_get_window(m_widget
);
4353 bool wxWindowGTK::SetFont( const wxFont
&font
)
4355 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4357 if (!wxWindowBase::SetFont(font
))
4360 // apply style change (forceStyle=true so that new style is applied
4361 // even if the font changed from valid to wxNullFont):
4362 GTKApplyWidgetStyle(true);
4367 void wxWindowGTK::DoCaptureMouse()
4369 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4371 GdkWindow
*window
= NULL
;
4373 window
= GTKGetDrawingWindow();
4375 window
= gtk_widget_get_window(GetConnectWidget());
4377 wxCHECK_RET( window
, wxT("CaptureMouse() failed") );
4379 const wxCursor
* cursor
= &m_cursor
;
4380 if (!cursor
->IsOk())
4381 cursor
= wxSTANDARD_CURSOR
;
4383 gdk_pointer_grab( window
, FALSE
,
4385 (GDK_BUTTON_PRESS_MASK
|
4386 GDK_BUTTON_RELEASE_MASK
|
4387 GDK_POINTER_MOTION_HINT_MASK
|
4388 GDK_POINTER_MOTION_MASK
),
4390 cursor
->GetCursor(),
4391 (guint32
)GDK_CURRENT_TIME
);
4392 g_captureWindow
= this;
4393 g_captureWindowHasMouse
= true;
4396 void wxWindowGTK::DoReleaseMouse()
4398 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4400 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4402 g_captureWindow
= NULL
;
4404 GdkWindow
*window
= NULL
;
4406 window
= GTKGetDrawingWindow();
4408 window
= gtk_widget_get_window(GetConnectWidget());
4413 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4416 void wxWindowGTK::GTKReleaseMouseAndNotify()
4419 wxMouseCaptureLostEvent
evt(GetId());
4420 evt
.SetEventObject( this );
4421 HandleWindowEvent( evt
);
4425 wxWindow
*wxWindowBase::GetCapture()
4427 return (wxWindow
*)g_captureWindow
;
4430 bool wxWindowGTK::IsRetained() const
4435 void wxWindowGTK::SetScrollbar(int orient
,
4439 bool WXUNUSED(update
))
4441 const int dir
= ScrollDirFromOrient(orient
);
4442 GtkRange
* const sb
= m_scrollBar
[dir
];
4443 wxCHECK_RET( sb
, wxT("this window is not scrollable") );
4447 // GtkRange requires upper > lower
4452 g_signal_handlers_block_by_func(
4453 sb
, (void*)gtk_scrollbar_value_changed
, this);
4455 gtk_range_set_increments(sb
, 1, thumbVisible
);
4456 gtk_adjustment_set_page_size(gtk_range_get_adjustment(sb
), thumbVisible
);
4457 gtk_range_set_range(sb
, 0, range
);
4458 gtk_range_set_value(sb
, pos
);
4459 m_scrollPos
[dir
] = gtk_range_get_value(sb
);
4461 g_signal_handlers_unblock_by_func(
4462 sb
, (void*)gtk_scrollbar_value_changed
, this);
4465 void wxWindowGTK::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4467 const int dir
= ScrollDirFromOrient(orient
);
4468 GtkRange
* const sb
= m_scrollBar
[dir
];
4469 wxCHECK_RET( sb
, wxT("this window is not scrollable") );
4471 // This check is more than an optimization. Without it, the slider
4472 // will not move smoothly while tracking when using wxScrollHelper.
4473 if (GetScrollPos(orient
) != pos
)
4475 g_signal_handlers_block_by_func(
4476 sb
, (void*)gtk_scrollbar_value_changed
, this);
4478 gtk_range_set_value(sb
, pos
);
4479 m_scrollPos
[dir
] = gtk_range_get_value(sb
);
4481 g_signal_handlers_unblock_by_func(
4482 sb
, (void*)gtk_scrollbar_value_changed
, this);
4486 int wxWindowGTK::GetScrollThumb(int orient
) const
4488 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4489 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4491 return wxRound(gtk_adjustment_get_page_size(gtk_range_get_adjustment(sb
)));
4494 int wxWindowGTK::GetScrollPos( int orient
) const
4496 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4497 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4499 return wxRound(gtk_range_get_value(sb
));
4502 int wxWindowGTK::GetScrollRange( int orient
) const
4504 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4505 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4507 return wxRound(gtk_adjustment_get_upper(gtk_range_get_adjustment(sb
)));
4510 // Determine if increment is the same as +/-x, allowing for some small
4511 // difference due to possible inexactness in floating point arithmetic
4512 static inline bool IsScrollIncrement(double increment
, double x
)
4514 wxASSERT(increment
> 0);
4515 const double tolerance
= 1.0 / 1024;
4516 return fabs(increment
- fabs(x
)) < tolerance
;
4519 wxEventType
wxWindowGTK::GTKGetScrollEventType(GtkRange
* range
)
4521 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4523 const int barIndex
= range
== m_scrollBar
[1];
4525 const double value
= gtk_range_get_value(range
);
4527 // save previous position
4528 const double oldPos
= m_scrollPos
[barIndex
];
4529 // update current position
4530 m_scrollPos
[barIndex
] = value
;
4531 // If event should be ignored, or integral position has not changed
4532 if (!m_hasVMT
|| g_blockEventsOnDrag
|| wxRound(value
) == wxRound(oldPos
))
4537 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4540 // Difference from last change event
4541 const double diff
= value
- oldPos
;
4542 const bool isDown
= diff
> 0;
4544 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
4545 if (IsScrollIncrement(gtk_adjustment_get_step_increment(adj
), diff
))
4547 eventType
= isDown
? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4549 else if (IsScrollIncrement(gtk_adjustment_get_page_increment(adj
), diff
))
4551 eventType
= isDown
? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4553 else if (m_mouseButtonDown
)
4555 // Assume track event
4556 m_isScrolling
= true;
4562 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4564 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4566 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4568 // No scrolling requested.
4569 if ((dx
== 0) && (dy
== 0)) return;
4571 m_clipPaintRegion
= true;
4573 WX_PIZZA(m_wxwindow
)->scroll(dx
, dy
);
4575 m_clipPaintRegion
= false;
4578 bool restoreCaret
= (GetCaret() != NULL
&& GetCaret()->IsVisible());
4581 wxRect
caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4583 caretRect
.width
+= dx
;
4586 caretRect
.x
+= dx
; caretRect
.width
-= dx
;
4589 caretRect
.height
+= dy
;
4592 caretRect
.y
+= dy
; caretRect
.height
-= dy
;
4595 RefreshRect(caretRect
);
4597 #endif // wxUSE_CARET
4600 void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4602 //RN: Note that static controls usually have no border on gtk, so maybe
4603 //it makes sense to treat that as simply no border at the wx level
4605 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4607 GtkShadowType gtkstyle
;
4609 if(wxstyle
& wxBORDER_RAISED
)
4610 gtkstyle
= GTK_SHADOW_OUT
;
4611 else if ((wxstyle
& wxBORDER_SUNKEN
) || (wxstyle
& wxBORDER_THEME
))
4612 gtkstyle
= GTK_SHADOW_IN
;
4615 else if (wxstyle
& wxBORDER_DOUBLE
)
4616 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4619 gtkstyle
= GTK_SHADOW_IN
;
4621 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4626 // Find the wxWindow at the current mouse position, also returning the mouse
4628 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4630 pt
= wxGetMousePosition();
4631 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4635 // Get the current mouse position.
4636 wxPoint
wxGetMousePosition()
4639 GdkModifierType unused
;
4640 GetMouseState(x
, y
, unused
);
4641 return wxPoint(x
, y
);
4644 GdkWindow
* wxWindowGTK::GTKGetDrawingWindow() const
4646 GdkWindow
* window
= NULL
;
4648 window
= gtk_widget_get_window(m_wxwindow
);
4652 // ----------------------------------------------------------------------------
4654 // ----------------------------------------------------------------------------
4659 // this is called if we attempted to freeze unrealized widget when it finally
4660 // is realized (and so can be frozen):
4661 static void wx_frozen_widget_realize(GtkWidget
* w
, wxWindowGTK
* win
)
4663 wxASSERT( w
&& gtk_widget_get_has_window(w
) );
4664 wxASSERT( gtk_widget_get_realized(w
) );
4666 g_signal_handlers_disconnect_by_func
4669 (void*)wx_frozen_widget_realize
,
4674 if (w
== win
->m_wxwindow
)
4675 window
= win
->GTKGetDrawingWindow();
4677 window
= gtk_widget_get_window(w
);
4678 gdk_window_freeze_updates(window
);
4683 void wxWindowGTK::GTKFreezeWidget(GtkWidget
*w
)
4685 if ( !w
|| !gtk_widget_get_has_window(w
) )
4686 return; // window-less widget, cannot be frozen
4688 GdkWindow
* window
= gtk_widget_get_window(w
);
4691 // we can't thaw unrealized widgets because they don't have GdkWindow,
4692 // so set it up to be done immediately after realization:
4693 g_signal_connect_after
4697 G_CALLBACK(wx_frozen_widget_realize
),
4703 if (w
== m_wxwindow
)
4704 window
= GTKGetDrawingWindow();
4705 gdk_window_freeze_updates(window
);
4708 void wxWindowGTK::GTKThawWidget(GtkWidget
*w
)
4710 if ( !w
|| !gtk_widget_get_has_window(w
) )
4711 return; // window-less widget, cannot be frozen
4713 GdkWindow
* window
= gtk_widget_get_window(w
);
4716 // the widget wasn't realized yet, no need to thaw
4717 g_signal_handlers_disconnect_by_func
4720 (void*)wx_frozen_widget_realize
,
4726 if (w
== m_wxwindow
)
4727 window
= GTKGetDrawingWindow();
4728 gdk_window_thaw_updates(window
);
4731 void wxWindowGTK::DoFreeze()
4733 GTKFreezeWidget(m_widget
);
4734 if ( m_wxwindow
&& m_widget
!= m_wxwindow
)
4735 GTKFreezeWidget(m_wxwindow
);
4738 void wxWindowGTK::DoThaw()
4740 GTKThawWidget(m_widget
);
4741 if ( m_wxwindow
&& m_widget
!= m_wxwindow
)
4742 GTKThawWidget(m_wxwindow
);