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
346 // clip rect is required to avoid painting background
347 // over upper left (w,h) of parent window
348 GdkRectangle clipRect
= { x
, y
, w
, h
};
350 gtk_widget_get_style(win
->m_wxwindow
), gdk_event
->window
, GTK_STATE_NORMAL
,
351 shadow
, &clipRect
, wxGTKPrivate::GetEntryWidget(), detail
, x
, y
, w
, h
);
357 //-----------------------------------------------------------------------------
358 // "parent_set" from m_wxwindow
359 //-----------------------------------------------------------------------------
363 parent_set(GtkWidget
* widget
, GtkObject
* old_parent
, wxWindow
* win
)
367 g_signal_handlers_disconnect_by_func(
368 old_parent
, (void*)expose_event_border
, win
);
370 GtkWidget
* parent
= gtk_widget_get_parent(widget
);
373 g_signal_connect_after(parent
, "expose_event",
374 G_CALLBACK(expose_event_border
), win
);
378 #endif // !__WXUNIVERSAL__
380 //-----------------------------------------------------------------------------
381 // "key_press_event" from any window
382 //-----------------------------------------------------------------------------
384 // These are used when transforming Ctrl-alpha to ascii values 1-26
385 inline bool wxIsLowerChar(int code
)
387 return (code
>= 'a' && code
<= 'z' );
390 inline bool wxIsUpperChar(int code
)
392 return (code
>= 'A' && code
<= 'Z' );
396 // set WXTRACE to this to see the key event codes on the console
397 #define TRACE_KEYS wxT("keyevent")
399 // translates an X key symbol to WXK_XXX value
401 // if isChar is true it means that the value returned will be used for EVT_CHAR
402 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
403 // for example, while if it is false it means that the value is going to be
404 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
406 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
412 // Shift, Control and Alt don't generate the CHAR events at all
415 key_code
= isChar
? 0 : WXK_SHIFT
;
419 key_code
= isChar
? 0 : WXK_CONTROL
;
427 key_code
= isChar
? 0 : WXK_ALT
;
430 // neither do the toggle modifies
431 case GDK_Scroll_Lock
:
432 key_code
= isChar
? 0 : WXK_SCROLL
;
436 key_code
= isChar
? 0 : WXK_CAPITAL
;
440 key_code
= isChar
? 0 : WXK_NUMLOCK
;
444 // various other special keys
457 case GDK_ISO_Left_Tab
:
464 key_code
= WXK_RETURN
;
468 key_code
= WXK_CLEAR
;
472 key_code
= WXK_PAUSE
;
476 key_code
= WXK_SELECT
;
480 key_code
= WXK_PRINT
;
484 key_code
= WXK_EXECUTE
;
488 key_code
= WXK_ESCAPE
;
491 // cursor and other extended keyboard keys
493 key_code
= WXK_DELETE
;
509 key_code
= WXK_RIGHT
;
516 case GDK_Prior
: // == GDK_Page_Up
517 key_code
= WXK_PAGEUP
;
520 case GDK_Next
: // == GDK_Page_Down
521 key_code
= WXK_PAGEDOWN
;
533 key_code
= WXK_INSERT
;
548 key_code
= (isChar
? '0' : int(WXK_NUMPAD0
)) + keysym
- GDK_KP_0
;
552 key_code
= isChar
? ' ' : int(WXK_NUMPAD_SPACE
);
556 key_code
= isChar
? WXK_TAB
: WXK_NUMPAD_TAB
;
560 key_code
= isChar
? WXK_RETURN
: WXK_NUMPAD_ENTER
;
564 key_code
= isChar
? WXK_F1
: WXK_NUMPAD_F1
;
568 key_code
= isChar
? WXK_F2
: WXK_NUMPAD_F2
;
572 key_code
= isChar
? WXK_F3
: WXK_NUMPAD_F3
;
576 key_code
= isChar
? WXK_F4
: WXK_NUMPAD_F4
;
580 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_HOME
;
584 key_code
= isChar
? WXK_LEFT
: WXK_NUMPAD_LEFT
;
588 key_code
= isChar
? WXK_UP
: WXK_NUMPAD_UP
;
592 key_code
= isChar
? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
596 key_code
= isChar
? WXK_DOWN
: WXK_NUMPAD_DOWN
;
599 case GDK_KP_Prior
: // == GDK_KP_Page_Up
600 key_code
= isChar
? WXK_PAGEUP
: WXK_NUMPAD_PAGEUP
;
603 case GDK_KP_Next
: // == GDK_KP_Page_Down
604 key_code
= isChar
? WXK_PAGEDOWN
: WXK_NUMPAD_PAGEDOWN
;
608 key_code
= isChar
? WXK_END
: WXK_NUMPAD_END
;
612 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_BEGIN
;
616 key_code
= isChar
? WXK_INSERT
: WXK_NUMPAD_INSERT
;
620 key_code
= isChar
? WXK_DELETE
: WXK_NUMPAD_DELETE
;
624 key_code
= isChar
? '=' : int(WXK_NUMPAD_EQUAL
);
627 case GDK_KP_Multiply
:
628 key_code
= isChar
? '*' : int(WXK_NUMPAD_MULTIPLY
);
632 key_code
= isChar
? '+' : int(WXK_NUMPAD_ADD
);
635 case GDK_KP_Separator
:
636 // FIXME: what is this?
637 key_code
= isChar
? '.' : int(WXK_NUMPAD_SEPARATOR
);
640 case GDK_KP_Subtract
:
641 key_code
= isChar
? '-' : int(WXK_NUMPAD_SUBTRACT
);
645 key_code
= isChar
? '.' : int(WXK_NUMPAD_DECIMAL
);
649 key_code
= isChar
? '/' : int(WXK_NUMPAD_DIVIDE
);
666 key_code
= WXK_F1
+ keysym
- GDK_F1
;
676 static inline bool wxIsAsciiKeysym(KeySym ks
)
681 static void wxFillOtherKeyEventFields(wxKeyEvent
& event
,
683 GdkEventKey
*gdk_event
)
687 GdkModifierType state
;
688 if (gdk_event
->window
)
689 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
691 event
.SetTimestamp( gdk_event
->time
);
692 event
.SetId(win
->GetId());
694 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
695 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
696 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
697 event
.m_metaDown
= (gdk_event
->state
& GDK_META_MASK
) != 0;
699 // Normally we take the state of modifiers directly from the low level GDK
700 // event but unfortunately GDK uses a different convention from MSW for the
701 // key events corresponding to the modifier keys themselves: in it, when
702 // e.g. Shift key is pressed, GDK_SHIFT_MASK is not set while it is set
703 // when Shift is released. Under MSW the situation is exactly reversed and
704 // the modifier corresponding to the key is set when it is pressed and
705 // unset when it is released. To ensure consistent behaviour between
706 // platforms (and because it seems to make slightly more sense, although
707 // arguably both behaviours are reasonable) we follow MSW here.
709 // Final notice: we set the flags to the desired value instead of just
710 // inverting them because they are not set correctly (i.e. in the same way
711 // as for the real events generated by the user) for wxUIActionSimulator-
712 // produced events and it seems better to keep that class code the same
713 // among all platforms and fix the discrepancy here instead of adding
714 // wxGTK-specific code to wxUIActionSimulator.
715 const bool isPress
= gdk_event
->type
== GDK_KEY_PRESS
;
716 switch ( gdk_event
->keyval
)
720 event
.m_shiftDown
= isPress
;
725 event
.m_controlDown
= isPress
;
730 event
.m_altDown
= isPress
;
737 event
.m_metaDown
= isPress
;
741 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
742 event
.m_rawFlags
= gdk_event
->hardware_keycode
;
744 wxGetMousePosition( &x
, &y
);
745 win
->ScreenToClient( &x
, &y
);
748 event
.SetEventObject( win
);
753 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
755 GdkEventKey
*gdk_event
)
757 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
758 // but only event->keyval which is quite useless to us, so remember
759 // the last character from GDK_KEY_PRESS and reuse it as last resort
761 // NB: should be MT-safe as we're always called from the main thread only
766 } s_lastKeyPress
= { 0, 0 };
768 KeySym keysym
= gdk_event
->keyval
;
770 wxLogTrace(TRACE_KEYS
, wxT("Key %s event: keysym = %ld"),
771 event
.GetEventType() == wxEVT_KEY_UP
? wxT("release")
775 long key_code
= wxTranslateKeySymToWXKey(keysym
, false /* !isChar */);
779 // do we have the translation or is it a plain ASCII character?
780 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
782 // we should use keysym if it is ASCII as X does some translations
783 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
784 // which we don't want here (but which we do use for OnChar())
785 if ( !wxIsAsciiKeysym(keysym
) )
787 keysym
= (KeySym
)gdk_event
->string
[0];
790 // we want to always get the same key code when the same key is
791 // pressed regardless of the state of the modifiers, i.e. on a
792 // standard US keyboard pressing '5' or '%' ('5' key with
793 // Shift) should result in the same key code in OnKeyDown():
794 // '5' (although OnChar() will get either '5' or '%').
796 // to do it we first translate keysym to keycode (== scan code)
797 // and then back but always using the lower register
798 Display
*dpy
= (Display
*)wxGetDisplay();
799 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
801 wxLogTrace(TRACE_KEYS
, wxT("\t-> keycode %d"), keycode
);
803 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
805 // use the normalized, i.e. lower register, keysym if we've
807 key_code
= keysymNormalized
? keysymNormalized
: keysym
;
809 // as explained above, we want to have lower register key codes
810 // normally but for the letter keys we want to have the upper ones
812 // NB: don't use XConvertCase() here, we want to do it for letters
814 key_code
= toupper(key_code
);
816 else // non ASCII key, what to do?
818 // by default, ignore it
821 // but if we have cached information from the last KEY_PRESS
822 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
825 if ( keysym
== s_lastKeyPress
.keysym
)
827 key_code
= s_lastKeyPress
.keycode
;
832 if ( gdk_event
->type
== GDK_KEY_PRESS
)
834 // remember it to be reused for KEY_UP event later
835 s_lastKeyPress
.keysym
= keysym
;
836 s_lastKeyPress
.keycode
= key_code
;
840 wxLogTrace(TRACE_KEYS
, wxT("\t-> wxKeyCode %ld"), key_code
);
842 // sending unknown key events doesn't really make sense
846 event
.m_keyCode
= key_code
;
849 event
.m_uniChar
= gdk_keyval_to_unicode(key_code
? key_code
: keysym
);
850 if ( !event
.m_uniChar
&& event
.m_keyCode
<= WXK_DELETE
)
852 // Set Unicode key code to the ASCII equivalent for compatibility. E.g.
853 // let RETURN generate the key event with both key and Unicode key
855 event
.m_uniChar
= event
.m_keyCode
;
857 #endif // wxUSE_UNICODE
859 // now fill all the other fields
860 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
868 GtkIMContext
*context
;
869 GdkEventKey
*lastKeyEvent
;
873 context
= gtk_im_multicontext_new();
878 g_object_unref (context
);
885 // Send wxEVT_CHAR_HOOK event to the parent of the window and if it wasn't
886 // processed, send wxEVT_CHAR to the window itself. Return true if either of
889 SendCharHookAndCharEvents(const wxKeyEvent
& event
, wxWindow
*win
)
891 // wxEVT_CHAR_HOOK must be sent to the top level parent window to allow it
892 // to handle key events in all of its children unless the mouse is captured
893 // in which case we consider that the keyboard should be "captured" too.
894 if ( !g_captureWindow
)
896 wxWindow
* const parent
= wxGetTopLevelParent(win
);
899 // We need to make a copy of the event object because it is
900 // modified while it's handled, notably its WasProcessed() flag
901 // is set after it had been processed once.
902 wxKeyEvent
eventCharHook(event
);
903 eventCharHook
.SetEventType(wxEVT_CHAR_HOOK
);
904 if ( parent
->HandleWindowEvent(eventCharHook
) )
909 // As above, make a copy of the event first.
910 wxKeyEvent
eventChar(event
);
911 eventChar
.SetEventType(wxEVT_CHAR
);
912 return win
->HandleWindowEvent(eventChar
);
915 } // anonymous namespace
919 gtk_window_key_press_callback( GtkWidget
*WXUNUSED(widget
),
920 GdkEventKey
*gdk_event
,
925 if (g_blockEventsOnDrag
)
928 wxKeyEvent
event( wxEVT_KEY_DOWN
);
930 bool return_after_IM
= false;
932 if( wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
934 // Emit KEY_DOWN event
935 ret
= win
->HandleWindowEvent( event
);
939 // Return after IM processing as we cannot do
940 // anything with it anyhow.
941 return_after_IM
= true;
944 if (!ret
&& win
->m_imData
)
946 win
->m_imData
->lastKeyEvent
= gdk_event
;
948 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
949 // docs, if IM filter returns true, no further processing should be done.
950 // we should send the key_down event anyway.
951 bool intercepted_by_IM
= gtk_im_context_filter_keypress(win
->m_imData
->context
, gdk_event
);
952 win
->m_imData
->lastKeyEvent
= NULL
;
953 if (intercepted_by_IM
)
955 wxLogTrace(TRACE_KEYS
, wxT("Key event intercepted by IM"));
966 wxWindowGTK
*ancestor
= win
;
969 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
972 wxCommandEvent
menu_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
973 ret
= ancestor
->HandleWindowEvent( menu_event
);
977 // if the accelerator wasn't handled as menu event, try
978 // it as button click (for compatibility with other
980 wxCommandEvent
button_event( wxEVT_COMMAND_BUTTON_CLICKED
, command
);
981 ret
= ancestor
->HandleWindowEvent( button_event
);
986 if (ancestor
->IsTopLevel())
988 ancestor
= ancestor
->GetParent();
991 #endif // wxUSE_ACCEL
993 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
994 // will only be sent if it is not in an accelerator table.
998 KeySym keysym
= gdk_event
->keyval
;
999 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1000 key_code
= wxTranslateKeySymToWXKey(keysym
, true /* isChar */);
1003 if ( wxIsAsciiKeysym(keysym
) )
1006 key_code
= (unsigned char)keysym
;
1008 // gdk_event->string is actually deprecated
1009 else if ( gdk_event
->length
== 1 )
1011 key_code
= (unsigned char)gdk_event
->string
[0];
1017 wxLogTrace(TRACE_KEYS
, wxT("Char event: %ld"), key_code
);
1019 event
.m_keyCode
= key_code
;
1021 // To conform to the docs we need to translate Ctrl-alpha
1022 // characters to values in the range 1-26.
1023 if ( event
.ControlDown() &&
1024 ( wxIsLowerChar(key_code
) || wxIsUpperChar(key_code
) ))
1026 if ( wxIsLowerChar(key_code
) )
1027 event
.m_keyCode
= key_code
- 'a' + 1;
1028 if ( wxIsUpperChar(key_code
) )
1029 event
.m_keyCode
= key_code
- 'A' + 1;
1031 event
.m_uniChar
= event
.m_keyCode
;
1035 ret
= SendCharHookAndCharEvents(event
, win
);
1045 gtk_wxwindow_commit_cb (GtkIMContext
* WXUNUSED(context
),
1049 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1051 // take modifiers, cursor position, timestamp etc. from the last
1052 // key_press_event that was fed into Input Method:
1053 if (window
->m_imData
->lastKeyEvent
)
1055 wxFillOtherKeyEventFields(event
,
1056 window
, window
->m_imData
->lastKeyEvent
);
1060 event
.SetEventObject( window
);
1063 const wxString
data(wxGTK_CONV_BACK_SYS(str
));
1067 for( wxString::const_iterator pstr
= data
.begin(); pstr
!= data
.end(); ++pstr
)
1070 event
.m_uniChar
= *pstr
;
1071 // Backward compatible for ISO-8859-1
1072 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
1073 wxLogTrace(TRACE_KEYS
, wxT("IM sent character '%c'"), event
.m_uniChar
);
1075 event
.m_keyCode
= (char)*pstr
;
1076 #endif // wxUSE_UNICODE
1078 // To conform to the docs we need to translate Ctrl-alpha
1079 // characters to values in the range 1-26.
1080 if ( event
.ControlDown() &&
1081 ( wxIsLowerChar(*pstr
) || wxIsUpperChar(*pstr
) ))
1083 if ( wxIsLowerChar(*pstr
) )
1084 event
.m_keyCode
= *pstr
- 'a' + 1;
1085 if ( wxIsUpperChar(*pstr
) )
1086 event
.m_keyCode
= *pstr
- 'A' + 1;
1088 event
.m_keyCode
= *pstr
- 'a' + 1;
1090 event
.m_uniChar
= event
.m_keyCode
;
1094 SendCharHookAndCharEvents(event
, window
);
1100 //-----------------------------------------------------------------------------
1101 // "key_release_event" from any window
1102 //-----------------------------------------------------------------------------
1106 gtk_window_key_release_callback( GtkWidget
* WXUNUSED(widget
),
1107 GdkEventKey
*gdk_event
,
1113 if (g_blockEventsOnDrag
)
1116 wxKeyEvent
event( wxEVT_KEY_UP
);
1117 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1119 // unknown key pressed, ignore (the event would be useless anyhow)
1123 return win
->GTKProcessEvent(event
);
1127 // ============================================================================
1129 // ============================================================================
1131 // ----------------------------------------------------------------------------
1132 // mouse event processing helpers
1133 // ----------------------------------------------------------------------------
1135 // init wxMouseEvent with the info from GdkEventXXX struct
1136 template<typename T
> void InitMouseEvent(wxWindowGTK
*win
,
1137 wxMouseEvent
& event
,
1140 event
.SetTimestamp( gdk_event
->time
);
1141 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
1142 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
1143 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
1144 event
.m_metaDown
= (gdk_event
->state
& GDK_META_MASK
) != 0;
1145 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
) != 0;
1146 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
) != 0;
1147 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
) != 0;
1148 event
.m_aux1Down
= (gdk_event
->state
& GDK_BUTTON4_MASK
) != 0;
1149 event
.m_aux2Down
= (gdk_event
->state
& GDK_BUTTON5_MASK
) != 0;
1151 wxPoint pt
= win
->GetClientAreaOrigin();
1152 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1153 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1155 if ((win
->m_wxwindow
) && (win
->GetLayoutDirection() == wxLayout_RightToLeft
))
1157 // origin in the upper right corner
1159 gtk_widget_get_allocation(win
->m_wxwindow
, &a
);
1160 int window_width
= a
.width
;
1161 event
.m_x
= window_width
- event
.m_x
;
1164 event
.SetEventObject( win
);
1165 event
.SetId( win
->GetId() );
1166 event
.SetTimestamp( gdk_event
->time
);
1169 static void AdjustEventButtonState(wxMouseEvent
& event
)
1171 // GDK reports the old state of the button for a button press event, but
1172 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1173 // for a LEFT_DOWN event, not FALSE, so we will invert
1174 // left/right/middleDown for the corresponding click events
1176 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1177 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1178 (event
.GetEventType() == wxEVT_LEFT_UP
))
1180 event
.m_leftDown
= !event
.m_leftDown
;
1184 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1185 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1186 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1188 event
.m_middleDown
= !event
.m_middleDown
;
1192 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1193 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1194 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1196 event
.m_rightDown
= !event
.m_rightDown
;
1201 // find the window to send the mouse event too
1203 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1208 if (win
->m_wxwindow
)
1210 wxPizza
* pizza
= WX_PIZZA(win
->m_wxwindow
);
1211 xx
+= pizza
->m_scroll_x
;
1212 yy
+= pizza
->m_scroll_y
;
1215 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
1218 wxWindowGTK
*child
= node
->GetData();
1220 node
= node
->GetNext();
1221 if (!child
->IsShown())
1224 if (child
->GTKIsTransparentForMouse())
1226 // wxStaticBox is transparent in the box itself
1227 int xx1
= child
->m_x
;
1228 int yy1
= child
->m_y
;
1229 int xx2
= child
->m_x
+ child
->m_width
;
1230 int yy2
= child
->m_y
+ child
->m_height
;
1233 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1235 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1237 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1239 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1250 if ((child
->m_wxwindow
== NULL
) &&
1251 (child
->m_x
<= xx
) &&
1252 (child
->m_y
<= yy
) &&
1253 (child
->m_x
+child
->m_width
>= xx
) &&
1254 (child
->m_y
+child
->m_height
>= yy
))
1267 // ----------------------------------------------------------------------------
1268 // common event handlers helpers
1269 // ----------------------------------------------------------------------------
1271 bool wxWindowGTK::GTKProcessEvent(wxEvent
& event
) const
1273 // nothing special at this level
1274 return HandleWindowEvent(event
);
1277 bool wxWindowGTK::GTKShouldIgnoreEvent() const
1279 return !m_hasVMT
|| g_blockEventsOnDrag
;
1282 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny
*event
) const
1286 if (g_blockEventsOnDrag
)
1288 if (g_blockEventsOnScroll
)
1291 if (!GTKIsOwnWindow(event
->window
))
1297 // overloads for all GDK event types we use here: we need to have this as
1298 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1299 // derives from it in the sense that the structs have the same layout
1300 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1301 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1303 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1306 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton
)
1307 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion
)
1308 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing
)
1310 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1312 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1313 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1317 // all event handlers must have C linkage as they're called from GTK+ C code
1321 //-----------------------------------------------------------------------------
1322 // "button_press_event"
1323 //-----------------------------------------------------------------------------
1326 gtk_window_button_press_callback( GtkWidget
*widget
,
1327 GdkEventButton
*gdk_event
,
1330 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1332 g_lastButtonNumber
= gdk_event
->button
;
1334 // GDK sends surplus button down events
1335 // before a double click event. We
1336 // need to filter these out.
1337 if ((gdk_event
->type
== GDK_BUTTON_PRESS
) && (win
->m_wxwindow
))
1339 GdkEvent
*peek_event
= gdk_event_peek();
1342 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1343 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1345 gdk_event_free( peek_event
);
1350 gdk_event_free( peek_event
);
1355 wxEventType event_type
= wxEVT_NULL
;
1357 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1358 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1360 // Reset GDK internal timestamp variables in order to disable GDK
1361 // triple click events. GDK will then next time believe no button has
1362 // been clicked just before, and send a normal button click event.
1363 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1364 display
->button_click_time
[1] = 0;
1365 display
->button_click_time
[0] = 0;
1368 if (gdk_event
->button
== 1)
1370 // note that GDK generates triple click events which are not supported
1371 // by wxWidgets but still have to be passed to the app as otherwise
1372 // clicks would simply go missing
1373 switch (gdk_event
->type
)
1375 // we shouldn't get triple clicks at all for GTK2 because we
1376 // suppress them artificially using the code above but we still
1377 // should map them to something for GTK1 and not just ignore them
1378 // as this would lose clicks
1379 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1380 case GDK_BUTTON_PRESS
:
1381 event_type
= wxEVT_LEFT_DOWN
;
1384 case GDK_2BUTTON_PRESS
:
1385 event_type
= wxEVT_LEFT_DCLICK
;
1389 // just to silence gcc warnings
1393 else if (gdk_event
->button
== 2)
1395 switch (gdk_event
->type
)
1397 case GDK_3BUTTON_PRESS
:
1398 case GDK_BUTTON_PRESS
:
1399 event_type
= wxEVT_MIDDLE_DOWN
;
1402 case GDK_2BUTTON_PRESS
:
1403 event_type
= wxEVT_MIDDLE_DCLICK
;
1410 else if (gdk_event
->button
== 3)
1412 switch (gdk_event
->type
)
1414 case GDK_3BUTTON_PRESS
:
1415 case GDK_BUTTON_PRESS
:
1416 event_type
= wxEVT_RIGHT_DOWN
;
1419 case GDK_2BUTTON_PRESS
:
1420 event_type
= wxEVT_RIGHT_DCLICK
;
1428 if ( event_type
== wxEVT_NULL
)
1430 // unknown mouse button or click type
1434 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1436 wxMouseEvent
event( event_type
);
1437 InitMouseEvent( win
, event
, gdk_event
);
1439 AdjustEventButtonState(event
);
1441 // find the correct window to send the event to: it may be a different one
1442 // from the one which got it at GTK+ level because some controls don't have
1443 // their own X window and thus cannot get any events.
1444 if ( !g_captureWindow
)
1445 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1447 // reset the event object and id in case win changed.
1448 event
.SetEventObject( win
);
1449 event
.SetId( win
->GetId() );
1451 bool ret
= win
->GTKProcessEvent( event
);
1452 g_lastMouseEvent
= NULL
;
1456 if ((event_type
== wxEVT_LEFT_DOWN
) && !win
->IsOfStandardClass() &&
1457 (gs_currentFocus
!= win
) /* && win->IsFocusable() */)
1462 if (event_type
== wxEVT_RIGHT_DOWN
)
1464 // generate a "context menu" event: this is similar to right mouse
1465 // click under many GUIs except that it is generated differently
1466 // (right up under MSW, ctrl-click under Mac, right down here) and
1468 // (a) it's a command event and so is propagated to the parent
1469 // (b) under some ports it can be generated from kbd too
1470 // (c) it uses screen coords (because of (a))
1471 wxContextMenuEvent
evtCtx(
1474 win
->ClientToScreen(event
.GetPosition()));
1475 evtCtx
.SetEventObject(win
);
1476 return win
->GTKProcessEvent(evtCtx
);
1482 //-----------------------------------------------------------------------------
1483 // "button_release_event"
1484 //-----------------------------------------------------------------------------
1487 gtk_window_button_release_callback( GtkWidget
*WXUNUSED(widget
),
1488 GdkEventButton
*gdk_event
,
1491 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1493 g_lastButtonNumber
= 0;
1495 wxEventType event_type
= wxEVT_NULL
;
1497 switch (gdk_event
->button
)
1500 event_type
= wxEVT_LEFT_UP
;
1504 event_type
= wxEVT_MIDDLE_UP
;
1508 event_type
= wxEVT_RIGHT_UP
;
1512 // unknown button, don't process
1516 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1518 wxMouseEvent
event( event_type
);
1519 InitMouseEvent( win
, event
, gdk_event
);
1521 AdjustEventButtonState(event
);
1523 if ( !g_captureWindow
)
1524 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1526 // reset the event object and id in case win changed.
1527 event
.SetEventObject( win
);
1528 event
.SetId( win
->GetId() );
1530 bool ret
= win
->GTKProcessEvent(event
);
1532 g_lastMouseEvent
= NULL
;
1537 //-----------------------------------------------------------------------------
1538 // "motion_notify_event"
1539 //-----------------------------------------------------------------------------
1542 gtk_window_motion_notify_callback( GtkWidget
* WXUNUSED(widget
),
1543 GdkEventMotion
*gdk_event
,
1546 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1548 if (gdk_event
->is_hint
)
1552 GdkModifierType state
;
1553 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1558 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1560 wxMouseEvent
event( wxEVT_MOTION
);
1561 InitMouseEvent(win
, event
, gdk_event
);
1563 if ( g_captureWindow
)
1565 // synthesise a mouse enter or leave event if needed
1566 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1567 // This seems to be necessary and actually been added to
1568 // GDK itself in version 2.0.X
1571 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1572 if ( hasMouse
!= g_captureWindowHasMouse
)
1574 // the mouse changed window
1575 g_captureWindowHasMouse
= hasMouse
;
1577 wxMouseEvent
eventM(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1578 : wxEVT_LEAVE_WINDOW
);
1579 InitMouseEvent(win
, eventM
, gdk_event
);
1580 eventM
.SetEventObject(win
);
1581 win
->GTKProcessEvent(eventM
);
1586 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1588 // reset the event object and id in case win changed.
1589 event
.SetEventObject( win
);
1590 event
.SetId( win
->GetId() );
1593 if ( !g_captureWindow
)
1595 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1596 if (win
->GTKProcessEvent( cevent
))
1598 win
->SetCursor( cevent
.GetCursor() );
1602 bool ret
= win
->GTKProcessEvent(event
);
1604 g_lastMouseEvent
= NULL
;
1609 //-----------------------------------------------------------------------------
1610 // "scroll_event" (mouse wheel event)
1611 //-----------------------------------------------------------------------------
1614 window_scroll_event_hscrollbar(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1616 if (gdk_event
->direction
!= GDK_SCROLL_LEFT
&&
1617 gdk_event
->direction
!= GDK_SCROLL_RIGHT
)
1622 GtkRange
*range
= win
->m_scrollBar
[wxWindow::ScrollDir_Horz
];
1624 if (range
&& gtk_widget_get_visible(GTK_WIDGET(range
)))
1626 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
1627 double delta
= gtk_adjustment_get_step_increment(adj
) * 3;
1628 if (gdk_event
->direction
== GDK_SCROLL_LEFT
)
1631 gtk_range_set_value(range
, gtk_adjustment_get_value(adj
) + delta
);
1640 window_scroll_event(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1642 if (gdk_event
->direction
!= GDK_SCROLL_UP
&&
1643 gdk_event
->direction
!= GDK_SCROLL_DOWN
)
1648 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1649 InitMouseEvent(win
, event
, gdk_event
);
1651 // FIXME: Get these values from GTK or GDK
1652 event
.m_linesPerAction
= 3;
1653 event
.m_wheelDelta
= 120;
1654 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1655 event
.m_wheelRotation
= 120;
1657 event
.m_wheelRotation
= -120;
1659 if (win
->GTKProcessEvent(event
))
1662 GtkRange
*range
= win
->m_scrollBar
[wxWindow::ScrollDir_Vert
];
1664 if (range
&& gtk_widget_get_visible(GTK_WIDGET(range
)))
1666 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
1667 double delta
= gtk_adjustment_get_step_increment(adj
) * 3;
1668 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1671 gtk_range_set_value(range
, gtk_adjustment_get_value(adj
) + delta
);
1679 //-----------------------------------------------------------------------------
1681 //-----------------------------------------------------------------------------
1683 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
1685 wxContextMenuEvent
event(wxEVT_CONTEXT_MENU
, win
->GetId(), wxPoint(-1, -1));
1686 event
.SetEventObject(win
);
1687 return win
->GTKProcessEvent(event
);
1690 //-----------------------------------------------------------------------------
1692 //-----------------------------------------------------------------------------
1695 gtk_window_focus_in_callback( GtkWidget
* WXUNUSED(widget
),
1696 GdkEventFocus
*WXUNUSED(event
),
1699 return win
->GTKHandleFocusIn();
1702 //-----------------------------------------------------------------------------
1703 // "focus_out_event"
1704 //-----------------------------------------------------------------------------
1707 gtk_window_focus_out_callback( GtkWidget
* WXUNUSED(widget
),
1708 GdkEventFocus
* WXUNUSED(gdk_event
),
1711 return win
->GTKHandleFocusOut();
1714 //-----------------------------------------------------------------------------
1716 //-----------------------------------------------------------------------------
1719 wx_window_focus_callback(GtkWidget
*widget
,
1720 GtkDirectionType
WXUNUSED(direction
),
1723 // the default handler for focus signal in GtkScrolledWindow sets
1724 // focus to the window itself even if it doesn't accept focus, i.e. has no
1725 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1726 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1727 // any children which might accept focus (we know we don't accept the focus
1728 // ourselves as this signal is only connected in this case)
1729 if ( win
->GetChildren().empty() )
1730 g_signal_stop_emission_by_name(widget
, "focus");
1732 // we didn't change the focus
1736 //-----------------------------------------------------------------------------
1737 // "enter_notify_event"
1738 //-----------------------------------------------------------------------------
1741 gtk_window_enter_callback( GtkWidget
*widget
,
1742 GdkEventCrossing
*gdk_event
,
1745 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1747 // Event was emitted after a grab
1748 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1752 GdkModifierType state
= (GdkModifierType
)0;
1754 gdk_window_get_pointer(gtk_widget_get_window(widget
), &x
, &y
, &state
);
1756 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1757 InitMouseEvent(win
, event
, gdk_event
);
1758 wxPoint pt
= win
->GetClientAreaOrigin();
1759 event
.m_x
= x
+ pt
.x
;
1760 event
.m_y
= y
+ pt
.y
;
1762 if ( !g_captureWindow
)
1764 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1765 if (win
->GTKProcessEvent( cevent
))
1767 win
->SetCursor( cevent
.GetCursor() );
1771 return win
->GTKProcessEvent(event
);
1774 //-----------------------------------------------------------------------------
1775 // "leave_notify_event"
1776 //-----------------------------------------------------------------------------
1779 gtk_window_leave_callback( GtkWidget
*widget
,
1780 GdkEventCrossing
*gdk_event
,
1783 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1785 // Event was emitted after an ungrab
1786 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1788 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1792 GdkModifierType state
= (GdkModifierType
)0;
1794 gdk_window_get_pointer(gtk_widget_get_window(widget
), &x
, &y
, &state
);
1796 InitMouseEvent(win
, event
, gdk_event
);
1798 return win
->GTKProcessEvent(event
);
1801 //-----------------------------------------------------------------------------
1802 // "value_changed" from scrollbar
1803 //-----------------------------------------------------------------------------
1806 gtk_scrollbar_value_changed(GtkRange
* range
, wxWindow
* win
)
1808 wxEventType eventType
= win
->GTKGetScrollEventType(range
);
1809 if (eventType
!= wxEVT_NULL
)
1811 // Convert scroll event type to scrollwin event type
1812 eventType
+= wxEVT_SCROLLWIN_TOP
- wxEVT_SCROLL_TOP
;
1814 // find the scrollbar which generated the event
1815 wxWindowGTK::ScrollDir dir
= win
->ScrollDirFromRange(range
);
1817 // generate the corresponding wx event
1818 const int orient
= wxWindow::OrientFromScrollDir(dir
);
1819 wxScrollWinEvent
event(eventType
, win
->GetScrollPos(orient
), orient
);
1820 event
.SetEventObject(win
);
1822 win
->GTKProcessEvent(event
);
1826 //-----------------------------------------------------------------------------
1827 // "button_press_event" from scrollbar
1828 //-----------------------------------------------------------------------------
1831 gtk_scrollbar_button_press_event(GtkRange
*, GdkEventButton
*, wxWindow
* win
)
1833 g_blockEventsOnScroll
= true;
1834 win
->m_mouseButtonDown
= true;
1839 //-----------------------------------------------------------------------------
1840 // "event_after" from scrollbar
1841 //-----------------------------------------------------------------------------
1844 gtk_scrollbar_event_after(GtkRange
* range
, GdkEvent
* event
, wxWindow
* win
)
1846 if (event
->type
== GDK_BUTTON_RELEASE
)
1848 g_signal_handlers_block_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1850 const int orient
= wxWindow::OrientFromScrollDir(
1851 win
->ScrollDirFromRange(range
));
1852 wxScrollWinEvent
evt(wxEVT_SCROLLWIN_THUMBRELEASE
,
1853 win
->GetScrollPos(orient
), orient
);
1854 evt
.SetEventObject(win
);
1855 win
->GTKProcessEvent(evt
);
1859 //-----------------------------------------------------------------------------
1860 // "button_release_event" from scrollbar
1861 //-----------------------------------------------------------------------------
1864 gtk_scrollbar_button_release_event(GtkRange
* range
, GdkEventButton
*, wxWindow
* win
)
1866 g_blockEventsOnScroll
= false;
1867 win
->m_mouseButtonDown
= false;
1868 // If thumb tracking
1869 if (win
->m_isScrolling
)
1871 win
->m_isScrolling
= false;
1872 // Hook up handler to send thumb release event after this emission is finished.
1873 // To allow setting scroll position from event handler, sending event must
1874 // be deferred until after the GtkRange handler for this signal has run
1875 g_signal_handlers_unblock_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1881 //-----------------------------------------------------------------------------
1882 // "realize" from m_widget
1883 //-----------------------------------------------------------------------------
1886 gtk_window_realized_callback(GtkWidget
* widget
, wxWindow
* win
)
1890 gtk_im_context_set_client_window( win
->m_imData
->context
,
1891 win
->m_wxwindow
? win
->GTKGetDrawingWindow() : gtk_widget_get_window(widget
));
1894 // We cannot set colours and fonts before the widget
1895 // been realized, so we do this directly after realization
1896 // or otherwise in idle time
1898 if (win
->m_needsStyleChange
)
1900 win
->SetBackgroundStyle(win
->GetBackgroundStyle());
1901 win
->m_needsStyleChange
= false;
1904 wxWindowCreateEvent
event( win
);
1905 event
.SetEventObject( win
);
1906 win
->GTKProcessEvent( event
);
1908 win
->GTKUpdateCursor(true, false);
1911 //-----------------------------------------------------------------------------
1912 // "size_allocate" from m_wxwindow or m_widget
1913 //-----------------------------------------------------------------------------
1916 size_allocate(GtkWidget
*, GtkAllocation
* alloc
, wxWindow
* win
)
1918 int w
= alloc
->width
;
1919 int h
= alloc
->height
;
1920 if (win
->m_wxwindow
)
1922 int border_x
, border_y
;
1923 WX_PIZZA(win
->m_wxwindow
)->get_border_widths(border_x
, border_y
);
1929 if (win
->m_oldClientWidth
!= w
|| win
->m_oldClientHeight
!= h
)
1931 win
->m_oldClientWidth
= w
;
1932 win
->m_oldClientHeight
= h
;
1933 // this callback can be connected to m_wxwindow,
1934 // so always get size from m_widget->allocation
1936 gtk_widget_get_allocation(win
->m_widget
, &a
);
1937 win
->m_width
= a
.width
;
1938 win
->m_height
= a
.height
;
1939 if (!win
->m_nativeSizeEvent
)
1941 wxSizeEvent
event(win
->GetSize(), win
->GetId());
1942 event
.SetEventObject(win
);
1943 win
->GTKProcessEvent(event
);
1948 //-----------------------------------------------------------------------------
1950 //-----------------------------------------------------------------------------
1952 #if GTK_CHECK_VERSION(2, 8, 0)
1954 gtk_window_grab_broken( GtkWidget
*,
1955 GdkEventGrabBroken
*event
,
1958 // Mouse capture has been lost involuntarily, notify the application
1959 if(!event
->keyboard
&& wxWindow::GetCapture() == win
)
1961 wxMouseCaptureLostEvent
evt( win
->GetId() );
1962 evt
.SetEventObject( win
);
1963 win
->HandleWindowEvent( evt
);
1969 //-----------------------------------------------------------------------------
1971 //-----------------------------------------------------------------------------
1974 void gtk_window_style_set_callback( GtkWidget
*WXUNUSED(widget
),
1975 GtkStyle
*previous_style
,
1978 if (win
&& previous_style
)
1980 wxSysColourChangedEvent event
;
1981 event
.SetEventObject(win
);
1983 win
->GTKProcessEvent( event
);
1989 // ----------------------------------------------------------------------------
1990 // this wxWindowBase function is implemented here (in platform-specific file)
1991 // because it is static and so couldn't be made virtual
1992 // ----------------------------------------------------------------------------
1994 wxWindow
*wxWindowBase::DoFindFocus()
1996 wxWindowGTK
*focus
= gs_pendingFocus
? gs_pendingFocus
: gs_currentFocus
;
1997 // the cast is necessary when we compile in wxUniversal mode
1998 return static_cast<wxWindow
*>(focus
);
2001 void wxWindowGTK::AddChildGTK(wxWindowGTK
* child
)
2003 wxASSERT_MSG(m_wxwindow
, "Cannot add a child to a window without a client area");
2005 // the window might have been scrolled already, we
2006 // have to adapt the position
2007 wxPizza
* pizza
= WX_PIZZA(m_wxwindow
);
2008 child
->m_x
+= pizza
->m_scroll_x
;
2009 child
->m_y
+= pizza
->m_scroll_y
;
2011 gtk_widget_set_size_request(
2012 child
->m_widget
, child
->m_width
, child
->m_height
);
2013 pizza
->put(child
->m_widget
, child
->m_x
, child
->m_y
);
2016 //-----------------------------------------------------------------------------
2018 //-----------------------------------------------------------------------------
2020 wxWindow
*wxGetActiveWindow()
2022 return wxWindow::FindFocus();
2026 wxMouseState
wxGetMouseState()
2032 GdkModifierType mask
;
2034 gdk_window_get_pointer(NULL
, &x
, &y
, &mask
);
2038 ms
.SetLeftDown((mask
& GDK_BUTTON1_MASK
) != 0);
2039 ms
.SetMiddleDown((mask
& GDK_BUTTON2_MASK
) != 0);
2040 ms
.SetRightDown((mask
& GDK_BUTTON3_MASK
) != 0);
2041 ms
.SetAux1Down((mask
& GDK_BUTTON4_MASK
) != 0);
2042 ms
.SetAux2Down((mask
& GDK_BUTTON5_MASK
) != 0);
2044 ms
.SetControlDown((mask
& GDK_CONTROL_MASK
) != 0);
2045 ms
.SetShiftDown((mask
& GDK_SHIFT_MASK
) != 0);
2046 ms
.SetAltDown((mask
& GDK_MOD1_MASK
) != 0);
2047 ms
.SetMetaDown((mask
& GDK_META_MASK
) != 0);
2052 //-----------------------------------------------------------------------------
2054 //-----------------------------------------------------------------------------
2056 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2058 #ifdef __WXUNIVERSAL__
2059 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2060 #endif // __WXUNIVERSAL__
2062 void wxWindowGTK::Init()
2067 m_focusWidget
= NULL
;
2077 m_showOnIdle
= false;
2080 m_nativeSizeEvent
= false;
2082 m_isScrolling
= false;
2083 m_mouseButtonDown
= false;
2085 // initialize scrolling stuff
2086 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2088 m_scrollBar
[dir
] = NULL
;
2089 m_scrollPos
[dir
] = 0;
2093 m_oldClientHeight
= 0;
2095 m_clipPaintRegion
= false;
2097 m_needsStyleChange
= false;
2099 m_cursor
= *wxSTANDARD_CURSOR
;
2102 m_dirtyTabOrder
= false;
2105 wxWindowGTK::wxWindowGTK()
2110 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2115 const wxString
&name
)
2119 Create( parent
, id
, pos
, size
, style
, name
);
2122 bool wxWindowGTK::Create( wxWindow
*parent
,
2127 const wxString
&name
)
2129 // Get default border
2130 wxBorder border
= GetBorder(style
);
2132 style
&= ~wxBORDER_MASK
;
2135 if (!PreCreation( parent
, pos
, size
) ||
2136 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2138 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2142 // We should accept the native look
2144 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2145 scroll_class
->scrollbar_spacing
= 0;
2149 m_wxwindow
= wxPizza::New(m_windowStyle
);
2150 #ifndef __WXUNIVERSAL__
2151 if (HasFlag(wxPizza::BORDER_STYLES
))
2153 g_signal_connect(m_wxwindow
, "parent_set",
2154 G_CALLBACK(parent_set
), this);
2157 if (!HasFlag(wxHSCROLL
) && !HasFlag(wxVSCROLL
))
2158 m_widget
= m_wxwindow
;
2161 m_widget
= gtk_scrolled_window_new( NULL
, NULL
);
2163 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2165 // There is a conflict with default bindings at GTK+
2166 // level between scrolled windows and notebooks both of which want to use
2167 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2168 // direction and notebooks for changing pages -- we decide that if we don't
2169 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2170 // means we can get working keyboard navigation in notebooks
2171 if ( !HasFlag(wxHSCROLL
) )
2174 bindings
= gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget
));
2177 gtk_binding_entry_remove(bindings
, GDK_Page_Up
, GDK_CONTROL_MASK
);
2178 gtk_binding_entry_remove(bindings
, GDK_Page_Down
, GDK_CONTROL_MASK
);
2182 if (HasFlag(wxALWAYS_SHOW_SB
))
2184 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_ALWAYS
, GTK_POLICY_ALWAYS
);
2188 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2191 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow
));
2192 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow
));
2193 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2194 gtk_range_set_inverted( m_scrollBar
[ScrollDir_Horz
], TRUE
);
2196 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2198 // connect various scroll-related events
2199 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2201 // these handlers block mouse events to any window during scrolling
2202 // such as motion events and prevent GTK and wxWidgets from fighting
2203 // over where the slider should be
2204 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2205 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2206 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2207 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2209 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2210 G_CALLBACK(gtk_scrollbar_event_after
), this);
2211 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2213 // these handlers get notified when scrollbar slider moves
2214 g_signal_connect_after(m_scrollBar
[dir
], "value_changed",
2215 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2218 gtk_widget_show( m_wxwindow
);
2220 g_object_ref(m_widget
);
2223 m_parent
->DoAddChild( this );
2225 m_focusWidget
= m_wxwindow
;
2227 SetCanFocus(AcceptsFocus());
2234 wxWindowGTK::~wxWindowGTK()
2238 if (gs_currentFocus
== this)
2239 gs_currentFocus
= NULL
;
2240 if (gs_pendingFocus
== this)
2241 gs_pendingFocus
= NULL
;
2243 if ( gs_deferredFocusOut
== this )
2244 gs_deferredFocusOut
= NULL
;
2248 // destroy children before destroying this window itself
2251 // unhook focus handlers to prevent stray events being
2252 // propagated to this (soon to be) dead object
2253 if (m_focusWidget
!= NULL
)
2255 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2256 (gpointer
) gtk_window_focus_in_callback
,
2258 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2259 (gpointer
) gtk_window_focus_out_callback
,
2266 // delete before the widgets to avoid a crash on solaris
2269 // avoid problem with GTK+ 2.18 where a frozen window causes the whole
2270 // TLW to be frozen, and if the window is then destroyed, nothing ever
2271 // gets painted again
2277 // Note that gtk_widget_destroy() does not destroy the widget, it just
2278 // emits the "destroy" signal. The widget is not actually destroyed
2279 // until its reference count drops to zero.
2280 gtk_widget_destroy(m_widget
);
2281 // Release our reference, should be the last one
2282 g_object_unref(m_widget
);
2288 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2290 if ( GTKNeedsParent() )
2292 wxCHECK_MSG( parent
, false, wxT("Must have non-NULL parent") );
2295 // Use either the given size, or the default if -1 is given.
2296 // See wxWindowBase for these functions.
2297 m_width
= WidthDefault(size
.x
) ;
2298 m_height
= HeightDefault(size
.y
);
2306 void wxWindowGTK::PostCreation()
2308 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2314 // these get reported to wxWidgets -> wxPaintEvent
2316 g_signal_connect (m_wxwindow
, "expose_event",
2317 G_CALLBACK (gtk_window_expose_callback
), this);
2319 if (GetLayoutDirection() == wxLayout_LeftToRight
)
2320 gtk_widget_set_redraw_on_allocate(m_wxwindow
, HasFlag(wxFULL_REPAINT_ON_RESIZE
));
2323 // Create input method handler
2324 m_imData
= new wxGtkIMData
;
2326 // Cannot handle drawing preedited text yet
2327 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2329 g_signal_connect (m_imData
->context
, "commit",
2330 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2335 if (!GTK_IS_WINDOW(m_widget
))
2337 if (m_focusWidget
== NULL
)
2338 m_focusWidget
= m_widget
;
2342 g_signal_connect (m_focusWidget
, "focus_in_event",
2343 G_CALLBACK (gtk_window_focus_in_callback
), this);
2344 g_signal_connect (m_focusWidget
, "focus_out_event",
2345 G_CALLBACK (gtk_window_focus_out_callback
), this);
2349 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2350 G_CALLBACK (gtk_window_focus_in_callback
), this);
2351 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2352 G_CALLBACK (gtk_window_focus_out_callback
), this);
2356 if ( !AcceptsFocusFromKeyboard() )
2360 g_signal_connect(m_widget
, "focus",
2361 G_CALLBACK(wx_window_focus_callback
), this);
2364 // connect to the various key and mouse handlers
2366 GtkWidget
*connect_widget
= GetConnectWidget();
2368 ConnectWidget( connect_widget
);
2370 /* We cannot set colours, fonts and cursors before the widget has
2371 been realized, so we do this directly after realization */
2372 g_signal_connect (connect_widget
, "realize",
2373 G_CALLBACK (gtk_window_realized_callback
), this);
2377 g_signal_connect(m_wxwindow
? m_wxwindow
: m_widget
, "size_allocate",
2378 G_CALLBACK(size_allocate
), this);
2381 #if GTK_CHECK_VERSION(2, 8, 0)
2382 if ( gtk_check_version(2,8,0) == NULL
)
2384 // Make sure we can notify the app when mouse capture is lost
2387 g_signal_connect (m_wxwindow
, "grab_broken_event",
2388 G_CALLBACK (gtk_window_grab_broken
), this);
2391 if ( connect_widget
!= m_wxwindow
)
2393 g_signal_connect (connect_widget
, "grab_broken_event",
2394 G_CALLBACK (gtk_window_grab_broken
), this);
2397 #endif // GTK+ >= 2.8
2399 if ( GTKShouldConnectSizeRequest() )
2401 // This is needed if we want to add our windows into native
2402 // GTK controls, such as the toolbar. With this callback, the
2403 // toolbar gets to know the correct size (the one set by the
2404 // programmer). Sadly, it misbehaves for wxComboBox.
2405 g_signal_connect (m_widget
, "size_request",
2406 G_CALLBACK (wxgtk_window_size_request_callback
),
2410 InheritAttributes();
2414 SetLayoutDirection(wxLayout_Default
);
2416 // unless the window was created initially hidden (i.e. Hide() had been
2417 // called before Create()), we should show it at GTK+ level as well
2419 gtk_widget_show( m_widget
);
2422 gulong
wxWindowGTK::GTKConnectWidget(const char *signal
, void (*callback
)())
2424 return g_signal_connect(m_widget
, signal
, callback
, this);
2427 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2429 g_signal_connect (widget
, "key_press_event",
2430 G_CALLBACK (gtk_window_key_press_callback
), this);
2431 g_signal_connect (widget
, "key_release_event",
2432 G_CALLBACK (gtk_window_key_release_callback
), this);
2433 g_signal_connect (widget
, "button_press_event",
2434 G_CALLBACK (gtk_window_button_press_callback
), this);
2435 g_signal_connect (widget
, "button_release_event",
2436 G_CALLBACK (gtk_window_button_release_callback
), this);
2437 g_signal_connect (widget
, "motion_notify_event",
2438 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2440 g_signal_connect (widget
, "scroll_event",
2441 G_CALLBACK (window_scroll_event
), this);
2442 if (m_scrollBar
[ScrollDir_Horz
])
2443 g_signal_connect (m_scrollBar
[ScrollDir_Horz
], "scroll_event",
2444 G_CALLBACK (window_scroll_event_hscrollbar
), this);
2445 if (m_scrollBar
[ScrollDir_Vert
])
2446 g_signal_connect (m_scrollBar
[ScrollDir_Vert
], "scroll_event",
2447 G_CALLBACK (window_scroll_event
), this);
2449 g_signal_connect (widget
, "popup_menu",
2450 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2451 g_signal_connect (widget
, "enter_notify_event",
2452 G_CALLBACK (gtk_window_enter_callback
), this);
2453 g_signal_connect (widget
, "leave_notify_event",
2454 G_CALLBACK (gtk_window_leave_callback
), this);
2456 if (IsTopLevel() && m_wxwindow
)
2457 g_signal_connect (m_wxwindow
, "style_set",
2458 G_CALLBACK (gtk_window_style_set_callback
), this);
2461 bool wxWindowGTK::Destroy()
2465 return wxWindowBase::Destroy();
2468 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2470 gtk_widget_set_size_request(m_widget
, width
, height
);
2472 // inform the parent to perform the move
2473 wxASSERT_MSG(m_parent
&& m_parent
->m_wxwindow
,
2474 "the parent window has no client area?");
2475 WX_PIZZA(m_parent
->m_wxwindow
)->move(m_widget
, x
, y
);
2478 void wxWindowGTK::ConstrainSize()
2481 // GPE's window manager doesn't like size hints at all, esp. when the user
2482 // has to use the virtual keyboard, so don't constrain size there
2486 const wxSize minSize
= GetMinSize();
2487 const wxSize maxSize
= GetMaxSize();
2488 if (minSize
.x
> 0 && m_width
< minSize
.x
) m_width
= minSize
.x
;
2489 if (minSize
.y
> 0 && m_height
< minSize
.y
) m_height
= minSize
.y
;
2490 if (maxSize
.x
> 0 && m_width
> maxSize
.x
) m_width
= maxSize
.x
;
2491 if (maxSize
.y
> 0 && m_height
> maxSize
.y
) m_height
= maxSize
.y
;
2495 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2497 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2498 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2500 int currentX
, currentY
;
2501 GetPosition(¤tX
, ¤tY
);
2502 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2504 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2506 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2508 // calculate the best size if we should auto size the window
2509 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2510 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2512 const wxSize sizeBest
= GetBestSize();
2513 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2515 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2516 height
= sizeBest
.y
;
2519 const wxSize
oldSize(m_width
, m_height
);
2525 if (m_parent
->m_wxwindow
)
2527 wxPizza
* pizza
= WX_PIZZA(m_parent
->m_wxwindow
);
2528 m_x
= x
+ pizza
->m_scroll_x
;
2529 m_y
= y
+ pizza
->m_scroll_y
;
2531 int left_border
= 0;
2532 int right_border
= 0;
2534 int bottom_border
= 0;
2536 /* the default button has a border around it */
2537 if (gtk_widget_get_can_default(m_widget
))
2539 GtkBorder
*default_border
= NULL
;
2540 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2543 left_border
+= default_border
->left
;
2544 right_border
+= default_border
->right
;
2545 top_border
+= default_border
->top
;
2546 bottom_border
+= default_border
->bottom
;
2547 gtk_border_free( default_border
);
2551 DoMoveWindow( m_x
- left_border
,
2553 m_width
+left_border
+right_border
,
2554 m_height
+top_border
+bottom_border
);
2557 if (m_width
!= oldSize
.x
|| m_height
!= oldSize
.y
)
2559 // update these variables to keep size_allocate handler
2560 // from sending another size event for this change
2561 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2563 gtk_widget_queue_resize(m_widget
);
2564 if (!m_nativeSizeEvent
)
2566 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2567 event
.SetEventObject( this );
2568 HandleWindowEvent( event
);
2571 if (sizeFlags
& wxSIZE_FORCE_EVENT
)
2573 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2574 event
.SetEventObject( this );
2575 HandleWindowEvent( event
);
2579 bool wxWindowGTK::GTKShowFromOnIdle()
2581 if (IsShown() && m_showOnIdle
&& !gtk_widget_get_visible (m_widget
))
2583 GtkAllocation alloc
;
2586 alloc
.width
= m_width
;
2587 alloc
.height
= m_height
;
2588 gtk_widget_size_allocate( m_widget
, &alloc
);
2589 gtk_widget_show( m_widget
);
2590 wxShowEvent
eventShow(GetId(), true);
2591 eventShow
.SetEventObject(this);
2592 HandleWindowEvent(eventShow
);
2593 m_showOnIdle
= false;
2600 void wxWindowGTK::OnInternalIdle()
2602 if ( gs_deferredFocusOut
)
2603 GTKHandleDeferredFocusOut();
2605 // Check if we have to show window now
2606 if (GTKShowFromOnIdle()) return;
2608 if ( m_dirtyTabOrder
)
2610 m_dirtyTabOrder
= false;
2614 // Update style if the window was not yet realized when
2615 // SetBackgroundStyle() was called
2616 if (m_needsStyleChange
)
2618 SetBackgroundStyle(GetBackgroundStyle());
2619 m_needsStyleChange
= false;
2622 wxWindowBase::OnInternalIdle();
2625 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
2627 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2629 if (width
) (*width
) = m_width
;
2630 if (height
) (*height
) = m_height
;
2633 void wxWindowGTK::DoSetClientSize( int width
, int height
)
2635 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2637 const wxSize size
= GetSize();
2638 const wxSize clientSize
= GetClientSize();
2639 SetSize(width
+ (size
.x
- clientSize
.x
), height
+ (size
.y
- clientSize
.y
));
2642 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
2644 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2651 // if window is scrollable, account for scrollbars
2652 if ( GTK_IS_SCROLLED_WINDOW(m_widget
) )
2654 GtkPolicyType policy
[ScrollDir_Max
];
2655 gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget
),
2656 &policy
[ScrollDir_Horz
],
2657 &policy
[ScrollDir_Vert
]);
2659 for ( int i
= 0; i
< ScrollDir_Max
; i
++ )
2661 // don't account for the scrollbars we don't have
2662 GtkRange
* const range
= m_scrollBar
[i
];
2666 // nor for the ones we have but don't current show
2667 switch ( policy
[i
] )
2669 case GTK_POLICY_NEVER
:
2670 // never shown so doesn't take any place
2673 case GTK_POLICY_ALWAYS
:
2674 // no checks necessary
2677 case GTK_POLICY_AUTOMATIC
:
2678 // may be shown or not, check
2679 GtkAdjustment
*adj
= gtk_range_get_adjustment(range
);
2680 if (gtk_adjustment_get_upper(adj
) <= gtk_adjustment_get_page_size(adj
))
2684 GtkScrolledWindowClass
*scroll_class
=
2685 GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2688 gtk_widget_size_request(GTK_WIDGET(range
), &req
);
2689 if (i
== ScrollDir_Horz
)
2690 h
-= req
.height
+ scroll_class
->scrollbar_spacing
;
2692 w
-= req
.width
+ scroll_class
->scrollbar_spacing
;
2696 const wxSize sizeBorders
= DoGetBorderSize();
2706 if (width
) *width
= w
;
2707 if (height
) *height
= h
;
2710 wxSize
wxWindowGTK::DoGetBorderSize() const
2713 return wxWindowBase::DoGetBorderSize();
2716 WX_PIZZA(m_wxwindow
)->get_border_widths(x
, y
);
2718 return 2*wxSize(x
, y
);
2721 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
2723 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2727 if (!IsTopLevel() && m_parent
&& m_parent
->m_wxwindow
)
2729 wxPizza
* pizza
= WX_PIZZA(m_parent
->m_wxwindow
);
2730 dx
= pizza
->m_scroll_x
;
2731 dy
= pizza
->m_scroll_y
;
2734 if (m_x
== -1 && m_y
== -1)
2736 GdkWindow
*source
= NULL
;
2738 source
= gtk_widget_get_window(m_wxwindow
);
2740 source
= gtk_widget_get_window(m_widget
);
2746 gdk_window_get_origin( source
, &org_x
, &org_y
);
2749 m_parent
->ScreenToClient(&org_x
, &org_y
);
2751 const_cast<wxWindowGTK
*>(this)->m_x
= org_x
;
2752 const_cast<wxWindowGTK
*>(this)->m_y
= org_y
;
2756 if (x
) (*x
) = m_x
- dx
;
2757 if (y
) (*y
) = m_y
- dy
;
2760 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
2762 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2764 if (gtk_widget_get_window(m_widget
) == NULL
) return;
2766 GdkWindow
*source
= NULL
;
2768 source
= gtk_widget_get_window(m_wxwindow
);
2770 source
= gtk_widget_get_window(m_widget
);
2774 gdk_window_get_origin( source
, &org_x
, &org_y
);
2778 if (!gtk_widget_get_has_window(m_widget
))
2781 gtk_widget_get_allocation(m_widget
, &a
);
2790 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2791 *x
= (GetClientSize().x
- *x
) + org_x
;
2799 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
2801 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2803 if (!gtk_widget_get_realized(m_widget
)) return;
2805 GdkWindow
*source
= NULL
;
2807 source
= gtk_widget_get_window(m_wxwindow
);
2809 source
= gtk_widget_get_window(m_widget
);
2813 gdk_window_get_origin( source
, &org_x
, &org_y
);
2817 if (!gtk_widget_get_has_window(m_widget
))
2820 gtk_widget_get_allocation(m_widget
, &a
);
2828 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2829 *x
= (GetClientSize().x
- *x
) - org_x
;
2836 bool wxWindowGTK::Show( bool show
)
2838 if ( !wxWindowBase::Show(show
) )
2844 // notice that we may call Hide() before the window is created and this is
2845 // actually useful to create it hidden initially -- but we can't call
2846 // Show() before it is created
2849 wxASSERT_MSG( !show
, "can't show invalid window" );
2857 // defer until later
2861 gtk_widget_show(m_widget
);
2865 gtk_widget_hide(m_widget
);
2868 wxShowEvent
eventShow(GetId(), show
);
2869 eventShow
.SetEventObject(this);
2870 HandleWindowEvent(eventShow
);
2875 void wxWindowGTK::DoEnable( bool enable
)
2877 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2879 gtk_widget_set_sensitive( m_widget
, enable
);
2880 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
2881 gtk_widget_set_sensitive( m_wxwindow
, enable
);
2884 int wxWindowGTK::GetCharHeight() const
2886 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
2888 wxFont font
= GetFont();
2889 wxCHECK_MSG( font
.IsOk(), 12, wxT("invalid font") );
2891 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
2896 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
2897 PangoLayout
*layout
= pango_layout_new(context
);
2898 pango_layout_set_font_description(layout
, desc
);
2899 pango_layout_set_text(layout
, "H", 1);
2900 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
2902 PangoRectangle rect
;
2903 pango_layout_line_get_extents(line
, NULL
, &rect
);
2905 g_object_unref (layout
);
2907 return (int) PANGO_PIXELS(rect
.height
);
2910 int wxWindowGTK::GetCharWidth() const
2912 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
2914 wxFont font
= GetFont();
2915 wxCHECK_MSG( font
.IsOk(), 8, wxT("invalid font") );
2917 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
2922 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
2923 PangoLayout
*layout
= pango_layout_new(context
);
2924 pango_layout_set_font_description(layout
, desc
);
2925 pango_layout_set_text(layout
, "g", 1);
2926 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
2928 PangoRectangle rect
;
2929 pango_layout_line_get_extents(line
, NULL
, &rect
);
2931 g_object_unref (layout
);
2933 return (int) PANGO_PIXELS(rect
.width
);
2936 void wxWindowGTK::DoGetTextExtent( const wxString
& string
,
2940 int *externalLeading
,
2941 const wxFont
*theFont
) const
2943 wxFont fontToUse
= theFont
? *theFont
: GetFont();
2945 wxCHECK_RET( fontToUse
.IsOk(), wxT("invalid font") );
2954 PangoContext
*context
= NULL
;
2956 context
= gtk_widget_get_pango_context( m_widget
);
2965 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
2966 PangoLayout
*layout
= pango_layout_new(context
);
2967 pango_layout_set_font_description(layout
, desc
);
2969 const wxCharBuffer data
= wxGTK_CONV( string
);
2971 pango_layout_set_text(layout
, data
, strlen(data
));
2974 PangoRectangle rect
;
2975 pango_layout_get_extents(layout
, NULL
, &rect
);
2977 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
2978 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
2981 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
2982 int baseline
= pango_layout_iter_get_baseline(iter
);
2983 pango_layout_iter_free(iter
);
2984 *descent
= *y
- PANGO_PIXELS(baseline
);
2986 if (externalLeading
) (*externalLeading
) = 0; // ??
2988 g_object_unref (layout
);
2991 void wxWindowGTK::GTKDisableFocusOutEvent()
2993 g_signal_handlers_block_by_func( m_focusWidget
,
2994 (gpointer
) gtk_window_focus_out_callback
, this);
2997 void wxWindowGTK::GTKEnableFocusOutEvent()
2999 g_signal_handlers_unblock_by_func( m_focusWidget
,
3000 (gpointer
) gtk_window_focus_out_callback
, this);
3003 bool wxWindowGTK::GTKHandleFocusIn()
3005 // Disable default focus handling for custom windows since the default GTK+
3006 // handler issues a repaint
3007 const bool retval
= m_wxwindow
? true : false;
3010 // NB: if there's still unprocessed deferred focus-out event (see
3011 // GTKHandleFocusOut() for explanation), we need to process it first so
3012 // that the order of focus events -- focus-out first, then focus-in
3013 // elsewhere -- is preserved
3014 if ( gs_deferredFocusOut
)
3016 if ( GTKNeedsToFilterSameWindowFocus() &&
3017 gs_deferredFocusOut
== this )
3019 // GTK+ focus changed from this wxWindow back to itself, so don't
3020 // emit any events at all
3021 wxLogTrace(TRACE_FOCUS
,
3022 "filtered out spurious focus change within %s(%p, %s)",
3023 GetClassInfo()->GetClassName(), this, GetLabel());
3024 gs_deferredFocusOut
= NULL
;
3028 // otherwise we need to send focus-out first
3029 wxASSERT_MSG ( gs_deferredFocusOut
!= this,
3030 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
3031 GTKHandleDeferredFocusOut();
3035 wxLogTrace(TRACE_FOCUS
,
3036 "handling focus_in event for %s(%p, %s)",
3037 GetClassInfo()->GetClassName(), this, GetLabel());
3040 gtk_im_context_focus_in(m_imData
->context
);
3042 gs_currentFocus
= this;
3043 gs_pendingFocus
= NULL
;
3046 // caret needs to be informed about focus change
3047 wxCaret
*caret
= GetCaret();
3050 caret
->OnSetFocus();
3052 #endif // wxUSE_CARET
3054 // Notify the parent keeping track of focus for the kbd navigation
3055 // purposes that we got it.
3056 wxChildFocusEvent
eventChildFocus(static_cast<wxWindow
*>(this));
3057 GTKProcessEvent(eventChildFocus
);
3059 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, GetId());
3060 eventFocus
.SetEventObject(this);
3061 GTKProcessEvent(eventFocus
);
3066 bool wxWindowGTK::GTKHandleFocusOut()
3068 // Disable default focus handling for custom windows since the default GTK+
3069 // handler issues a repaint
3070 const bool retval
= m_wxwindow
? true : false;
3073 // NB: If a control is composed of several GtkWidgets and when focus
3074 // changes from one of them to another within the same wxWindow, we get
3075 // a focus-out event followed by focus-in for another GtkWidget owned
3076 // by the same wx control. We don't want to generate two spurious
3077 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3078 // from GTKHandleFocusOut() until we know for sure it's not coming back
3079 // (i.e. in GTKHandleFocusIn() or at idle time).
3080 if ( GTKNeedsToFilterSameWindowFocus() )
3082 wxASSERT_MSG( gs_deferredFocusOut
== NULL
,
3083 "deferred focus out event already pending" );
3084 wxLogTrace(TRACE_FOCUS
,
3085 "deferring focus_out event for %s(%p, %s)",
3086 GetClassInfo()->GetClassName(), this, GetLabel());
3087 gs_deferredFocusOut
= this;
3091 GTKHandleFocusOutNoDeferring();
3096 void wxWindowGTK::GTKHandleFocusOutNoDeferring()
3098 wxLogTrace(TRACE_FOCUS
,
3099 "handling focus_out event for %s(%p, %s)",
3100 GetClassInfo()->GetClassName(), this, GetLabel());
3103 gtk_im_context_focus_out(m_imData
->context
);
3105 if ( gs_currentFocus
!= this )
3107 // Something is terribly wrong, gs_currentFocus is out of sync with the
3108 // real focus. We will reset it to NULL anyway, because after this
3109 // focus-out event is handled, one of the following with happen:
3111 // * either focus will go out of the app altogether, in which case
3112 // gs_currentFocus _should_ be NULL
3114 // * or it goes to another control, in which case focus-in event will
3115 // follow immediately and it will set gs_currentFocus to the right
3117 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3118 GetClassInfo()->GetClassName(), this, GetLabel());
3120 gs_currentFocus
= NULL
;
3123 // caret needs to be informed about focus change
3124 wxCaret
*caret
= GetCaret();
3127 caret
->OnKillFocus();
3129 #endif // wxUSE_CARET
3131 wxFocusEvent
event( wxEVT_KILL_FOCUS
, GetId() );
3132 event
.SetEventObject( this );
3133 GTKProcessEvent( event
);
3137 void wxWindowGTK::GTKHandleDeferredFocusOut()
3139 // NB: See GTKHandleFocusOut() for explanation. This function is called
3140 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3142 if ( gs_deferredFocusOut
)
3144 wxWindowGTK
*win
= gs_deferredFocusOut
;
3145 gs_deferredFocusOut
= NULL
;
3147 wxLogTrace(TRACE_FOCUS
,
3148 "processing deferred focus_out event for %s(%p, %s)",
3149 win
->GetClassInfo()->GetClassName(), win
, win
->GetLabel());
3151 win
->GTKHandleFocusOutNoDeferring();
3155 void wxWindowGTK::SetFocus()
3157 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3159 // Setting "physical" focus is not immediate in GTK+ and while
3160 // gtk_widget_is_focus ("determines if the widget is the focus widget
3161 // within its toplevel", i.e. returns true for one widget per TLW, not
3162 // globally) returns true immediately after grabbing focus,
3163 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3164 // has focus at the moment) takes effect only after the window is shown
3165 // (if it was hidden at the moment of the call) or at the next event loop
3168 // Because we want to FindFocus() call immediately following
3169 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3171 gs_pendingFocus
= this;
3173 GtkWidget
*widget
= m_wxwindow
? m_wxwindow
: m_focusWidget
;
3175 if ( GTK_IS_CONTAINER(widget
) &&
3176 !gtk_widget_get_can_focus(widget
) )
3178 wxLogTrace(TRACE_FOCUS
,
3179 wxT("Setting focus to a child of %s(%p, %s)"),
3180 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3181 gtk_widget_child_focus(widget
, GTK_DIR_TAB_FORWARD
);
3185 wxLogTrace(TRACE_FOCUS
,
3186 wxT("Setting focus to %s(%p, %s)"),
3187 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3188 gtk_widget_grab_focus(widget
);
3192 void wxWindowGTK::SetCanFocus(bool canFocus
)
3194 gtk_widget_set_can_focus(m_widget
, canFocus
);
3196 if ( m_wxwindow
&& (m_widget
!= m_wxwindow
) )
3198 gtk_widget_set_can_focus(m_wxwindow
, canFocus
);
3202 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3204 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3206 wxWindowGTK
*oldParent
= m_parent
,
3207 *newParent
= (wxWindowGTK
*)newParentBase
;
3209 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3211 if ( !wxWindowBase::Reparent(newParent
) )
3214 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3217 gtk_container_remove(GTK_CONTAINER(gtk_widget_get_parent(m_widget
)), m_widget
);
3219 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3223 if (gtk_widget_get_visible (newParent
->m_widget
))
3225 m_showOnIdle
= true;
3226 gtk_widget_hide( m_widget
);
3228 /* insert GTK representation */
3229 newParent
->AddChildGTK(this);
3232 SetLayoutDirection(wxLayout_Default
);
3237 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3239 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3240 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3245 /* insert GTK representation */
3249 void wxWindowGTK::AddChild(wxWindowBase
*child
)
3251 wxWindowBase::AddChild(child
);
3252 m_dirtyTabOrder
= true;
3253 wxTheApp
->WakeUpIdle();
3256 void wxWindowGTK::RemoveChild(wxWindowBase
*child
)
3258 wxWindowBase::RemoveChild(child
);
3259 m_dirtyTabOrder
= true;
3260 wxTheApp
->WakeUpIdle();
3264 wxLayoutDirection
wxWindowGTK::GTKGetLayout(GtkWidget
*widget
)
3266 return gtk_widget_get_direction(widget
) == GTK_TEXT_DIR_RTL
3267 ? wxLayout_RightToLeft
3268 : wxLayout_LeftToRight
;
3272 void wxWindowGTK::GTKSetLayout(GtkWidget
*widget
, wxLayoutDirection dir
)
3274 wxASSERT_MSG( dir
!= wxLayout_Default
, wxT("invalid layout direction") );
3276 gtk_widget_set_direction(widget
,
3277 dir
== wxLayout_RightToLeft
? GTK_TEXT_DIR_RTL
3278 : GTK_TEXT_DIR_LTR
);
3281 wxLayoutDirection
wxWindowGTK::GetLayoutDirection() const
3283 return GTKGetLayout(m_widget
);
3286 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir
)
3288 if ( dir
== wxLayout_Default
)
3290 const wxWindow
*const parent
= GetParent();
3293 // inherit layout from parent.
3294 dir
= parent
->GetLayoutDirection();
3296 else // no parent, use global default layout
3298 dir
= wxTheApp
->GetLayoutDirection();
3302 if ( dir
== wxLayout_Default
)
3305 GTKSetLayout(m_widget
, dir
);
3307 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3308 GTKSetLayout(m_wxwindow
, dir
);
3312 wxWindowGTK::AdjustForLayoutDirection(wxCoord x
,
3313 wxCoord
WXUNUSED(width
),
3314 wxCoord
WXUNUSED(widthTotal
)) const
3316 // We now mirror the coordinates of RTL windows in wxPizza
3320 void wxWindowGTK::DoMoveInTabOrder(wxWindow
*win
, WindowOrder move
)
3322 wxWindowBase::DoMoveInTabOrder(win
, move
);
3323 m_dirtyTabOrder
= true;
3324 wxTheApp
->WakeUpIdle();
3327 bool wxWindowGTK::DoNavigateIn(int flags
)
3329 if ( flags
& wxNavigationKeyEvent::WinChange
)
3331 wxFAIL_MSG( wxT("not implemented") );
3335 else // navigate inside the container
3337 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3338 wxCHECK_MSG( parent
, false, wxT("every window must have a TLW parent") );
3340 GtkDirectionType dir
;
3341 dir
= flags
& wxNavigationKeyEvent::IsForward
? GTK_DIR_TAB_FORWARD
3342 : GTK_DIR_TAB_BACKWARD
;
3345 g_signal_emit_by_name(parent
->m_widget
, "focus", dir
, &rc
);
3351 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3353 // none needed by default
3357 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3359 // nothing to do by default since none is needed
3362 void wxWindowGTK::RealizeTabOrder()
3366 if ( !m_children
.empty() )
3368 // we don't only construct the correct focus chain but also use
3369 // this opportunity to update the mnemonic widgets for the widgets
3372 GList
*chain
= NULL
;
3373 wxWindowGTK
* mnemonicWindow
= NULL
;
3375 for ( wxWindowList::const_iterator i
= m_children
.begin();
3376 i
!= m_children
.end();
3379 wxWindowGTK
*win
= *i
;
3381 if ( mnemonicWindow
)
3383 if ( win
->AcceptsFocusFromKeyboard() )
3385 // wxComboBox et al. needs to focus on on a different
3386 // widget than m_widget, so if the main widget isn't
3387 // focusable try the connect widget
3388 GtkWidget
* w
= win
->m_widget
;
3389 if ( !gtk_widget_get_can_focus(w
) )
3391 w
= win
->GetConnectWidget();
3392 if ( !gtk_widget_get_can_focus(w
) )
3398 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3399 mnemonicWindow
= NULL
;
3403 else if ( win
->GTKWidgetNeedsMnemonic() )
3405 mnemonicWindow
= win
;
3408 chain
= g_list_prepend(chain
, win
->m_widget
);
3411 chain
= g_list_reverse(chain
);
3413 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3418 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3423 void wxWindowGTK::Raise()
3425 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3427 if (m_wxwindow
&& gtk_widget_get_window(m_wxwindow
))
3429 gdk_window_raise(gtk_widget_get_window(m_wxwindow
));
3431 else if (gtk_widget_get_window(m_widget
))
3433 gdk_window_raise(gtk_widget_get_window(m_widget
));
3437 void wxWindowGTK::Lower()
3439 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3441 if (m_wxwindow
&& gtk_widget_get_window(m_wxwindow
))
3443 gdk_window_lower(gtk_widget_get_window(m_wxwindow
));
3445 else if (gtk_widget_get_window(m_widget
))
3447 gdk_window_lower(gtk_widget_get_window(m_widget
));
3451 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3453 if ( !wxWindowBase::SetCursor(cursor
.IsOk() ? cursor
: *wxSTANDARD_CURSOR
) )
3461 void wxWindowGTK::GTKUpdateCursor(bool update_self
/*=true*/, bool recurse
/*=true*/)
3465 wxCursor
cursor(g_globalCursor
.IsOk() ? g_globalCursor
: GetCursor());
3466 if ( cursor
.IsOk() )
3468 wxArrayGdkWindows windowsThis
;
3469 GdkWindow
* window
= GTKGetWindow(windowsThis
);
3471 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3474 const size_t count
= windowsThis
.size();
3475 for ( size_t n
= 0; n
< count
; n
++ )
3477 GdkWindow
*win
= windowsThis
[n
];
3478 // It can be zero if the window has not been realized yet.
3481 gdk_window_set_cursor(win
, cursor
.GetCursor());
3490 for (wxWindowList::iterator it
= GetChildren().begin(); it
!= GetChildren().end(); ++it
)
3492 (*it
)->GTKUpdateCursor( true );
3497 void wxWindowGTK::WarpPointer( int x
, int y
)
3499 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3501 // We provide this function ourselves as it is
3502 // missing in GDK (top of this file).
3504 GdkWindow
*window
= NULL
;
3506 window
= gtk_widget_get_window(m_wxwindow
);
3508 window
= gtk_widget_get_window(GetConnectWidget());
3511 gdk_window_warp_pointer( window
, x
, y
);
3514 wxWindowGTK::ScrollDir
wxWindowGTK::ScrollDirFromRange(GtkRange
*range
) const
3516 // find the scrollbar which generated the event
3517 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3519 if ( range
== m_scrollBar
[dir
] )
3520 return (ScrollDir
)dir
;
3523 wxFAIL_MSG( wxT("event from unknown scrollbar received") );
3525 return ScrollDir_Max
;
3528 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3530 bool changed
= false;
3531 GtkRange
* range
= m_scrollBar
[dir
];
3532 if ( range
&& units
)
3534 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
3535 double inc
= unit
== ScrollUnit_Line
? gtk_adjustment_get_step_increment(adj
)
3536 : gtk_adjustment_get_page_increment(adj
);
3538 const int posOld
= wxRound(gtk_adjustment_get_value(adj
));
3539 gtk_range_set_value(range
, posOld
+ units
*inc
);
3541 changed
= wxRound(gtk_adjustment_get_value(adj
)) != posOld
;
3547 bool wxWindowGTK::ScrollLines(int lines
)
3549 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3552 bool wxWindowGTK::ScrollPages(int pages
)
3554 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3557 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground
),
3562 // it is valid to call Refresh() for a window which hasn't been created
3563 // yet, it simply doesn't do anything in this case
3570 gtk_widget_queue_draw_area( m_widget
, rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3572 gtk_widget_queue_draw( m_widget
);
3576 // Just return if the widget or one of its ancestors isn't mapped
3578 for (w
= m_wxwindow
; w
!= NULL
; w
= gtk_widget_get_parent(w
))
3579 if (!gtk_widget_get_mapped (w
))
3582 GdkWindow
* window
= GTKGetDrawingWindow();
3586 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3587 x
= GetClientSize().x
- x
- rect
->width
;
3591 r
.width
= rect
->width
;
3592 r
.height
= rect
->height
;
3593 gdk_window_invalidate_rect(window
, &r
, true);
3596 gdk_window_invalidate_rect(window
, NULL
, true);
3600 void wxWindowGTK::Update()
3602 if (m_widget
&& gtk_widget_get_mapped(m_widget
))
3604 GdkDisplay
* display
= gtk_widget_get_display(m_widget
);
3605 // Flush everything out to the server, and wait for it to finish.
3606 // This ensures nothing will overwrite the drawing we are about to do.
3607 gdk_display_sync(display
);
3609 GdkWindow
* window
= GTKGetDrawingWindow();
3611 window
= gtk_widget_get_window(m_widget
);
3612 gdk_window_process_updates(window
, true);
3614 // Flush again, but no need to wait for it to finish
3615 gdk_display_flush(display
);
3619 bool wxWindowGTK::DoIsExposed( int x
, int y
) const
3621 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
3624 bool wxWindowGTK::DoIsExposed( int x
, int y
, int w
, int h
) const
3626 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3627 return m_updateRegion
.Contains(x
-w
, y
, w
, h
) != wxOutRegion
;
3629 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
3632 void wxWindowGTK::GtkSendPaintEvents()
3636 m_updateRegion
.Clear();
3640 // Clip to paint region in wxClientDC
3641 m_clipPaintRegion
= true;
3643 m_nativeUpdateRegion
= m_updateRegion
;
3645 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3647 // Transform m_updateRegion under RTL
3648 m_updateRegion
.Clear();
3651 gdk_drawable_get_size(gtk_widget_get_window(m_wxwindow
), &width
, NULL
);
3653 wxRegionIterator
upd( m_nativeUpdateRegion
);
3657 rect
.x
= upd
.GetX();
3658 rect
.y
= upd
.GetY();
3659 rect
.width
= upd
.GetWidth();
3660 rect
.height
= upd
.GetHeight();
3662 rect
.x
= width
- rect
.x
- rect
.width
;
3663 m_updateRegion
.Union( rect
);
3669 switch ( GetBackgroundStyle() )
3671 case wxBG_STYLE_ERASE
:
3673 wxWindowDC
dc( (wxWindow
*)this );
3674 dc
.SetDeviceClippingRegion( m_updateRegion
);
3676 // Work around gtk-qt <= 0.60 bug whereby the window colour
3680 GetOptionInt("gtk.window.force-background-colour") )
3682 dc
.SetBackground(GetBackgroundColour());
3686 wxEraseEvent
erase_event( GetId(), &dc
);
3687 erase_event
.SetEventObject( this );
3689 if ( HandleWindowEvent(erase_event
) )
3691 // background erased, don't do it again
3697 case wxBG_STYLE_SYSTEM
:
3698 if ( GetThemeEnabled() )
3700 // find ancestor from which to steal background
3701 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3703 parent
= (wxWindow
*)this;
3705 if (gtk_widget_get_mapped(parent
->m_widget
))
3707 wxRegionIterator
upd( m_nativeUpdateRegion
);
3711 rect
.x
= upd
.GetX();
3712 rect
.y
= upd
.GetY();
3713 rect
.width
= upd
.GetWidth();
3714 rect
.height
= upd
.GetHeight();
3716 gtk_paint_flat_box(gtk_widget_get_style(parent
->m_widget
),
3717 GTKGetDrawingWindow(),
3718 gtk_widget_get_state(m_wxwindow
),
3731 case wxBG_STYLE_PAINT
:
3732 // nothing to do: window will be painted over in EVT_PAINT
3736 wxFAIL_MSG( "unsupported background style" );
3739 wxNcPaintEvent
nc_paint_event( GetId() );
3740 nc_paint_event
.SetEventObject( this );
3741 HandleWindowEvent( nc_paint_event
);
3743 wxPaintEvent
paint_event( GetId() );
3744 paint_event
.SetEventObject( this );
3745 HandleWindowEvent( paint_event
);
3747 m_clipPaintRegion
= false;
3749 m_updateRegion
.Clear();
3750 m_nativeUpdateRegion
.Clear();
3753 void wxWindowGTK::SetDoubleBuffered( bool on
)
3755 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3758 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3761 bool wxWindowGTK::IsDoubleBuffered() const
3763 return gtk_widget_get_double_buffered( m_wxwindow
);
3766 void wxWindowGTK::ClearBackground()
3768 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3772 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3774 if (m_tooltip
!= tip
)
3776 wxWindowBase::DoSetToolTip(tip
);
3779 m_tooltip
->GTKSetWindow(static_cast<wxWindow
*>(this));
3781 GTKApplyToolTip(NULL
);
3785 void wxWindowGTK::GTKApplyToolTip(const char* tip
)
3787 wxToolTip::GTKApply(GetConnectWidget(), tip
);
3789 #endif // wxUSE_TOOLTIPS
3791 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
3793 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3795 if (!wxWindowBase::SetBackgroundColour(colour
))
3800 // We need the pixel value e.g. for background clearing.
3801 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3804 // apply style change (forceStyle=true so that new style is applied
3805 // even if the bg colour changed from valid to wxNullColour)
3806 GTKApplyWidgetStyle(true);
3811 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
3813 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3815 if (!wxWindowBase::SetForegroundColour(colour
))
3822 // We need the pixel value e.g. for background clearing.
3823 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3826 // apply style change (forceStyle=true so that new style is applied
3827 // even if the bg colour changed from valid to wxNullColour):
3828 GTKApplyWidgetStyle(true);
3833 PangoContext
*wxWindowGTK::GTKGetPangoDefaultContext()
3835 return gtk_widget_get_pango_context( m_widget
);
3838 GtkRcStyle
*wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle
)
3840 // do we need to apply any changes at all?
3843 !m_foregroundColour
.IsOk() && !m_backgroundColour
.IsOk() )
3848 GtkRcStyle
*style
= gtk_rc_style_new();
3850 if ( m_font
.IsOk() )
3853 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
3856 int flagsNormal
= 0,
3859 flagsInsensitive
= 0;
3861 if ( m_foregroundColour
.IsOk() )
3863 const GdkColor
*fg
= m_foregroundColour
.GetColor();
3865 style
->fg
[GTK_STATE_NORMAL
] =
3866 style
->text
[GTK_STATE_NORMAL
] = *fg
;
3867 flagsNormal
|= GTK_RC_FG
| GTK_RC_TEXT
;
3869 style
->fg
[GTK_STATE_PRELIGHT
] =
3870 style
->text
[GTK_STATE_PRELIGHT
] = *fg
;
3871 flagsPrelight
|= GTK_RC_FG
| GTK_RC_TEXT
;
3873 style
->fg
[GTK_STATE_ACTIVE
] =
3874 style
->text
[GTK_STATE_ACTIVE
] = *fg
;
3875 flagsActive
|= GTK_RC_FG
| GTK_RC_TEXT
;
3878 if ( m_backgroundColour
.IsOk() )
3880 const GdkColor
*bg
= m_backgroundColour
.GetColor();
3882 style
->bg
[GTK_STATE_NORMAL
] =
3883 style
->base
[GTK_STATE_NORMAL
] = *bg
;
3884 flagsNormal
|= GTK_RC_BG
| GTK_RC_BASE
;
3886 style
->bg
[GTK_STATE_PRELIGHT
] =
3887 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
3888 flagsPrelight
|= GTK_RC_BG
| GTK_RC_BASE
;
3890 style
->bg
[GTK_STATE_ACTIVE
] =
3891 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
3892 flagsActive
|= GTK_RC_BG
| GTK_RC_BASE
;
3894 style
->bg
[GTK_STATE_INSENSITIVE
] =
3895 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
3896 flagsInsensitive
|= GTK_RC_BG
| GTK_RC_BASE
;
3899 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)flagsNormal
;
3900 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)flagsPrelight
;
3901 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)flagsActive
;
3902 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)flagsInsensitive
;
3907 void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle
)
3909 GtkRcStyle
*style
= GTKCreateWidgetStyle(forceStyle
);
3912 DoApplyWidgetStyle(style
);
3913 g_object_unref(style
);
3916 // Style change may affect GTK+'s size calculation:
3917 InvalidateBestSize();
3920 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
3924 // block the signal temporarily to avoid sending
3925 // wxSysColourChangedEvents when we change the colours ourselves
3926 bool unblock
= false;
3930 g_signal_handlers_block_by_func(
3931 m_wxwindow
, (void *)gtk_window_style_set_callback
, this);
3934 gtk_widget_modify_style(m_wxwindow
, style
);
3938 g_signal_handlers_unblock_by_func(
3939 m_wxwindow
, (void *)gtk_window_style_set_callback
, this);
3944 gtk_widget_modify_style(m_widget
, style
);
3948 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style
)
3950 wxWindowBase::SetBackgroundStyle(style
);
3952 if ( style
== wxBG_STYLE_PAINT
)
3957 window
= GTKGetDrawingWindow();
3961 GtkWidget
* const w
= GetConnectWidget();
3962 window
= w
? gtk_widget_get_window(w
) : NULL
;
3967 // Make sure GDK/X11 doesn't refresh the window
3969 gdk_window_set_back_pixmap( window
, None
, False
);
3971 Display
* display
= GDK_WINDOW_DISPLAY(window
);
3974 m_needsStyleChange
= false;
3976 else // window not realized yet
3978 // Do in OnIdle, because the window is not yet available
3979 m_needsStyleChange
= true;
3982 // Don't apply widget style, or we get a grey background
3986 // apply style change (forceStyle=true so that new style is applied
3987 // even if the bg colour changed from valid to wxNullColour):
3988 GTKApplyWidgetStyle(true);
3994 // ----------------------------------------------------------------------------
3995 // Pop-up menu stuff
3996 // ----------------------------------------------------------------------------
3998 #if wxUSE_MENUS_NATIVE
4002 void wxPopupMenuPositionCallback( GtkMenu
*menu
,
4004 gboolean
* WXUNUSED(whatever
),
4005 gpointer user_data
)
4007 // ensure that the menu appears entirely on screen
4009 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
4011 wxSize sizeScreen
= wxGetDisplaySize();
4012 wxPoint
*pos
= (wxPoint
*)user_data
;
4014 gint xmax
= sizeScreen
.x
- req
.width
,
4015 ymax
= sizeScreen
.y
- req
.height
;
4017 *x
= pos
->x
< xmax
? pos
->x
: xmax
;
4018 *y
= pos
->y
< ymax
? pos
->y
: ymax
;
4022 bool wxWindowGTK::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
4024 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4030 GtkMenuPositionFunc posfunc
;
4031 if ( x
== -1 && y
== -1 )
4033 // use GTK's default positioning algorithm
4039 pos
= ClientToScreen(wxPoint(x
, y
));
4041 posfunc
= wxPopupMenuPositionCallback
;
4044 menu
->m_popupShown
= true;
4046 GTK_MENU(menu
->m_menu
),
4047 NULL
, // parent menu shell
4048 NULL
, // parent menu item
4049 posfunc
, // function to position it
4050 userdata
, // client data
4051 0, // button used to activate it
4052 gtk_get_current_event_time()
4055 while (menu
->m_popupShown
)
4057 gtk_main_iteration();
4063 #endif // wxUSE_MENUS_NATIVE
4065 #if wxUSE_DRAG_AND_DROP
4067 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4069 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4071 GtkWidget
*dnd_widget
= GetConnectWidget();
4073 if (m_dropTarget
) m_dropTarget
->GtkUnregisterWidget( dnd_widget
);
4075 if (m_dropTarget
) delete m_dropTarget
;
4076 m_dropTarget
= dropTarget
;
4078 if (m_dropTarget
) m_dropTarget
->GtkRegisterWidget( dnd_widget
);
4081 #endif // wxUSE_DRAG_AND_DROP
4083 GtkWidget
* wxWindowGTK::GetConnectWidget()
4085 GtkWidget
*connect_widget
= m_widget
;
4086 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4088 return connect_widget
;
4091 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow
*window
) const
4093 wxArrayGdkWindows windowsThis
;
4094 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
4096 return winThis
? window
== winThis
4097 : windowsThis
.Index(window
) != wxNOT_FOUND
;
4100 GdkWindow
*wxWindowGTK::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
4102 return m_wxwindow
? GTKGetDrawingWindow() : gtk_widget_get_window(m_widget
);
4105 bool wxWindowGTK::SetFont( const wxFont
&font
)
4107 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4109 if (!wxWindowBase::SetFont(font
))
4112 // apply style change (forceStyle=true so that new style is applied
4113 // even if the font changed from valid to wxNullFont):
4114 GTKApplyWidgetStyle(true);
4119 void wxWindowGTK::DoCaptureMouse()
4121 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4123 GdkWindow
*window
= NULL
;
4125 window
= GTKGetDrawingWindow();
4127 window
= gtk_widget_get_window(GetConnectWidget());
4129 wxCHECK_RET( window
, wxT("CaptureMouse() failed") );
4131 const wxCursor
* cursor
= &m_cursor
;
4132 if (!cursor
->IsOk())
4133 cursor
= wxSTANDARD_CURSOR
;
4135 gdk_pointer_grab( window
, FALSE
,
4137 (GDK_BUTTON_PRESS_MASK
|
4138 GDK_BUTTON_RELEASE_MASK
|
4139 GDK_POINTER_MOTION_HINT_MASK
|
4140 GDK_POINTER_MOTION_MASK
),
4142 cursor
->GetCursor(),
4143 (guint32
)GDK_CURRENT_TIME
);
4144 g_captureWindow
= this;
4145 g_captureWindowHasMouse
= true;
4148 void wxWindowGTK::DoReleaseMouse()
4150 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4152 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4154 g_captureWindow
= NULL
;
4156 GdkWindow
*window
= NULL
;
4158 window
= GTKGetDrawingWindow();
4160 window
= gtk_widget_get_window(GetConnectWidget());
4165 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4168 void wxWindowGTK::GTKReleaseMouseAndNotify()
4171 wxMouseCaptureLostEvent
evt(GetId());
4172 evt
.SetEventObject( this );
4173 HandleWindowEvent( evt
);
4177 wxWindow
*wxWindowBase::GetCapture()
4179 return (wxWindow
*)g_captureWindow
;
4182 bool wxWindowGTK::IsRetained() const
4187 void wxWindowGTK::SetScrollbar(int orient
,
4191 bool WXUNUSED(update
))
4193 const int dir
= ScrollDirFromOrient(orient
);
4194 GtkRange
* const sb
= m_scrollBar
[dir
];
4195 wxCHECK_RET( sb
, wxT("this window is not scrollable") );
4199 // GtkRange requires upper > lower
4204 g_signal_handlers_block_by_func(
4205 sb
, (void*)gtk_scrollbar_value_changed
, this);
4207 gtk_range_set_increments(sb
, 1, thumbVisible
);
4208 gtk_adjustment_set_page_size(gtk_range_get_adjustment(sb
), thumbVisible
);
4209 gtk_range_set_range(sb
, 0, range
);
4210 gtk_range_set_value(sb
, pos
);
4211 m_scrollPos
[dir
] = gtk_range_get_value(sb
);
4213 g_signal_handlers_unblock_by_func(
4214 sb
, (void*)gtk_scrollbar_value_changed
, this);
4217 void wxWindowGTK::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4219 const int dir
= ScrollDirFromOrient(orient
);
4220 GtkRange
* const sb
= m_scrollBar
[dir
];
4221 wxCHECK_RET( sb
, wxT("this window is not scrollable") );
4223 // This check is more than an optimization. Without it, the slider
4224 // will not move smoothly while tracking when using wxScrollHelper.
4225 if (GetScrollPos(orient
) != pos
)
4227 g_signal_handlers_block_by_func(
4228 sb
, (void*)gtk_scrollbar_value_changed
, this);
4230 gtk_range_set_value(sb
, pos
);
4231 m_scrollPos
[dir
] = gtk_range_get_value(sb
);
4233 g_signal_handlers_unblock_by_func(
4234 sb
, (void*)gtk_scrollbar_value_changed
, this);
4238 int wxWindowGTK::GetScrollThumb(int orient
) const
4240 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4241 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4243 return wxRound(gtk_adjustment_get_page_size(gtk_range_get_adjustment(sb
)));
4246 int wxWindowGTK::GetScrollPos( int orient
) const
4248 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4249 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4251 return wxRound(gtk_range_get_value(sb
));
4254 int wxWindowGTK::GetScrollRange( int orient
) const
4256 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4257 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4259 return wxRound(gtk_adjustment_get_upper(gtk_range_get_adjustment(sb
)));
4262 // Determine if increment is the same as +/-x, allowing for some small
4263 // difference due to possible inexactness in floating point arithmetic
4264 static inline bool IsScrollIncrement(double increment
, double x
)
4266 wxASSERT(increment
> 0);
4267 const double tolerance
= 1.0 / 1024;
4268 return fabs(increment
- fabs(x
)) < tolerance
;
4271 wxEventType
wxWindowGTK::GTKGetScrollEventType(GtkRange
* range
)
4273 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4275 const int barIndex
= range
== m_scrollBar
[1];
4277 const double value
= gtk_range_get_value(range
);
4279 // save previous position
4280 const double oldPos
= m_scrollPos
[barIndex
];
4281 // update current position
4282 m_scrollPos
[barIndex
] = value
;
4283 // If event should be ignored, or integral position has not changed
4284 if (!m_hasVMT
|| g_blockEventsOnDrag
|| wxRound(value
) == wxRound(oldPos
))
4289 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4292 // Difference from last change event
4293 const double diff
= value
- oldPos
;
4294 const bool isDown
= diff
> 0;
4296 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
4297 if (IsScrollIncrement(gtk_adjustment_get_step_increment(adj
), diff
))
4299 eventType
= isDown
? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4301 else if (IsScrollIncrement(gtk_adjustment_get_page_increment(adj
), diff
))
4303 eventType
= isDown
? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4305 else if (m_mouseButtonDown
)
4307 // Assume track event
4308 m_isScrolling
= true;
4314 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4316 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4318 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4320 // No scrolling requested.
4321 if ((dx
== 0) && (dy
== 0)) return;
4323 m_clipPaintRegion
= true;
4325 WX_PIZZA(m_wxwindow
)->scroll(dx
, dy
);
4327 m_clipPaintRegion
= false;
4330 bool restoreCaret
= (GetCaret() != NULL
&& GetCaret()->IsVisible());
4333 wxRect
caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4335 caretRect
.width
+= dx
;
4338 caretRect
.x
+= dx
; caretRect
.width
-= dx
;
4341 caretRect
.height
+= dy
;
4344 caretRect
.y
+= dy
; caretRect
.height
-= dy
;
4347 RefreshRect(caretRect
);
4349 #endif // wxUSE_CARET
4352 void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4354 //RN: Note that static controls usually have no border on gtk, so maybe
4355 //it makes sense to treat that as simply no border at the wx level
4357 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4359 GtkShadowType gtkstyle
;
4361 if(wxstyle
& wxBORDER_RAISED
)
4362 gtkstyle
= GTK_SHADOW_OUT
;
4363 else if ((wxstyle
& wxBORDER_SUNKEN
) || (wxstyle
& wxBORDER_THEME
))
4364 gtkstyle
= GTK_SHADOW_IN
;
4367 else if (wxstyle
& wxBORDER_DOUBLE
)
4368 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4371 gtkstyle
= GTK_SHADOW_IN
;
4373 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4378 void wxWindowGTK::SetWindowStyleFlag( long style
)
4380 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4381 wxWindowBase::SetWindowStyleFlag(style
);
4384 // Find the wxWindow at the current mouse position, also returning the mouse
4386 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4388 pt
= wxGetMousePosition();
4389 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4393 // Get the current mouse position.
4394 wxPoint
wxGetMousePosition()
4396 /* This crashes when used within wxHelpContext,
4397 so we have to use the X-specific implementation below.
4399 GdkModifierType *mask;
4400 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4402 return wxPoint(x, y);
4406 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4408 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4409 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4410 Window rootReturn
, childReturn
;
4411 int rootX
, rootY
, winX
, winY
;
4412 unsigned int maskReturn
;
4414 XQueryPointer (display
,
4418 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4419 return wxPoint(rootX
, rootY
);
4423 GdkWindow
* wxWindowGTK::GTKGetDrawingWindow() const
4425 GdkWindow
* window
= NULL
;
4427 window
= gtk_widget_get_window(m_wxwindow
);
4431 // ----------------------------------------------------------------------------
4433 // ----------------------------------------------------------------------------
4438 // this is called if we attempted to freeze unrealized widget when it finally
4439 // is realized (and so can be frozen):
4440 static void wx_frozen_widget_realize(GtkWidget
* w
, wxWindowGTK
* win
)
4442 wxASSERT( w
&& gtk_widget_get_has_window(w
) );
4443 wxASSERT( gtk_widget_get_realized(w
) );
4445 g_signal_handlers_disconnect_by_func
4448 (void*)wx_frozen_widget_realize
,
4453 if (w
== win
->m_wxwindow
)
4454 window
= win
->GTKGetDrawingWindow();
4456 window
= gtk_widget_get_window(w
);
4457 gdk_window_freeze_updates(window
);
4462 void wxWindowGTK::GTKFreezeWidget(GtkWidget
*w
)
4464 if ( !w
|| !gtk_widget_get_has_window(w
) )
4465 return; // window-less widget, cannot be frozen
4467 GdkWindow
* window
= gtk_widget_get_window(w
);
4470 // we can't thaw unrealized widgets because they don't have GdkWindow,
4471 // so set it up to be done immediately after realization:
4472 g_signal_connect_after
4476 G_CALLBACK(wx_frozen_widget_realize
),
4482 if (w
== m_wxwindow
)
4483 window
= GTKGetDrawingWindow();
4484 gdk_window_freeze_updates(window
);
4487 void wxWindowGTK::GTKThawWidget(GtkWidget
*w
)
4489 if ( !w
|| !gtk_widget_get_has_window(w
) )
4490 return; // window-less widget, cannot be frozen
4492 GdkWindow
* window
= gtk_widget_get_window(w
);
4495 // the widget wasn't realized yet, no need to thaw
4496 g_signal_handlers_disconnect_by_func
4499 (void*)wx_frozen_widget_realize
,
4505 if (w
== m_wxwindow
)
4506 window
= GTKGetDrawingWindow();
4507 gdk_window_thaw_updates(window
);
4510 void wxWindowGTK::DoFreeze()
4512 GTKFreezeWidget(m_widget
);
4513 if ( m_wxwindow
&& m_widget
!= m_wxwindow
)
4514 GTKFreezeWidget(m_wxwindow
);
4517 void wxWindowGTK::DoThaw()
4519 GTKThawWidget(m_widget
);
4520 if ( m_wxwindow
&& m_widget
!= m_wxwindow
)
4521 GTKThawWidget(m_wxwindow
);