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"
38 #include "wx/gtk/private.h"
39 #include "wx/gtk/private/win_gtk.h"
40 #include "wx/gtk/private/event.h"
41 using namespace wxGTKImpl
;
43 #ifdef GDK_WINDOWING_X11
45 #include "wx/x11/private/wrapxkb.h"
50 #include <gdk/gdkkeysyms.h>
51 #if GTK_CHECK_VERSION(3,0,0)
52 #include <gdk/gdkkeysyms-compat.h>
55 // gdk_window_set_composited() is only supported since 2.12
56 #define wxGTK_VERSION_REQUIRED_FOR_COMPOSITING 2,12,0
57 #define wxGTK_HAS_COMPOSITING_SUPPORT GTK_CHECK_VERSION(2,12,0)
59 //-----------------------------------------------------------------------------
60 // documentation on internals
61 //-----------------------------------------------------------------------------
64 I have been asked several times about writing some documentation about
65 the GTK port of wxWidgets, especially its internal structures. Obviously,
66 you cannot understand wxGTK without knowing a little about the GTK, but
67 some more information about what the wxWindow, which is the base class
68 for all other window classes, does seems required as well.
72 What does wxWindow do? It contains the common interface for the following
73 jobs of its descendants:
75 1) Define the rudimentary behaviour common to all window classes, such as
76 resizing, intercepting user input (so as to make it possible to use these
77 events for special purposes in a derived class), window names etc.
79 2) Provide the possibility to contain and manage children, if the derived
80 class is allowed to contain children, which holds true for those window
81 classes which do not display a native GTK widget. To name them, these
82 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
83 work classes are a special case and are handled a bit differently from
84 the rest. The same holds true for the wxNotebook class.
86 3) Provide the possibility to draw into a client area of a window. This,
87 too, only holds true for classes that do not display a native GTK widget
90 4) Provide the entire mechanism for scrolling widgets. This actual inter-
91 face for this is usually in wxScrolledWindow, but the GTK implementation
94 5) A multitude of helper or extra methods for special purposes, such as
95 Drag'n'Drop, managing validators etc.
97 6) Display a border (sunken, raised, simple or none).
99 Normally one might expect, that one wxWidgets window would always correspond
100 to one GTK widget. Under GTK, there is no such all-round widget that has all
101 the functionality. Moreover, the GTK defines a client area as a different
102 widget from the actual widget you are handling. Last but not least some
103 special classes (e.g. wxFrame) handle different categories of widgets and
104 still have the possibility to draw something in the client area.
105 It was therefore required to write a special purpose GTK widget, that would
106 represent a client area in the sense of wxWidgets capable to do the jobs
107 2), 3) and 4). I have written this class and it resides in win_gtk.c of
110 All windows must have a widget, with which they interact with other under-
111 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
112 the wxWindow class has a member variable called m_widget which holds a
113 pointer to this widget. When the window class represents a GTK native widget,
114 this is (in most cases) the only GTK widget the class manages. E.g. the
115 wxStaticText class handles only a GtkLabel widget a pointer to which you
116 can find in m_widget (defined in wxWindow)
118 When the class has a client area for drawing into and for containing children
119 it has to handle the client area widget (of the type wxPizza, defined in
120 win_gtk.cpp), but there could be any number of widgets, handled by a class.
121 The common rule for all windows is only, that the widget that interacts with
122 the rest of GTK must be referenced in m_widget and all other widgets must be
123 children of this widget on the GTK level. The top-most widget, which also
124 represents the client area, must be in the m_wxwindow field and must be of
127 As I said, the window classes that display a GTK native widget only have
128 one widget, so in the case of e.g. the wxButton class m_widget holds a
129 pointer to a GtkButton widget. But windows with client areas (for drawing
130 and children) have a m_widget field that is a pointer to a GtkScrolled-
131 Window and a m_wxwindow field that is pointer to a wxPizza and this
132 one is (in the GTK sense) a child of the GtkScrolledWindow.
134 If the m_wxwindow field is set, then all input to this widget is inter-
135 cepted and sent to the wxWidgets class. If not, all input to the widget
136 that gets pointed to by m_widget gets intercepted and sent to the class.
140 The design of scrolling in wxWidgets is markedly different from that offered
141 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
142 clicking on a scrollbar belonging to scrolled window will inevitably move
143 the window. In wxWidgets, the scrollbar will only emit an event, send this
144 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
145 which actually moves the window and its sub-windows. Note that wxPizza
146 memorizes how much it has been scrolled but that wxWidgets forgets this
147 so that the two coordinates systems have to be kept in synch. This is done
148 in various places using the pizza->m_scroll_x and pizza->m_scroll_y values.
152 Singularly the most broken code in GTK is the code that is supposed to
153 inform subwindows (child windows) about new positions. Very often, duplicate
154 events are sent without changes in size or position, equally often no
155 events are sent at all (All this is due to a bug in the GtkContainer code
156 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
157 GTK's own system and it simply waits for size events for toplevel windows
158 and then iterates down the respective size events to all window. This has
159 the disadvantage that windows might get size events before the GTK widget
160 actually has the reported size. This doesn't normally pose any problem, but
161 the OpenGL drawing routines rely on correct behaviour. Therefore, I have
162 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
163 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
164 window that is used for OpenGL output really has that size (as reported by
169 If someone at some point of time feels the immense desire to have a look at,
170 change or attempt to optimise the Refresh() logic, this person will need an
171 intimate understanding of what "draw" and "expose" events are and what
172 they are used for, in particular when used in connection with GTK's
173 own windowless widgets. Beware.
177 Cursors, too, have been a constant source of pleasure. The main difficulty
178 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
179 for the parent. To prevent this from doing too much harm, SetCursor calls
180 GTKUpdateCursor, which will recursively re-set the cursors of all child windows.
181 Also don't forget that cursors (like much else) are connected to GdkWindows,
182 not GtkWidgets and that the "window" field of a GtkWidget might very well
183 point to the GdkWindow of the parent widget (-> "window-less widget") and
184 that the two obviously have very different meanings.
187 //-----------------------------------------------------------------------------
189 //-----------------------------------------------------------------------------
191 // Don't allow event propagation during drag
192 bool g_blockEventsOnDrag
;
193 // Don't allow mouse event propagation during scroll
194 bool g_blockEventsOnScroll
;
195 extern wxCursor g_globalCursor
;
197 // mouse capture state: the window which has it and if the mouse is currently
199 static wxWindowGTK
*g_captureWindow
= NULL
;
200 static bool g_captureWindowHasMouse
= false;
202 // The window that currently has focus:
203 static wxWindowGTK
*gs_currentFocus
= NULL
;
204 // The window that is scheduled to get focus in the next event loop iteration
205 // or NULL if there's no pending focus change:
206 static wxWindowGTK
*gs_pendingFocus
= NULL
;
208 // the window that has deferred focus-out event pending, if any (see
209 // GTKAddDeferredFocusOut() for details)
210 static wxWindowGTK
*gs_deferredFocusOut
= NULL
;
212 // global variables because GTK+ DnD want to have the
213 // mouse event that caused it
214 GdkEvent
*g_lastMouseEvent
= NULL
;
215 int g_lastButtonNumber
= 0;
217 //-----------------------------------------------------------------------------
219 //-----------------------------------------------------------------------------
221 // the trace mask used for the focus debugging messages
222 #define TRACE_FOCUS wxT("focus")
224 //-----------------------------------------------------------------------------
225 // "expose_event" of m_wxwindow
226 //-----------------------------------------------------------------------------
230 gtk_window_expose_callback( GtkWidget
*,
231 GdkEventExpose
*gdk_event
,
234 if (gdk_event
->window
== win
->GTKGetDrawingWindow())
236 win
->GetUpdateRegion() = wxRegion( gdk_event
->region
);
237 win
->GtkSendPaintEvents();
239 // Let parent window draw window-less widgets
244 #ifndef __WXUNIVERSAL__
245 //-----------------------------------------------------------------------------
246 // "expose_event" from m_wxwindow->parent, for drawing border
247 //-----------------------------------------------------------------------------
251 expose_event_border(GtkWidget
* widget
, GdkEventExpose
* gdk_event
, wxWindow
* win
)
253 if (gdk_event
->window
!= gtk_widget_get_parent_window(win
->m_wxwindow
))
260 gtk_widget_get_allocation(win
->m_wxwindow
, &alloc
);
261 const int x
= alloc
.x
;
262 const int y
= alloc
.y
;
263 const int w
= alloc
.width
;
264 const int h
= alloc
.height
;
266 if (w
<= 0 || h
<= 0)
269 if (win
->HasFlag(wxBORDER_SIMPLE
))
271 gdk_draw_rectangle(gdk_event
->window
,
272 gtk_widget_get_style(widget
)->black_gc
, false, x
, y
, w
- 1, h
- 1);
276 GtkShadowType shadow
= GTK_SHADOW_IN
;
277 if (win
->HasFlag(wxBORDER_RAISED
))
278 shadow
= GTK_SHADOW_OUT
;
280 // Style detail to use
282 if (win
->m_widget
== win
->m_wxwindow
)
283 // for non-scrollable wxWindows
286 // for scrollable ones
289 // clip rect is required to avoid painting background
290 // over upper left (w,h) of parent window
291 GdkRectangle clipRect
= { x
, y
, w
, h
};
293 gtk_widget_get_style(win
->m_wxwindow
), gdk_event
->window
, GTK_STATE_NORMAL
,
294 shadow
, &clipRect
, wxGTKPrivate
::GetEntryWidget(), detail
, x
, y
, w
, h
);
300 //-----------------------------------------------------------------------------
301 // "parent_set" from m_wxwindow
302 //-----------------------------------------------------------------------------
306 parent_set(GtkWidget
* widget
, GtkWidget
* old_parent
, wxWindow
* win
)
310 g_signal_handlers_disconnect_by_func(
311 old_parent
, (void*)expose_event_border
, win
);
313 GtkWidget
* parent
= gtk_widget_get_parent(widget
);
316 g_signal_connect_after(parent
, "expose_event",
317 G_CALLBACK(expose_event_border
), win
);
321 #endif // !__WXUNIVERSAL__
323 //-----------------------------------------------------------------------------
324 // "key_press_event" from any window
325 //-----------------------------------------------------------------------------
327 // set WXTRACE to this to see the key event codes on the console
328 #define TRACE_KEYS wxT("keyevent")
330 // translates an X key symbol to WXK_XXX value
332 // if isChar is true it means that the value returned will be used for EVT_CHAR
333 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
334 // for example, while if it is false it means that the value is going to be
335 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
337 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
343 // Shift, Control and Alt don't generate the CHAR events at all
346 key_code
= isChar ?
0 : WXK_SHIFT
;
350 key_code
= isChar ?
0 : WXK_CONTROL
;
358 key_code
= isChar ?
0 : WXK_ALT
;
361 // neither do the toggle modifies
362 case GDK_Scroll_Lock
:
363 key_code
= isChar ?
0 : WXK_SCROLL
;
367 key_code
= isChar ?
0 : WXK_CAPITAL
;
371 key_code
= isChar ?
0 : WXK_NUMLOCK
;
375 // various other special keys
388 case GDK_ISO_Left_Tab
:
395 key_code
= WXK_RETURN
;
399 key_code
= WXK_CLEAR
;
403 key_code
= WXK_PAUSE
;
407 key_code
= WXK_SELECT
;
411 key_code
= WXK_PRINT
;
415 key_code
= WXK_EXECUTE
;
419 key_code
= WXK_ESCAPE
;
422 // cursor and other extended keyboard keys
424 key_code
= WXK_DELETE
;
440 key_code
= WXK_RIGHT
;
447 case GDK_Prior
: // == GDK_Page_Up
448 key_code
= WXK_PAGEUP
;
451 case GDK_Next
: // == GDK_Page_Down
452 key_code
= WXK_PAGEDOWN
;
464 key_code
= WXK_INSERT
;
479 key_code
= (isChar ?
'0' : int(WXK_NUMPAD0
)) + keysym
- GDK_KP_0
;
483 key_code
= isChar ?
' ' : int(WXK_NUMPAD_SPACE
);
487 key_code
= isChar ? WXK_TAB
: WXK_NUMPAD_TAB
;
491 key_code
= isChar ? WXK_RETURN
: WXK_NUMPAD_ENTER
;
495 key_code
= isChar ? WXK_F1
: WXK_NUMPAD_F1
;
499 key_code
= isChar ? WXK_F2
: WXK_NUMPAD_F2
;
503 key_code
= isChar ? WXK_F3
: WXK_NUMPAD_F3
;
507 key_code
= isChar ? WXK_F4
: WXK_NUMPAD_F4
;
511 key_code
= isChar ? WXK_HOME
: WXK_NUMPAD_HOME
;
515 key_code
= isChar ? WXK_LEFT
: WXK_NUMPAD_LEFT
;
519 key_code
= isChar ? WXK_UP
: WXK_NUMPAD_UP
;
523 key_code
= isChar ? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
527 key_code
= isChar ? WXK_DOWN
: WXK_NUMPAD_DOWN
;
530 case GDK_KP_Prior
: // == GDK_KP_Page_Up
531 key_code
= isChar ? WXK_PAGEUP
: WXK_NUMPAD_PAGEUP
;
534 case GDK_KP_Next
: // == GDK_KP_Page_Down
535 key_code
= isChar ? WXK_PAGEDOWN
: WXK_NUMPAD_PAGEDOWN
;
539 key_code
= isChar ? WXK_END
: WXK_NUMPAD_END
;
543 key_code
= isChar ? WXK_HOME
: WXK_NUMPAD_BEGIN
;
547 key_code
= isChar ? WXK_INSERT
: WXK_NUMPAD_INSERT
;
551 key_code
= isChar ? WXK_DELETE
: WXK_NUMPAD_DELETE
;
555 key_code
= isChar ?
'=' : int(WXK_NUMPAD_EQUAL
);
558 case GDK_KP_Multiply
:
559 key_code
= isChar ?
'*' : int(WXK_NUMPAD_MULTIPLY
);
563 key_code
= isChar ?
'+' : int(WXK_NUMPAD_ADD
);
566 case GDK_KP_Separator
:
567 // FIXME: what is this?
568 key_code
= isChar ?
'.' : int(WXK_NUMPAD_SEPARATOR
);
571 case GDK_KP_Subtract
:
572 key_code
= isChar ?
'-' : int(WXK_NUMPAD_SUBTRACT
);
576 key_code
= isChar ?
'.' : int(WXK_NUMPAD_DECIMAL
);
580 key_code
= isChar ?
'/' : int(WXK_NUMPAD_DIVIDE
);
597 key_code
= WXK_F1
+ keysym
- GDK_F1
;
607 static inline bool wxIsAsciiKeysym(KeySym ks
)
612 static void wxFillOtherKeyEventFields(wxKeyEvent
& event
,
614 GdkEventKey
*gdk_event
)
616 event
.SetTimestamp( gdk_event
->time
);
617 event
.SetId(win
->GetId());
619 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
620 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
621 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
622 event
.m_metaDown
= (gdk_event
->state
& GDK_META_MASK
) != 0;
624 // Normally we take the state of modifiers directly from the low level GDK
625 // event but unfortunately GDK uses a different convention from MSW for the
626 // key events corresponding to the modifier keys themselves: in it, when
627 // e.g. Shift key is pressed, GDK_SHIFT_MASK is not set while it is set
628 // when Shift is released. Under MSW the situation is exactly reversed and
629 // the modifier corresponding to the key is set when it is pressed and
630 // unset when it is released. To ensure consistent behaviour between
631 // platforms (and because it seems to make slightly more sense, although
632 // arguably both behaviours are reasonable) we follow MSW here.
634 // Final notice: we set the flags to the desired value instead of just
635 // inverting them because they are not set correctly (i.e. in the same way
636 // as for the real events generated by the user) for wxUIActionSimulator-
637 // produced events and it seems better to keep that class code the same
638 // among all platforms and fix the discrepancy here instead of adding
639 // wxGTK-specific code to wxUIActionSimulator.
640 const bool isPress
= gdk_event
->type
== GDK_KEY_PRESS
;
641 switch ( gdk_event
->keyval
)
645 event
.m_shiftDown
= isPress
;
650 event
.m_controlDown
= isPress
;
655 event
.m_altDown
= isPress
;
662 event
.m_metaDown
= isPress
;
666 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
667 event
.m_rawFlags
= gdk_event
->hardware_keycode
;
669 wxGetMousePosition(&event
.m_x
, &event
.m_y
);
670 win
->ScreenToClient(&event
.m_x
, &event
.m_y
);
671 event
.SetEventObject( win
);
676 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
678 GdkEventKey
*gdk_event
)
680 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
681 // but only event->keyval which is quite useless to us, so remember
682 // the last character from GDK_KEY_PRESS and reuse it as last resort
684 // NB: should be MT-safe as we're always called from the main thread only
689 } s_lastKeyPress
= { 0, 0 };
691 KeySym keysym
= gdk_event
->keyval
;
693 wxLogTrace(TRACE_KEYS
, wxT("Key %s event: keysym = %ld"),
694 event
.GetEventType() == wxEVT_KEY_UP ?
wxT("release")
698 long key_code
= wxTranslateKeySymToWXKey(keysym
, false /* !isChar */);
702 // do we have the translation or is it a plain ASCII character?
703 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
705 // we should use keysym if it is ASCII as X does some translations
706 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
707 // which we don't want here (but which we do use for OnChar())
708 if ( !wxIsAsciiKeysym(keysym
) )
710 keysym
= (KeySym
)gdk_event
->string
[0];
713 #ifdef GDK_WINDOWING_X11
714 // we want to always get the same key code when the same key is
715 // pressed regardless of the state of the modifiers, i.e. on a
716 // standard US keyboard pressing '5' or '%' ('5' key with
717 // Shift) should result in the same key code in OnKeyDown():
718 // '5' (although OnChar() will get either '5' or '%').
720 // to do it we first translate keysym to keycode (== scan code)
721 // and then back but always using the lower register
722 Display
*dpy
= (Display
*)wxGetDisplay();
723 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
725 wxLogTrace(TRACE_KEYS
, wxT("\t-> keycode %d"), keycode
);
727 #ifdef HAVE_X11_XKBLIB_H
728 KeySym keysymNormalized
= XkbKeycodeToKeysym(dpy
, keycode
, 0, 0);
730 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
733 // use the normalized, i.e. lower register, keysym if we've
735 key_code
= keysymNormalized ? keysymNormalized
: keysym
;
740 // as explained above, we want to have lower register key codes
741 // normally but for the letter keys we want to have the upper ones
743 // NB: don't use XConvertCase() here, we want to do it for letters
745 key_code
= toupper(key_code
);
747 else // non ASCII key, what to do?
749 // by default, ignore it
752 // but if we have cached information from the last KEY_PRESS
753 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
756 if ( keysym
== s_lastKeyPress
.keysym
)
758 key_code
= s_lastKeyPress
.keycode
;
763 if ( gdk_event
->type
== GDK_KEY_PRESS
)
765 // remember it to be reused for KEY_UP event later
766 s_lastKeyPress
.keysym
= keysym
;
767 s_lastKeyPress
.keycode
= key_code
;
771 wxLogTrace(TRACE_KEYS
, wxT("\t-> wxKeyCode %ld"), key_code
);
773 // sending unknown key events doesn't really make sense
777 event
.m_keyCode
= key_code
;
780 event
.m_uniChar
= gdk_keyval_to_unicode(key_code ? key_code
: keysym
);
781 if ( !event
.m_uniChar
&& event
.m_keyCode
<= WXK_DELETE
)
783 // Set Unicode key code to the ASCII equivalent for compatibility. E.g.
784 // let RETURN generate the key event with both key and Unicode key
786 event
.m_uniChar
= event
.m_keyCode
;
788 #endif // wxUSE_UNICODE
790 // now fill all the other fields
791 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
799 GtkIMContext
*context
;
800 GdkEventKey
*lastKeyEvent
;
804 context
= gtk_im_multicontext_new();
809 g_object_unref (context
);
816 // Send wxEVT_CHAR_HOOK event to the parent of the window and return true only
817 // if it was processed (and not skipped).
818 bool SendCharHookEvent(const wxKeyEvent
& event
, wxWindow
*win
)
820 // wxEVT_CHAR_HOOK must be sent to allow the parent windows (e.g. a dialog
821 // which typically closes when Esc key is pressed in any of its controls)
822 // to handle key events in all of its children unless the mouse is captured
823 // in which case we consider that the keyboard should be "captured" too.
824 if ( !g_captureWindow
)
826 wxKeyEvent
eventCharHook(wxEVT_CHAR_HOOK
, event
);
827 if ( win
->HandleWindowEvent(eventCharHook
)
828 && !event
.IsNextEventAllowed() )
835 // Adjust wxEVT_CHAR event key code fields. This function takes care of two
837 // (a) Ctrl-letter key presses generate key codes in range 1..26
838 // (b) Unicode key codes are same as key codes for the codes in 1..255 range
839 void AdjustCharEventKeyCodes(wxKeyEvent
& event
)
841 const int code
= event
.m_keyCode
;
843 // Check for (a) above.
844 if ( event
.ControlDown() )
846 // We intentionally don't use isupper/lower() here, we really need
847 // ASCII letters only as it doesn't make sense to translate any other
848 // ones into this range which has only 26 slots.
849 if ( code
>= 'a' && code
<= 'z' )
850 event
.m_keyCode
= code
- 'a' + 1;
851 else if ( code
>= 'A' && code
<= 'Z' )
852 event
.m_keyCode
= code
- 'A' + 1;
855 // Adjust the Unicode equivalent in the same way too.
856 if ( event
.m_keyCode
!= code
)
857 event
.m_uniChar
= event
.m_keyCode
;
858 #endif // wxUSE_UNICODE
862 // Check for (b) from above.
864 // FIXME: Should we do it for key codes up to 255?
865 if ( !event
.m_uniChar
&& code
< WXK_DELETE
)
866 event
.m_uniChar
= code
;
867 #endif // wxUSE_UNICODE
870 } // anonymous namespace
872 // If a widget does not handle a key or mouse event, GTK+ sends it up the
873 // parent chain until it is handled. These events are not supposed to propagate
874 // in wxWidgets, so this code avoids handling them in any parent wxWindow,
875 // while still allowing the event to propagate so things like native keyboard
876 // navigation will work.
877 #define wxPROCESS_EVENT_ONCE(EventType, event) \
878 static EventType eventPrev; \
879 if (memcmp(&eventPrev, event, sizeof(EventType)) == 0) \
885 gtk_window_key_press_callback( GtkWidget
*WXUNUSED(widget
),
886 GdkEventKey
*gdk_event
,
891 if (g_blockEventsOnDrag
)
894 wxPROCESS_EVENT_ONCE(GdkEventKey
, gdk_event
);
896 wxKeyEvent
event( wxEVT_KEY_DOWN
);
898 bool return_after_IM
= false;
900 if( wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
902 // Send the CHAR_HOOK event first
903 if ( SendCharHookEvent(event
, win
) )
905 // Don't do anything at all with this event any more.
909 // Emit KEY_DOWN event
910 ret
= win
->HandleWindowEvent( event
);
914 // Return after IM processing as we cannot do
915 // anything with it anyhow.
916 return_after_IM
= true;
919 if (!ret
&& win
->m_imData
)
921 win
->m_imData
->lastKeyEvent
= gdk_event
;
923 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
924 // docs, if IM filter returns true, no further processing should be done.
925 // we should send the key_down event anyway.
926 bool intercepted_by_IM
= gtk_im_context_filter_keypress(win
->m_imData
->context
, gdk_event
);
927 win
->m_imData
->lastKeyEvent
= NULL
;
928 if (intercepted_by_IM
)
930 wxLogTrace(TRACE_KEYS
, wxT("Key event intercepted by IM"));
941 wxWindowGTK
*ancestor
= win
;
944 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
947 wxCommandEvent
menu_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
948 ret
= ancestor
->HandleWindowEvent( menu_event
);
952 // if the accelerator wasn't handled as menu event, try
953 // it as button click (for compatibility with other
955 wxCommandEvent
button_event( wxEVT_COMMAND_BUTTON_CLICKED
, command
);
956 ret
= ancestor
->HandleWindowEvent( button_event
);
961 if (ancestor
->IsTopLevel())
963 ancestor
= ancestor
->GetParent();
966 #endif // wxUSE_ACCEL
968 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
969 // will only be sent if it is not in an accelerator table.
973 KeySym keysym
= gdk_event
->keyval
;
974 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
975 key_code
= wxTranslateKeySymToWXKey(keysym
, true /* isChar */);
978 if ( wxIsAsciiKeysym(keysym
) )
981 key_code
= (unsigned char)keysym
;
983 // gdk_event->string is actually deprecated
984 else if ( gdk_event
->length
== 1 )
986 key_code
= (unsigned char)gdk_event
->string
[0];
992 wxKeyEvent
eventChar(wxEVT_CHAR
, event
);
994 wxLogTrace(TRACE_KEYS
, wxT("Char event: %ld"), key_code
);
996 eventChar
.m_keyCode
= key_code
;
998 AdjustCharEventKeyCodes(eventChar
);
1000 ret
= win
->HandleWindowEvent(eventChar
);
1010 gtk_wxwindow_commit_cb (GtkIMContext
* WXUNUSED(context
),
1014 wxKeyEvent
event( wxEVT_CHAR
);
1016 // take modifiers, cursor position, timestamp etc. from the last
1017 // key_press_event that was fed into Input Method:
1018 if (window
->m_imData
->lastKeyEvent
)
1020 wxFillOtherKeyEventFields(event
,
1021 window
, window
->m_imData
->lastKeyEvent
);
1025 event
.SetEventObject( window
);
1028 const wxString
data(wxGTK_CONV_BACK_SYS(str
));
1032 for( wxString
::const_iterator pstr
= data
.begin(); pstr
!= data
.end(); ++pstr
)
1035 event
.m_uniChar
= *pstr
;
1036 // Backward compatible for ISO-8859-1
1037 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
1038 wxLogTrace(TRACE_KEYS
, wxT("IM sent character '%c'"), event
.m_uniChar
);
1040 event
.m_keyCode
= (char)*pstr
;
1041 #endif // wxUSE_UNICODE
1043 AdjustCharEventKeyCodes(event
);
1045 window
->HandleWindowEvent(event
);
1051 //-----------------------------------------------------------------------------
1052 // "key_release_event" from any window
1053 //-----------------------------------------------------------------------------
1057 gtk_window_key_release_callback( GtkWidget
* WXUNUSED(widget
),
1058 GdkEventKey
*gdk_event
,
1064 if (g_blockEventsOnDrag
)
1067 wxPROCESS_EVENT_ONCE(GdkEventKey
, gdk_event
);
1069 wxKeyEvent
event( wxEVT_KEY_UP
);
1070 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1072 // unknown key pressed, ignore (the event would be useless anyhow)
1076 return win
->GTKProcessEvent(event
);
1080 // ============================================================================
1082 // ============================================================================
1084 // ----------------------------------------------------------------------------
1085 // mouse event processing helpers
1086 // ----------------------------------------------------------------------------
1088 static void AdjustEventButtonState(wxMouseEvent
& event
)
1090 // GDK reports the old state of the button for a button press event, but
1091 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1092 // for a LEFT_DOWN event, not FALSE, so we will invert
1093 // left/right/middleDown for the corresponding click events
1095 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1096 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1097 (event
.GetEventType() == wxEVT_LEFT_UP
))
1099 event
.m_leftDown
= !event
.m_leftDown
;
1103 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1104 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1105 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1107 event
.m_middleDown
= !event
.m_middleDown
;
1111 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1112 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1113 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1115 event
.m_rightDown
= !event
.m_rightDown
;
1119 if ((event
.GetEventType() == wxEVT_AUX1_DOWN
) ||
1120 (event
.GetEventType() == wxEVT_AUX1_DCLICK
))
1122 event
.m_aux1Down
= true;
1126 if ((event
.GetEventType() == wxEVT_AUX2_DOWN
) ||
1127 (event
.GetEventType() == wxEVT_AUX2_DCLICK
))
1129 event
.m_aux2Down
= true;
1134 // find the window to send the mouse event to
1136 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1141 if (win
->m_wxwindow
)
1143 wxPizza
* pizza
= WX_PIZZA(win
->m_wxwindow
);
1144 xx
+= pizza
->m_scroll_x
;
1145 yy
+= pizza
->m_scroll_y
;
1148 wxWindowList
::compatibility_iterator node
= win
->GetChildren().GetFirst();
1151 wxWindow
* child
= static_cast<wxWindow
*>(node
->GetData());
1153 node
= node
->GetNext();
1154 if (!child
->IsShown())
1157 if (child
->GTKIsTransparentForMouse())
1159 // wxStaticBox is transparent in the box itself
1160 int xx1
= child
->m_x
;
1161 int yy1
= child
->m_y
;
1162 int xx2
= child
->m_x
+ child
->m_width
;
1163 int yy2
= child
->m_y
+ child
->m_height
;
1166 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1168 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1170 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1172 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1183 if ((child
->m_wxwindow
== NULL
) &&
1184 win
->IsClientAreaChild(child
) &&
1185 (child
->m_x
<= xx
) &&
1186 (child
->m_y
<= yy
) &&
1187 (child
->m_x
+child
->m_width
>= xx
) &&
1188 (child
->m_y
+child
->m_height
>= yy
))
1201 // ----------------------------------------------------------------------------
1202 // common event handlers helpers
1203 // ----------------------------------------------------------------------------
1205 bool wxWindowGTK
::GTKProcessEvent(wxEvent
& event
) const
1207 // nothing special at this level
1208 return HandleWindowEvent(event
);
1211 bool wxWindowGTK
::GTKShouldIgnoreEvent() const
1213 return !m_hasVMT
|| g_blockEventsOnDrag
;
1216 int wxWindowGTK
::GTKCallbackCommonPrologue(GdkEventAny
*event
) const
1220 if (g_blockEventsOnDrag
)
1222 if (g_blockEventsOnScroll
)
1225 if (!GTKIsOwnWindow(event
->window
))
1231 // overloads for all GDK event types we use here: we need to have this as
1232 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1233 // derives from it in the sense that the structs have the same layout
1234 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1235 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1237 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1240 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton
)
1241 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion
)
1242 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing
)
1244 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1246 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1247 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1251 // all event handlers must have C linkage as they're called from GTK+ C code
1255 //-----------------------------------------------------------------------------
1256 // "button_press_event"
1257 //-----------------------------------------------------------------------------
1260 gtk_window_button_press_callback( GtkWidget
*widget
,
1261 GdkEventButton
*gdk_event
,
1264 wxPROCESS_EVENT_ONCE(GdkEventButton
, gdk_event
);
1266 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1268 g_lastButtonNumber
= gdk_event
->button
;
1270 // GDK sends surplus button down events
1271 // before a double click event. We
1272 // need to filter these out.
1273 if ((gdk_event
->type
== GDK_BUTTON_PRESS
) && (win
->m_wxwindow
))
1275 GdkEvent
*peek_event
= gdk_event_peek();
1278 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1279 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1281 gdk_event_free( peek_event
);
1286 gdk_event_free( peek_event
);
1291 wxEventType event_type
= wxEVT_NULL
;
1293 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1294 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1296 // Reset GDK internal timestamp variables in order to disable GDK
1297 // triple click events. GDK will then next time believe no button has
1298 // been clicked just before, and send a normal button click event.
1299 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1300 display
->button_click_time
[1] = 0;
1301 display
->button_click_time
[0] = 0;
1304 if (gdk_event
->button
== 1)
1306 // note that GDK generates triple click events which are not supported
1307 // by wxWidgets but still have to be passed to the app as otherwise
1308 // clicks would simply go missing
1309 switch (gdk_event
->type
)
1311 // we shouldn't get triple clicks at all for GTK2 because we
1312 // suppress them artificially using the code above but we still
1313 // should map them to something for GTK1 and not just ignore them
1314 // as this would lose clicks
1315 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1316 case GDK_BUTTON_PRESS
:
1317 event_type
= wxEVT_LEFT_DOWN
;
1320 case GDK_2BUTTON_PRESS
:
1321 event_type
= wxEVT_LEFT_DCLICK
;
1325 // just to silence gcc warnings
1329 else if (gdk_event
->button
== 2)
1331 switch (gdk_event
->type
)
1333 case GDK_3BUTTON_PRESS
:
1334 case GDK_BUTTON_PRESS
:
1335 event_type
= wxEVT_MIDDLE_DOWN
;
1338 case GDK_2BUTTON_PRESS
:
1339 event_type
= wxEVT_MIDDLE_DCLICK
;
1346 else if (gdk_event
->button
== 3)
1348 switch (gdk_event
->type
)
1350 case GDK_3BUTTON_PRESS
:
1351 case GDK_BUTTON_PRESS
:
1352 event_type
= wxEVT_RIGHT_DOWN
;
1355 case GDK_2BUTTON_PRESS
:
1356 event_type
= wxEVT_RIGHT_DCLICK
;
1364 else if (gdk_event
->button
== 8)
1366 switch (gdk_event
->type
)
1368 case GDK_3BUTTON_PRESS
:
1369 case GDK_BUTTON_PRESS
:
1370 event_type
= wxEVT_AUX1_DOWN
;
1373 case GDK_2BUTTON_PRESS
:
1374 event_type
= wxEVT_AUX1_DCLICK
;
1382 else if (gdk_event
->button
== 9)
1384 switch (gdk_event
->type
)
1386 case GDK_3BUTTON_PRESS
:
1387 case GDK_BUTTON_PRESS
:
1388 event_type
= wxEVT_AUX2_DOWN
;
1391 case GDK_2BUTTON_PRESS
:
1392 event_type
= wxEVT_AUX2_DCLICK
;
1400 if ( event_type
== wxEVT_NULL
)
1402 // unknown mouse button or click type
1406 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1408 wxMouseEvent
event( event_type
);
1409 InitMouseEvent( win
, event
, gdk_event
);
1411 AdjustEventButtonState(event
);
1413 // find the correct window to send the event to: it may be a different one
1414 // from the one which got it at GTK+ level because some controls don't have
1415 // their own X window and thus cannot get any events.
1416 if ( !g_captureWindow
)
1417 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1419 // reset the event object and id in case win changed.
1420 event
.SetEventObject( win
);
1421 event
.SetId( win
->GetId() );
1423 bool ret
= win
->GTKProcessEvent( event
);
1424 g_lastMouseEvent
= NULL
;
1428 if ((event_type
== wxEVT_LEFT_DOWN
) && !win
->IsOfStandardClass() &&
1429 (gs_currentFocus
!= win
) /* && win->IsFocusable() */)
1434 if (event_type
== wxEVT_RIGHT_DOWN
)
1436 // generate a "context menu" event: this is similar to right mouse
1437 // click under many GUIs except that it is generated differently
1438 // (right up under MSW, ctrl-click under Mac, right down here) and
1440 // (a) it's a command event and so is propagated to the parent
1441 // (b) under some ports it can be generated from kbd too
1442 // (c) it uses screen coords (because of (a))
1443 wxContextMenuEvent
evtCtx(
1446 win
->ClientToScreen(event
.GetPosition()));
1447 evtCtx
.SetEventObject(win
);
1448 return win
->GTKProcessEvent(evtCtx
);
1454 //-----------------------------------------------------------------------------
1455 // "button_release_event"
1456 //-----------------------------------------------------------------------------
1459 gtk_window_button_release_callback( GtkWidget
*WXUNUSED(widget
),
1460 GdkEventButton
*gdk_event
,
1463 wxPROCESS_EVENT_ONCE(GdkEventButton
, gdk_event
);
1465 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1467 g_lastButtonNumber
= 0;
1469 wxEventType event_type
= wxEVT_NULL
;
1471 switch (gdk_event
->button
)
1474 event_type
= wxEVT_LEFT_UP
;
1478 event_type
= wxEVT_MIDDLE_UP
;
1482 event_type
= wxEVT_RIGHT_UP
;
1486 event_type
= wxEVT_AUX1_UP
;
1490 event_type
= wxEVT_AUX2_UP
;
1494 // unknown button, don't process
1498 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1500 wxMouseEvent
event( event_type
);
1501 InitMouseEvent( win
, event
, gdk_event
);
1503 AdjustEventButtonState(event
);
1505 if ( !g_captureWindow
)
1506 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1508 // reset the event object and id in case win changed.
1509 event
.SetEventObject( win
);
1510 event
.SetId( win
->GetId() );
1512 bool ret
= win
->GTKProcessEvent(event
);
1514 g_lastMouseEvent
= NULL
;
1519 //-----------------------------------------------------------------------------
1520 // "motion_notify_event"
1521 //-----------------------------------------------------------------------------
1524 gtk_window_motion_notify_callback( GtkWidget
* WXUNUSED(widget
),
1525 GdkEventMotion
*gdk_event
,
1528 wxPROCESS_EVENT_ONCE(GdkEventMotion
, gdk_event
);
1530 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1532 if (gdk_event
->is_hint
)
1536 GdkModifierType state
;
1537 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1542 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1544 wxMouseEvent
event( wxEVT_MOTION
);
1545 InitMouseEvent(win
, event
, gdk_event
);
1547 if ( g_captureWindow
)
1549 // synthesise a mouse enter or leave event if needed
1550 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1551 // This seems to be necessary and actually been added to
1552 // GDK itself in version 2.0.X
1555 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1556 if ( hasMouse
!= g_captureWindowHasMouse
)
1558 // the mouse changed window
1559 g_captureWindowHasMouse
= hasMouse
;
1561 wxMouseEvent
eventM(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1562 : wxEVT_LEAVE_WINDOW
);
1563 InitMouseEvent(win
, eventM
, gdk_event
);
1564 eventM
.SetEventObject(win
);
1565 win
->GTKProcessEvent(eventM
);
1570 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1572 // reset the event object and id in case win changed.
1573 event
.SetEventObject( win
);
1574 event
.SetId( win
->GetId() );
1577 if ( !g_captureWindow
)
1579 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1580 if (win
->GTKProcessEvent( cevent
))
1582 win
->SetCursor( cevent
.GetCursor() );
1586 bool ret
= win
->GTKProcessEvent(event
);
1588 g_lastMouseEvent
= NULL
;
1593 //-----------------------------------------------------------------------------
1594 // "scroll_event" (mouse wheel event)
1595 //-----------------------------------------------------------------------------
1598 window_scroll_event_hscrollbar(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1600 if (gdk_event
->direction
!= GDK_SCROLL_LEFT
&&
1601 gdk_event
->direction
!= GDK_SCROLL_RIGHT
)
1606 GtkRange
*range
= win
->m_scrollBar
[wxWindow
::ScrollDir_Horz
];
1608 if (range
&& gtk_widget_get_visible(GTK_WIDGET(range
)))
1610 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
1611 double delta
= gtk_adjustment_get_step_increment(adj
) * 3;
1612 if (gdk_event
->direction
== GDK_SCROLL_LEFT
)
1615 gtk_range_set_value(range
, gtk_adjustment_get_value(adj
) + delta
);
1624 window_scroll_event(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1626 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1627 InitMouseEvent(win
, event
, gdk_event
);
1629 // FIXME: Get these values from GTK or GDK
1630 event
.m_linesPerAction
= 3;
1631 event
.m_wheelDelta
= 120;
1633 // Determine the scroll direction.
1634 switch (gdk_event
->direction
)
1637 case GDK_SCROLL_RIGHT
:
1638 event
.m_wheelRotation
= 120;
1641 case GDK_SCROLL_DOWN
:
1642 case GDK_SCROLL_LEFT
:
1643 event
.m_wheelRotation
= -120;
1647 return false; // Unknown/unhandled direction
1650 // And the scroll axis.
1651 switch (gdk_event
->direction
)
1654 case GDK_SCROLL_DOWN
:
1655 event
.m_wheelAxis
= wxMOUSE_WHEEL_VERTICAL
;
1658 case GDK_SCROLL_LEFT
:
1659 case GDK_SCROLL_RIGHT
:
1660 event
.m_wheelAxis
= wxMOUSE_WHEEL_HORIZONTAL
;
1664 if (win
->GTKProcessEvent(event
))
1667 GtkRange
*range
= win
->m_scrollBar
[wxWindow
::ScrollDir_Vert
];
1669 if (range
&& gtk_widget_get_visible(GTK_WIDGET(range
)))
1671 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
1672 double delta
= gtk_adjustment_get_step_increment(adj
) * 3;
1673 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1676 gtk_range_set_value(range
, gtk_adjustment_get_value(adj
) + delta
);
1684 //-----------------------------------------------------------------------------
1686 //-----------------------------------------------------------------------------
1688 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
1690 wxContextMenuEvent
event(wxEVT_CONTEXT_MENU
, win
->GetId(), wxPoint(-1, -1));
1691 event
.SetEventObject(win
);
1692 return win
->GTKProcessEvent(event
);
1695 //-----------------------------------------------------------------------------
1697 //-----------------------------------------------------------------------------
1700 gtk_window_focus_in_callback( GtkWidget
* WXUNUSED(widget
),
1701 GdkEventFocus
*WXUNUSED(event
),
1704 return win
->GTKHandleFocusIn();
1707 //-----------------------------------------------------------------------------
1708 // "focus_out_event"
1709 //-----------------------------------------------------------------------------
1712 gtk_window_focus_out_callback( GtkWidget
* WXUNUSED(widget
),
1713 GdkEventFocus
* WXUNUSED(gdk_event
),
1716 return win
->GTKHandleFocusOut();
1719 //-----------------------------------------------------------------------------
1721 //-----------------------------------------------------------------------------
1724 wx_window_focus_callback(GtkWidget
*widget
,
1725 GtkDirectionType
WXUNUSED(direction
),
1728 // the default handler for focus signal in GtkScrolledWindow sets
1729 // focus to the window itself even if it doesn't accept focus, i.e. has no
1730 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1731 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1732 // any children which might accept focus (we know we don't accept the focus
1733 // ourselves as this signal is only connected in this case)
1734 if ( win
->GetChildren().empty() )
1735 g_signal_stop_emission_by_name(widget
, "focus");
1737 // we didn't change the focus
1741 //-----------------------------------------------------------------------------
1742 // "enter_notify_event"
1743 //-----------------------------------------------------------------------------
1746 gtk_window_enter_callback( GtkWidget
*widget
,
1747 GdkEventCrossing
*gdk_event
,
1750 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1752 // Event was emitted after a grab
1753 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1757 GdkModifierType state
= (GdkModifierType
)0;
1759 gdk_window_get_pointer(gtk_widget_get_window(widget
), &x
, &y
, &state
);
1761 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1762 InitMouseEvent(win
, event
, gdk_event
);
1763 wxPoint pt
= win
->GetClientAreaOrigin();
1764 event
.m_x
= x
+ pt
.x
;
1765 event
.m_y
= y
+ pt
.y
;
1767 if ( !g_captureWindow
)
1769 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1770 if (win
->GTKProcessEvent( cevent
))
1772 win
->SetCursor( cevent
.GetCursor() );
1776 return win
->GTKProcessEvent(event
);
1779 //-----------------------------------------------------------------------------
1780 // "leave_notify_event"
1781 //-----------------------------------------------------------------------------
1784 gtk_window_leave_callback( GtkWidget
*widget
,
1785 GdkEventCrossing
*gdk_event
,
1788 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1790 // Event was emitted after an ungrab
1791 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1793 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1797 GdkModifierType state
= (GdkModifierType
)0;
1799 gdk_window_get_pointer(gtk_widget_get_window(widget
), &x
, &y
, &state
);
1801 InitMouseEvent(win
, event
, gdk_event
);
1803 return win
->GTKProcessEvent(event
);
1806 //-----------------------------------------------------------------------------
1807 // "value_changed" from scrollbar
1808 //-----------------------------------------------------------------------------
1811 gtk_scrollbar_value_changed(GtkRange
* range
, wxWindow
* win
)
1813 wxEventType eventType
= win
->GTKGetScrollEventType(range
);
1814 if (eventType
!= wxEVT_NULL
)
1816 // Convert scroll event type to scrollwin event type
1817 eventType
+= wxEVT_SCROLLWIN_TOP
- wxEVT_SCROLL_TOP
;
1819 // find the scrollbar which generated the event
1820 wxWindowGTK
::ScrollDir dir
= win
->ScrollDirFromRange(range
);
1822 // generate the corresponding wx event
1823 const int orient
= wxWindow
::OrientFromScrollDir(dir
);
1824 wxScrollWinEvent
event(eventType
, win
->GetScrollPos(orient
), orient
);
1825 event
.SetEventObject(win
);
1827 win
->GTKProcessEvent(event
);
1831 //-----------------------------------------------------------------------------
1832 // "button_press_event" from scrollbar
1833 //-----------------------------------------------------------------------------
1836 gtk_scrollbar_button_press_event(GtkRange
*, GdkEventButton
*, wxWindow
* win
)
1838 g_blockEventsOnScroll
= true;
1839 win
->m_mouseButtonDown
= true;
1844 //-----------------------------------------------------------------------------
1845 // "event_after" from scrollbar
1846 //-----------------------------------------------------------------------------
1849 gtk_scrollbar_event_after(GtkRange
* range
, GdkEvent
* event
, wxWindow
* win
)
1851 if (event
->type
== GDK_BUTTON_RELEASE
)
1853 g_signal_handlers_block_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1855 const int orient
= wxWindow
::OrientFromScrollDir(
1856 win
->ScrollDirFromRange(range
));
1857 wxScrollWinEvent
evt(wxEVT_SCROLLWIN_THUMBRELEASE
,
1858 win
->GetScrollPos(orient
), orient
);
1859 evt
.SetEventObject(win
);
1860 win
->GTKProcessEvent(evt
);
1864 //-----------------------------------------------------------------------------
1865 // "button_release_event" from scrollbar
1866 //-----------------------------------------------------------------------------
1869 gtk_scrollbar_button_release_event(GtkRange
* range
, GdkEventButton
*, wxWindow
* win
)
1871 g_blockEventsOnScroll
= false;
1872 win
->m_mouseButtonDown
= false;
1873 // If thumb tracking
1874 if (win
->m_isScrolling
)
1876 win
->m_isScrolling
= false;
1877 // Hook up handler to send thumb release event after this emission is finished.
1878 // To allow setting scroll position from event handler, sending event must
1879 // be deferred until after the GtkRange handler for this signal has run
1880 g_signal_handlers_unblock_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1886 //-----------------------------------------------------------------------------
1887 // "realize" from m_widget
1888 //-----------------------------------------------------------------------------
1891 gtk_window_realized_callback(GtkWidget
* WXUNUSED(widget
), wxWindowGTK
* win
)
1893 win
->GTKHandleRealized();
1896 //-----------------------------------------------------------------------------
1897 // "unrealize" from m_wxwindow
1898 //-----------------------------------------------------------------------------
1900 static void unrealize(GtkWidget
*, wxWindowGTK
* win
)
1903 gtk_im_context_set_client_window(win
->m_imData
->context
, NULL
);
1906 //-----------------------------------------------------------------------------
1907 // "size_allocate" from m_wxwindow or m_widget
1908 //-----------------------------------------------------------------------------
1911 size_allocate(GtkWidget
*, GtkAllocation
* alloc
, wxWindow
* win
)
1913 int w
= alloc
->width
;
1914 int h
= alloc
->height
;
1915 if (win
->m_wxwindow
)
1917 int border_x
, border_y
;
1918 WX_PIZZA(win
->m_wxwindow
)->get_border_widths(border_x
, border_y
);
1924 if (win
->m_oldClientWidth
!= w
|| win
->m_oldClientHeight
!= h
)
1926 win
->m_oldClientWidth
= w
;
1927 win
->m_oldClientHeight
= h
;
1928 // this callback can be connected to m_wxwindow,
1929 // so always get size from m_widget->allocation
1931 gtk_widget_get_allocation(win
->m_widget
, &a
);
1932 win
->m_width
= a
.width
;
1933 win
->m_height
= a
.height
;
1934 if (!win
->m_nativeSizeEvent
)
1936 wxSizeEvent
event(win
->GetSize(), win
->GetId());
1937 event
.SetEventObject(win
);
1938 win
->GTKProcessEvent(event
);
1943 //-----------------------------------------------------------------------------
1945 //-----------------------------------------------------------------------------
1947 #if GTK_CHECK_VERSION(2, 8, 0)
1949 gtk_window_grab_broken( GtkWidget
*,
1950 GdkEventGrabBroken
*event
,
1953 // Mouse capture has been lost involuntarily, notify the application
1954 if(!event
->keyboard
&& wxWindow
::GetCapture() == win
)
1956 wxMouseCaptureLostEvent
evt( win
->GetId() );
1957 evt
.SetEventObject( win
);
1958 win
->HandleWindowEvent( evt
);
1964 //-----------------------------------------------------------------------------
1966 //-----------------------------------------------------------------------------
1969 void gtk_window_style_set_callback( GtkWidget
*WXUNUSED(widget
),
1970 GtkStyle
*previous_style
,
1973 if (win
&& previous_style
)
1975 if (win
->IsTopLevel())
1977 wxSysColourChangedEvent event
;
1978 event
.SetEventObject(win
);
1979 win
->GTKProcessEvent(event
);
1983 // Border width could change, which will change client size.
1984 // Make sure size event occurs for this
1985 win
->m_oldClientWidth
= 0;
1992 void wxWindowGTK
::GTKHandleRealized()
1996 gtk_im_context_set_client_window
1999 m_wxwindow ?
GTKGetDrawingWindow()
2000 : gtk_widget_get_window(m_widget
)
2004 // Use composited window if background is transparent, if supported.
2005 if (m_backgroundStyle
== wxBG_STYLE_TRANSPARENT
)
2007 #if wxGTK_HAS_COMPOSITING_SUPPORT
2008 if (IsTransparentBackgroundSupported())
2010 GdkWindow
* const window
= GTKGetDrawingWindow();
2012 gdk_window_set_composited(window
, true);
2015 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
2017 // We revert to erase mode if transparency is not supported
2018 m_backgroundStyle
= wxBG_STYLE_ERASE
;
2023 // We cannot set colours and fonts before the widget
2024 // been realized, so we do this directly after realization
2025 // or otherwise in idle time
2027 if (m_needsStyleChange
)
2029 SetBackgroundStyle(GetBackgroundStyle());
2030 m_needsStyleChange
= false;
2033 wxWindowCreateEvent
event(static_cast<wxWindow
*>(this));
2034 event
.SetEventObject( this );
2035 GTKProcessEvent( event
);
2037 GTKUpdateCursor(true, false);
2040 // ----------------------------------------------------------------------------
2041 // this wxWindowBase function is implemented here (in platform-specific file)
2042 // because it is static and so couldn't be made virtual
2043 // ----------------------------------------------------------------------------
2045 wxWindow
*wxWindowBase
::DoFindFocus()
2047 // For compatibility with wxMSW, pretend that showing a popup menu doesn't
2048 // change the focus and that it remains on the window showing it, even
2049 // though the real focus does change in GTK.
2050 extern wxMenu
*wxCurrentPopupMenu
;
2051 if ( wxCurrentPopupMenu
)
2052 return wxCurrentPopupMenu
->GetInvokingWindow();
2054 wxWindowGTK
*focus
= gs_pendingFocus ? gs_pendingFocus
: gs_currentFocus
;
2055 // the cast is necessary when we compile in wxUniversal mode
2056 return static_cast<wxWindow
*>(focus
);
2059 void wxWindowGTK
::AddChildGTK(wxWindowGTK
* child
)
2061 wxASSERT_MSG(m_wxwindow
, "Cannot add a child to a window without a client area");
2063 // the window might have been scrolled already, we
2064 // have to adapt the position
2065 wxPizza
* pizza
= WX_PIZZA(m_wxwindow
);
2066 child
->m_x
+= pizza
->m_scroll_x
;
2067 child
->m_y
+= pizza
->m_scroll_y
;
2069 pizza
->put(child
->m_widget
,
2070 child
->m_x
, child
->m_y
, child
->m_width
, child
->m_height
);
2073 //-----------------------------------------------------------------------------
2075 //-----------------------------------------------------------------------------
2077 wxWindow
*wxGetActiveWindow()
2079 return wxWindow
::FindFocus();
2083 wxMouseState
wxGetMouseState()
2089 GdkModifierType mask
;
2091 gdk_window_get_pointer(NULL
, &x
, &y
, &mask
);
2095 ms
.SetLeftDown((mask
& GDK_BUTTON1_MASK
) != 0);
2096 ms
.SetMiddleDown((mask
& GDK_BUTTON2_MASK
) != 0);
2097 ms
.SetRightDown((mask
& GDK_BUTTON3_MASK
) != 0);
2098 // see the comment in InitMouseEvent()
2099 ms
.SetAux1Down((mask
& GDK_BUTTON4_MASK
) != 0);
2100 ms
.SetAux2Down((mask
& GDK_BUTTON5_MASK
) != 0);
2102 ms
.SetControlDown((mask
& GDK_CONTROL_MASK
) != 0);
2103 ms
.SetShiftDown((mask
& GDK_SHIFT_MASK
) != 0);
2104 ms
.SetAltDown((mask
& GDK_MOD1_MASK
) != 0);
2105 ms
.SetMetaDown((mask
& GDK_META_MASK
) != 0);
2110 //-----------------------------------------------------------------------------
2112 //-----------------------------------------------------------------------------
2114 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2116 #ifdef __WXUNIVERSAL__
2117 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2118 #endif // __WXUNIVERSAL__
2120 void wxWindowGTK
::Init()
2125 m_focusWidget
= NULL
;
2135 m_showOnIdle
= false;
2138 m_nativeSizeEvent
= false;
2140 m_isScrolling
= false;
2141 m_mouseButtonDown
= false;
2143 // initialize scrolling stuff
2144 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2146 m_scrollBar
[dir
] = NULL
;
2147 m_scrollPos
[dir
] = 0;
2151 m_oldClientHeight
= 0;
2153 m_clipPaintRegion
= false;
2155 m_needsStyleChange
= false;
2157 m_cursor
= *wxSTANDARD_CURSOR
;
2160 m_dirtyTabOrder
= false;
2163 wxWindowGTK
::wxWindowGTK()
2168 wxWindowGTK
::wxWindowGTK( wxWindow
*parent
,
2173 const wxString
&name
)
2177 Create( parent
, id
, pos
, size
, style
, name
);
2180 bool wxWindowGTK
::Create( wxWindow
*parent
,
2185 const wxString
&name
)
2187 // Get default border
2188 wxBorder border
= GetBorder(style
);
2190 style
&= ~wxBORDER_MASK
;
2193 if (!PreCreation( parent
, pos
, size
) ||
2194 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2196 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2200 // We should accept the native look
2202 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2203 scroll_class
->scrollbar_spacing
= 0;
2207 m_wxwindow
= wxPizza
::New(m_windowStyle
);
2208 #ifndef __WXUNIVERSAL__
2209 if (HasFlag(wxPizza
::BORDER_STYLES
))
2211 g_signal_connect(m_wxwindow
, "parent_set",
2212 G_CALLBACK(parent_set
), this);
2215 if (!HasFlag(wxHSCROLL
) && !HasFlag(wxVSCROLL
))
2216 m_widget
= m_wxwindow
;
2219 m_widget
= gtk_scrolled_window_new( NULL
, NULL
);
2221 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2223 // There is a conflict with default bindings at GTK+
2224 // level between scrolled windows and notebooks both of which want to use
2225 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2226 // direction and notebooks for changing pages -- we decide that if we don't
2227 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2228 // means we can get working keyboard navigation in notebooks
2229 if ( !HasFlag(wxHSCROLL
) )
2232 bindings
= gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget
));
2235 gtk_binding_entry_remove(bindings
, GDK_Page_Up
, GDK_CONTROL_MASK
);
2236 gtk_binding_entry_remove(bindings
, GDK_Page_Down
, GDK_CONTROL_MASK
);
2240 if (HasFlag(wxALWAYS_SHOW_SB
))
2242 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_ALWAYS
, GTK_POLICY_ALWAYS
);
2246 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2249 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow
));
2250 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow
));
2251 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2252 gtk_range_set_inverted( m_scrollBar
[ScrollDir_Horz
], TRUE
);
2254 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2256 // connect various scroll-related events
2257 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2259 // these handlers block mouse events to any window during scrolling
2260 // such as motion events and prevent GTK and wxWidgets from fighting
2261 // over where the slider should be
2262 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2263 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2264 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2265 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2267 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2268 G_CALLBACK(gtk_scrollbar_event_after
), this);
2269 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2271 // these handlers get notified when scrollbar slider moves
2272 g_signal_connect_after(m_scrollBar
[dir
], "value_changed",
2273 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2276 gtk_widget_show( m_wxwindow
);
2278 g_object_ref(m_widget
);
2281 m_parent
->DoAddChild( this );
2283 m_focusWidget
= m_wxwindow
;
2285 SetCanFocus(AcceptsFocus());
2292 wxWindowGTK
::~wxWindowGTK()
2296 if (gs_currentFocus
== this)
2297 gs_currentFocus
= NULL
;
2298 if (gs_pendingFocus
== this)
2299 gs_pendingFocus
= NULL
;
2301 if ( gs_deferredFocusOut
== this )
2302 gs_deferredFocusOut
= NULL
;
2306 // destroy children before destroying this window itself
2309 // unhook focus handlers to prevent stray events being
2310 // propagated to this (soon to be) dead object
2311 if (m_focusWidget
!= NULL
)
2313 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2314 (gpointer
) gtk_window_focus_in_callback
,
2316 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2317 (gpointer
) gtk_window_focus_out_callback
,
2324 // delete before the widgets to avoid a crash on solaris
2328 // avoid problem with GTK+ 2.18 where a frozen window causes the whole
2329 // TLW to be frozen, and if the window is then destroyed, nothing ever
2330 // gets painted again
2336 // Note that gtk_widget_destroy() does not destroy the widget, it just
2337 // emits the "destroy" signal. The widget is not actually destroyed
2338 // until its reference count drops to zero.
2339 gtk_widget_destroy(m_widget
);
2340 // Release our reference, should be the last one
2341 g_object_unref(m_widget
);
2347 bool wxWindowGTK
::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2349 if ( GTKNeedsParent() )
2351 wxCHECK_MSG( parent
, false, wxT("Must have non-NULL parent") );
2354 // Use either the given size, or the default if -1 is given.
2355 // See wxWindowBase for these functions.
2356 m_width
= WidthDefault(size
.x
) ;
2357 m_height
= HeightDefault(size
.y
);
2359 if (pos
!= wxDefaultPosition
)
2368 void wxWindowGTK
::PostCreation()
2370 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2372 #if wxGTK_HAS_COMPOSITING_SUPPORT
2373 // Set RGBA visual as soon as possible to minimize the possibility that
2374 // somebody uses the wrong one.
2375 if ( m_backgroundStyle
== wxBG_STYLE_TRANSPARENT
&&
2376 IsTransparentBackgroundSupported() )
2378 GdkScreen
*screen
= gtk_widget_get_screen (m_widget
);
2380 GdkColormap
*rgba_colormap
= gdk_screen_get_rgba_colormap (screen
);
2383 gtk_widget_set_colormap(m_widget
, rgba_colormap
);
2385 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
2391 // these get reported to wxWidgets -> wxPaintEvent
2393 g_signal_connect (m_wxwindow
, "expose_event",
2394 G_CALLBACK (gtk_window_expose_callback
), this);
2396 if (GetLayoutDirection() == wxLayout_LeftToRight
)
2397 gtk_widget_set_redraw_on_allocate(m_wxwindow
, HasFlag(wxFULL_REPAINT_ON_RESIZE
));
2400 // Create input method handler
2401 m_imData
= new wxGtkIMData
;
2403 // Cannot handle drawing preedited text yet
2404 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2406 g_signal_connect (m_imData
->context
, "commit",
2407 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2408 g_signal_connect(m_wxwindow
, "unrealize", G_CALLBACK(unrealize
), this);
2413 if (!GTK_IS_WINDOW(m_widget
))
2415 if (m_focusWidget
== NULL
)
2416 m_focusWidget
= m_widget
;
2420 g_signal_connect (m_focusWidget
, "focus_in_event",
2421 G_CALLBACK (gtk_window_focus_in_callback
), this);
2422 g_signal_connect (m_focusWidget
, "focus_out_event",
2423 G_CALLBACK (gtk_window_focus_out_callback
), this);
2427 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2428 G_CALLBACK (gtk_window_focus_in_callback
), this);
2429 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2430 G_CALLBACK (gtk_window_focus_out_callback
), this);
2434 if ( !AcceptsFocusFromKeyboard() )
2438 g_signal_connect(m_widget
, "focus",
2439 G_CALLBACK(wx_window_focus_callback
), this);
2442 // connect to the various key and mouse handlers
2444 GtkWidget
*connect_widget
= GetConnectWidget();
2446 ConnectWidget( connect_widget
);
2448 // We cannot set colours, fonts and cursors before the widget has been
2449 // realized, so we do this directly after realization -- unless the widget
2450 // was in fact realized already.
2451 if ( gtk_widget_get_realized(connect_widget
) )
2453 gtk_window_realized_callback(connect_widget
, this);
2457 g_signal_connect (connect_widget
, "realize",
2458 G_CALLBACK (gtk_window_realized_callback
), this);
2463 g_signal_connect(m_wxwindow ? m_wxwindow
: m_widget
, "size_allocate",
2464 G_CALLBACK(size_allocate
), this);
2467 #if GTK_CHECK_VERSION(2, 8, 0)
2468 if ( gtk_check_version(2,8,0) == NULL
)
2470 // Make sure we can notify the app when mouse capture is lost
2473 g_signal_connect (m_wxwindow
, "grab_broken_event",
2474 G_CALLBACK (gtk_window_grab_broken
), this);
2477 if ( connect_widget
!= m_wxwindow
)
2479 g_signal_connect (connect_widget
, "grab_broken_event",
2480 G_CALLBACK (gtk_window_grab_broken
), this);
2483 #endif // GTK+ >= 2.8
2485 if (!WX_IS_PIZZA(gtk_widget_get_parent(m_widget
)) && !GTK_IS_WINDOW(m_widget
))
2486 gtk_widget_set_size_request(m_widget
, m_width
, m_height
);
2488 InheritAttributes();
2492 SetLayoutDirection(wxLayout_Default
);
2494 // unless the window was created initially hidden (i.e. Hide() had been
2495 // called before Create()), we should show it at GTK+ level as well
2497 gtk_widget_show( m_widget
);
2501 wxWindowGTK
::GTKConnectWidget(const char *signal
, wxGTKCallback callback
)
2503 return g_signal_connect(m_widget
, signal
, callback
, this);
2506 void wxWindowGTK
::ConnectWidget( GtkWidget
*widget
)
2508 g_signal_connect (widget
, "key_press_event",
2509 G_CALLBACK (gtk_window_key_press_callback
), this);
2510 g_signal_connect (widget
, "key_release_event",
2511 G_CALLBACK (gtk_window_key_release_callback
), this);
2512 g_signal_connect (widget
, "button_press_event",
2513 G_CALLBACK (gtk_window_button_press_callback
), this);
2514 g_signal_connect (widget
, "button_release_event",
2515 G_CALLBACK (gtk_window_button_release_callback
), this);
2516 g_signal_connect (widget
, "motion_notify_event",
2517 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2519 g_signal_connect (widget
, "scroll_event",
2520 G_CALLBACK (window_scroll_event
), this);
2521 if (m_scrollBar
[ScrollDir_Horz
])
2522 g_signal_connect (m_scrollBar
[ScrollDir_Horz
], "scroll_event",
2523 G_CALLBACK (window_scroll_event_hscrollbar
), this);
2524 if (m_scrollBar
[ScrollDir_Vert
])
2525 g_signal_connect (m_scrollBar
[ScrollDir_Vert
], "scroll_event",
2526 G_CALLBACK (window_scroll_event
), this);
2528 g_signal_connect (widget
, "popup_menu",
2529 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2530 g_signal_connect (widget
, "enter_notify_event",
2531 G_CALLBACK (gtk_window_enter_callback
), this);
2532 g_signal_connect (widget
, "leave_notify_event",
2533 G_CALLBACK (gtk_window_leave_callback
), this);
2535 if (m_wxwindow
&& (IsTopLevel() || HasFlag(wxBORDER_RAISED
| wxBORDER_SUNKEN
| wxBORDER_THEME
)))
2536 g_signal_connect (m_wxwindow
, "style_set",
2537 G_CALLBACK (gtk_window_style_set_callback
), this);
2540 bool wxWindowGTK
::Destroy()
2544 return wxWindowBase
::Destroy();
2547 static GSList
* gs_queueResizeList
;
2550 static gboolean
queue_resize(void*)
2552 gdk_threads_enter();
2553 for (GSList
* p
= gs_queueResizeList
; p
; p
= p
->next
)
2557 gtk_widget_queue_resize(GTK_WIDGET(p
->data
));
2558 g_object_remove_weak_pointer(G_OBJECT(p
->data
), &p
->data
);
2561 g_slist_free(gs_queueResizeList
);
2562 gs_queueResizeList
= NULL
;
2563 gdk_threads_leave();
2568 void wxWindowGTK
::DoMoveWindow(int x
, int y
, int width
, int height
)
2570 gtk_widget_set_size_request(m_widget
, width
, height
);
2571 GtkWidget
* parent
= gtk_widget_get_parent(m_widget
);
2572 if (WX_IS_PIZZA(parent
))
2573 WX_PIZZA(parent
)->move(m_widget
, x
, y
, width
, height
);
2575 // With GTK3, gtk_widget_queue_resize() is ignored while a size-allocate
2576 // is in progress. This situation is common in wxWidgets, since
2577 // size-allocate can generate wxSizeEvent and size event handlers often
2578 // call SetSize(), directly or indirectly. Work around this by deferring
2579 // the queue-resize until after size-allocate processing is finished.
2580 if (g_slist_find(gs_queueResizeList
, m_widget
) == NULL
)
2582 if (gs_queueResizeList
== NULL
)
2583 g_idle_add_full(GTK_PRIORITY_RESIZE
, queue_resize
, NULL
, NULL
);
2584 gs_queueResizeList
= g_slist_prepend(gs_queueResizeList
, m_widget
);
2585 g_object_add_weak_pointer(G_OBJECT(m_widget
), &gs_queueResizeList
->data
);
2589 void wxWindowGTK
::ConstrainSize()
2592 // GPE's window manager doesn't like size hints at all, esp. when the user
2593 // has to use the virtual keyboard, so don't constrain size there
2597 const wxSize minSize
= GetMinSize();
2598 const wxSize maxSize
= GetMaxSize();
2599 if (minSize
.x
> 0 && m_width
< minSize
.x
) m_width
= minSize
.x
;
2600 if (minSize
.y
> 0 && m_height
< minSize
.y
) m_height
= minSize
.y
;
2601 if (maxSize
.x
> 0 && m_width
> maxSize
.x
) m_width
= maxSize
.x
;
2602 if (maxSize
.y
> 0 && m_height
> maxSize
.y
) m_height
= maxSize
.y
;
2606 void wxWindowGTK
::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2608 wxCHECK_RET(m_widget
, "invalid window");
2610 int scrollX
= 0, scrollY
= 0;
2611 GtkWidget
* parent
= gtk_widget_get_parent(m_widget
);
2612 if (WX_IS_PIZZA(parent
))
2614 wxPizza
* pizza
= WX_PIZZA(parent
);
2615 scrollX
= pizza
->m_scroll_x
;
2616 scrollY
= pizza
->m_scroll_y
;
2618 if (x
!= -1 || (sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2622 if (y
!= -1 || (sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2627 // calculate the best size if we should auto size the window
2628 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2629 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2631 const wxSize sizeBest
= GetBestSize();
2632 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2634 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2635 height
= sizeBest
.y
;
2643 const bool sizeChange
= m_width
!= width
|| m_height
!= height
;
2644 if (sizeChange
|| m_x
!= x
|| m_y
!= y
)
2651 /* the default button has a border around it */
2652 if (gtk_widget_get_can_default(m_widget
))
2654 GtkBorder
*default_border
= NULL
;
2655 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2658 x
-= default_border
->left
;
2659 y
-= default_border
->top
;
2660 width
+= default_border
->left
+ default_border
->right
;
2661 height
+= default_border
->top
+ default_border
->bottom
;
2662 gtk_border_free( default_border
);
2666 DoMoveWindow(x
, y
, width
, height
);
2669 if ((sizeChange
&& !m_nativeSizeEvent
) || (sizeFlags
& wxSIZE_FORCE_EVENT
))
2671 // update these variables to keep size_allocate handler
2672 // from sending another size event for this change
2673 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2675 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2676 event
.SetEventObject( this );
2677 HandleWindowEvent( event
);
2681 bool wxWindowGTK
::GTKShowFromOnIdle()
2683 if (IsShown() && m_showOnIdle
&& !gtk_widget_get_visible (m_widget
))
2685 GtkAllocation alloc
;
2688 alloc
.width
= m_width
;
2689 alloc
.height
= m_height
;
2690 gtk_widget_size_allocate( m_widget
, &alloc
);
2691 gtk_widget_show( m_widget
);
2692 wxShowEvent
eventShow(GetId(), true);
2693 eventShow
.SetEventObject(this);
2694 HandleWindowEvent(eventShow
);
2695 m_showOnIdle
= false;
2702 void wxWindowGTK
::OnInternalIdle()
2704 if ( gs_deferredFocusOut
)
2705 GTKHandleDeferredFocusOut();
2707 // Check if we have to show window now
2708 if (GTKShowFromOnIdle()) return;
2710 if ( m_dirtyTabOrder
)
2712 m_dirtyTabOrder
= false;
2716 wxWindowBase
::OnInternalIdle();
2719 void wxWindowGTK
::DoGetSize( int *width
, int *height
) const
2721 if (width
) (*width
) = m_width
;
2722 if (height
) (*height
) = m_height
;
2725 void wxWindowGTK
::DoSetClientSize( int width
, int height
)
2727 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2729 const wxSize size
= GetSize();
2730 const wxSize clientSize
= GetClientSize();
2731 SetSize(width
+ (size
.x
- clientSize
.x
), height
+ (size
.y
- clientSize
.y
));
2734 void wxWindowGTK
::DoGetClientSize( int *width
, int *height
) const
2736 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2743 // if window is scrollable, account for scrollbars
2744 if ( GTK_IS_SCROLLED_WINDOW(m_widget
) )
2746 GtkPolicyType policy
[ScrollDir_Max
];
2747 gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget
),
2748 &policy
[ScrollDir_Horz
],
2749 &policy
[ScrollDir_Vert
]);
2751 for ( int i
= 0; i
< ScrollDir_Max
; i
++ )
2753 // don't account for the scrollbars we don't have
2754 GtkRange
* const range
= m_scrollBar
[i
];
2758 // nor for the ones we have but don't current show
2759 switch ( policy
[i
] )
2761 case GTK_POLICY_NEVER
:
2762 // never shown so doesn't take any place
2765 case GTK_POLICY_ALWAYS
:
2766 // no checks necessary
2769 case GTK_POLICY_AUTOMATIC
:
2770 // may be shown or not, check
2771 GtkAdjustment
*adj
= gtk_range_get_adjustment(range
);
2772 if (gtk_adjustment_get_upper(adj
) <= gtk_adjustment_get_page_size(adj
))
2776 GtkScrolledWindowClass
*scroll_class
=
2777 GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2780 gtk_widget_size_request(GTK_WIDGET(range
), &req
);
2781 if (i
== ScrollDir_Horz
)
2782 h
-= req
.height
+ scroll_class
->scrollbar_spacing
;
2784 w
-= req
.width
+ scroll_class
->scrollbar_spacing
;
2788 const wxSize sizeBorders
= DoGetBorderSize();
2798 if (width
) *width
= w
;
2799 if (height
) *height
= h
;
2802 wxSize wxWindowGTK
::DoGetBorderSize() const
2805 return wxWindowBase
::DoGetBorderSize();
2808 WX_PIZZA(m_wxwindow
)->get_border_widths(x
, y
);
2810 return 2*wxSize(x
, y
);
2813 void wxWindowGTK
::DoGetPosition( int *x
, int *y
) const
2817 GtkWidget
* parent
= NULL
;
2819 parent
= gtk_widget_get_parent(m_widget
);
2820 if (WX_IS_PIZZA(parent
))
2822 wxPizza
* pizza
= WX_PIZZA(parent
);
2823 dx
= pizza
->m_scroll_x
;
2824 dy
= pizza
->m_scroll_y
;
2826 if (x
) (*x
) = m_x
- dx
;
2827 if (y
) (*y
) = m_y
- dy
;
2830 void wxWindowGTK
::DoClientToScreen( int *x
, int *y
) const
2832 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2834 if (gtk_widget_get_window(m_widget
) == NULL
) return;
2836 GdkWindow
*source
= NULL
;
2838 source
= gtk_widget_get_window(m_wxwindow
);
2840 source
= gtk_widget_get_window(m_widget
);
2844 gdk_window_get_origin( source
, &org_x
, &org_y
);
2848 if (!gtk_widget_get_has_window(m_widget
))
2851 gtk_widget_get_allocation(m_widget
, &a
);
2860 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2861 *x
= (GetClientSize().x
- *x
) + org_x
;
2869 void wxWindowGTK
::DoScreenToClient( int *x
, int *y
) const
2871 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2873 if (!gtk_widget_get_realized(m_widget
)) return;
2875 GdkWindow
*source
= NULL
;
2877 source
= gtk_widget_get_window(m_wxwindow
);
2879 source
= gtk_widget_get_window(m_widget
);
2883 gdk_window_get_origin( source
, &org_x
, &org_y
);
2887 if (!gtk_widget_get_has_window(m_widget
))
2890 gtk_widget_get_allocation(m_widget
, &a
);
2898 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2899 *x
= (GetClientSize().x
- *x
) - org_x
;
2906 bool wxWindowGTK
::Show( bool show
)
2908 if ( !wxWindowBase
::Show(show
) )
2914 // notice that we may call Hide() before the window is created and this is
2915 // actually useful to create it hidden initially -- but we can't call
2916 // Show() before it is created
2919 wxASSERT_MSG( !show
, "can't show invalid window" );
2927 // defer until later
2931 gtk_widget_show(m_widget
);
2935 gtk_widget_hide(m_widget
);
2938 wxShowEvent
eventShow(GetId(), show
);
2939 eventShow
.SetEventObject(this);
2940 HandleWindowEvent(eventShow
);
2945 void wxWindowGTK
::DoEnable( bool enable
)
2947 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2949 gtk_widget_set_sensitive( m_widget
, enable
);
2950 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
2951 gtk_widget_set_sensitive( m_wxwindow
, enable
);
2954 int wxWindowGTK
::GetCharHeight() const
2956 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
2958 wxFont font
= GetFont();
2959 wxCHECK_MSG( font
.IsOk(), 12, wxT("invalid font") );
2961 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
2966 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
2967 PangoLayout
*layout
= pango_layout_new(context
);
2968 pango_layout_set_font_description(layout
, desc
);
2969 pango_layout_set_text(layout
, "H", 1);
2970 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
2972 PangoRectangle rect
;
2973 pango_layout_line_get_extents(line
, NULL
, &rect
);
2975 g_object_unref (layout
);
2977 return (int) PANGO_PIXELS(rect
.height
);
2980 int wxWindowGTK
::GetCharWidth() const
2982 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
2984 wxFont font
= GetFont();
2985 wxCHECK_MSG( font
.IsOk(), 8, wxT("invalid font") );
2987 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
2992 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
2993 PangoLayout
*layout
= pango_layout_new(context
);
2994 pango_layout_set_font_description(layout
, desc
);
2995 pango_layout_set_text(layout
, "g", 1);
2996 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
2998 PangoRectangle rect
;
2999 pango_layout_line_get_extents(line
, NULL
, &rect
);
3001 g_object_unref (layout
);
3003 return (int) PANGO_PIXELS(rect
.width
);
3006 void wxWindowGTK
::DoGetTextExtent( const wxString
& string
,
3010 int *externalLeading
,
3011 const wxFont
*theFont
) const
3013 wxFont fontToUse
= theFont ?
*theFont
: GetFont();
3015 wxCHECK_RET( fontToUse
.IsOk(), wxT("invalid font") );
3024 PangoContext
*context
= NULL
;
3026 context
= gtk_widget_get_pango_context( m_widget
);
3035 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3036 PangoLayout
*layout
= pango_layout_new(context
);
3037 pango_layout_set_font_description(layout
, desc
);
3039 const wxCharBuffer data
= wxGTK_CONV( string
);
3041 pango_layout_set_text(layout
, data
, strlen(data
));
3044 PangoRectangle rect
;
3045 pango_layout_get_extents(layout
, NULL
, &rect
);
3047 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
3048 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
3051 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
3052 int baseline
= pango_layout_iter_get_baseline(iter
);
3053 pango_layout_iter_free(iter
);
3054 *descent
= *y
- PANGO_PIXELS(baseline
);
3056 if (externalLeading
) (*externalLeading
) = 0; // ??
3058 g_object_unref (layout
);
3061 void wxWindowGTK
::GTKDisableFocusOutEvent()
3063 g_signal_handlers_block_by_func( m_focusWidget
,
3064 (gpointer
) gtk_window_focus_out_callback
, this);
3067 void wxWindowGTK
::GTKEnableFocusOutEvent()
3069 g_signal_handlers_unblock_by_func( m_focusWidget
,
3070 (gpointer
) gtk_window_focus_out_callback
, this);
3073 bool wxWindowGTK
::GTKHandleFocusIn()
3075 // Disable default focus handling for custom windows since the default GTK+
3076 // handler issues a repaint
3077 const bool retval
= m_wxwindow ?
true : false;
3080 // NB: if there's still unprocessed deferred focus-out event (see
3081 // GTKHandleFocusOut() for explanation), we need to process it first so
3082 // that the order of focus events -- focus-out first, then focus-in
3083 // elsewhere -- is preserved
3084 if ( gs_deferredFocusOut
)
3086 if ( GTKNeedsToFilterSameWindowFocus() &&
3087 gs_deferredFocusOut
== this )
3089 // GTK+ focus changed from this wxWindow back to itself, so don't
3090 // emit any events at all
3091 wxLogTrace(TRACE_FOCUS
,
3092 "filtered out spurious focus change within %s(%p, %s)",
3093 GetClassInfo()->GetClassName(), this, GetLabel());
3094 gs_deferredFocusOut
= NULL
;
3098 // otherwise we need to send focus-out first
3099 wxASSERT_MSG ( gs_deferredFocusOut
!= this,
3100 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
3101 GTKHandleDeferredFocusOut();
3105 wxLogTrace(TRACE_FOCUS
,
3106 "handling focus_in event for %s(%p, %s)",
3107 GetClassInfo()->GetClassName(), this, GetLabel());
3110 gtk_im_context_focus_in(m_imData
->context
);
3112 gs_currentFocus
= this;
3113 gs_pendingFocus
= NULL
;
3116 // caret needs to be informed about focus change
3117 wxCaret
*caret
= GetCaret();
3120 caret
->OnSetFocus();
3122 #endif // wxUSE_CARET
3124 // Notify the parent keeping track of focus for the kbd navigation
3125 // purposes that we got it.
3126 wxChildFocusEvent
eventChildFocus(static_cast<wxWindow
*>(this));
3127 GTKProcessEvent(eventChildFocus
);
3129 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, GetId());
3130 eventFocus
.SetEventObject(this);
3131 GTKProcessEvent(eventFocus
);
3136 bool wxWindowGTK
::GTKHandleFocusOut()
3138 // Disable default focus handling for custom windows since the default GTK+
3139 // handler issues a repaint
3140 const bool retval
= m_wxwindow ?
true : false;
3143 // NB: If a control is composed of several GtkWidgets and when focus
3144 // changes from one of them to another within the same wxWindow, we get
3145 // a focus-out event followed by focus-in for another GtkWidget owned
3146 // by the same wx control. We don't want to generate two spurious
3147 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3148 // from GTKHandleFocusOut() until we know for sure it's not coming back
3149 // (i.e. in GTKHandleFocusIn() or at idle time).
3150 if ( GTKNeedsToFilterSameWindowFocus() )
3152 wxASSERT_MSG( gs_deferredFocusOut
== NULL
,
3153 "deferred focus out event already pending" );
3154 wxLogTrace(TRACE_FOCUS
,
3155 "deferring focus_out event for %s(%p, %s)",
3156 GetClassInfo()->GetClassName(), this, GetLabel());
3157 gs_deferredFocusOut
= this;
3161 GTKHandleFocusOutNoDeferring();
3166 void wxWindowGTK
::GTKHandleFocusOutNoDeferring()
3168 wxLogTrace(TRACE_FOCUS
,
3169 "handling focus_out event for %s(%p, %s)",
3170 GetClassInfo()->GetClassName(), this, GetLabel());
3173 gtk_im_context_focus_out(m_imData
->context
);
3175 if ( gs_currentFocus
!= this )
3177 // Something is terribly wrong, gs_currentFocus is out of sync with the
3178 // real focus. We will reset it to NULL anyway, because after this
3179 // focus-out event is handled, one of the following with happen:
3181 // * either focus will go out of the app altogether, in which case
3182 // gs_currentFocus _should_ be NULL
3184 // * or it goes to another control, in which case focus-in event will
3185 // follow immediately and it will set gs_currentFocus to the right
3187 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3188 GetClassInfo()->GetClassName(), this, GetLabel());
3190 gs_currentFocus
= NULL
;
3193 // caret needs to be informed about focus change
3194 wxCaret
*caret
= GetCaret();
3197 caret
->OnKillFocus();
3199 #endif // wxUSE_CARET
3201 wxFocusEvent
event( wxEVT_KILL_FOCUS
, GetId() );
3202 event
.SetEventObject( this );
3203 event
.SetWindow( FindFocus() );
3204 GTKProcessEvent( event
);
3208 void wxWindowGTK
::GTKHandleDeferredFocusOut()
3210 // NB: See GTKHandleFocusOut() for explanation. This function is called
3211 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3213 if ( gs_deferredFocusOut
)
3215 wxWindowGTK
*win
= gs_deferredFocusOut
;
3216 gs_deferredFocusOut
= NULL
;
3218 wxLogTrace(TRACE_FOCUS
,
3219 "processing deferred focus_out event for %s(%p, %s)",
3220 win
->GetClassInfo()->GetClassName(), win
, win
->GetLabel());
3222 win
->GTKHandleFocusOutNoDeferring();
3226 void wxWindowGTK
::SetFocus()
3228 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3230 // Setting "physical" focus is not immediate in GTK+ and while
3231 // gtk_widget_is_focus ("determines if the widget is the focus widget
3232 // within its toplevel", i.e. returns true for one widget per TLW, not
3233 // globally) returns true immediately after grabbing focus,
3234 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3235 // has focus at the moment) takes effect only after the window is shown
3236 // (if it was hidden at the moment of the call) or at the next event loop
3239 // Because we want to FindFocus() call immediately following
3240 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3242 gs_pendingFocus
= this;
3244 GtkWidget
*widget
= m_wxwindow ? m_wxwindow
: m_focusWidget
;
3246 if ( GTK_IS_CONTAINER(widget
) &&
3247 !gtk_widget_get_can_focus(widget
) )
3249 wxLogTrace(TRACE_FOCUS
,
3250 wxT("Setting focus to a child of %s(%p, %s)"),
3251 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3252 gtk_widget_child_focus(widget
, GTK_DIR_TAB_FORWARD
);
3256 wxLogTrace(TRACE_FOCUS
,
3257 wxT("Setting focus to %s(%p, %s)"),
3258 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3259 gtk_widget_grab_focus(widget
);
3263 void wxWindowGTK
::SetCanFocus(bool canFocus
)
3265 gtk_widget_set_can_focus(m_widget
, canFocus
);
3267 if ( m_wxwindow
&& (m_widget
!= m_wxwindow
) )
3269 gtk_widget_set_can_focus(m_wxwindow
, canFocus
);
3273 bool wxWindowGTK
::Reparent( wxWindowBase
*newParentBase
)
3275 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3277 wxWindowGTK
* const newParent
= (wxWindowGTK
*)newParentBase
;
3279 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3281 if ( !wxWindowBase
::Reparent(newParent
) )
3284 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3286 // Notice that old m_parent pointer might be non-NULL here but the widget
3287 // still not have any parent at GTK level if it's a notebook page that had
3288 // been removed from the notebook so test this at GTK level and not wx one.
3289 if ( GtkWidget
*parentGTK
= gtk_widget_get_parent(m_widget
) )
3290 gtk_container_remove(GTK_CONTAINER(parentGTK
), m_widget
);
3292 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3296 if (gtk_widget_get_visible (newParent
->m_widget
))
3298 m_showOnIdle
= true;
3299 gtk_widget_hide( m_widget
);
3301 /* insert GTK representation */
3302 newParent
->AddChildGTK(this);
3305 SetLayoutDirection(wxLayout_Default
);
3310 void wxWindowGTK
::DoAddChild(wxWindowGTK
*child
)
3312 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3313 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3318 /* insert GTK representation */
3322 void wxWindowGTK
::AddChild(wxWindowBase
*child
)
3324 wxWindowBase
::AddChild(child
);
3325 m_dirtyTabOrder
= true;
3326 wxTheApp
->WakeUpIdle();
3329 void wxWindowGTK
::RemoveChild(wxWindowBase
*child
)
3331 wxWindowBase
::RemoveChild(child
);
3332 m_dirtyTabOrder
= true;
3333 wxTheApp
->WakeUpIdle();
3337 wxLayoutDirection wxWindowGTK
::GTKGetLayout(GtkWidget
*widget
)
3339 return gtk_widget_get_direction(widget
) == GTK_TEXT_DIR_RTL
3340 ? wxLayout_RightToLeft
3341 : wxLayout_LeftToRight
;
3345 void wxWindowGTK
::GTKSetLayout(GtkWidget
*widget
, wxLayoutDirection dir
)
3347 wxASSERT_MSG( dir
!= wxLayout_Default
, wxT("invalid layout direction") );
3349 gtk_widget_set_direction(widget
,
3350 dir
== wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
3351 : GTK_TEXT_DIR_LTR
);
3354 wxLayoutDirection wxWindowGTK
::GetLayoutDirection() const
3356 return GTKGetLayout(m_widget
);
3359 void wxWindowGTK
::SetLayoutDirection(wxLayoutDirection dir
)
3361 if ( dir
== wxLayout_Default
)
3363 const wxWindow
*const parent
= GetParent();
3366 // inherit layout from parent.
3367 dir
= parent
->GetLayoutDirection();
3369 else // no parent, use global default layout
3371 dir
= wxTheApp
->GetLayoutDirection();
3375 if ( dir
== wxLayout_Default
)
3378 GTKSetLayout(m_widget
, dir
);
3380 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3381 GTKSetLayout(m_wxwindow
, dir
);
3385 wxWindowGTK
::AdjustForLayoutDirection(wxCoord x
,
3386 wxCoord
WXUNUSED(width
),
3387 wxCoord
WXUNUSED(widthTotal
)) const
3389 // We now mirror the coordinates of RTL windows in wxPizza
3393 void wxWindowGTK
::DoMoveInTabOrder(wxWindow
*win
, WindowOrder move
)
3395 wxWindowBase
::DoMoveInTabOrder(win
, move
);
3396 m_dirtyTabOrder
= true;
3397 wxTheApp
->WakeUpIdle();
3400 bool wxWindowGTK
::DoNavigateIn(int flags
)
3402 if ( flags
& wxNavigationKeyEvent
::WinChange
)
3404 wxFAIL_MSG( wxT("not implemented") );
3408 else // navigate inside the container
3410 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3411 wxCHECK_MSG( parent
, false, wxT("every window must have a TLW parent") );
3413 GtkDirectionType dir
;
3414 dir
= flags
& wxNavigationKeyEvent
::IsForward ? GTK_DIR_TAB_FORWARD
3415 : GTK_DIR_TAB_BACKWARD
;
3418 g_signal_emit_by_name(parent
->m_widget
, "focus", dir
, &rc
);
3424 bool wxWindowGTK
::GTKWidgetNeedsMnemonic() const
3426 // none needed by default
3430 void wxWindowGTK
::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3432 // nothing to do by default since none is needed
3435 void wxWindowGTK
::RealizeTabOrder()
3439 if ( !m_children
.empty() )
3441 // we don't only construct the correct focus chain but also use
3442 // this opportunity to update the mnemonic widgets for the widgets
3445 GList
*chain
= NULL
;
3446 wxWindowGTK
* mnemonicWindow
= NULL
;
3448 for ( wxWindowList
::const_iterator i
= m_children
.begin();
3449 i
!= m_children
.end();
3452 wxWindowGTK
*win
= *i
;
3454 bool focusableFromKeyboard
= win
->AcceptsFocusFromKeyboard();
3456 if ( mnemonicWindow
)
3458 if ( focusableFromKeyboard
)
3460 // wxComboBox et al. needs to focus on on a different
3461 // widget than m_widget, so if the main widget isn't
3462 // focusable try the connect widget
3463 GtkWidget
* w
= win
->m_widget
;
3464 if ( !gtk_widget_get_can_focus(w
) )
3466 w
= win
->GetConnectWidget();
3467 if ( !gtk_widget_get_can_focus(w
) )
3473 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3474 mnemonicWindow
= NULL
;
3478 else if ( win
->GTKWidgetNeedsMnemonic() )
3480 mnemonicWindow
= win
;
3483 if ( focusableFromKeyboard
)
3484 chain
= g_list_prepend(chain
, win
->m_widget
);
3487 chain
= g_list_reverse(chain
);
3489 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3494 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3499 void wxWindowGTK
::Raise()
3501 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3503 if (m_wxwindow
&& gtk_widget_get_window(m_wxwindow
))
3505 gdk_window_raise(gtk_widget_get_window(m_wxwindow
));
3507 else if (gtk_widget_get_window(m_widget
))
3509 gdk_window_raise(gtk_widget_get_window(m_widget
));
3513 void wxWindowGTK
::Lower()
3515 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3517 if (m_wxwindow
&& gtk_widget_get_window(m_wxwindow
))
3519 gdk_window_lower(gtk_widget_get_window(m_wxwindow
));
3521 else if (gtk_widget_get_window(m_widget
))
3523 gdk_window_lower(gtk_widget_get_window(m_widget
));
3527 bool wxWindowGTK
::SetCursor( const wxCursor
&cursor
)
3529 if ( !wxWindowBase
::SetCursor(cursor
.IsOk() ? cursor
: *wxSTANDARD_CURSOR
) )
3537 void wxWindowGTK
::GTKUpdateCursor(bool update_self
/*=true*/, bool recurse
/*=true*/)
3541 wxCursor
cursor(g_globalCursor
.IsOk() ? g_globalCursor
: GetCursor());
3542 if ( cursor
.IsOk() )
3544 wxArrayGdkWindows windowsThis
;
3545 GdkWindow
* window
= GTKGetWindow(windowsThis
);
3547 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3550 const size_t count
= windowsThis
.size();
3551 for ( size_t n
= 0; n
< count
; n
++ )
3553 GdkWindow
*win
= windowsThis
[n
];
3554 // It can be zero if the window has not been realized yet.
3557 gdk_window_set_cursor(win
, cursor
.GetCursor());
3566 for (wxWindowList
::iterator it
= GetChildren().begin(); it
!= GetChildren().end(); ++it
)
3568 (*it
)->GTKUpdateCursor( true );
3573 void wxWindowGTK
::WarpPointer( int x
, int y
)
3575 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3577 ClientToScreen(&x
, &y
);
3578 GdkDisplay
* display
= gtk_widget_get_display(m_widget
);
3579 GdkScreen
* screen
= gtk_widget_get_screen(m_widget
);
3581 GdkDeviceManager
* manager
= gdk_display_get_device_manager(display
);
3582 gdk_device_warp(gdk_device_manager_get_client_pointer(manager
), screen
, x
, y
);
3584 #ifdef GDK_WINDOWING_X11
3585 XWarpPointer(GDK_DISPLAY_XDISPLAY(display
),
3587 GDK_WINDOW_XID(gdk_screen_get_root_window(screen
)),
3593 wxWindowGTK
::ScrollDir wxWindowGTK
::ScrollDirFromRange(GtkRange
*range
) const
3595 // find the scrollbar which generated the event
3596 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3598 if ( range
== m_scrollBar
[dir
] )
3599 return (ScrollDir
)dir
;
3602 wxFAIL_MSG( wxT("event from unknown scrollbar received") );
3604 return ScrollDir_Max
;
3607 bool wxWindowGTK
::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3609 bool changed
= false;
3610 GtkRange
* range
= m_scrollBar
[dir
];
3611 if ( range
&& units
)
3613 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
3614 double inc
= unit
== ScrollUnit_Line ?
gtk_adjustment_get_step_increment(adj
)
3615 : gtk_adjustment_get_page_increment(adj
);
3617 const int posOld
= wxRound(gtk_adjustment_get_value(adj
));
3618 gtk_range_set_value(range
, posOld
+ units
*inc
);
3620 changed
= wxRound(gtk_adjustment_get_value(adj
)) != posOld
;
3626 bool wxWindowGTK
::ScrollLines(int lines
)
3628 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3631 bool wxWindowGTK
::ScrollPages(int pages
)
3633 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3636 void wxWindowGTK
::Refresh(bool WXUNUSED(eraseBackground
),
3641 if (gtk_widget_get_mapped(m_wxwindow
))
3643 GdkWindow
* window
= gtk_widget_get_window(m_wxwindow
);
3646 GdkRectangle r
= { rect
->x
, rect
->y
, rect
->width
, rect
->height
};
3647 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3648 r
.x
= gdk_window_get_width(window
) - r
.x
- rect
->width
;
3649 gdk_window_invalidate_rect(window
, &r
, true);
3652 gdk_window_invalidate_rect(window
, NULL
, true);
3657 if (gtk_widget_get_mapped(m_widget
))
3660 gtk_widget_queue_draw_area(m_widget
, rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3662 gtk_widget_queue_draw(m_widget
);
3667 void wxWindowGTK
::Update()
3669 if (m_widget
&& gtk_widget_get_mapped(m_widget
))
3671 GdkDisplay
* display
= gtk_widget_get_display(m_widget
);
3672 // Flush everything out to the server, and wait for it to finish.
3673 // This ensures nothing will overwrite the drawing we are about to do.
3674 gdk_display_sync(display
);
3676 GdkWindow
* window
= GTKGetDrawingWindow();
3678 window
= gtk_widget_get_window(m_widget
);
3679 gdk_window_process_updates(window
, true);
3681 // Flush again, but no need to wait for it to finish
3682 gdk_display_flush(display
);
3686 bool wxWindowGTK
::DoIsExposed( int x
, int y
) const
3688 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
3691 bool wxWindowGTK
::DoIsExposed( int x
, int y
, int w
, int h
) const
3693 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3694 return m_updateRegion
.Contains(x
-w
, y
, w
, h
) != wxOutRegion
;
3696 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
3699 void wxWindowGTK
::GtkSendPaintEvents()
3703 m_updateRegion
.Clear();
3706 #if wxGTK_HAS_COMPOSITING_SUPPORT
3709 // Clip to paint region in wxClientDC
3710 m_clipPaintRegion
= true;
3712 m_nativeUpdateRegion
= m_updateRegion
;
3714 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3716 // Transform m_updateRegion under RTL
3717 m_updateRegion
.Clear();
3720 gdk_drawable_get_size(gtk_widget_get_window(m_wxwindow
), &width
, NULL
);
3722 wxRegionIterator
upd( m_nativeUpdateRegion
);
3726 rect
.x
= upd
.GetX();
3727 rect
.y
= upd
.GetY();
3728 rect
.width
= upd
.GetWidth();
3729 rect
.height
= upd
.GetHeight();
3731 rect
.x
= width
- rect
.x
- rect
.width
;
3732 m_updateRegion
.Union( rect
);
3738 switch ( GetBackgroundStyle() )
3740 case wxBG_STYLE_TRANSPARENT
:
3741 #if wxGTK_HAS_COMPOSITING_SUPPORT
3742 if (IsTransparentBackgroundSupported())
3744 // Set a transparent background, so that overlaying in parent
3745 // might indeed let see through where this child did not
3746 // explicitly paint.
3747 // NB: it works also for top level windows (but this is the
3748 // windows manager which then does the compositing job)
3749 cr
= gdk_cairo_create(m_wxwindow
->window
);
3750 gdk_cairo_region(cr
, m_nativeUpdateRegion
.GetRegion());
3753 cairo_set_operator(cr
, CAIRO_OPERATOR_CLEAR
);
3755 cairo_set_operator(cr
, CAIRO_OPERATOR_OVER
);
3756 cairo_surface_flush(cairo_get_target(cr
));
3758 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
3761 case wxBG_STYLE_ERASE
:
3763 wxWindowDC
dc( (wxWindow
*)this );
3764 dc
.SetDeviceClippingRegion( m_updateRegion
);
3766 // Work around gtk-qt <= 0.60 bug whereby the window colour
3770 GetOptionInt("gtk.window.force-background-colour") )
3772 dc
.SetBackground(GetBackgroundColour());
3776 wxEraseEvent
erase_event( GetId(), &dc
);
3777 erase_event
.SetEventObject( this );
3779 if ( HandleWindowEvent(erase_event
) )
3781 // background erased, don't do it again
3787 case wxBG_STYLE_SYSTEM
:
3788 if ( GetThemeEnabled() )
3790 // find ancestor from which to steal background
3791 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3793 parent
= (wxWindow
*)this;
3795 if (gtk_widget_get_mapped(parent
->m_widget
))
3797 wxRegionIterator
upd( m_nativeUpdateRegion
);
3801 rect
.x
= upd
.GetX();
3802 rect
.y
= upd
.GetY();
3803 rect
.width
= upd
.GetWidth();
3804 rect
.height
= upd
.GetHeight();
3806 gtk_paint_flat_box(gtk_widget_get_style(parent
->m_widget
),
3807 GTKGetDrawingWindow(),
3808 gtk_widget_get_state(m_wxwindow
),
3821 case wxBG_STYLE_PAINT
:
3822 // nothing to do: window will be painted over in EVT_PAINT
3826 wxFAIL_MSG( "unsupported background style" );
3829 wxNcPaintEvent
nc_paint_event( GetId() );
3830 nc_paint_event
.SetEventObject( this );
3831 HandleWindowEvent( nc_paint_event
);
3833 wxPaintEvent
paint_event( GetId() );
3834 paint_event
.SetEventObject( this );
3835 HandleWindowEvent( paint_event
);
3837 #if wxGTK_HAS_COMPOSITING_SUPPORT
3838 if (IsTransparentBackgroundSupported())
3839 { // now composite children which need it
3840 // Overlay all our composite children on top of the painted area
3841 wxWindowList
::compatibility_iterator node
;
3842 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
3844 wxWindow
*compositeChild
= node
->GetData();
3845 if (compositeChild
->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT
)
3849 cr
= gdk_cairo_create(m_wxwindow
->window
);
3850 gdk_cairo_region(cr
, m_nativeUpdateRegion
.GetRegion());
3854 GtkWidget
*child
= compositeChild
->m_wxwindow
;
3855 GtkAllocation alloc
;
3856 gtk_widget_get_allocation(child
, &alloc
);
3858 // The source data is the (composited) child
3859 gdk_cairo_set_source_window(
3860 cr
, gtk_widget_get_window(child
), alloc
.x
, alloc
.y
);
3868 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
3870 m_clipPaintRegion
= false;
3872 m_updateRegion
.Clear();
3873 m_nativeUpdateRegion
.Clear();
3876 void wxWindowGTK
::SetDoubleBuffered( bool on
)
3878 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3881 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3884 bool wxWindowGTK
::IsDoubleBuffered() const
3886 return gtk_widget_get_double_buffered( m_wxwindow
);
3889 void wxWindowGTK
::ClearBackground()
3891 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3895 void wxWindowGTK
::DoSetToolTip( wxToolTip
*tip
)
3897 if (m_tooltip
!= tip
)
3899 wxWindowBase
::DoSetToolTip(tip
);
3902 m_tooltip
->GTKSetWindow(static_cast<wxWindow
*>(this));
3904 GTKApplyToolTip(NULL
);
3908 void wxWindowGTK
::GTKApplyToolTip(const char* tip
)
3910 wxToolTip
::GTKApply(GetConnectWidget(), tip
);
3912 #endif // wxUSE_TOOLTIPS
3914 bool wxWindowGTK
::SetBackgroundColour( const wxColour
&colour
)
3916 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3918 if (!wxWindowBase
::SetBackgroundColour(colour
))
3923 // We need the pixel value e.g. for background clearing.
3924 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3927 // apply style change (forceStyle=true so that new style is applied
3928 // even if the bg colour changed from valid to wxNullColour)
3929 GTKApplyWidgetStyle(true);
3934 bool wxWindowGTK
::SetForegroundColour( const wxColour
&colour
)
3936 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3938 if (!wxWindowBase
::SetForegroundColour(colour
))
3945 // We need the pixel value e.g. for background clearing.
3946 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3949 // apply style change (forceStyle=true so that new style is applied
3950 // even if the bg colour changed from valid to wxNullColour):
3951 GTKApplyWidgetStyle(true);
3956 PangoContext
*wxWindowGTK
::GTKGetPangoDefaultContext()
3958 return gtk_widget_get_pango_context( m_widget
);
3961 GtkRcStyle
*wxWindowGTK
::GTKCreateWidgetStyle(bool forceStyle
)
3963 // do we need to apply any changes at all?
3966 !m_foregroundColour
.IsOk() && !m_backgroundColour
.IsOk() )
3971 GtkRcStyle
*style
= gtk_rc_style_new();
3973 if ( m_font
.IsOk() )
3976 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
3979 int flagsNormal
= 0,
3982 flagsInsensitive
= 0;
3984 if ( m_foregroundColour
.IsOk() )
3986 const GdkColor
*fg
= m_foregroundColour
.GetColor();
3988 style
->fg
[GTK_STATE_NORMAL
] =
3989 style
->text
[GTK_STATE_NORMAL
] = *fg
;
3990 flagsNormal
|= GTK_RC_FG
| GTK_RC_TEXT
;
3992 style
->fg
[GTK_STATE_PRELIGHT
] =
3993 style
->text
[GTK_STATE_PRELIGHT
] = *fg
;
3994 flagsPrelight
|= GTK_RC_FG
| GTK_RC_TEXT
;
3996 style
->fg
[GTK_STATE_ACTIVE
] =
3997 style
->text
[GTK_STATE_ACTIVE
] = *fg
;
3998 flagsActive
|= GTK_RC_FG
| GTK_RC_TEXT
;
4001 if ( m_backgroundColour
.IsOk() )
4003 const GdkColor
*bg
= m_backgroundColour
.GetColor();
4005 style
->bg
[GTK_STATE_NORMAL
] =
4006 style
->base
[GTK_STATE_NORMAL
] = *bg
;
4007 flagsNormal
|= GTK_RC_BG
| GTK_RC_BASE
;
4009 style
->bg
[GTK_STATE_PRELIGHT
] =
4010 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
4011 flagsPrelight
|= GTK_RC_BG
| GTK_RC_BASE
;
4013 style
->bg
[GTK_STATE_ACTIVE
] =
4014 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
4015 flagsActive
|= GTK_RC_BG
| GTK_RC_BASE
;
4017 style
->bg
[GTK_STATE_INSENSITIVE
] =
4018 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
4019 flagsInsensitive
|= GTK_RC_BG
| GTK_RC_BASE
;
4022 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)flagsNormal
;
4023 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)flagsPrelight
;
4024 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)flagsActive
;
4025 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)flagsInsensitive
;
4030 void wxWindowGTK
::GTKApplyWidgetStyle(bool forceStyle
)
4032 GtkRcStyle
*style
= GTKCreateWidgetStyle(forceStyle
);
4035 DoApplyWidgetStyle(style
);
4036 g_object_unref(style
);
4039 // Style change may affect GTK+'s size calculation:
4040 InvalidateBestSize();
4043 void wxWindowGTK
::DoApplyWidgetStyle(GtkRcStyle
*style
)
4047 // block the signal temporarily to avoid sending
4048 // wxSysColourChangedEvents when we change the colours ourselves
4049 bool unblock
= false;
4053 g_signal_handlers_block_by_func(
4054 m_wxwindow
, (void *)gtk_window_style_set_callback
, this);
4057 gtk_widget_modify_style(m_wxwindow
, style
);
4061 g_signal_handlers_unblock_by_func(
4062 m_wxwindow
, (void *)gtk_window_style_set_callback
, this);
4067 gtk_widget_modify_style(m_widget
, style
);
4071 bool wxWindowGTK
::SetBackgroundStyle(wxBackgroundStyle style
)
4073 if (!wxWindowBase
::SetBackgroundStyle(style
))
4079 window
= GTKGetDrawingWindow();
4083 GtkWidget
* const w
= GetConnectWidget();
4084 window
= w ?
gtk_widget_get_window(w
) : NULL
;
4087 bool wantNoBackPixmap
= style
== wxBG_STYLE_PAINT
|| style
== wxBG_STYLE_TRANSPARENT
;
4089 if ( wantNoBackPixmap
)
4093 // Make sure GDK/X11 doesn't refresh the window
4095 gdk_window_set_back_pixmap( window
, NULL
, FALSE
);
4096 m_needsStyleChange
= false;
4098 else // window not realized yet
4100 // Do when window is realized
4101 m_needsStyleChange
= true;
4104 // Don't apply widget style, or we get a grey background
4108 // apply style change (forceStyle=true so that new style is applied
4109 // even if the bg colour changed from valid to wxNullColour):
4110 GTKApplyWidgetStyle(true);
4116 bool wxWindowGTK
::IsTransparentBackgroundSupported(wxString
* reason
) const
4118 #if wxGTK_HAS_COMPOSITING_SUPPORT
4119 if (gtk_check_version(wxGTK_VERSION_REQUIRED_FOR_COMPOSITING
) != NULL
)
4123 *reason
= _("GTK+ installed on this machine is too old to "
4124 "support screen compositing, please install "
4125 "GTK+ 2.12 or later.");
4131 // NB: We don't check here if the particular kind of widget supports
4132 // transparency, we check only if it would be possible for a generic window
4134 wxCHECK_MSG ( m_widget
, false, "Window must be created first" );
4136 if (!gdk_screen_is_composited(gtk_widget_get_screen(m_widget
)))
4140 *reason
= _("Compositing not supported by this system, "
4141 "please enable it in your Window Manager.");
4151 *reason
= _("This program was compiled with a too old version of GTK+, "
4152 "please rebuild with GTK+ 2.12 or newer.");
4154 #endif // wxGTK_HAS_COMPOSITING_SUPPORT/!wxGTK_HAS_COMPOSITING_SUPPORT
4159 // ----------------------------------------------------------------------------
4160 // Pop-up menu stuff
4161 // ----------------------------------------------------------------------------
4163 #if wxUSE_MENUS_NATIVE
4167 void wxPopupMenuPositionCallback( GtkMenu
*menu
,
4169 gboolean
* WXUNUSED(whatever
),
4170 gpointer user_data
)
4172 // ensure that the menu appears entirely on screen
4174 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
4176 wxSize sizeScreen
= wxGetDisplaySize();
4177 wxPoint
*pos
= (wxPoint
*)user_data
;
4179 gint xmax
= sizeScreen
.x
- req
.width
,
4180 ymax
= sizeScreen
.y
- req
.height
;
4182 *x
= pos
->x
< xmax ? pos
->x
: xmax
;
4183 *y
= pos
->y
< ymax ? pos
->y
: ymax
;
4187 bool wxWindowGTK
::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
4189 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4195 GtkMenuPositionFunc posfunc
;
4196 if ( x
== -1 && y
== -1 )
4198 // use GTK's default positioning algorithm
4204 pos
= ClientToScreen(wxPoint(x
, y
));
4206 posfunc
= wxPopupMenuPositionCallback
;
4209 menu
->m_popupShown
= true;
4211 GTK_MENU(menu
->m_menu
),
4212 NULL
, // parent menu shell
4213 NULL
, // parent menu item
4214 posfunc
, // function to position it
4215 userdata
, // client data
4216 0, // button used to activate it
4217 gtk_get_current_event_time()
4220 while (menu
->m_popupShown
)
4222 gtk_main_iteration();
4228 #endif // wxUSE_MENUS_NATIVE
4230 #if wxUSE_DRAG_AND_DROP
4232 void wxWindowGTK
::SetDropTarget( wxDropTarget
*dropTarget
)
4234 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4236 GtkWidget
*dnd_widget
= GetConnectWidget();
4238 if (m_dropTarget
) m_dropTarget
->GtkUnregisterWidget( dnd_widget
);
4240 if (m_dropTarget
) delete m_dropTarget
;
4241 m_dropTarget
= dropTarget
;
4243 if (m_dropTarget
) m_dropTarget
->GtkRegisterWidget( dnd_widget
);
4246 #endif // wxUSE_DRAG_AND_DROP
4248 GtkWidget
* wxWindowGTK
::GetConnectWidget()
4250 GtkWidget
*connect_widget
= m_widget
;
4251 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4253 return connect_widget
;
4256 bool wxWindowGTK
::GTKIsOwnWindow(GdkWindow
*window
) const
4258 wxArrayGdkWindows windowsThis
;
4259 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
4261 return winThis ? window
== winThis
4262 : windowsThis
.Index(window
) != wxNOT_FOUND
;
4265 GdkWindow
*wxWindowGTK
::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
4267 return m_wxwindow ?
GTKGetDrawingWindow() : gtk_widget_get_window(m_widget
);
4270 bool wxWindowGTK
::SetFont( const wxFont
&font
)
4272 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4274 if (!wxWindowBase
::SetFont(font
))
4277 // apply style change (forceStyle=true so that new style is applied
4278 // even if the font changed from valid to wxNullFont):
4279 GTKApplyWidgetStyle(true);
4284 void wxWindowGTK
::DoCaptureMouse()
4286 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4288 GdkWindow
*window
= NULL
;
4290 window
= GTKGetDrawingWindow();
4292 window
= gtk_widget_get_window(GetConnectWidget());
4294 wxCHECK_RET( window
, wxT("CaptureMouse() failed") );
4296 const wxCursor
* cursor
= &m_cursor
;
4297 if (!cursor
->IsOk())
4298 cursor
= wxSTANDARD_CURSOR
;
4300 gdk_pointer_grab( window
, FALSE
,
4302 (GDK_BUTTON_PRESS_MASK
|
4303 GDK_BUTTON_RELEASE_MASK
|
4304 GDK_POINTER_MOTION_HINT_MASK
|
4305 GDK_POINTER_MOTION_MASK
),
4307 cursor
->GetCursor(),
4308 (guint32
)GDK_CURRENT_TIME
);
4309 g_captureWindow
= this;
4310 g_captureWindowHasMouse
= true;
4313 void wxWindowGTK
::DoReleaseMouse()
4315 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4317 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4319 g_captureWindow
= NULL
;
4321 GdkWindow
*window
= NULL
;
4323 window
= GTKGetDrawingWindow();
4325 window
= gtk_widget_get_window(GetConnectWidget());
4330 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4333 void wxWindowGTK
::GTKReleaseMouseAndNotify()
4336 wxMouseCaptureLostEvent
evt(GetId());
4337 evt
.SetEventObject( this );
4338 HandleWindowEvent( evt
);
4342 wxWindow
*wxWindowBase
::GetCapture()
4344 return (wxWindow
*)g_captureWindow
;
4347 bool wxWindowGTK
::IsRetained() const
4352 void wxWindowGTK
::SetScrollbar(int orient
,
4356 bool WXUNUSED(update
))
4358 const int dir
= ScrollDirFromOrient(orient
);
4359 GtkRange
* const sb
= m_scrollBar
[dir
];
4360 wxCHECK_RET( sb
, wxT("this window is not scrollable") );
4364 // GtkRange requires upper > lower
4369 g_signal_handlers_block_by_func(
4370 sb
, (void*)gtk_scrollbar_value_changed
, this);
4372 gtk_range_set_increments(sb
, 1, thumbVisible
);
4373 gtk_adjustment_set_page_size(gtk_range_get_adjustment(sb
), thumbVisible
);
4374 gtk_range_set_range(sb
, 0, range
);
4375 gtk_range_set_value(sb
, pos
);
4376 m_scrollPos
[dir
] = gtk_range_get_value(sb
);
4378 g_signal_handlers_unblock_by_func(
4379 sb
, (void*)gtk_scrollbar_value_changed
, this);
4382 void wxWindowGTK
::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4384 const int dir
= ScrollDirFromOrient(orient
);
4385 GtkRange
* const sb
= m_scrollBar
[dir
];
4386 wxCHECK_RET( sb
, wxT("this window is not scrollable") );
4388 // This check is more than an optimization. Without it, the slider
4389 // will not move smoothly while tracking when using wxScrollHelper.
4390 if (GetScrollPos(orient
) != pos
)
4392 g_signal_handlers_block_by_func(
4393 sb
, (void*)gtk_scrollbar_value_changed
, this);
4395 gtk_range_set_value(sb
, pos
);
4396 m_scrollPos
[dir
] = gtk_range_get_value(sb
);
4398 g_signal_handlers_unblock_by_func(
4399 sb
, (void*)gtk_scrollbar_value_changed
, this);
4403 int wxWindowGTK
::GetScrollThumb(int orient
) const
4405 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4406 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4408 return wxRound(gtk_adjustment_get_page_size(gtk_range_get_adjustment(sb
)));
4411 int wxWindowGTK
::GetScrollPos( int orient
) const
4413 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4414 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4416 return wxRound(gtk_range_get_value(sb
));
4419 int wxWindowGTK
::GetScrollRange( int orient
) const
4421 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4422 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4424 return wxRound(gtk_adjustment_get_upper(gtk_range_get_adjustment(sb
)));
4427 // Determine if increment is the same as +/-x, allowing for some small
4428 // difference due to possible inexactness in floating point arithmetic
4429 static inline bool IsScrollIncrement(double increment
, double x
)
4431 wxASSERT(increment
> 0);
4432 const double tolerance
= 1.0 / 1024;
4433 return fabs(increment
- fabs(x
)) < tolerance
;
4436 wxEventType wxWindowGTK
::GTKGetScrollEventType(GtkRange
* range
)
4438 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4440 const int barIndex
= range
== m_scrollBar
[1];
4442 const double value
= gtk_range_get_value(range
);
4444 // save previous position
4445 const double oldPos
= m_scrollPos
[barIndex
];
4446 // update current position
4447 m_scrollPos
[barIndex
] = value
;
4448 // If event should be ignored, or integral position has not changed
4449 if (!m_hasVMT
|| g_blockEventsOnDrag
|| wxRound(value
) == wxRound(oldPos
))
4454 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4457 // Difference from last change event
4458 const double diff
= value
- oldPos
;
4459 const bool isDown
= diff
> 0;
4461 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
4462 if (IsScrollIncrement(gtk_adjustment_get_step_increment(adj
), diff
))
4464 eventType
= isDown ? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4466 else if (IsScrollIncrement(gtk_adjustment_get_page_increment(adj
), diff
))
4468 eventType
= isDown ? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4470 else if (m_mouseButtonDown
)
4472 // Assume track event
4473 m_isScrolling
= true;
4479 void wxWindowGTK
::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4481 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4483 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4485 // No scrolling requested.
4486 if ((dx
== 0) && (dy
== 0)) return;
4488 m_clipPaintRegion
= true;
4490 WX_PIZZA(m_wxwindow
)->scroll(dx
, dy
);
4492 m_clipPaintRegion
= false;
4495 bool restoreCaret
= (GetCaret() != NULL
&& GetCaret()->IsVisible());
4498 wxRect
caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4500 caretRect
.width
+= dx
;
4503 caretRect
.x
+= dx
; caretRect
.width
-= dx
;
4506 caretRect
.height
+= dy
;
4509 caretRect
.y
+= dy
; caretRect
.height
-= dy
;
4512 RefreshRect(caretRect
);
4514 #endif // wxUSE_CARET
4517 void wxWindowGTK
::GTKScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4519 //RN: Note that static controls usually have no border on gtk, so maybe
4520 //it makes sense to treat that as simply no border at the wx level
4522 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4524 GtkShadowType gtkstyle
;
4526 if(wxstyle
& wxBORDER_RAISED
)
4527 gtkstyle
= GTK_SHADOW_OUT
;
4528 else if ((wxstyle
& wxBORDER_SUNKEN
) || (wxstyle
& wxBORDER_THEME
))
4529 gtkstyle
= GTK_SHADOW_IN
;
4532 else if (wxstyle
& wxBORDER_DOUBLE
)
4533 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4536 gtkstyle
= GTK_SHADOW_IN
;
4538 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4543 // Find the wxWindow at the current mouse position, also returning the mouse
4545 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4547 pt
= wxGetMousePosition();
4548 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4552 // Get the current mouse position.
4553 wxPoint
wxGetMousePosition()
4555 wxWindow
* tlw
= NULL
;
4556 if (!wxTopLevelWindows
.empty())
4557 tlw
= wxTopLevelWindows
.front();
4558 GdkDisplay
* display
;
4559 if (tlw
&& tlw
->m_widget
)
4560 display
= gtk_widget_get_display(tlw
->m_widget
);
4562 display
= gdk_display_get_default();
4565 gdk_display_get_pointer(display
, NULL
, &x
, &y
, NULL
);
4566 return wxPoint(x
, y
);
4569 GdkWindow
* wxWindowGTK
::GTKGetDrawingWindow() const
4571 GdkWindow
* window
= NULL
;
4573 window
= gtk_widget_get_window(m_wxwindow
);
4577 // ----------------------------------------------------------------------------
4579 // ----------------------------------------------------------------------------
4584 // this is called if we attempted to freeze unrealized widget when it finally
4585 // is realized (and so can be frozen):
4586 static void wx_frozen_widget_realize(GtkWidget
* w
, wxWindowGTK
* win
)
4588 wxASSERT( w
&& gtk_widget_get_has_window(w
) );
4589 wxASSERT( gtk_widget_get_realized(w
) );
4591 g_signal_handlers_disconnect_by_func
4594 (void*)wx_frozen_widget_realize
,
4599 if (w
== win
->m_wxwindow
)
4600 window
= win
->GTKGetDrawingWindow();
4602 window
= gtk_widget_get_window(w
);
4603 gdk_window_freeze_updates(window
);
4608 void wxWindowGTK
::GTKFreezeWidget(GtkWidget
*w
)
4610 if ( !w
|| !gtk_widget_get_has_window(w
) )
4611 return; // window-less widget, cannot be frozen
4613 GdkWindow
* window
= gtk_widget_get_window(w
);
4616 // we can't thaw unrealized widgets because they don't have GdkWindow,
4617 // so set it up to be done immediately after realization:
4618 g_signal_connect_after
4622 G_CALLBACK(wx_frozen_widget_realize
),
4628 if (w
== m_wxwindow
)
4629 window
= GTKGetDrawingWindow();
4630 gdk_window_freeze_updates(window
);
4633 void wxWindowGTK
::GTKThawWidget(GtkWidget
*w
)
4635 if ( !w
|| !gtk_widget_get_has_window(w
) )
4636 return; // window-less widget, cannot be frozen
4638 GdkWindow
* window
= gtk_widget_get_window(w
);
4641 // the widget wasn't realized yet, no need to thaw
4642 g_signal_handlers_disconnect_by_func
4645 (void*)wx_frozen_widget_realize
,
4651 if (w
== m_wxwindow
)
4652 window
= GTKGetDrawingWindow();
4653 gdk_window_thaw_updates(window
);
4656 void wxWindowGTK
::DoFreeze()
4658 GTKFreezeWidget(m_widget
);
4659 if ( m_wxwindow
&& m_widget
!= m_wxwindow
)
4660 GTKFreezeWidget(m_wxwindow
);
4663 void wxWindowGTK
::DoThaw()
4665 GTKThawWidget(m_widget
);
4666 if ( m_wxwindow
&& m_widget
!= m_wxwindow
)
4667 GTKThawWidget(m_wxwindow
);