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"
43 #include <gdk/gdkkeysyms.h>
44 #if GTK_CHECK_VERSION(3,0,0)
45 #include <gdk/gdkkeysyms-compat.h>
48 #if !GTK_CHECK_VERSION(2,10,0)
49 // GTK+ can reliably detect Meta key state only since 2.10 when
50 // GDK_META_MASK was introduced -- there wasn't any way to detect it
51 // in older versions. wxGTK used GDK_MOD2_MASK for this purpose, but
52 // GDK_MOD2_MASK is documented as:
54 // the fifth modifier key (it depends on the modifier mapping of the X
55 // server which key is interpreted as this modifier)
57 // In other words, it isn't guaranteed to map to Meta. This is a real
58 // problem: it is common to map NumLock to it (in fact, it's an exception
59 // if the X server _doesn't_ use it for NumLock). So the old code caused
60 // wxKeyEvent::MetaDown() to always return true as long as NumLock was on
61 // on many systems, which broke all applications using
62 // wxKeyEvent::GetModifiers() to check modifiers state (see e.g. here:
63 // http://tinyurl.com/56lsk2).
65 // Because of this, it's better to not detect Meta key state at all than
66 // to detect it incorrectly. Hence the following #define, which causes
67 // m_metaDown to be always set to false.
68 #define GDK_META_MASK 0
71 //-----------------------------------------------------------------------------
72 // documentation on internals
73 //-----------------------------------------------------------------------------
76 I have been asked several times about writing some documentation about
77 the GTK port of wxWidgets, especially its internal structures. Obviously,
78 you cannot understand wxGTK without knowing a little about the GTK, but
79 some more information about what the wxWindow, which is the base class
80 for all other window classes, does seems required as well.
84 What does wxWindow do? It contains the common interface for the following
85 jobs of its descendants:
87 1) Define the rudimentary behaviour common to all window classes, such as
88 resizing, intercepting user input (so as to make it possible to use these
89 events for special purposes in a derived class), window names etc.
91 2) Provide the possibility to contain and manage children, if the derived
92 class is allowed to contain children, which holds true for those window
93 classes which do not display a native GTK widget. To name them, these
94 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
95 work classes are a special case and are handled a bit differently from
96 the rest. The same holds true for the wxNotebook class.
98 3) Provide the possibility to draw into a client area of a window. This,
99 too, only holds true for classes that do not display a native GTK widget
102 4) Provide the entire mechanism for scrolling widgets. This actual inter-
103 face for this is usually in wxScrolledWindow, but the GTK implementation
106 5) A multitude of helper or extra methods for special purposes, such as
107 Drag'n'Drop, managing validators etc.
109 6) Display a border (sunken, raised, simple or none).
111 Normally one might expect, that one wxWidgets window would always correspond
112 to one GTK widget. Under GTK, there is no such all-round widget that has all
113 the functionality. Moreover, the GTK defines a client area as a different
114 widget from the actual widget you are handling. Last but not least some
115 special classes (e.g. wxFrame) handle different categories of widgets and
116 still have the possibility to draw something in the client area.
117 It was therefore required to write a special purpose GTK widget, that would
118 represent a client area in the sense of wxWidgets capable to do the jobs
119 2), 3) and 4). I have written this class and it resides in win_gtk.c of
122 All windows must have a widget, with which they interact with other under-
123 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
124 the wxWindow class has a member variable called m_widget which holds a
125 pointer to this widget. When the window class represents a GTK native widget,
126 this is (in most cases) the only GTK widget the class manages. E.g. the
127 wxStaticText class handles only a GtkLabel widget a pointer to which you
128 can find in m_widget (defined in wxWindow)
130 When the class has a client area for drawing into and for containing children
131 it has to handle the client area widget (of the type wxPizza, defined in
132 win_gtk.cpp), but there could be any number of widgets, handled by a class.
133 The common rule for all windows is only, that the widget that interacts with
134 the rest of GTK must be referenced in m_widget and all other widgets must be
135 children of this widget on the GTK level. The top-most widget, which also
136 represents the client area, must be in the m_wxwindow field and must be of
139 As I said, the window classes that display a GTK native widget only have
140 one widget, so in the case of e.g. the wxButton class m_widget holds a
141 pointer to a GtkButton widget. But windows with client areas (for drawing
142 and children) have a m_widget field that is a pointer to a GtkScrolled-
143 Window and a m_wxwindow field that is pointer to a wxPizza and this
144 one is (in the GTK sense) a child of the GtkScrolledWindow.
146 If the m_wxwindow field is set, then all input to this widget is inter-
147 cepted and sent to the wxWidgets class. If not, all input to the widget
148 that gets pointed to by m_widget gets intercepted and sent to the class.
152 The design of scrolling in wxWidgets is markedly different from that offered
153 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
154 clicking on a scrollbar belonging to scrolled window will inevitably move
155 the window. In wxWidgets, the scrollbar will only emit an event, send this
156 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
157 which actually moves the window and its sub-windows. Note that wxPizza
158 memorizes how much it has been scrolled but that wxWidgets forgets this
159 so that the two coordinates systems have to be kept in synch. This is done
160 in various places using the pizza->m_scroll_x and pizza->m_scroll_y values.
164 Singularly the most broken code in GTK is the code that is supposed to
165 inform subwindows (child windows) about new positions. Very often, duplicate
166 events are sent without changes in size or position, equally often no
167 events are sent at all (All this is due to a bug in the GtkContainer code
168 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
169 GTK's own system and it simply waits for size events for toplevel windows
170 and then iterates down the respective size events to all window. This has
171 the disadvantage that windows might get size events before the GTK widget
172 actually has the reported size. This doesn't normally pose any problem, but
173 the OpenGL drawing routines rely on correct behaviour. Therefore, I have
174 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
175 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
176 window that is used for OpenGL output really has that size (as reported by
181 If someone at some point of time feels the immense desire to have a look at,
182 change or attempt to optimise the Refresh() logic, this person will need an
183 intimate understanding of what "draw" and "expose" events are and what
184 they are used for, in particular when used in connection with GTK's
185 own windowless widgets. Beware.
189 Cursors, too, have been a constant source of pleasure. The main difficulty
190 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
191 for the parent. To prevent this from doing too much harm, SetCursor calls
192 GTKUpdateCursor, which will recursively re-set the cursors of all child windows.
193 Also don't forget that cursors (like much else) are connected to GdkWindows,
194 not GtkWidgets and that the "window" field of a GtkWidget might very well
195 point to the GdkWindow of the parent widget (-> "window-less widget") and
196 that the two obviously have very different meanings.
199 //-----------------------------------------------------------------------------
201 //-----------------------------------------------------------------------------
203 // Don't allow event propagation during drag
204 bool g_blockEventsOnDrag
;
205 // Don't allow mouse event propagation during scroll
206 bool g_blockEventsOnScroll
;
207 extern wxCursor g_globalCursor
;
209 // mouse capture state: the window which has it and if the mouse is currently
211 static wxWindowGTK
*g_captureWindow
= NULL
;
212 static bool g_captureWindowHasMouse
= false;
214 // The window that currently has focus:
215 static wxWindowGTK
*gs_currentFocus
= NULL
;
216 // The window that is scheduled to get focus in the next event loop iteration
217 // or NULL if there's no pending focus change:
218 static wxWindowGTK
*gs_pendingFocus
= NULL
;
220 // the window that has deferred focus-out event pending, if any (see
221 // GTKAddDeferredFocusOut() for details)
222 static wxWindowGTK
*gs_deferredFocusOut
= NULL
;
224 // global variables because GTK+ DnD want to have the
225 // mouse event that caused it
226 GdkEvent
*g_lastMouseEvent
= NULL
;
227 int g_lastButtonNumber
= 0;
229 //-----------------------------------------------------------------------------
231 //-----------------------------------------------------------------------------
233 // the trace mask used for the focus debugging messages
234 #define TRACE_FOCUS wxT("focus")
236 //-----------------------------------------------------------------------------
237 // missing gdk functions
238 //-----------------------------------------------------------------------------
241 gdk_window_warp_pointer (GdkWindow
*window
,
246 window
= gdk_get_default_root_window();
248 if (!GDK_WINDOW_DESTROYED(window
))
250 XWarpPointer (GDK_WINDOW_XDISPLAY(window
),
251 None
, /* not source window -> move from anywhere */
252 GDK_WINDOW_XID(window
), /* dest window */
253 0, 0, 0, 0, /* not source window -> move from anywhere */
259 //-----------------------------------------------------------------------------
260 // "size_request" of m_widget
261 //-----------------------------------------------------------------------------
265 wxgtk_window_size_request_callback(GtkWidget
* WXUNUSED(widget
),
266 GtkRequisition
*requisition
,
270 win
->GetSize( &w
, &h
);
276 requisition
->height
= h
;
277 requisition
->width
= w
;
281 //-----------------------------------------------------------------------------
282 // "expose_event" of m_wxwindow
283 //-----------------------------------------------------------------------------
287 gtk_window_expose_callback( GtkWidget
*,
288 GdkEventExpose
*gdk_event
,
291 if (gdk_event
->window
== win
->GTKGetDrawingWindow())
293 win
->GetUpdateRegion() = wxRegion( gdk_event
->region
);
294 win
->GtkSendPaintEvents();
296 // Let parent window draw window-less widgets
301 #ifndef __WXUNIVERSAL__
302 //-----------------------------------------------------------------------------
303 // "expose_event" from m_wxwindow->parent, for drawing border
304 //-----------------------------------------------------------------------------
308 expose_event_border(GtkWidget
* widget
, GdkEventExpose
* gdk_event
, wxWindow
* win
)
310 if (gdk_event
->window
!= gtk_widget_get_parent_window(win
->m_wxwindow
))
317 gtk_widget_get_allocation(win
->m_wxwindow
, &alloc
);
318 const int x
= alloc
.x
;
319 const int y
= alloc
.y
;
320 const int w
= alloc
.width
;
321 const int h
= alloc
.height
;
323 if (w
<= 0 || h
<= 0)
326 if (win
->HasFlag(wxBORDER_SIMPLE
))
328 gdk_draw_rectangle(gdk_event
->window
,
329 gtk_widget_get_style(widget
)->black_gc
, false, x
, y
, w
- 1, h
- 1);
333 GtkShadowType shadow
= GTK_SHADOW_IN
;
334 if (win
->HasFlag(wxBORDER_RAISED
))
335 shadow
= GTK_SHADOW_OUT
;
337 // Style detail to use
339 if (win
->m_widget
== win
->m_wxwindow
)
340 // for non-scrollable wxWindows
343 // for scrollable ones
347 gtk_widget_get_style(win
->m_wxwindow
), gdk_event
->window
, GTK_STATE_NORMAL
,
348 shadow
, NULL
, wxGTKPrivate::GetEntryWidget(), detail
, x
, y
, w
, h
);
354 //-----------------------------------------------------------------------------
355 // "parent_set" from m_wxwindow
356 //-----------------------------------------------------------------------------
360 parent_set(GtkWidget
* widget
, GtkObject
* old_parent
, wxWindow
* win
)
364 g_signal_handlers_disconnect_by_func(
365 old_parent
, (void*)expose_event_border
, win
);
367 GtkWidget
* parent
= gtk_widget_get_parent(widget
);
370 g_signal_connect_after(parent
, "expose_event",
371 G_CALLBACK(expose_event_border
), win
);
375 #endif // !__WXUNIVERSAL__
377 //-----------------------------------------------------------------------------
378 // "key_press_event" from any window
379 //-----------------------------------------------------------------------------
381 // These are used when transforming Ctrl-alpha to ascii values 1-26
382 inline bool wxIsLowerChar(int code
)
384 return (code
>= 'a' && code
<= 'z' );
387 inline bool wxIsUpperChar(int code
)
389 return (code
>= 'A' && code
<= 'Z' );
393 // set WXTRACE to this to see the key event codes on the console
394 #define TRACE_KEYS wxT("keyevent")
396 // translates an X key symbol to WXK_XXX value
398 // if isChar is true it means that the value returned will be used for EVT_CHAR
399 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
400 // for example, while if it is false it means that the value is going to be
401 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
403 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
409 // Shift, Control and Alt don't generate the CHAR events at all
412 key_code
= isChar
? 0 : WXK_SHIFT
;
416 key_code
= isChar
? 0 : WXK_CONTROL
;
424 key_code
= isChar
? 0 : WXK_ALT
;
427 // neither do the toggle modifies
428 case GDK_Scroll_Lock
:
429 key_code
= isChar
? 0 : WXK_SCROLL
;
433 key_code
= isChar
? 0 : WXK_CAPITAL
;
437 key_code
= isChar
? 0 : WXK_NUMLOCK
;
441 // various other special keys
454 case GDK_ISO_Left_Tab
:
461 key_code
= WXK_RETURN
;
465 key_code
= WXK_CLEAR
;
469 key_code
= WXK_PAUSE
;
473 key_code
= WXK_SELECT
;
477 key_code
= WXK_PRINT
;
481 key_code
= WXK_EXECUTE
;
485 key_code
= WXK_ESCAPE
;
488 // cursor and other extended keyboard keys
490 key_code
= WXK_DELETE
;
506 key_code
= WXK_RIGHT
;
513 case GDK_Prior
: // == GDK_Page_Up
514 key_code
= WXK_PAGEUP
;
517 case GDK_Next
: // == GDK_Page_Down
518 key_code
= WXK_PAGEDOWN
;
530 key_code
= WXK_INSERT
;
545 key_code
= (isChar
? '0' : int(WXK_NUMPAD0
)) + keysym
- GDK_KP_0
;
549 key_code
= isChar
? ' ' : int(WXK_NUMPAD_SPACE
);
553 key_code
= isChar
? WXK_TAB
: WXK_NUMPAD_TAB
;
557 key_code
= isChar
? WXK_RETURN
: WXK_NUMPAD_ENTER
;
561 key_code
= isChar
? WXK_F1
: WXK_NUMPAD_F1
;
565 key_code
= isChar
? WXK_F2
: WXK_NUMPAD_F2
;
569 key_code
= isChar
? WXK_F3
: WXK_NUMPAD_F3
;
573 key_code
= isChar
? WXK_F4
: WXK_NUMPAD_F4
;
577 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_HOME
;
581 key_code
= isChar
? WXK_LEFT
: WXK_NUMPAD_LEFT
;
585 key_code
= isChar
? WXK_UP
: WXK_NUMPAD_UP
;
589 key_code
= isChar
? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
593 key_code
= isChar
? WXK_DOWN
: WXK_NUMPAD_DOWN
;
596 case GDK_KP_Prior
: // == GDK_KP_Page_Up
597 key_code
= isChar
? WXK_PAGEUP
: WXK_NUMPAD_PAGEUP
;
600 case GDK_KP_Next
: // == GDK_KP_Page_Down
601 key_code
= isChar
? WXK_PAGEDOWN
: WXK_NUMPAD_PAGEDOWN
;
605 key_code
= isChar
? WXK_END
: WXK_NUMPAD_END
;
609 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_BEGIN
;
613 key_code
= isChar
? WXK_INSERT
: WXK_NUMPAD_INSERT
;
617 key_code
= isChar
? WXK_DELETE
: WXK_NUMPAD_DELETE
;
621 key_code
= isChar
? '=' : int(WXK_NUMPAD_EQUAL
);
624 case GDK_KP_Multiply
:
625 key_code
= isChar
? '*' : int(WXK_NUMPAD_MULTIPLY
);
629 key_code
= isChar
? '+' : int(WXK_NUMPAD_ADD
);
632 case GDK_KP_Separator
:
633 // FIXME: what is this?
634 key_code
= isChar
? '.' : int(WXK_NUMPAD_SEPARATOR
);
637 case GDK_KP_Subtract
:
638 key_code
= isChar
? '-' : int(WXK_NUMPAD_SUBTRACT
);
642 key_code
= isChar
? '.' : int(WXK_NUMPAD_DECIMAL
);
646 key_code
= isChar
? '/' : int(WXK_NUMPAD_DIVIDE
);
663 key_code
= WXK_F1
+ keysym
- GDK_F1
;
673 static inline bool wxIsAsciiKeysym(KeySym ks
)
678 static void wxFillOtherKeyEventFields(wxKeyEvent
& event
,
680 GdkEventKey
*gdk_event
)
684 GdkModifierType state
;
685 if (gdk_event
->window
)
686 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
688 event
.SetTimestamp( gdk_event
->time
);
689 event
.SetId(win
->GetId());
691 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
692 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
693 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
694 event
.m_metaDown
= (gdk_event
->state
& GDK_META_MASK
) != 0;
696 // Normally we take the state of modifiers directly from the low level GDK
697 // event but unfortunately GDK uses a different convention from MSW for the
698 // key events corresponding to the modifier keys themselves: in it, when
699 // e.g. Shift key is pressed, GDK_SHIFT_MASK is not set while it is set
700 // when Shift is released. Under MSW the situation is exactly reversed and
701 // the modifier corresponding to the key is set when it is pressed and
702 // unset when it is released. To ensure consistent behaviour between
703 // platforms (and because it seems to make slightly more sense, although
704 // arguably both behaviours are reasonable) we follow MSW here.
706 // Final notice: we set the flags to the desired value instead of just
707 // inverting them because they are not set correctly (i.e. in the same way
708 // as for the real events generated by the user) for wxUIActionSimulator-
709 // produced events and it seems better to keep that class code the same
710 // among all platforms and fix the discrepancy here instead of adding
711 // wxGTK-specific code to wxUIActionSimulator.
712 const bool isPress
= gdk_event
->type
== GDK_KEY_PRESS
;
713 switch ( gdk_event
->keyval
)
717 event
.m_shiftDown
= isPress
;
722 event
.m_controlDown
= isPress
;
727 event
.m_altDown
= isPress
;
734 event
.m_metaDown
= isPress
;
738 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
739 event
.m_rawFlags
= gdk_event
->hardware_keycode
;
741 wxGetMousePosition( &x
, &y
);
742 win
->ScreenToClient( &x
, &y
);
745 event
.SetEventObject( win
);
750 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
752 GdkEventKey
*gdk_event
)
754 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
755 // but only event->keyval which is quite useless to us, so remember
756 // the last character from GDK_KEY_PRESS and reuse it as last resort
758 // NB: should be MT-safe as we're always called from the main thread only
763 } s_lastKeyPress
= { 0, 0 };
765 KeySym keysym
= gdk_event
->keyval
;
767 wxLogTrace(TRACE_KEYS
, wxT("Key %s event: keysym = %ld"),
768 event
.GetEventType() == wxEVT_KEY_UP
? wxT("release")
772 long key_code
= wxTranslateKeySymToWXKey(keysym
, false /* !isChar */);
776 // do we have the translation or is it a plain ASCII character?
777 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
779 // we should use keysym if it is ASCII as X does some translations
780 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
781 // which we don't want here (but which we do use for OnChar())
782 if ( !wxIsAsciiKeysym(keysym
) )
784 keysym
= (KeySym
)gdk_event
->string
[0];
787 // we want to always get the same key code when the same key is
788 // pressed regardless of the state of the modifiers, i.e. on a
789 // standard US keyboard pressing '5' or '%' ('5' key with
790 // Shift) should result in the same key code in OnKeyDown():
791 // '5' (although OnChar() will get either '5' or '%').
793 // to do it we first translate keysym to keycode (== scan code)
794 // and then back but always using the lower register
795 Display
*dpy
= (Display
*)wxGetDisplay();
796 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
798 wxLogTrace(TRACE_KEYS
, wxT("\t-> keycode %d"), keycode
);
800 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
802 // use the normalized, i.e. lower register, keysym if we've
804 key_code
= keysymNormalized
? keysymNormalized
: keysym
;
806 // as explained above, we want to have lower register key codes
807 // normally but for the letter keys we want to have the upper ones
809 // NB: don't use XConvertCase() here, we want to do it for letters
811 key_code
= toupper(key_code
);
813 else // non ASCII key, what to do?
815 // by default, ignore it
818 // but if we have cached information from the last KEY_PRESS
819 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
822 if ( keysym
== s_lastKeyPress
.keysym
)
824 key_code
= s_lastKeyPress
.keycode
;
829 if ( gdk_event
->type
== GDK_KEY_PRESS
)
831 // remember it to be reused for KEY_UP event later
832 s_lastKeyPress
.keysym
= keysym
;
833 s_lastKeyPress
.keycode
= key_code
;
837 wxLogTrace(TRACE_KEYS
, wxT("\t-> wxKeyCode %ld"), key_code
);
839 // sending unknown key events doesn't really make sense
843 event
.m_keyCode
= key_code
;
846 event
.m_uniChar
= gdk_keyval_to_unicode(key_code
? key_code
: keysym
);
847 if ( !event
.m_uniChar
&& event
.m_keyCode
<= WXK_DELETE
)
849 // Set Unicode key code to the ASCII equivalent for compatibility. E.g.
850 // let RETURN generate the key event with both key and Unicode key
852 event
.m_uniChar
= event
.m_keyCode
;
854 #endif // wxUSE_UNICODE
856 // now fill all the other fields
857 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
865 GtkIMContext
*context
;
866 GdkEventKey
*lastKeyEvent
;
870 context
= gtk_im_multicontext_new();
875 g_object_unref (context
);
882 // Send wxEVT_CHAR_HOOK event to the parent of the window and if it wasn't
883 // processed, send wxEVT_CHAR to the window itself. Return true if either of
886 SendCharHookAndCharEvents(const wxKeyEvent
& event
, wxWindow
*win
)
888 // wxEVT_CHAR_HOOK must be sent to the top level parent window to allow it
889 // to handle key events in all of its children unless the mouse is captured
890 // in which case we consider that the keyboard should be "captured" too.
891 if ( !g_captureWindow
)
893 wxWindow
* const parent
= wxGetTopLevelParent(win
);
896 // We need to make a copy of the event object because it is
897 // modified while it's handled, notably its WasProcessed() flag
898 // is set after it had been processed once.
899 wxKeyEvent
eventCharHook(event
);
900 eventCharHook
.SetEventType(wxEVT_CHAR_HOOK
);
901 if ( parent
->HandleWindowEvent(eventCharHook
) )
906 // As above, make a copy of the event first.
907 wxKeyEvent
eventChar(event
);
908 eventChar
.SetEventType(wxEVT_CHAR
);
909 return win
->HandleWindowEvent(eventChar
);
912 } // anonymous namespace
916 gtk_window_key_press_callback( GtkWidget
*WXUNUSED(widget
),
917 GdkEventKey
*gdk_event
,
922 if (g_blockEventsOnDrag
)
925 wxKeyEvent
event( wxEVT_KEY_DOWN
);
927 bool return_after_IM
= false;
929 if( wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
931 // Emit KEY_DOWN event
932 ret
= win
->HandleWindowEvent( event
);
936 // Return after IM processing as we cannot do
937 // anything with it anyhow.
938 return_after_IM
= true;
941 if (!ret
&& win
->m_imData
)
943 win
->m_imData
->lastKeyEvent
= gdk_event
;
945 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
946 // docs, if IM filter returns true, no further processing should be done.
947 // we should send the key_down event anyway.
948 bool intercepted_by_IM
= gtk_im_context_filter_keypress(win
->m_imData
->context
, gdk_event
);
949 win
->m_imData
->lastKeyEvent
= NULL
;
950 if (intercepted_by_IM
)
952 wxLogTrace(TRACE_KEYS
, wxT("Key event intercepted by IM"));
963 wxWindowGTK
*ancestor
= win
;
966 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
969 wxCommandEvent
menu_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
970 ret
= ancestor
->HandleWindowEvent( menu_event
);
974 // if the accelerator wasn't handled as menu event, try
975 // it as button click (for compatibility with other
977 wxCommandEvent
button_event( wxEVT_COMMAND_BUTTON_CLICKED
, command
);
978 ret
= ancestor
->HandleWindowEvent( button_event
);
983 if (ancestor
->IsTopLevel())
985 ancestor
= ancestor
->GetParent();
988 #endif // wxUSE_ACCEL
990 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
991 // will only be sent if it is not in an accelerator table.
995 KeySym keysym
= gdk_event
->keyval
;
996 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
997 key_code
= wxTranslateKeySymToWXKey(keysym
, true /* isChar */);
1000 if ( wxIsAsciiKeysym(keysym
) )
1003 key_code
= (unsigned char)keysym
;
1005 // gdk_event->string is actually deprecated
1006 else if ( gdk_event
->length
== 1 )
1008 key_code
= (unsigned char)gdk_event
->string
[0];
1014 wxLogTrace(TRACE_KEYS
, wxT("Char event: %ld"), key_code
);
1016 event
.m_keyCode
= key_code
;
1018 // To conform to the docs we need to translate Ctrl-alpha
1019 // characters to values in the range 1-26.
1020 if ( event
.ControlDown() &&
1021 ( wxIsLowerChar(key_code
) || wxIsUpperChar(key_code
) ))
1023 if ( wxIsLowerChar(key_code
) )
1024 event
.m_keyCode
= key_code
- 'a' + 1;
1025 if ( wxIsUpperChar(key_code
) )
1026 event
.m_keyCode
= key_code
- 'A' + 1;
1028 event
.m_uniChar
= event
.m_keyCode
;
1032 ret
= SendCharHookAndCharEvents(event
, win
);
1042 gtk_wxwindow_commit_cb (GtkIMContext
* WXUNUSED(context
),
1046 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1048 // take modifiers, cursor position, timestamp etc. from the last
1049 // key_press_event that was fed into Input Method:
1050 if (window
->m_imData
->lastKeyEvent
)
1052 wxFillOtherKeyEventFields(event
,
1053 window
, window
->m_imData
->lastKeyEvent
);
1057 event
.SetEventObject( window
);
1060 const wxString
data(wxGTK_CONV_BACK_SYS(str
));
1064 for( wxString::const_iterator pstr
= data
.begin(); pstr
!= data
.end(); ++pstr
)
1067 event
.m_uniChar
= *pstr
;
1068 // Backward compatible for ISO-8859-1
1069 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
1070 wxLogTrace(TRACE_KEYS
, wxT("IM sent character '%c'"), event
.m_uniChar
);
1072 event
.m_keyCode
= (char)*pstr
;
1073 #endif // wxUSE_UNICODE
1075 // To conform to the docs we need to translate Ctrl-alpha
1076 // characters to values in the range 1-26.
1077 if ( event
.ControlDown() &&
1078 ( wxIsLowerChar(*pstr
) || wxIsUpperChar(*pstr
) ))
1080 if ( wxIsLowerChar(*pstr
) )
1081 event
.m_keyCode
= *pstr
- 'a' + 1;
1082 if ( wxIsUpperChar(*pstr
) )
1083 event
.m_keyCode
= *pstr
- 'A' + 1;
1085 event
.m_keyCode
= *pstr
- 'a' + 1;
1087 event
.m_uniChar
= event
.m_keyCode
;
1091 SendCharHookAndCharEvents(event
, window
);
1097 //-----------------------------------------------------------------------------
1098 // "key_release_event" from any window
1099 //-----------------------------------------------------------------------------
1103 gtk_window_key_release_callback( GtkWidget
* WXUNUSED(widget
),
1104 GdkEventKey
*gdk_event
,
1110 if (g_blockEventsOnDrag
)
1113 wxKeyEvent
event( wxEVT_KEY_UP
);
1114 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1116 // unknown key pressed, ignore (the event would be useless anyhow)
1120 return win
->GTKProcessEvent(event
);
1124 // ============================================================================
1126 // ============================================================================
1128 // ----------------------------------------------------------------------------
1129 // mouse event processing helpers
1130 // ----------------------------------------------------------------------------
1132 // init wxMouseEvent with the info from GdkEventXXX struct
1133 template<typename T
> void InitMouseEvent(wxWindowGTK
*win
,
1134 wxMouseEvent
& event
,
1137 event
.SetTimestamp( gdk_event
->time
);
1138 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
1139 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
1140 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
1141 event
.m_metaDown
= (gdk_event
->state
& GDK_META_MASK
) != 0;
1142 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
) != 0;
1143 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
) != 0;
1144 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
) != 0;
1145 event
.m_aux1Down
= (gdk_event
->state
& GDK_BUTTON4_MASK
) != 0;
1146 event
.m_aux2Down
= (gdk_event
->state
& GDK_BUTTON5_MASK
) != 0;
1148 wxPoint pt
= win
->GetClientAreaOrigin();
1149 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1150 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1152 if ((win
->m_wxwindow
) && (win
->GetLayoutDirection() == wxLayout_RightToLeft
))
1154 // origin in the upper right corner
1156 gtk_widget_get_allocation(win
->m_wxwindow
, &a
);
1157 int window_width
= a
.width
;
1158 event
.m_x
= window_width
- event
.m_x
;
1161 event
.SetEventObject( win
);
1162 event
.SetId( win
->GetId() );
1163 event
.SetTimestamp( gdk_event
->time
);
1166 static void AdjustEventButtonState(wxMouseEvent
& event
)
1168 // GDK reports the old state of the button for a button press event, but
1169 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1170 // for a LEFT_DOWN event, not FALSE, so we will invert
1171 // left/right/middleDown for the corresponding click events
1173 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1174 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1175 (event
.GetEventType() == wxEVT_LEFT_UP
))
1177 event
.m_leftDown
= !event
.m_leftDown
;
1181 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1182 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1183 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1185 event
.m_middleDown
= !event
.m_middleDown
;
1189 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1190 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1191 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1193 event
.m_rightDown
= !event
.m_rightDown
;
1198 // find the window to send the mouse event too
1200 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1205 if (win
->m_wxwindow
)
1207 wxPizza
* pizza
= WX_PIZZA(win
->m_wxwindow
);
1208 xx
+= pizza
->m_scroll_x
;
1209 yy
+= pizza
->m_scroll_y
;
1212 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
1215 wxWindowGTK
*child
= node
->GetData();
1217 node
= node
->GetNext();
1218 if (!child
->IsShown())
1221 if (child
->GTKIsTransparentForMouse())
1223 // wxStaticBox is transparent in the box itself
1224 int xx1
= child
->m_x
;
1225 int yy1
= child
->m_y
;
1226 int xx2
= child
->m_x
+ child
->m_width
;
1227 int yy2
= child
->m_y
+ child
->m_height
;
1230 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1232 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1234 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1236 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1247 if ((child
->m_wxwindow
== NULL
) &&
1248 (child
->m_x
<= xx
) &&
1249 (child
->m_y
<= yy
) &&
1250 (child
->m_x
+child
->m_width
>= xx
) &&
1251 (child
->m_y
+child
->m_height
>= yy
))
1264 // ----------------------------------------------------------------------------
1265 // common event handlers helpers
1266 // ----------------------------------------------------------------------------
1268 bool wxWindowGTK::GTKProcessEvent(wxEvent
& event
) const
1270 // nothing special at this level
1271 return HandleWindowEvent(event
);
1274 bool wxWindowGTK::GTKShouldIgnoreEvent() const
1276 return !m_hasVMT
|| g_blockEventsOnDrag
;
1279 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny
*event
) const
1283 if (g_blockEventsOnDrag
)
1285 if (g_blockEventsOnScroll
)
1288 if (!GTKIsOwnWindow(event
->window
))
1294 // overloads for all GDK event types we use here: we need to have this as
1295 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1296 // derives from it in the sense that the structs have the same layout
1297 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1298 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1300 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1303 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton
)
1304 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion
)
1305 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing
)
1307 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1309 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1310 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1314 // all event handlers must have C linkage as they're called from GTK+ C code
1318 //-----------------------------------------------------------------------------
1319 // "button_press_event"
1320 //-----------------------------------------------------------------------------
1323 gtk_window_button_press_callback( GtkWidget
*widget
,
1324 GdkEventButton
*gdk_event
,
1327 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1329 g_lastButtonNumber
= gdk_event
->button
;
1331 // GDK sends surplus button down events
1332 // before a double click event. We
1333 // need to filter these out.
1334 if ((gdk_event
->type
== GDK_BUTTON_PRESS
) && (win
->m_wxwindow
))
1336 GdkEvent
*peek_event
= gdk_event_peek();
1339 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1340 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1342 gdk_event_free( peek_event
);
1347 gdk_event_free( peek_event
);
1352 wxEventType event_type
= wxEVT_NULL
;
1354 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1355 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1357 // Reset GDK internal timestamp variables in order to disable GDK
1358 // triple click events. GDK will then next time believe no button has
1359 // been clicked just before, and send a normal button click event.
1360 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1361 display
->button_click_time
[1] = 0;
1362 display
->button_click_time
[0] = 0;
1365 if (gdk_event
->button
== 1)
1367 // note that GDK generates triple click events which are not supported
1368 // by wxWidgets but still have to be passed to the app as otherwise
1369 // clicks would simply go missing
1370 switch (gdk_event
->type
)
1372 // we shouldn't get triple clicks at all for GTK2 because we
1373 // suppress them artificially using the code above but we still
1374 // should map them to something for GTK1 and not just ignore them
1375 // as this would lose clicks
1376 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1377 case GDK_BUTTON_PRESS
:
1378 event_type
= wxEVT_LEFT_DOWN
;
1381 case GDK_2BUTTON_PRESS
:
1382 event_type
= wxEVT_LEFT_DCLICK
;
1386 // just to silence gcc warnings
1390 else if (gdk_event
->button
== 2)
1392 switch (gdk_event
->type
)
1394 case GDK_3BUTTON_PRESS
:
1395 case GDK_BUTTON_PRESS
:
1396 event_type
= wxEVT_MIDDLE_DOWN
;
1399 case GDK_2BUTTON_PRESS
:
1400 event_type
= wxEVT_MIDDLE_DCLICK
;
1407 else if (gdk_event
->button
== 3)
1409 switch (gdk_event
->type
)
1411 case GDK_3BUTTON_PRESS
:
1412 case GDK_BUTTON_PRESS
:
1413 event_type
= wxEVT_RIGHT_DOWN
;
1416 case GDK_2BUTTON_PRESS
:
1417 event_type
= wxEVT_RIGHT_DCLICK
;
1425 if ( event_type
== wxEVT_NULL
)
1427 // unknown mouse button or click type
1431 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1433 wxMouseEvent
event( event_type
);
1434 InitMouseEvent( win
, event
, gdk_event
);
1436 AdjustEventButtonState(event
);
1438 // find the correct window to send the event to: it may be a different one
1439 // from the one which got it at GTK+ level because some controls don't have
1440 // their own X window and thus cannot get any events.
1441 if ( !g_captureWindow
)
1442 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1444 // reset the event object and id in case win changed.
1445 event
.SetEventObject( win
);
1446 event
.SetId( win
->GetId() );
1448 bool ret
= win
->GTKProcessEvent( event
);
1449 g_lastMouseEvent
= NULL
;
1453 if ((event_type
== wxEVT_LEFT_DOWN
) && !win
->IsOfStandardClass() &&
1454 (gs_currentFocus
!= win
) /* && win->IsFocusable() */)
1459 if (event_type
== wxEVT_RIGHT_DOWN
)
1461 // generate a "context menu" event: this is similar to right mouse
1462 // click under many GUIs except that it is generated differently
1463 // (right up under MSW, ctrl-click under Mac, right down here) and
1465 // (a) it's a command event and so is propagated to the parent
1466 // (b) under some ports it can be generated from kbd too
1467 // (c) it uses screen coords (because of (a))
1468 wxContextMenuEvent
evtCtx(
1471 win
->ClientToScreen(event
.GetPosition()));
1472 evtCtx
.SetEventObject(win
);
1473 return win
->GTKProcessEvent(evtCtx
);
1479 //-----------------------------------------------------------------------------
1480 // "button_release_event"
1481 //-----------------------------------------------------------------------------
1484 gtk_window_button_release_callback( GtkWidget
*WXUNUSED(widget
),
1485 GdkEventButton
*gdk_event
,
1488 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1490 g_lastButtonNumber
= 0;
1492 wxEventType event_type
= wxEVT_NULL
;
1494 switch (gdk_event
->button
)
1497 event_type
= wxEVT_LEFT_UP
;
1501 event_type
= wxEVT_MIDDLE_UP
;
1505 event_type
= wxEVT_RIGHT_UP
;
1509 // unknown button, don't process
1513 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1515 wxMouseEvent
event( event_type
);
1516 InitMouseEvent( win
, event
, gdk_event
);
1518 AdjustEventButtonState(event
);
1520 if ( !g_captureWindow
)
1521 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1523 // reset the event object and id in case win changed.
1524 event
.SetEventObject( win
);
1525 event
.SetId( win
->GetId() );
1527 bool ret
= win
->GTKProcessEvent(event
);
1529 g_lastMouseEvent
= NULL
;
1534 //-----------------------------------------------------------------------------
1535 // "motion_notify_event"
1536 //-----------------------------------------------------------------------------
1539 gtk_window_motion_notify_callback( GtkWidget
* WXUNUSED(widget
),
1540 GdkEventMotion
*gdk_event
,
1543 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1545 if (gdk_event
->is_hint
)
1549 GdkModifierType state
;
1550 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1555 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1557 wxMouseEvent
event( wxEVT_MOTION
);
1558 InitMouseEvent(win
, event
, gdk_event
);
1560 if ( g_captureWindow
)
1562 // synthesise a mouse enter or leave event if needed
1563 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1564 // This seems to be necessary and actually been added to
1565 // GDK itself in version 2.0.X
1568 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1569 if ( hasMouse
!= g_captureWindowHasMouse
)
1571 // the mouse changed window
1572 g_captureWindowHasMouse
= hasMouse
;
1574 wxMouseEvent
eventM(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1575 : wxEVT_LEAVE_WINDOW
);
1576 InitMouseEvent(win
, eventM
, gdk_event
);
1577 eventM
.SetEventObject(win
);
1578 win
->GTKProcessEvent(eventM
);
1583 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1585 // reset the event object and id in case win changed.
1586 event
.SetEventObject( win
);
1587 event
.SetId( win
->GetId() );
1590 if ( !g_captureWindow
)
1592 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1593 if (win
->GTKProcessEvent( cevent
))
1595 win
->SetCursor( cevent
.GetCursor() );
1599 bool ret
= win
->GTKProcessEvent(event
);
1601 g_lastMouseEvent
= NULL
;
1606 //-----------------------------------------------------------------------------
1607 // "scroll_event" (mouse wheel event)
1608 //-----------------------------------------------------------------------------
1611 window_scroll_event_hscrollbar(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1613 if (gdk_event
->direction
!= GDK_SCROLL_LEFT
&&
1614 gdk_event
->direction
!= GDK_SCROLL_RIGHT
)
1619 GtkRange
*range
= win
->m_scrollBar
[wxWindow::ScrollDir_Horz
];
1621 if (range
&& gtk_widget_get_visible(GTK_WIDGET(range
)))
1623 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
1624 double delta
= gtk_adjustment_get_step_increment(adj
) * 3;
1625 if (gdk_event
->direction
== GDK_SCROLL_LEFT
)
1628 gtk_range_set_value(range
, gtk_adjustment_get_value(adj
) + delta
);
1637 window_scroll_event(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1639 if (gdk_event
->direction
!= GDK_SCROLL_UP
&&
1640 gdk_event
->direction
!= GDK_SCROLL_DOWN
)
1645 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1646 InitMouseEvent(win
, event
, gdk_event
);
1648 // FIXME: Get these values from GTK or GDK
1649 event
.m_linesPerAction
= 3;
1650 event
.m_wheelDelta
= 120;
1651 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1652 event
.m_wheelRotation
= 120;
1654 event
.m_wheelRotation
= -120;
1656 if (win
->GTKProcessEvent(event
))
1659 GtkRange
*range
= win
->m_scrollBar
[wxWindow::ScrollDir_Vert
];
1661 if (range
&& gtk_widget_get_visible(GTK_WIDGET(range
)))
1663 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
1664 double delta
= gtk_adjustment_get_step_increment(adj
) * 3;
1665 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1668 gtk_range_set_value(range
, gtk_adjustment_get_value(adj
) + delta
);
1676 //-----------------------------------------------------------------------------
1678 //-----------------------------------------------------------------------------
1680 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
1682 wxContextMenuEvent
event(wxEVT_CONTEXT_MENU
, win
->GetId(), wxPoint(-1, -1));
1683 event
.SetEventObject(win
);
1684 return win
->GTKProcessEvent(event
);
1687 //-----------------------------------------------------------------------------
1689 //-----------------------------------------------------------------------------
1692 gtk_window_focus_in_callback( GtkWidget
* WXUNUSED(widget
),
1693 GdkEventFocus
*WXUNUSED(event
),
1696 return win
->GTKHandleFocusIn();
1699 //-----------------------------------------------------------------------------
1700 // "focus_out_event"
1701 //-----------------------------------------------------------------------------
1704 gtk_window_focus_out_callback( GtkWidget
* WXUNUSED(widget
),
1705 GdkEventFocus
* WXUNUSED(gdk_event
),
1708 return win
->GTKHandleFocusOut();
1711 //-----------------------------------------------------------------------------
1713 //-----------------------------------------------------------------------------
1716 wx_window_focus_callback(GtkWidget
*widget
,
1717 GtkDirectionType
WXUNUSED(direction
),
1720 // the default handler for focus signal in GtkScrolledWindow sets
1721 // focus to the window itself even if it doesn't accept focus, i.e. has no
1722 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1723 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1724 // any children which might accept focus (we know we don't accept the focus
1725 // ourselves as this signal is only connected in this case)
1726 if ( win
->GetChildren().empty() )
1727 g_signal_stop_emission_by_name(widget
, "focus");
1729 // we didn't change the focus
1733 //-----------------------------------------------------------------------------
1734 // "enter_notify_event"
1735 //-----------------------------------------------------------------------------
1738 gtk_window_enter_callback( GtkWidget
*widget
,
1739 GdkEventCrossing
*gdk_event
,
1742 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1744 // Event was emitted after a grab
1745 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1749 GdkModifierType state
= (GdkModifierType
)0;
1751 gdk_window_get_pointer(gtk_widget_get_window(widget
), &x
, &y
, &state
);
1753 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1754 InitMouseEvent(win
, event
, gdk_event
);
1755 wxPoint pt
= win
->GetClientAreaOrigin();
1756 event
.m_x
= x
+ pt
.x
;
1757 event
.m_y
= y
+ pt
.y
;
1759 if ( !g_captureWindow
)
1761 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1762 if (win
->GTKProcessEvent( cevent
))
1764 win
->SetCursor( cevent
.GetCursor() );
1768 return win
->GTKProcessEvent(event
);
1771 //-----------------------------------------------------------------------------
1772 // "leave_notify_event"
1773 //-----------------------------------------------------------------------------
1776 gtk_window_leave_callback( GtkWidget
*widget
,
1777 GdkEventCrossing
*gdk_event
,
1780 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1782 // Event was emitted after an ungrab
1783 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1785 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1789 GdkModifierType state
= (GdkModifierType
)0;
1791 gdk_window_get_pointer(gtk_widget_get_window(widget
), &x
, &y
, &state
);
1793 InitMouseEvent(win
, event
, gdk_event
);
1795 return win
->GTKProcessEvent(event
);
1798 //-----------------------------------------------------------------------------
1799 // "value_changed" from scrollbar
1800 //-----------------------------------------------------------------------------
1803 gtk_scrollbar_value_changed(GtkRange
* range
, wxWindow
* win
)
1805 wxEventType eventType
= win
->GTKGetScrollEventType(range
);
1806 if (eventType
!= wxEVT_NULL
)
1808 // Convert scroll event type to scrollwin event type
1809 eventType
+= wxEVT_SCROLLWIN_TOP
- wxEVT_SCROLL_TOP
;
1811 // find the scrollbar which generated the event
1812 wxWindowGTK::ScrollDir dir
= win
->ScrollDirFromRange(range
);
1814 // generate the corresponding wx event
1815 const int orient
= wxWindow::OrientFromScrollDir(dir
);
1816 wxScrollWinEvent
event(eventType
, win
->GetScrollPos(orient
), orient
);
1817 event
.SetEventObject(win
);
1819 win
->GTKProcessEvent(event
);
1823 //-----------------------------------------------------------------------------
1824 // "button_press_event" from scrollbar
1825 //-----------------------------------------------------------------------------
1828 gtk_scrollbar_button_press_event(GtkRange
*, GdkEventButton
*, wxWindow
* win
)
1830 g_blockEventsOnScroll
= true;
1831 win
->m_mouseButtonDown
= true;
1836 //-----------------------------------------------------------------------------
1837 // "event_after" from scrollbar
1838 //-----------------------------------------------------------------------------
1841 gtk_scrollbar_event_after(GtkRange
* range
, GdkEvent
* event
, wxWindow
* win
)
1843 if (event
->type
== GDK_BUTTON_RELEASE
)
1845 g_signal_handlers_block_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1847 const int orient
= wxWindow::OrientFromScrollDir(
1848 win
->ScrollDirFromRange(range
));
1849 wxScrollWinEvent
evt(wxEVT_SCROLLWIN_THUMBRELEASE
,
1850 win
->GetScrollPos(orient
), orient
);
1851 evt
.SetEventObject(win
);
1852 win
->GTKProcessEvent(evt
);
1856 //-----------------------------------------------------------------------------
1857 // "button_release_event" from scrollbar
1858 //-----------------------------------------------------------------------------
1861 gtk_scrollbar_button_release_event(GtkRange
* range
, GdkEventButton
*, wxWindow
* win
)
1863 g_blockEventsOnScroll
= false;
1864 win
->m_mouseButtonDown
= false;
1865 // If thumb tracking
1866 if (win
->m_isScrolling
)
1868 win
->m_isScrolling
= false;
1869 // Hook up handler to send thumb release event after this emission is finished.
1870 // To allow setting scroll position from event handler, sending event must
1871 // be deferred until after the GtkRange handler for this signal has run
1872 g_signal_handlers_unblock_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1878 //-----------------------------------------------------------------------------
1879 // "realize" from m_widget
1880 //-----------------------------------------------------------------------------
1883 gtk_window_realized_callback(GtkWidget
* widget
, wxWindow
* win
)
1887 gtk_im_context_set_client_window( win
->m_imData
->context
,
1888 win
->m_wxwindow
? win
->GTKGetDrawingWindow() : gtk_widget_get_window(widget
));
1891 // We cannot set colours and fonts before the widget
1892 // been realized, so we do this directly after realization
1893 // or otherwise in idle time
1895 if (win
->m_needsStyleChange
)
1897 win
->SetBackgroundStyle(win
->GetBackgroundStyle());
1898 win
->m_needsStyleChange
= false;
1901 wxWindowCreateEvent
event( win
);
1902 event
.SetEventObject( win
);
1903 win
->GTKProcessEvent( event
);
1905 win
->GTKUpdateCursor(true, false);
1908 //-----------------------------------------------------------------------------
1909 // "size_allocate" from m_wxwindow or m_widget
1910 //-----------------------------------------------------------------------------
1913 size_allocate(GtkWidget
*, GtkAllocation
* alloc
, wxWindow
* win
)
1915 int w
= alloc
->width
;
1916 int h
= alloc
->height
;
1917 if (win
->m_wxwindow
)
1919 int border_x
, border_y
;
1920 WX_PIZZA(win
->m_wxwindow
)->get_border_widths(border_x
, border_y
);
1926 if (win
->m_oldClientWidth
!= w
|| win
->m_oldClientHeight
!= h
)
1928 win
->m_oldClientWidth
= w
;
1929 win
->m_oldClientHeight
= h
;
1930 // this callback can be connected to m_wxwindow,
1931 // so always get size from m_widget->allocation
1933 gtk_widget_get_allocation(win
->m_widget
, &a
);
1934 win
->m_width
= a
.width
;
1935 win
->m_height
= a
.height
;
1936 if (!win
->m_nativeSizeEvent
)
1938 wxSizeEvent
event(win
->GetSize(), win
->GetId());
1939 event
.SetEventObject(win
);
1940 win
->GTKProcessEvent(event
);
1945 //-----------------------------------------------------------------------------
1947 //-----------------------------------------------------------------------------
1949 #if GTK_CHECK_VERSION(2, 8, 0)
1951 gtk_window_grab_broken( GtkWidget
*,
1952 GdkEventGrabBroken
*event
,
1955 // Mouse capture has been lost involuntarily, notify the application
1956 if(!event
->keyboard
&& wxWindow::GetCapture() == win
)
1958 wxMouseCaptureLostEvent
evt( win
->GetId() );
1959 evt
.SetEventObject( win
);
1960 win
->HandleWindowEvent( evt
);
1966 //-----------------------------------------------------------------------------
1968 //-----------------------------------------------------------------------------
1971 void gtk_window_style_set_callback( GtkWidget
*WXUNUSED(widget
),
1972 GtkStyle
*previous_style
,
1975 if (win
&& previous_style
)
1977 wxSysColourChangedEvent event
;
1978 event
.SetEventObject(win
);
1980 win
->GTKProcessEvent( event
);
1986 // ----------------------------------------------------------------------------
1987 // this wxWindowBase function is implemented here (in platform-specific file)
1988 // because it is static and so couldn't be made virtual
1989 // ----------------------------------------------------------------------------
1991 wxWindow
*wxWindowBase::DoFindFocus()
1993 wxWindowGTK
*focus
= gs_pendingFocus
? gs_pendingFocus
: gs_currentFocus
;
1994 // the cast is necessary when we compile in wxUniversal mode
1995 return static_cast<wxWindow
*>(focus
);
1998 void wxWindowGTK::AddChildGTK(wxWindowGTK
* child
)
2000 wxASSERT_MSG(m_wxwindow
, "Cannot add a child to a window without a client area");
2002 // the window might have been scrolled already, we
2003 // have to adapt the position
2004 wxPizza
* pizza
= WX_PIZZA(m_wxwindow
);
2005 child
->m_x
+= pizza
->m_scroll_x
;
2006 child
->m_y
+= pizza
->m_scroll_y
;
2008 gtk_widget_set_size_request(
2009 child
->m_widget
, child
->m_width
, child
->m_height
);
2010 pizza
->put(child
->m_widget
, child
->m_x
, child
->m_y
);
2013 //-----------------------------------------------------------------------------
2015 //-----------------------------------------------------------------------------
2017 wxWindow
*wxGetActiveWindow()
2019 return wxWindow::FindFocus();
2023 wxMouseState
wxGetMouseState()
2029 GdkModifierType mask
;
2031 gdk_window_get_pointer(NULL
, &x
, &y
, &mask
);
2035 ms
.SetLeftDown((mask
& GDK_BUTTON1_MASK
) != 0);
2036 ms
.SetMiddleDown((mask
& GDK_BUTTON2_MASK
) != 0);
2037 ms
.SetRightDown((mask
& GDK_BUTTON3_MASK
) != 0);
2038 ms
.SetAux1Down((mask
& GDK_BUTTON4_MASK
) != 0);
2039 ms
.SetAux2Down((mask
& GDK_BUTTON5_MASK
) != 0);
2041 ms
.SetControlDown((mask
& GDK_CONTROL_MASK
) != 0);
2042 ms
.SetShiftDown((mask
& GDK_SHIFT_MASK
) != 0);
2043 ms
.SetAltDown((mask
& GDK_MOD1_MASK
) != 0);
2044 ms
.SetMetaDown((mask
& GDK_META_MASK
) != 0);
2049 //-----------------------------------------------------------------------------
2051 //-----------------------------------------------------------------------------
2053 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2055 #ifdef __WXUNIVERSAL__
2056 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2057 #endif // __WXUNIVERSAL__
2059 void wxWindowGTK::Init()
2064 m_focusWidget
= NULL
;
2074 m_showOnIdle
= false;
2077 m_nativeSizeEvent
= false;
2079 m_isScrolling
= false;
2080 m_mouseButtonDown
= false;
2082 // initialize scrolling stuff
2083 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2085 m_scrollBar
[dir
] = NULL
;
2086 m_scrollPos
[dir
] = 0;
2090 m_oldClientHeight
= 0;
2092 m_clipPaintRegion
= false;
2094 m_needsStyleChange
= false;
2096 m_cursor
= *wxSTANDARD_CURSOR
;
2099 m_dirtyTabOrder
= false;
2102 wxWindowGTK::wxWindowGTK()
2107 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2112 const wxString
&name
)
2116 Create( parent
, id
, pos
, size
, style
, name
);
2119 bool wxWindowGTK::Create( wxWindow
*parent
,
2124 const wxString
&name
)
2126 // Get default border
2127 wxBorder border
= GetBorder(style
);
2129 style
&= ~wxBORDER_MASK
;
2132 if (!PreCreation( parent
, pos
, size
) ||
2133 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2135 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2139 // We should accept the native look
2141 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2142 scroll_class
->scrollbar_spacing
= 0;
2146 m_wxwindow
= wxPizza::New(m_windowStyle
);
2147 #ifndef __WXUNIVERSAL__
2148 if (HasFlag(wxPizza::BORDER_STYLES
))
2150 g_signal_connect(m_wxwindow
, "parent_set",
2151 G_CALLBACK(parent_set
), this);
2154 if (!HasFlag(wxHSCROLL
) && !HasFlag(wxVSCROLL
))
2155 m_widget
= m_wxwindow
;
2158 m_widget
= gtk_scrolled_window_new( NULL
, NULL
);
2160 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2162 // There is a conflict with default bindings at GTK+
2163 // level between scrolled windows and notebooks both of which want to use
2164 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2165 // direction and notebooks for changing pages -- we decide that if we don't
2166 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2167 // means we can get working keyboard navigation in notebooks
2168 if ( !HasFlag(wxHSCROLL
) )
2171 bindings
= gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget
));
2174 gtk_binding_entry_remove(bindings
, GDK_Page_Up
, GDK_CONTROL_MASK
);
2175 gtk_binding_entry_remove(bindings
, GDK_Page_Down
, GDK_CONTROL_MASK
);
2179 if (HasFlag(wxALWAYS_SHOW_SB
))
2181 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_ALWAYS
, GTK_POLICY_ALWAYS
);
2185 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2188 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow
));
2189 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow
));
2190 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2191 gtk_range_set_inverted( m_scrollBar
[ScrollDir_Horz
], TRUE
);
2193 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2195 // connect various scroll-related events
2196 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2198 // these handlers block mouse events to any window during scrolling
2199 // such as motion events and prevent GTK and wxWidgets from fighting
2200 // over where the slider should be
2201 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2202 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2203 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2204 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2206 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2207 G_CALLBACK(gtk_scrollbar_event_after
), this);
2208 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2210 // these handlers get notified when scrollbar slider moves
2211 g_signal_connect_after(m_scrollBar
[dir
], "value_changed",
2212 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2215 gtk_widget_show( m_wxwindow
);
2217 g_object_ref(m_widget
);
2220 m_parent
->DoAddChild( this );
2222 m_focusWidget
= m_wxwindow
;
2224 SetCanFocus(AcceptsFocus());
2231 wxWindowGTK::~wxWindowGTK()
2235 if (gs_currentFocus
== this)
2236 gs_currentFocus
= NULL
;
2237 if (gs_pendingFocus
== this)
2238 gs_pendingFocus
= NULL
;
2240 if ( gs_deferredFocusOut
== this )
2241 gs_deferredFocusOut
= NULL
;
2245 // destroy children before destroying this window itself
2248 // unhook focus handlers to prevent stray events being
2249 // propagated to this (soon to be) dead object
2250 if (m_focusWidget
!= NULL
)
2252 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2253 (gpointer
) gtk_window_focus_in_callback
,
2255 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2256 (gpointer
) gtk_window_focus_out_callback
,
2263 // delete before the widgets to avoid a crash on solaris
2266 // avoid problem with GTK+ 2.18 where a frozen window causes the whole
2267 // TLW to be frozen, and if the window is then destroyed, nothing ever
2268 // gets painted again
2274 // Note that gtk_widget_destroy() does not destroy the widget, it just
2275 // emits the "destroy" signal. The widget is not actually destroyed
2276 // until its reference count drops to zero.
2277 gtk_widget_destroy(m_widget
);
2278 // Release our reference, should be the last one
2279 g_object_unref(m_widget
);
2285 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2287 if ( GTKNeedsParent() )
2289 wxCHECK_MSG( parent
, false, wxT("Must have non-NULL parent") );
2292 // Use either the given size, or the default if -1 is given.
2293 // See wxWindowBase for these functions.
2294 m_width
= WidthDefault(size
.x
) ;
2295 m_height
= HeightDefault(size
.y
);
2303 void wxWindowGTK::PostCreation()
2305 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2311 // these get reported to wxWidgets -> wxPaintEvent
2313 g_signal_connect (m_wxwindow
, "expose_event",
2314 G_CALLBACK (gtk_window_expose_callback
), this);
2316 if (GetLayoutDirection() == wxLayout_LeftToRight
)
2317 gtk_widget_set_redraw_on_allocate(m_wxwindow
, HasFlag(wxFULL_REPAINT_ON_RESIZE
));
2320 // Create input method handler
2321 m_imData
= new wxGtkIMData
;
2323 // Cannot handle drawing preedited text yet
2324 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2326 g_signal_connect (m_imData
->context
, "commit",
2327 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2332 if (!GTK_IS_WINDOW(m_widget
))
2334 if (m_focusWidget
== NULL
)
2335 m_focusWidget
= m_widget
;
2339 g_signal_connect (m_focusWidget
, "focus_in_event",
2340 G_CALLBACK (gtk_window_focus_in_callback
), this);
2341 g_signal_connect (m_focusWidget
, "focus_out_event",
2342 G_CALLBACK (gtk_window_focus_out_callback
), this);
2346 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2347 G_CALLBACK (gtk_window_focus_in_callback
), this);
2348 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2349 G_CALLBACK (gtk_window_focus_out_callback
), this);
2353 if ( !AcceptsFocusFromKeyboard() )
2357 g_signal_connect(m_widget
, "focus",
2358 G_CALLBACK(wx_window_focus_callback
), this);
2361 // connect to the various key and mouse handlers
2363 GtkWidget
*connect_widget
= GetConnectWidget();
2365 ConnectWidget( connect_widget
);
2367 /* We cannot set colours, fonts and cursors before the widget has
2368 been realized, so we do this directly after realization */
2369 g_signal_connect (connect_widget
, "realize",
2370 G_CALLBACK (gtk_window_realized_callback
), this);
2374 g_signal_connect(m_wxwindow
? m_wxwindow
: m_widget
, "size_allocate",
2375 G_CALLBACK(size_allocate
), this);
2378 #if GTK_CHECK_VERSION(2, 8, 0)
2379 if ( gtk_check_version(2,8,0) == NULL
)
2381 // Make sure we can notify the app when mouse capture is lost
2384 g_signal_connect (m_wxwindow
, "grab_broken_event",
2385 G_CALLBACK (gtk_window_grab_broken
), this);
2388 if ( connect_widget
!= m_wxwindow
)
2390 g_signal_connect (connect_widget
, "grab_broken_event",
2391 G_CALLBACK (gtk_window_grab_broken
), this);
2394 #endif // GTK+ >= 2.8
2396 if ( GTKShouldConnectSizeRequest() )
2398 // This is needed if we want to add our windows into native
2399 // GTK controls, such as the toolbar. With this callback, the
2400 // toolbar gets to know the correct size (the one set by the
2401 // programmer). Sadly, it misbehaves for wxComboBox.
2402 g_signal_connect (m_widget
, "size_request",
2403 G_CALLBACK (wxgtk_window_size_request_callback
),
2407 InheritAttributes();
2411 SetLayoutDirection(wxLayout_Default
);
2413 // unless the window was created initially hidden (i.e. Hide() had been
2414 // called before Create()), we should show it at GTK+ level as well
2416 gtk_widget_show( m_widget
);
2419 gulong
wxWindowGTK::GTKConnectWidget(const char *signal
, void (*callback
)())
2421 return g_signal_connect(m_widget
, signal
, callback
, this);
2424 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2426 g_signal_connect (widget
, "key_press_event",
2427 G_CALLBACK (gtk_window_key_press_callback
), this);
2428 g_signal_connect (widget
, "key_release_event",
2429 G_CALLBACK (gtk_window_key_release_callback
), this);
2430 g_signal_connect (widget
, "button_press_event",
2431 G_CALLBACK (gtk_window_button_press_callback
), this);
2432 g_signal_connect (widget
, "button_release_event",
2433 G_CALLBACK (gtk_window_button_release_callback
), this);
2434 g_signal_connect (widget
, "motion_notify_event",
2435 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2437 g_signal_connect (widget
, "scroll_event",
2438 G_CALLBACK (window_scroll_event
), this);
2439 if (m_scrollBar
[ScrollDir_Horz
])
2440 g_signal_connect (m_scrollBar
[ScrollDir_Horz
], "scroll_event",
2441 G_CALLBACK (window_scroll_event_hscrollbar
), this);
2442 if (m_scrollBar
[ScrollDir_Vert
])
2443 g_signal_connect (m_scrollBar
[ScrollDir_Vert
], "scroll_event",
2444 G_CALLBACK (window_scroll_event
), this);
2446 g_signal_connect (widget
, "popup_menu",
2447 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2448 g_signal_connect (widget
, "enter_notify_event",
2449 G_CALLBACK (gtk_window_enter_callback
), this);
2450 g_signal_connect (widget
, "leave_notify_event",
2451 G_CALLBACK (gtk_window_leave_callback
), this);
2453 if (IsTopLevel() && m_wxwindow
)
2454 g_signal_connect (m_wxwindow
, "style_set",
2455 G_CALLBACK (gtk_window_style_set_callback
), this);
2458 bool wxWindowGTK::Destroy()
2460 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2464 return wxWindowBase::Destroy();
2467 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2469 gtk_widget_set_size_request(m_widget
, width
, height
);
2471 // inform the parent to perform the move
2472 wxASSERT_MSG(m_parent
&& m_parent
->m_wxwindow
,
2473 "the parent window has no client area?");
2474 WX_PIZZA(m_parent
->m_wxwindow
)->move(m_widget
, x
, y
);
2477 void wxWindowGTK::ConstrainSize()
2480 // GPE's window manager doesn't like size hints at all, esp. when the user
2481 // has to use the virtual keyboard, so don't constrain size there
2485 const wxSize minSize
= GetMinSize();
2486 const wxSize maxSize
= GetMaxSize();
2487 if (minSize
.x
> 0 && m_width
< minSize
.x
) m_width
= minSize
.x
;
2488 if (minSize
.y
> 0 && m_height
< minSize
.y
) m_height
= minSize
.y
;
2489 if (maxSize
.x
> 0 && m_width
> maxSize
.x
) m_width
= maxSize
.x
;
2490 if (maxSize
.y
> 0 && m_height
> maxSize
.y
) m_height
= maxSize
.y
;
2494 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2496 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2497 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2499 int currentX
, currentY
;
2500 GetPosition(¤tX
, ¤tY
);
2501 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2503 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2505 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2507 // calculate the best size if we should auto size the window
2508 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2509 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2511 const wxSize sizeBest
= GetBestSize();
2512 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2514 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2515 height
= sizeBest
.y
;
2518 const wxSize
oldSize(m_width
, m_height
);
2524 if (m_parent
->m_wxwindow
)
2526 wxPizza
* pizza
= WX_PIZZA(m_parent
->m_wxwindow
);
2527 m_x
= x
+ pizza
->m_scroll_x
;
2528 m_y
= y
+ pizza
->m_scroll_y
;
2530 int left_border
= 0;
2531 int right_border
= 0;
2533 int bottom_border
= 0;
2535 /* the default button has a border around it */
2536 if (gtk_widget_get_can_default(m_widget
))
2538 GtkBorder
*default_border
= NULL
;
2539 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2542 left_border
+= default_border
->left
;
2543 right_border
+= default_border
->right
;
2544 top_border
+= default_border
->top
;
2545 bottom_border
+= default_border
->bottom
;
2546 gtk_border_free( default_border
);
2550 DoMoveWindow( m_x
- left_border
,
2552 m_width
+left_border
+right_border
,
2553 m_height
+top_border
+bottom_border
);
2556 if (m_width
!= oldSize
.x
|| m_height
!= oldSize
.y
)
2558 // update these variables to keep size_allocate handler
2559 // from sending another size event for this change
2560 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2562 gtk_widget_queue_resize(m_widget
);
2563 if (!m_nativeSizeEvent
)
2565 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2566 event
.SetEventObject( this );
2567 HandleWindowEvent( event
);
2570 if (sizeFlags
& wxSIZE_FORCE_EVENT
)
2572 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2573 event
.SetEventObject( this );
2574 HandleWindowEvent( event
);
2578 bool wxWindowGTK::GTKShowFromOnIdle()
2580 if (IsShown() && m_showOnIdle
&& !gtk_widget_get_visible (m_widget
))
2582 GtkAllocation alloc
;
2585 alloc
.width
= m_width
;
2586 alloc
.height
= m_height
;
2587 gtk_widget_size_allocate( m_widget
, &alloc
);
2588 gtk_widget_show( m_widget
);
2589 wxShowEvent
eventShow(GetId(), true);
2590 eventShow
.SetEventObject(this);
2591 HandleWindowEvent(eventShow
);
2592 m_showOnIdle
= false;
2599 void wxWindowGTK::OnInternalIdle()
2601 if ( gs_deferredFocusOut
)
2602 GTKHandleDeferredFocusOut();
2604 // Check if we have to show window now
2605 if (GTKShowFromOnIdle()) return;
2607 if ( m_dirtyTabOrder
)
2609 m_dirtyTabOrder
= false;
2613 // Update style if the window was not yet realized when
2614 // SetBackgroundStyle() was called
2615 if (m_needsStyleChange
)
2617 SetBackgroundStyle(GetBackgroundStyle());
2618 m_needsStyleChange
= false;
2621 wxWindowBase::OnInternalIdle();
2624 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
2626 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2628 if (width
) (*width
) = m_width
;
2629 if (height
) (*height
) = m_height
;
2632 void wxWindowGTK::DoSetClientSize( int width
, int height
)
2634 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2636 const wxSize size
= GetSize();
2637 const wxSize clientSize
= GetClientSize();
2638 SetSize(width
+ (size
.x
- clientSize
.x
), height
+ (size
.y
- clientSize
.y
));
2641 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
2643 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2650 // if window is scrollable, account for scrollbars
2651 if ( GTK_IS_SCROLLED_WINDOW(m_widget
) )
2653 GtkPolicyType policy
[ScrollDir_Max
];
2654 gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget
),
2655 &policy
[ScrollDir_Horz
],
2656 &policy
[ScrollDir_Vert
]);
2658 for ( int i
= 0; i
< ScrollDir_Max
; i
++ )
2660 // don't account for the scrollbars we don't have
2661 GtkRange
* const range
= m_scrollBar
[i
];
2665 // nor for the ones we have but don't current show
2666 switch ( policy
[i
] )
2668 case GTK_POLICY_NEVER
:
2669 // never shown so doesn't take any place
2672 case GTK_POLICY_ALWAYS
:
2673 // no checks necessary
2676 case GTK_POLICY_AUTOMATIC
:
2677 // may be shown or not, check
2678 GtkAdjustment
*adj
= gtk_range_get_adjustment(range
);
2679 if (gtk_adjustment_get_upper(adj
) <= gtk_adjustment_get_page_size(adj
))
2683 GtkScrolledWindowClass
*scroll_class
=
2684 GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2687 gtk_widget_size_request(GTK_WIDGET(range
), &req
);
2688 if (i
== ScrollDir_Horz
)
2689 h
-= req
.height
+ scroll_class
->scrollbar_spacing
;
2691 w
-= req
.width
+ scroll_class
->scrollbar_spacing
;
2695 const wxSize sizeBorders
= DoGetBorderSize();
2705 if (width
) *width
= w
;
2706 if (height
) *height
= h
;
2709 wxSize
wxWindowGTK::DoGetBorderSize() const
2712 return wxWindowBase::DoGetBorderSize();
2715 WX_PIZZA(m_wxwindow
)->get_border_widths(x
, y
);
2717 return 2*wxSize(x
, y
);
2720 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
2722 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2726 if (!IsTopLevel() && m_parent
&& m_parent
->m_wxwindow
)
2728 wxPizza
* pizza
= WX_PIZZA(m_parent
->m_wxwindow
);
2729 dx
= pizza
->m_scroll_x
;
2730 dy
= pizza
->m_scroll_y
;
2733 if (m_x
== -1 && m_y
== -1)
2735 GdkWindow
*source
= NULL
;
2737 source
= gtk_widget_get_window(m_wxwindow
);
2739 source
= gtk_widget_get_window(m_widget
);
2745 gdk_window_get_origin( source
, &org_x
, &org_y
);
2748 m_parent
->ScreenToClient(&org_x
, &org_y
);
2750 const_cast<wxWindowGTK
*>(this)->m_x
= org_x
;
2751 const_cast<wxWindowGTK
*>(this)->m_y
= org_y
;
2755 if (x
) (*x
) = m_x
- dx
;
2756 if (y
) (*y
) = m_y
- dy
;
2759 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
2761 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2763 if (gtk_widget_get_window(m_widget
) == NULL
) return;
2765 GdkWindow
*source
= NULL
;
2767 source
= gtk_widget_get_window(m_wxwindow
);
2769 source
= gtk_widget_get_window(m_widget
);
2773 gdk_window_get_origin( source
, &org_x
, &org_y
);
2777 if (!gtk_widget_get_has_window(m_widget
))
2780 gtk_widget_get_allocation(m_widget
, &a
);
2789 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2790 *x
= (GetClientSize().x
- *x
) + org_x
;
2798 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
2800 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2802 if (!gtk_widget_get_realized(m_widget
)) return;
2804 GdkWindow
*source
= NULL
;
2806 source
= gtk_widget_get_window(m_wxwindow
);
2808 source
= gtk_widget_get_window(m_widget
);
2812 gdk_window_get_origin( source
, &org_x
, &org_y
);
2816 if (!gtk_widget_get_has_window(m_widget
))
2819 gtk_widget_get_allocation(m_widget
, &a
);
2827 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2828 *x
= (GetClientSize().x
- *x
) - org_x
;
2835 bool wxWindowGTK::Show( bool show
)
2837 if ( !wxWindowBase::Show(show
) )
2843 // notice that we may call Hide() before the window is created and this is
2844 // actually useful to create it hidden initially -- but we can't call
2845 // Show() before it is created
2848 wxASSERT_MSG( !show
, "can't show invalid window" );
2856 // defer until later
2860 gtk_widget_show(m_widget
);
2864 gtk_widget_hide(m_widget
);
2867 wxShowEvent
eventShow(GetId(), show
);
2868 eventShow
.SetEventObject(this);
2869 HandleWindowEvent(eventShow
);
2874 void wxWindowGTK::DoEnable( bool enable
)
2876 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2878 gtk_widget_set_sensitive( m_widget
, enable
);
2879 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
2880 gtk_widget_set_sensitive( m_wxwindow
, enable
);
2883 int wxWindowGTK::GetCharHeight() const
2885 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
2887 wxFont font
= GetFont();
2888 wxCHECK_MSG( font
.Ok(), 12, wxT("invalid font") );
2890 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
2895 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
2896 PangoLayout
*layout
= pango_layout_new(context
);
2897 pango_layout_set_font_description(layout
, desc
);
2898 pango_layout_set_text(layout
, "H", 1);
2899 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
2901 PangoRectangle rect
;
2902 pango_layout_line_get_extents(line
, NULL
, &rect
);
2904 g_object_unref (layout
);
2906 return (int) PANGO_PIXELS(rect
.height
);
2909 int wxWindowGTK::GetCharWidth() const
2911 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
2913 wxFont font
= GetFont();
2914 wxCHECK_MSG( font
.Ok(), 8, wxT("invalid font") );
2916 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
2921 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
2922 PangoLayout
*layout
= pango_layout_new(context
);
2923 pango_layout_set_font_description(layout
, desc
);
2924 pango_layout_set_text(layout
, "g", 1);
2925 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
2927 PangoRectangle rect
;
2928 pango_layout_line_get_extents(line
, NULL
, &rect
);
2930 g_object_unref (layout
);
2932 return (int) PANGO_PIXELS(rect
.width
);
2935 void wxWindowGTK::DoGetTextExtent( const wxString
& string
,
2939 int *externalLeading
,
2940 const wxFont
*theFont
) const
2942 wxFont fontToUse
= theFont
? *theFont
: GetFont();
2944 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
2953 PangoContext
*context
= NULL
;
2955 context
= gtk_widget_get_pango_context( m_widget
);
2964 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
2965 PangoLayout
*layout
= pango_layout_new(context
);
2966 pango_layout_set_font_description(layout
, desc
);
2968 const wxCharBuffer data
= wxGTK_CONV( string
);
2970 pango_layout_set_text(layout
, data
, strlen(data
));
2973 PangoRectangle rect
;
2974 pango_layout_get_extents(layout
, NULL
, &rect
);
2976 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
2977 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
2980 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
2981 int baseline
= pango_layout_iter_get_baseline(iter
);
2982 pango_layout_iter_free(iter
);
2983 *descent
= *y
- PANGO_PIXELS(baseline
);
2985 if (externalLeading
) (*externalLeading
) = 0; // ??
2987 g_object_unref (layout
);
2990 void wxWindowGTK::GTKDisableFocusOutEvent()
2992 g_signal_handlers_block_by_func( m_focusWidget
,
2993 (gpointer
) gtk_window_focus_out_callback
, this);
2996 void wxWindowGTK::GTKEnableFocusOutEvent()
2998 g_signal_handlers_unblock_by_func( m_focusWidget
,
2999 (gpointer
) gtk_window_focus_out_callback
, this);
3002 bool wxWindowGTK::GTKHandleFocusIn()
3004 // Disable default focus handling for custom windows since the default GTK+
3005 // handler issues a repaint
3006 const bool retval
= m_wxwindow
? true : false;
3009 // NB: if there's still unprocessed deferred focus-out event (see
3010 // GTKHandleFocusOut() for explanation), we need to process it first so
3011 // that the order of focus events -- focus-out first, then focus-in
3012 // elsewhere -- is preserved
3013 if ( gs_deferredFocusOut
)
3015 if ( GTKNeedsToFilterSameWindowFocus() &&
3016 gs_deferredFocusOut
== this )
3018 // GTK+ focus changed from this wxWindow back to itself, so don't
3019 // emit any events at all
3020 wxLogTrace(TRACE_FOCUS
,
3021 "filtered out spurious focus change within %s(%p, %s)",
3022 GetClassInfo()->GetClassName(), this, GetLabel());
3023 gs_deferredFocusOut
= NULL
;
3027 // otherwise we need to send focus-out first
3028 wxASSERT_MSG ( gs_deferredFocusOut
!= this,
3029 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
3030 GTKHandleDeferredFocusOut();
3034 wxLogTrace(TRACE_FOCUS
,
3035 "handling focus_in event for %s(%p, %s)",
3036 GetClassInfo()->GetClassName(), this, GetLabel());
3039 gtk_im_context_focus_in(m_imData
->context
);
3041 gs_currentFocus
= this;
3042 gs_pendingFocus
= NULL
;
3045 // caret needs to be informed about focus change
3046 wxCaret
*caret
= GetCaret();
3049 caret
->OnSetFocus();
3051 #endif // wxUSE_CARET
3053 // Notify the parent keeping track of focus for the kbd navigation
3054 // purposes that we got it.
3055 wxChildFocusEvent
eventChildFocus(static_cast<wxWindow
*>(this));
3056 GTKProcessEvent(eventChildFocus
);
3058 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, GetId());
3059 eventFocus
.SetEventObject(this);
3060 GTKProcessEvent(eventFocus
);
3065 bool wxWindowGTK::GTKHandleFocusOut()
3067 // Disable default focus handling for custom windows since the default GTK+
3068 // handler issues a repaint
3069 const bool retval
= m_wxwindow
? true : false;
3072 // NB: If a control is composed of several GtkWidgets and when focus
3073 // changes from one of them to another within the same wxWindow, we get
3074 // a focus-out event followed by focus-in for another GtkWidget owned
3075 // by the same wx control. We don't want to generate two spurious
3076 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3077 // from GTKHandleFocusOut() until we know for sure it's not coming back
3078 // (i.e. in GTKHandleFocusIn() or at idle time).
3079 if ( GTKNeedsToFilterSameWindowFocus() )
3081 wxASSERT_MSG( gs_deferredFocusOut
== NULL
,
3082 "deferred focus out event already pending" );
3083 wxLogTrace(TRACE_FOCUS
,
3084 "deferring focus_out event for %s(%p, %s)",
3085 GetClassInfo()->GetClassName(), this, GetLabel());
3086 gs_deferredFocusOut
= this;
3090 GTKHandleFocusOutNoDeferring();
3095 void wxWindowGTK::GTKHandleFocusOutNoDeferring()
3097 wxLogTrace(TRACE_FOCUS
,
3098 "handling focus_out event for %s(%p, %s)",
3099 GetClassInfo()->GetClassName(), this, GetLabel());
3102 gtk_im_context_focus_out(m_imData
->context
);
3104 if ( gs_currentFocus
!= this )
3106 // Something is terribly wrong, gs_currentFocus is out of sync with the
3107 // real focus. We will reset it to NULL anyway, because after this
3108 // focus-out event is handled, one of the following with happen:
3110 // * either focus will go out of the app altogether, in which case
3111 // gs_currentFocus _should_ be NULL
3113 // * or it goes to another control, in which case focus-in event will
3114 // follow immediately and it will set gs_currentFocus to the right
3116 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3117 GetClassInfo()->GetClassName(), this, GetLabel());
3119 gs_currentFocus
= NULL
;
3122 // caret needs to be informed about focus change
3123 wxCaret
*caret
= GetCaret();
3126 caret
->OnKillFocus();
3128 #endif // wxUSE_CARET
3130 wxFocusEvent
event( wxEVT_KILL_FOCUS
, GetId() );
3131 event
.SetEventObject( this );
3132 GTKProcessEvent( event
);
3136 void wxWindowGTK::GTKHandleDeferredFocusOut()
3138 // NB: See GTKHandleFocusOut() for explanation. This function is called
3139 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3141 if ( gs_deferredFocusOut
)
3143 wxWindowGTK
*win
= gs_deferredFocusOut
;
3144 gs_deferredFocusOut
= NULL
;
3146 wxLogTrace(TRACE_FOCUS
,
3147 "processing deferred focus_out event for %s(%p, %s)",
3148 win
->GetClassInfo()->GetClassName(), win
, win
->GetLabel());
3150 win
->GTKHandleFocusOutNoDeferring();
3154 void wxWindowGTK::SetFocus()
3156 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3158 // Setting "physical" focus is not immediate in GTK+ and while
3159 // gtk_widget_is_focus ("determines if the widget is the focus widget
3160 // within its toplevel", i.e. returns true for one widget per TLW, not
3161 // globally) returns true immediately after grabbing focus,
3162 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3163 // has focus at the moment) takes effect only after the window is shown
3164 // (if it was hidden at the moment of the call) or at the next event loop
3167 // Because we want to FindFocus() call immediately following
3168 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3170 gs_pendingFocus
= this;
3172 GtkWidget
*widget
= m_wxwindow
? m_wxwindow
: m_focusWidget
;
3174 if ( GTK_IS_CONTAINER(widget
) &&
3175 !gtk_widget_get_can_focus(widget
) )
3177 wxLogTrace(TRACE_FOCUS
,
3178 wxT("Setting focus to a child of %s(%p, %s)"),
3179 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3180 gtk_widget_child_focus(widget
, GTK_DIR_TAB_FORWARD
);
3184 wxLogTrace(TRACE_FOCUS
,
3185 wxT("Setting focus to %s(%p, %s)"),
3186 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3187 gtk_widget_grab_focus(widget
);
3191 void wxWindowGTK::SetCanFocus(bool canFocus
)
3193 gtk_widget_set_can_focus(m_widget
, canFocus
);
3195 if ( m_wxwindow
&& (m_widget
!= m_wxwindow
) )
3197 gtk_widget_set_can_focus(m_wxwindow
, canFocus
);
3201 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3203 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3205 wxWindowGTK
*oldParent
= m_parent
,
3206 *newParent
= (wxWindowGTK
*)newParentBase
;
3208 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3210 if ( !wxWindowBase::Reparent(newParent
) )
3213 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3216 gtk_container_remove(GTK_CONTAINER(gtk_widget_get_parent(m_widget
)), m_widget
);
3218 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3222 if (gtk_widget_get_visible (newParent
->m_widget
))
3224 m_showOnIdle
= true;
3225 gtk_widget_hide( m_widget
);
3227 /* insert GTK representation */
3228 newParent
->AddChildGTK(this);
3231 SetLayoutDirection(wxLayout_Default
);
3236 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3238 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3239 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3244 /* insert GTK representation */
3248 void wxWindowGTK::AddChild(wxWindowBase
*child
)
3250 wxWindowBase::AddChild(child
);
3251 m_dirtyTabOrder
= true;
3252 wxTheApp
->WakeUpIdle();
3255 void wxWindowGTK::RemoveChild(wxWindowBase
*child
)
3257 wxWindowBase::RemoveChild(child
);
3258 m_dirtyTabOrder
= true;
3259 wxTheApp
->WakeUpIdle();
3263 wxLayoutDirection
wxWindowGTK::GTKGetLayout(GtkWidget
*widget
)
3265 return gtk_widget_get_direction(widget
) == GTK_TEXT_DIR_RTL
3266 ? wxLayout_RightToLeft
3267 : wxLayout_LeftToRight
;
3271 void wxWindowGTK::GTKSetLayout(GtkWidget
*widget
, wxLayoutDirection dir
)
3273 wxASSERT_MSG( dir
!= wxLayout_Default
, wxT("invalid layout direction") );
3275 gtk_widget_set_direction(widget
,
3276 dir
== wxLayout_RightToLeft
? GTK_TEXT_DIR_RTL
3277 : GTK_TEXT_DIR_LTR
);
3280 wxLayoutDirection
wxWindowGTK::GetLayoutDirection() const
3282 return GTKGetLayout(m_widget
);
3285 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir
)
3287 if ( dir
== wxLayout_Default
)
3289 const wxWindow
*const parent
= GetParent();
3292 // inherit layout from parent.
3293 dir
= parent
->GetLayoutDirection();
3295 else // no parent, use global default layout
3297 dir
= wxTheApp
->GetLayoutDirection();
3301 if ( dir
== wxLayout_Default
)
3304 GTKSetLayout(m_widget
, dir
);
3306 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3307 GTKSetLayout(m_wxwindow
, dir
);
3311 wxWindowGTK::AdjustForLayoutDirection(wxCoord x
,
3312 wxCoord
WXUNUSED(width
),
3313 wxCoord
WXUNUSED(widthTotal
)) const
3315 // We now mirror the coordinates of RTL windows in wxPizza
3319 void wxWindowGTK::DoMoveInTabOrder(wxWindow
*win
, WindowOrder move
)
3321 wxWindowBase::DoMoveInTabOrder(win
, move
);
3322 m_dirtyTabOrder
= true;
3323 wxTheApp
->WakeUpIdle();
3326 bool wxWindowGTK::DoNavigateIn(int flags
)
3328 if ( flags
& wxNavigationKeyEvent::WinChange
)
3330 wxFAIL_MSG( wxT("not implemented") );
3334 else // navigate inside the container
3336 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3337 wxCHECK_MSG( parent
, false, wxT("every window must have a TLW parent") );
3339 GtkDirectionType dir
;
3340 dir
= flags
& wxNavigationKeyEvent::IsForward
? GTK_DIR_TAB_FORWARD
3341 : GTK_DIR_TAB_BACKWARD
;
3344 g_signal_emit_by_name(parent
->m_widget
, "focus", dir
, &rc
);
3350 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3352 // none needed by default
3356 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3358 // nothing to do by default since none is needed
3361 void wxWindowGTK::RealizeTabOrder()
3365 if ( !m_children
.empty() )
3367 // we don't only construct the correct focus chain but also use
3368 // this opportunity to update the mnemonic widgets for the widgets
3371 GList
*chain
= NULL
;
3372 wxWindowGTK
* mnemonicWindow
= NULL
;
3374 for ( wxWindowList::const_iterator i
= m_children
.begin();
3375 i
!= m_children
.end();
3378 wxWindowGTK
*win
= *i
;
3380 if ( mnemonicWindow
)
3382 if ( win
->AcceptsFocusFromKeyboard() )
3384 // wxComboBox et al. needs to focus on on a different
3385 // widget than m_widget, so if the main widget isn't
3386 // focusable try the connect widget
3387 GtkWidget
* w
= win
->m_widget
;
3388 if ( !gtk_widget_get_can_focus(w
) )
3390 w
= win
->GetConnectWidget();
3391 if ( !gtk_widget_get_can_focus(w
) )
3397 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3398 mnemonicWindow
= NULL
;
3402 else if ( win
->GTKWidgetNeedsMnemonic() )
3404 mnemonicWindow
= win
;
3407 chain
= g_list_prepend(chain
, win
->m_widget
);
3410 chain
= g_list_reverse(chain
);
3412 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3417 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3422 void wxWindowGTK::Raise()
3424 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3426 if (m_wxwindow
&& gtk_widget_get_window(m_wxwindow
))
3428 gdk_window_raise(gtk_widget_get_window(m_wxwindow
));
3430 else if (gtk_widget_get_window(m_widget
))
3432 gdk_window_raise(gtk_widget_get_window(m_widget
));
3436 void wxWindowGTK::Lower()
3438 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3440 if (m_wxwindow
&& gtk_widget_get_window(m_wxwindow
))
3442 gdk_window_lower(gtk_widget_get_window(m_wxwindow
));
3444 else if (gtk_widget_get_window(m_widget
))
3446 gdk_window_lower(gtk_widget_get_window(m_widget
));
3450 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3452 if ( !wxWindowBase::SetCursor(cursor
.Ok() ? cursor
: *wxSTANDARD_CURSOR
) )
3460 void wxWindowGTK::GTKUpdateCursor(bool update_self
/*=true*/, bool recurse
/*=true*/)
3464 wxCursor
cursor(g_globalCursor
.Ok() ? g_globalCursor
: GetCursor());
3467 wxArrayGdkWindows windowsThis
;
3468 GdkWindow
* window
= GTKGetWindow(windowsThis
);
3470 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3473 const size_t count
= windowsThis
.size();
3474 for ( size_t n
= 0; n
< count
; n
++ )
3476 GdkWindow
*win
= windowsThis
[n
];
3477 // It can be zero if the window has not been realized yet.
3480 gdk_window_set_cursor(win
, cursor
.GetCursor());
3489 for (wxWindowList::iterator it
= GetChildren().begin(); it
!= GetChildren().end(); ++it
)
3491 (*it
)->GTKUpdateCursor( true );
3496 void wxWindowGTK::WarpPointer( int x
, int y
)
3498 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3500 // We provide this function ourselves as it is
3501 // missing in GDK (top of this file).
3503 GdkWindow
*window
= NULL
;
3505 window
= gtk_widget_get_window(m_wxwindow
);
3507 window
= gtk_widget_get_window(GetConnectWidget());
3510 gdk_window_warp_pointer( window
, x
, y
);
3513 wxWindowGTK::ScrollDir
wxWindowGTK::ScrollDirFromRange(GtkRange
*range
) const
3515 // find the scrollbar which generated the event
3516 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3518 if ( range
== m_scrollBar
[dir
] )
3519 return (ScrollDir
)dir
;
3522 wxFAIL_MSG( wxT("event from unknown scrollbar received") );
3524 return ScrollDir_Max
;
3527 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3529 bool changed
= false;
3530 GtkRange
* range
= m_scrollBar
[dir
];
3531 if ( range
&& units
)
3533 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
3534 double inc
= unit
== ScrollUnit_Line
? gtk_adjustment_get_step_increment(adj
)
3535 : gtk_adjustment_get_page_increment(adj
);
3537 const int posOld
= wxRound(gtk_adjustment_get_value(adj
));
3538 gtk_range_set_value(range
, posOld
+ units
*inc
);
3540 changed
= wxRound(gtk_adjustment_get_value(adj
)) != posOld
;
3546 bool wxWindowGTK::ScrollLines(int lines
)
3548 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3551 bool wxWindowGTK::ScrollPages(int pages
)
3553 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3556 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground
),
3561 // it is valid to call Refresh() for a window which hasn't been created
3562 // yet, it simply doesn't do anything in this case
3569 gtk_widget_queue_draw_area( m_widget
, rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3571 gtk_widget_queue_draw( m_widget
);
3575 // Just return if the widget or one of its ancestors isn't mapped
3577 for (w
= m_wxwindow
; w
!= NULL
; w
= gtk_widget_get_parent(w
))
3578 if (!gtk_widget_get_mapped (w
))
3581 GdkWindow
* window
= GTKGetDrawingWindow();
3585 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3586 x
= GetClientSize().x
- x
- rect
->width
;
3590 r
.width
= rect
->width
;
3591 r
.height
= rect
->height
;
3592 gdk_window_invalidate_rect(window
, &r
, true);
3595 gdk_window_invalidate_rect(window
, NULL
, true);
3599 void wxWindowGTK::Update()
3601 if (m_widget
&& gtk_widget_get_mapped(m_widget
))
3603 GdkDisplay
* display
= gtk_widget_get_display(m_widget
);
3604 // Flush everything out to the server, and wait for it to finish.
3605 // This ensures nothing will overwrite the drawing we are about to do.
3606 gdk_display_sync(display
);
3608 GdkWindow
* window
= GTKGetDrawingWindow();
3610 window
= gtk_widget_get_window(m_widget
);
3611 gdk_window_process_updates(window
, true);
3613 // Flush again, but no need to wait for it to finish
3614 gdk_display_flush(display
);
3618 bool wxWindowGTK::DoIsExposed( int x
, int y
) const
3620 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
3623 bool wxWindowGTK::DoIsExposed( int x
, int y
, int w
, int h
) const
3625 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3626 return m_updateRegion
.Contains(x
-w
, y
, w
, h
) != wxOutRegion
;
3628 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
3631 void wxWindowGTK::GtkSendPaintEvents()
3635 m_updateRegion
.Clear();
3639 // Clip to paint region in wxClientDC
3640 m_clipPaintRegion
= true;
3642 m_nativeUpdateRegion
= m_updateRegion
;
3644 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3646 // Transform m_updateRegion under RTL
3647 m_updateRegion
.Clear();
3650 gdk_drawable_get_size(gtk_widget_get_window(m_wxwindow
), &width
, NULL
);
3652 wxRegionIterator
upd( m_nativeUpdateRegion
);
3656 rect
.x
= upd
.GetX();
3657 rect
.y
= upd
.GetY();
3658 rect
.width
= upd
.GetWidth();
3659 rect
.height
= upd
.GetHeight();
3661 rect
.x
= width
- rect
.x
- rect
.width
;
3662 m_updateRegion
.Union( rect
);
3668 switch ( GetBackgroundStyle() )
3670 case wxBG_STYLE_ERASE
:
3672 wxWindowDC
dc( (wxWindow
*)this );
3673 dc
.SetDeviceClippingRegion( m_updateRegion
);
3675 // Work around gtk-qt <= 0.60 bug whereby the window colour
3679 GetOptionInt("gtk.window.force-background-colour") )
3681 dc
.SetBackground(GetBackgroundColour());
3685 wxEraseEvent
erase_event( GetId(), &dc
);
3686 erase_event
.SetEventObject( this );
3688 if ( HandleWindowEvent(erase_event
) )
3690 // background erased, don't do it again
3696 case wxBG_STYLE_SYSTEM
:
3697 if ( GetThemeEnabled() )
3699 // find ancestor from which to steal background
3700 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3702 parent
= (wxWindow
*)this;
3704 if (gtk_widget_get_mapped(parent
->m_widget
))
3706 wxRegionIterator
upd( m_nativeUpdateRegion
);
3710 rect
.x
= upd
.GetX();
3711 rect
.y
= upd
.GetY();
3712 rect
.width
= upd
.GetWidth();
3713 rect
.height
= upd
.GetHeight();
3715 gtk_paint_flat_box(gtk_widget_get_style(parent
->m_widget
),
3716 GTKGetDrawingWindow(),
3717 gtk_widget_get_state(m_wxwindow
),
3730 case wxBG_STYLE_PAINT
:
3731 // nothing to do: window will be painted over in EVT_PAINT
3735 wxFAIL_MSG( "unsupported background style" );
3738 wxNcPaintEvent
nc_paint_event( GetId() );
3739 nc_paint_event
.SetEventObject( this );
3740 HandleWindowEvent( nc_paint_event
);
3742 wxPaintEvent
paint_event( GetId() );
3743 paint_event
.SetEventObject( this );
3744 HandleWindowEvent( paint_event
);
3746 m_clipPaintRegion
= false;
3748 m_updateRegion
.Clear();
3749 m_nativeUpdateRegion
.Clear();
3752 void wxWindowGTK::SetDoubleBuffered( bool on
)
3754 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3757 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3760 bool wxWindowGTK::IsDoubleBuffered() const
3762 return gtk_widget_get_double_buffered( m_wxwindow
);
3765 void wxWindowGTK::ClearBackground()
3767 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3771 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3773 if (m_tooltip
!= tip
)
3775 wxWindowBase::DoSetToolTip(tip
);
3778 m_tooltip
->GTKSetWindow(static_cast<wxWindow
*>(this));
3780 GTKApplyToolTip(NULL
);
3784 void wxWindowGTK::GTKApplyToolTip(const char* tip
)
3786 wxToolTip::GTKApply(GetConnectWidget(), tip
);
3788 #endif // wxUSE_TOOLTIPS
3790 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
3792 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3794 if (!wxWindowBase::SetBackgroundColour(colour
))
3799 // We need the pixel value e.g. for background clearing.
3800 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3803 // apply style change (forceStyle=true so that new style is applied
3804 // even if the bg colour changed from valid to wxNullColour)
3805 GTKApplyWidgetStyle(true);
3810 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
3812 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3814 if (!wxWindowBase::SetForegroundColour(colour
))
3821 // We need the pixel value e.g. for background clearing.
3822 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3825 // apply style change (forceStyle=true so that new style is applied
3826 // even if the bg colour changed from valid to wxNullColour):
3827 GTKApplyWidgetStyle(true);
3832 PangoContext
*wxWindowGTK::GTKGetPangoDefaultContext()
3834 return gtk_widget_get_pango_context( m_widget
);
3837 GtkRcStyle
*wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle
)
3839 // do we need to apply any changes at all?
3842 !m_foregroundColour
.Ok() && !m_backgroundColour
.Ok() )
3847 GtkRcStyle
*style
= gtk_rc_style_new();
3852 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
3855 int flagsNormal
= 0,
3858 flagsInsensitive
= 0;
3860 if ( m_foregroundColour
.Ok() )
3862 const GdkColor
*fg
= m_foregroundColour
.GetColor();
3864 style
->fg
[GTK_STATE_NORMAL
] =
3865 style
->text
[GTK_STATE_NORMAL
] = *fg
;
3866 flagsNormal
|= GTK_RC_FG
| GTK_RC_TEXT
;
3868 style
->fg
[GTK_STATE_PRELIGHT
] =
3869 style
->text
[GTK_STATE_PRELIGHT
] = *fg
;
3870 flagsPrelight
|= GTK_RC_FG
| GTK_RC_TEXT
;
3872 style
->fg
[GTK_STATE_ACTIVE
] =
3873 style
->text
[GTK_STATE_ACTIVE
] = *fg
;
3874 flagsActive
|= GTK_RC_FG
| GTK_RC_TEXT
;
3877 if ( m_backgroundColour
.Ok() )
3879 const GdkColor
*bg
= m_backgroundColour
.GetColor();
3881 style
->bg
[GTK_STATE_NORMAL
] =
3882 style
->base
[GTK_STATE_NORMAL
] = *bg
;
3883 flagsNormal
|= GTK_RC_BG
| GTK_RC_BASE
;
3885 style
->bg
[GTK_STATE_PRELIGHT
] =
3886 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
3887 flagsPrelight
|= GTK_RC_BG
| GTK_RC_BASE
;
3889 style
->bg
[GTK_STATE_ACTIVE
] =
3890 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
3891 flagsActive
|= GTK_RC_BG
| GTK_RC_BASE
;
3893 style
->bg
[GTK_STATE_INSENSITIVE
] =
3894 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
3895 flagsInsensitive
|= GTK_RC_BG
| GTK_RC_BASE
;
3898 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)flagsNormal
;
3899 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)flagsPrelight
;
3900 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)flagsActive
;
3901 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)flagsInsensitive
;
3906 void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle
)
3908 GtkRcStyle
*style
= GTKCreateWidgetStyle(forceStyle
);
3911 DoApplyWidgetStyle(style
);
3912 g_object_unref(style
);
3915 // Style change may affect GTK+'s size calculation:
3916 InvalidateBestSize();
3919 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
3923 // block the signal temporarily to avoid sending
3924 // wxSysColourChangedEvents when we change the colours ourselves
3925 bool unblock
= false;
3929 g_signal_handlers_block_by_func(
3930 m_wxwindow
, (void *)gtk_window_style_set_callback
, this);
3933 gtk_widget_modify_style(m_wxwindow
, style
);
3937 g_signal_handlers_unblock_by_func(
3938 m_wxwindow
, (void *)gtk_window_style_set_callback
, this);
3943 gtk_widget_modify_style(m_widget
, style
);
3947 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style
)
3949 wxWindowBase::SetBackgroundStyle(style
);
3951 if ( style
== wxBG_STYLE_PAINT
)
3956 window
= GTKGetDrawingWindow();
3960 GtkWidget
* const w
= GetConnectWidget();
3961 window
= w
? gtk_widget_get_window(w
) : NULL
;
3966 // Make sure GDK/X11 doesn't refresh the window
3968 gdk_window_set_back_pixmap( window
, None
, False
);
3970 Display
* display
= GDK_WINDOW_DISPLAY(window
);
3973 m_needsStyleChange
= false;
3975 else // window not realized yet
3977 // Do in OnIdle, because the window is not yet available
3978 m_needsStyleChange
= true;
3981 // Don't apply widget style, or we get a grey background
3985 // apply style change (forceStyle=true so that new style is applied
3986 // even if the bg colour changed from valid to wxNullColour):
3987 GTKApplyWidgetStyle(true);
3993 // ----------------------------------------------------------------------------
3994 // Pop-up menu stuff
3995 // ----------------------------------------------------------------------------
3997 #if wxUSE_MENUS_NATIVE
4001 void wxPopupMenuPositionCallback( GtkMenu
*menu
,
4003 gboolean
* WXUNUSED(whatever
),
4004 gpointer user_data
)
4006 // ensure that the menu appears entirely on screen
4008 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
4010 wxSize sizeScreen
= wxGetDisplaySize();
4011 wxPoint
*pos
= (wxPoint
*)user_data
;
4013 gint xmax
= sizeScreen
.x
- req
.width
,
4014 ymax
= sizeScreen
.y
- req
.height
;
4016 *x
= pos
->x
< xmax
? pos
->x
: xmax
;
4017 *y
= pos
->y
< ymax
? pos
->y
: ymax
;
4021 bool wxWindowGTK::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
4023 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4029 GtkMenuPositionFunc posfunc
;
4030 if ( x
== -1 && y
== -1 )
4032 // use GTK's default positioning algorithm
4038 pos
= ClientToScreen(wxPoint(x
, y
));
4040 posfunc
= wxPopupMenuPositionCallback
;
4043 menu
->m_popupShown
= true;
4045 GTK_MENU(menu
->m_menu
),
4046 NULL
, // parent menu shell
4047 NULL
, // parent menu item
4048 posfunc
, // function to position it
4049 userdata
, // client data
4050 0, // button used to activate it
4051 gtk_get_current_event_time()
4054 while (menu
->m_popupShown
)
4056 gtk_main_iteration();
4062 #endif // wxUSE_MENUS_NATIVE
4064 #if wxUSE_DRAG_AND_DROP
4066 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4068 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4070 GtkWidget
*dnd_widget
= GetConnectWidget();
4072 if (m_dropTarget
) m_dropTarget
->GtkUnregisterWidget( dnd_widget
);
4074 if (m_dropTarget
) delete m_dropTarget
;
4075 m_dropTarget
= dropTarget
;
4077 if (m_dropTarget
) m_dropTarget
->GtkRegisterWidget( dnd_widget
);
4080 #endif // wxUSE_DRAG_AND_DROP
4082 GtkWidget
* wxWindowGTK::GetConnectWidget()
4084 GtkWidget
*connect_widget
= m_widget
;
4085 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4087 return connect_widget
;
4090 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow
*window
) const
4092 wxArrayGdkWindows windowsThis
;
4093 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
4095 return winThis
? window
== winThis
4096 : windowsThis
.Index(window
) != wxNOT_FOUND
;
4099 GdkWindow
*wxWindowGTK::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
4101 return m_wxwindow
? GTKGetDrawingWindow() : gtk_widget_get_window(m_widget
);
4104 bool wxWindowGTK::SetFont( const wxFont
&font
)
4106 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4108 if (!wxWindowBase::SetFont(font
))
4111 // apply style change (forceStyle=true so that new style is applied
4112 // even if the font changed from valid to wxNullFont):
4113 GTKApplyWidgetStyle(true);
4118 void wxWindowGTK::DoCaptureMouse()
4120 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4122 GdkWindow
*window
= NULL
;
4124 window
= GTKGetDrawingWindow();
4126 window
= gtk_widget_get_window(GetConnectWidget());
4128 wxCHECK_RET( window
, wxT("CaptureMouse() failed") );
4130 const wxCursor
* cursor
= &m_cursor
;
4132 cursor
= wxSTANDARD_CURSOR
;
4134 gdk_pointer_grab( window
, FALSE
,
4136 (GDK_BUTTON_PRESS_MASK
|
4137 GDK_BUTTON_RELEASE_MASK
|
4138 GDK_POINTER_MOTION_HINT_MASK
|
4139 GDK_POINTER_MOTION_MASK
),
4141 cursor
->GetCursor(),
4142 (guint32
)GDK_CURRENT_TIME
);
4143 g_captureWindow
= this;
4144 g_captureWindowHasMouse
= true;
4147 void wxWindowGTK::DoReleaseMouse()
4149 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4151 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4153 g_captureWindow
= NULL
;
4155 GdkWindow
*window
= NULL
;
4157 window
= GTKGetDrawingWindow();
4159 window
= gtk_widget_get_window(GetConnectWidget());
4164 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4167 void wxWindowGTK::GTKReleaseMouseAndNotify()
4170 wxMouseCaptureLostEvent
evt(GetId());
4171 evt
.SetEventObject( this );
4172 HandleWindowEvent( evt
);
4176 wxWindow
*wxWindowBase::GetCapture()
4178 return (wxWindow
*)g_captureWindow
;
4181 bool wxWindowGTK::IsRetained() const
4186 void wxWindowGTK::SetScrollbar(int orient
,
4190 bool WXUNUSED(update
))
4192 const int dir
= ScrollDirFromOrient(orient
);
4193 GtkRange
* const sb
= m_scrollBar
[dir
];
4194 wxCHECK_RET( sb
, wxT("this window is not scrollable") );
4198 // GtkRange requires upper > lower
4203 g_signal_handlers_block_by_func(
4204 sb
, (void*)gtk_scrollbar_value_changed
, this);
4206 gtk_range_set_increments(sb
, 1, thumbVisible
);
4207 gtk_adjustment_set_page_size(gtk_range_get_adjustment(sb
), thumbVisible
);
4208 gtk_range_set_range(sb
, 0, range
);
4209 gtk_range_set_value(sb
, pos
);
4210 m_scrollPos
[dir
] = gtk_range_get_value(sb
);
4212 g_signal_handlers_unblock_by_func(
4213 sb
, (void*)gtk_scrollbar_value_changed
, this);
4216 void wxWindowGTK::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4218 const int dir
= ScrollDirFromOrient(orient
);
4219 GtkRange
* const sb
= m_scrollBar
[dir
];
4220 wxCHECK_RET( sb
, wxT("this window is not scrollable") );
4222 // This check is more than an optimization. Without it, the slider
4223 // will not move smoothly while tracking when using wxScrollHelper.
4224 if (GetScrollPos(orient
) != pos
)
4226 g_signal_handlers_block_by_func(
4227 sb
, (void*)gtk_scrollbar_value_changed
, this);
4229 gtk_range_set_value(sb
, pos
);
4230 m_scrollPos
[dir
] = gtk_range_get_value(sb
);
4232 g_signal_handlers_unblock_by_func(
4233 sb
, (void*)gtk_scrollbar_value_changed
, this);
4237 int wxWindowGTK::GetScrollThumb(int orient
) const
4239 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4240 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4242 return wxRound(gtk_adjustment_get_page_size(gtk_range_get_adjustment(sb
)));
4245 int wxWindowGTK::GetScrollPos( int orient
) const
4247 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4248 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4250 return wxRound(gtk_range_get_value(sb
));
4253 int wxWindowGTK::GetScrollRange( int orient
) const
4255 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4256 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4258 return wxRound(gtk_adjustment_get_upper(gtk_range_get_adjustment(sb
)));
4261 // Determine if increment is the same as +/-x, allowing for some small
4262 // difference due to possible inexactness in floating point arithmetic
4263 static inline bool IsScrollIncrement(double increment
, double x
)
4265 wxASSERT(increment
> 0);
4266 const double tolerance
= 1.0 / 1024;
4267 return fabs(increment
- fabs(x
)) < tolerance
;
4270 wxEventType
wxWindowGTK::GTKGetScrollEventType(GtkRange
* range
)
4272 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4274 const int barIndex
= range
== m_scrollBar
[1];
4276 const double value
= gtk_range_get_value(range
);
4278 // save previous position
4279 const double oldPos
= m_scrollPos
[barIndex
];
4280 // update current position
4281 m_scrollPos
[barIndex
] = value
;
4282 // If event should be ignored, or integral position has not changed
4283 if (!m_hasVMT
|| g_blockEventsOnDrag
|| wxRound(value
) == wxRound(oldPos
))
4288 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4291 // Difference from last change event
4292 const double diff
= value
- oldPos
;
4293 const bool isDown
= diff
> 0;
4295 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
4296 if (IsScrollIncrement(gtk_adjustment_get_step_increment(adj
), diff
))
4298 eventType
= isDown
? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4300 else if (IsScrollIncrement(gtk_adjustment_get_page_increment(adj
), diff
))
4302 eventType
= isDown
? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4304 else if (m_mouseButtonDown
)
4306 // Assume track event
4307 m_isScrolling
= true;
4313 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4315 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4317 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4319 // No scrolling requested.
4320 if ((dx
== 0) && (dy
== 0)) return;
4322 m_clipPaintRegion
= true;
4324 WX_PIZZA(m_wxwindow
)->scroll(dx
, dy
);
4326 m_clipPaintRegion
= false;
4329 bool restoreCaret
= (GetCaret() != NULL
&& GetCaret()->IsVisible());
4332 wxRect
caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4334 caretRect
.width
+= dx
;
4337 caretRect
.x
+= dx
; caretRect
.width
-= dx
;
4340 caretRect
.height
+= dy
;
4343 caretRect
.y
+= dy
; caretRect
.height
-= dy
;
4346 RefreshRect(caretRect
);
4348 #endif // wxUSE_CARET
4351 void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4353 //RN: Note that static controls usually have no border on gtk, so maybe
4354 //it makes sense to treat that as simply no border at the wx level
4356 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4358 GtkShadowType gtkstyle
;
4360 if(wxstyle
& wxBORDER_RAISED
)
4361 gtkstyle
= GTK_SHADOW_OUT
;
4362 else if ((wxstyle
& wxBORDER_SUNKEN
) || (wxstyle
& wxBORDER_THEME
))
4363 gtkstyle
= GTK_SHADOW_IN
;
4366 else if (wxstyle
& wxBORDER_DOUBLE
)
4367 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4370 gtkstyle
= GTK_SHADOW_IN
;
4372 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4377 void wxWindowGTK::SetWindowStyleFlag( long style
)
4379 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4380 wxWindowBase::SetWindowStyleFlag(style
);
4383 // Find the wxWindow at the current mouse position, also returning the mouse
4385 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4387 pt
= wxGetMousePosition();
4388 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4392 // Get the current mouse position.
4393 wxPoint
wxGetMousePosition()
4395 /* This crashes when used within wxHelpContext,
4396 so we have to use the X-specific implementation below.
4398 GdkModifierType *mask;
4399 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4401 return wxPoint(x, y);
4405 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4407 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4408 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4409 Window rootReturn
, childReturn
;
4410 int rootX
, rootY
, winX
, winY
;
4411 unsigned int maskReturn
;
4413 XQueryPointer (display
,
4417 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4418 return wxPoint(rootX
, rootY
);
4422 GdkWindow
* wxWindowGTK::GTKGetDrawingWindow() const
4424 GdkWindow
* window
= NULL
;
4426 window
= gtk_widget_get_window(m_wxwindow
);
4430 // ----------------------------------------------------------------------------
4432 // ----------------------------------------------------------------------------
4437 // this is called if we attempted to freeze unrealized widget when it finally
4438 // is realized (and so can be frozen):
4439 static void wx_frozen_widget_realize(GtkWidget
* w
, wxWindowGTK
* win
)
4441 wxASSERT( w
&& gtk_widget_get_has_window(w
) );
4442 wxASSERT( gtk_widget_get_realized(w
) );
4444 g_signal_handlers_disconnect_by_func
4447 (void*)wx_frozen_widget_realize
,
4452 if (w
== win
->m_wxwindow
)
4453 window
= win
->GTKGetDrawingWindow();
4455 window
= gtk_widget_get_window(w
);
4456 gdk_window_freeze_updates(window
);
4461 void wxWindowGTK::GTKFreezeWidget(GtkWidget
*w
)
4463 if ( !w
|| !gtk_widget_get_has_window(w
) )
4464 return; // window-less widget, cannot be frozen
4466 GdkWindow
* window
= gtk_widget_get_window(w
);
4469 // we can't thaw unrealized widgets because they don't have GdkWindow,
4470 // so set it up to be done immediately after realization:
4471 g_signal_connect_after
4475 G_CALLBACK(wx_frozen_widget_realize
),
4481 if (w
== m_wxwindow
)
4482 window
= GTKGetDrawingWindow();
4483 gdk_window_freeze_updates(window
);
4486 void wxWindowGTK::GTKThawWidget(GtkWidget
*w
)
4488 if ( !w
|| !gtk_widget_get_has_window(w
) )
4489 return; // window-less widget, cannot be frozen
4491 GdkWindow
* window
= gtk_widget_get_window(w
);
4494 // the widget wasn't realized yet, no need to thaw
4495 g_signal_handlers_disconnect_by_func
4498 (void*)wx_frozen_widget_realize
,
4504 if (w
== m_wxwindow
)
4505 window
= GTKGetDrawingWindow();
4506 gdk_window_thaw_updates(window
);
4509 void wxWindowGTK::DoFreeze()
4511 GTKFreezeWidget(m_widget
);
4512 if ( m_wxwindow
&& m_widget
!= m_wxwindow
)
4513 GTKFreezeWidget(m_wxwindow
);
4516 void wxWindowGTK::DoThaw()
4518 GTKThawWidget(m_widget
);
4519 if ( m_wxwindow
&& m_widget
!= m_wxwindow
)
4520 GTKThawWidget(m_wxwindow
);