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 // "size_request" of m_widget
238 //-----------------------------------------------------------------------------
242 wxgtk_window_size_request_callback(GtkWidget
* WXUNUSED(widget
),
243 GtkRequisition
*requisition
,
247 win
->GetSize( &w
, &h
);
253 requisition
->height
= h
;
254 requisition
->width
= w
;
258 //-----------------------------------------------------------------------------
259 // "expose_event" of m_wxwindow
260 //-----------------------------------------------------------------------------
264 gtk_window_expose_callback( GtkWidget
*,
265 GdkEventExpose
*gdk_event
,
268 if (gdk_event
->window
== win
->GTKGetDrawingWindow())
270 win
->GetUpdateRegion() = wxRegion( gdk_event
->region
);
271 win
->GtkSendPaintEvents();
273 // Let parent window draw window-less widgets
278 #ifndef __WXUNIVERSAL__
279 //-----------------------------------------------------------------------------
280 // "expose_event" from m_wxwindow->parent, for drawing border
281 //-----------------------------------------------------------------------------
285 expose_event_border(GtkWidget
* widget
, GdkEventExpose
* gdk_event
, wxWindow
* win
)
287 if (gdk_event
->window
!= gtk_widget_get_parent_window(win
->m_wxwindow
))
294 gtk_widget_get_allocation(win
->m_wxwindow
, &alloc
);
295 const int x
= alloc
.x
;
296 const int y
= alloc
.y
;
297 const int w
= alloc
.width
;
298 const int h
= alloc
.height
;
300 if (w
<= 0 || h
<= 0)
303 if (win
->HasFlag(wxBORDER_SIMPLE
))
305 gdk_draw_rectangle(gdk_event
->window
,
306 gtk_widget_get_style(widget
)->black_gc
, false, x
, y
, w
- 1, h
- 1);
310 GtkShadowType shadow
= GTK_SHADOW_IN
;
311 if (win
->HasFlag(wxBORDER_RAISED
))
312 shadow
= GTK_SHADOW_OUT
;
314 // Style detail to use
316 if (win
->m_widget
== win
->m_wxwindow
)
317 // for non-scrollable wxWindows
320 // for scrollable ones
323 // clip rect is required to avoid painting background
324 // over upper left (w,h) of parent window
325 GdkRectangle clipRect
= { x
, y
, w
, h
};
327 gtk_widget_get_style(win
->m_wxwindow
), gdk_event
->window
, GTK_STATE_NORMAL
,
328 shadow
, &clipRect
, wxGTKPrivate::GetEntryWidget(), detail
, x
, y
, w
, h
);
334 //-----------------------------------------------------------------------------
335 // "parent_set" from m_wxwindow
336 //-----------------------------------------------------------------------------
340 parent_set(GtkWidget
* widget
, GtkObject
* old_parent
, wxWindow
* win
)
344 g_signal_handlers_disconnect_by_func(
345 old_parent
, (void*)expose_event_border
, win
);
347 GtkWidget
* parent
= gtk_widget_get_parent(widget
);
350 g_signal_connect_after(parent
, "expose_event",
351 G_CALLBACK(expose_event_border
), win
);
355 #endif // !__WXUNIVERSAL__
357 //-----------------------------------------------------------------------------
358 // "key_press_event" from any window
359 //-----------------------------------------------------------------------------
361 // These are used when transforming Ctrl-alpha to ascii values 1-26
362 inline bool wxIsLowerChar(int code
)
364 return (code
>= 'a' && code
<= 'z' );
367 inline bool wxIsUpperChar(int code
)
369 return (code
>= 'A' && code
<= 'Z' );
373 // set WXTRACE to this to see the key event codes on the console
374 #define TRACE_KEYS wxT("keyevent")
376 // translates an X key symbol to WXK_XXX value
378 // if isChar is true it means that the value returned will be used for EVT_CHAR
379 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
380 // for example, while if it is false it means that the value is going to be
381 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
383 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
389 // Shift, Control and Alt don't generate the CHAR events at all
392 key_code
= isChar
? 0 : WXK_SHIFT
;
396 key_code
= isChar
? 0 : WXK_CONTROL
;
404 key_code
= isChar
? 0 : WXK_ALT
;
407 // neither do the toggle modifies
408 case GDK_Scroll_Lock
:
409 key_code
= isChar
? 0 : WXK_SCROLL
;
413 key_code
= isChar
? 0 : WXK_CAPITAL
;
417 key_code
= isChar
? 0 : WXK_NUMLOCK
;
421 // various other special keys
434 case GDK_ISO_Left_Tab
:
441 key_code
= WXK_RETURN
;
445 key_code
= WXK_CLEAR
;
449 key_code
= WXK_PAUSE
;
453 key_code
= WXK_SELECT
;
457 key_code
= WXK_PRINT
;
461 key_code
= WXK_EXECUTE
;
465 key_code
= WXK_ESCAPE
;
468 // cursor and other extended keyboard keys
470 key_code
= WXK_DELETE
;
486 key_code
= WXK_RIGHT
;
493 case GDK_Prior
: // == GDK_Page_Up
494 key_code
= WXK_PAGEUP
;
497 case GDK_Next
: // == GDK_Page_Down
498 key_code
= WXK_PAGEDOWN
;
510 key_code
= WXK_INSERT
;
525 key_code
= (isChar
? '0' : int(WXK_NUMPAD0
)) + keysym
- GDK_KP_0
;
529 key_code
= isChar
? ' ' : int(WXK_NUMPAD_SPACE
);
533 key_code
= isChar
? WXK_TAB
: WXK_NUMPAD_TAB
;
537 key_code
= isChar
? WXK_RETURN
: WXK_NUMPAD_ENTER
;
541 key_code
= isChar
? WXK_F1
: WXK_NUMPAD_F1
;
545 key_code
= isChar
? WXK_F2
: WXK_NUMPAD_F2
;
549 key_code
= isChar
? WXK_F3
: WXK_NUMPAD_F3
;
553 key_code
= isChar
? WXK_F4
: WXK_NUMPAD_F4
;
557 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_HOME
;
561 key_code
= isChar
? WXK_LEFT
: WXK_NUMPAD_LEFT
;
565 key_code
= isChar
? WXK_UP
: WXK_NUMPAD_UP
;
569 key_code
= isChar
? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
573 key_code
= isChar
? WXK_DOWN
: WXK_NUMPAD_DOWN
;
576 case GDK_KP_Prior
: // == GDK_KP_Page_Up
577 key_code
= isChar
? WXK_PAGEUP
: WXK_NUMPAD_PAGEUP
;
580 case GDK_KP_Next
: // == GDK_KP_Page_Down
581 key_code
= isChar
? WXK_PAGEDOWN
: WXK_NUMPAD_PAGEDOWN
;
585 key_code
= isChar
? WXK_END
: WXK_NUMPAD_END
;
589 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_BEGIN
;
593 key_code
= isChar
? WXK_INSERT
: WXK_NUMPAD_INSERT
;
597 key_code
= isChar
? WXK_DELETE
: WXK_NUMPAD_DELETE
;
601 key_code
= isChar
? '=' : int(WXK_NUMPAD_EQUAL
);
604 case GDK_KP_Multiply
:
605 key_code
= isChar
? '*' : int(WXK_NUMPAD_MULTIPLY
);
609 key_code
= isChar
? '+' : int(WXK_NUMPAD_ADD
);
612 case GDK_KP_Separator
:
613 // FIXME: what is this?
614 key_code
= isChar
? '.' : int(WXK_NUMPAD_SEPARATOR
);
617 case GDK_KP_Subtract
:
618 key_code
= isChar
? '-' : int(WXK_NUMPAD_SUBTRACT
);
622 key_code
= isChar
? '.' : int(WXK_NUMPAD_DECIMAL
);
626 key_code
= isChar
? '/' : int(WXK_NUMPAD_DIVIDE
);
643 key_code
= WXK_F1
+ keysym
- GDK_F1
;
653 static inline bool wxIsAsciiKeysym(KeySym ks
)
658 static void wxFillOtherKeyEventFields(wxKeyEvent
& event
,
660 GdkEventKey
*gdk_event
)
662 event
.SetTimestamp( gdk_event
->time
);
663 event
.SetId(win
->GetId());
665 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
666 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
667 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
668 event
.m_metaDown
= (gdk_event
->state
& GDK_META_MASK
) != 0;
670 // Normally we take the state of modifiers directly from the low level GDK
671 // event but unfortunately GDK uses a different convention from MSW for the
672 // key events corresponding to the modifier keys themselves: in it, when
673 // e.g. Shift key is pressed, GDK_SHIFT_MASK is not set while it is set
674 // when Shift is released. Under MSW the situation is exactly reversed and
675 // the modifier corresponding to the key is set when it is pressed and
676 // unset when it is released. To ensure consistent behaviour between
677 // platforms (and because it seems to make slightly more sense, although
678 // arguably both behaviours are reasonable) we follow MSW here.
680 // Final notice: we set the flags to the desired value instead of just
681 // inverting them because they are not set correctly (i.e. in the same way
682 // as for the real events generated by the user) for wxUIActionSimulator-
683 // produced events and it seems better to keep that class code the same
684 // among all platforms and fix the discrepancy here instead of adding
685 // wxGTK-specific code to wxUIActionSimulator.
686 const bool isPress
= gdk_event
->type
== GDK_KEY_PRESS
;
687 switch ( gdk_event
->keyval
)
691 event
.m_shiftDown
= isPress
;
696 event
.m_controlDown
= isPress
;
701 event
.m_altDown
= isPress
;
708 event
.m_metaDown
= isPress
;
712 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
713 event
.m_rawFlags
= gdk_event
->hardware_keycode
;
715 wxGetMousePosition(&event
.m_x
, &event
.m_y
);
716 win
->ScreenToClient(&event
.m_x
, &event
.m_y
);
717 event
.SetEventObject( win
);
722 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
724 GdkEventKey
*gdk_event
)
726 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
727 // but only event->keyval which is quite useless to us, so remember
728 // the last character from GDK_KEY_PRESS and reuse it as last resort
730 // NB: should be MT-safe as we're always called from the main thread only
735 } s_lastKeyPress
= { 0, 0 };
737 KeySym keysym
= gdk_event
->keyval
;
739 wxLogTrace(TRACE_KEYS
, wxT("Key %s event: keysym = %ld"),
740 event
.GetEventType() == wxEVT_KEY_UP
? wxT("release")
744 long key_code
= wxTranslateKeySymToWXKey(keysym
, false /* !isChar */);
748 // do we have the translation or is it a plain ASCII character?
749 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
751 // we should use keysym if it is ASCII as X does some translations
752 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
753 // which we don't want here (but which we do use for OnChar())
754 if ( !wxIsAsciiKeysym(keysym
) )
756 keysym
= (KeySym
)gdk_event
->string
[0];
759 // we want to always get the same key code when the same key is
760 // pressed regardless of the state of the modifiers, i.e. on a
761 // standard US keyboard pressing '5' or '%' ('5' key with
762 // Shift) should result in the same key code in OnKeyDown():
763 // '5' (although OnChar() will get either '5' or '%').
765 // to do it we first translate keysym to keycode (== scan code)
766 // and then back but always using the lower register
767 Display
*dpy
= (Display
*)wxGetDisplay();
768 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
770 wxLogTrace(TRACE_KEYS
, wxT("\t-> keycode %d"), keycode
);
772 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
774 // use the normalized, i.e. lower register, keysym if we've
776 key_code
= keysymNormalized
? keysymNormalized
: keysym
;
778 // as explained above, we want to have lower register key codes
779 // normally but for the letter keys we want to have the upper ones
781 // NB: don't use XConvertCase() here, we want to do it for letters
783 key_code
= toupper(key_code
);
785 else // non ASCII key, what to do?
787 // by default, ignore it
790 // but if we have cached information from the last KEY_PRESS
791 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
794 if ( keysym
== s_lastKeyPress
.keysym
)
796 key_code
= s_lastKeyPress
.keycode
;
801 if ( gdk_event
->type
== GDK_KEY_PRESS
)
803 // remember it to be reused for KEY_UP event later
804 s_lastKeyPress
.keysym
= keysym
;
805 s_lastKeyPress
.keycode
= key_code
;
809 wxLogTrace(TRACE_KEYS
, wxT("\t-> wxKeyCode %ld"), key_code
);
811 // sending unknown key events doesn't really make sense
815 event
.m_keyCode
= key_code
;
818 event
.m_uniChar
= gdk_keyval_to_unicode(key_code
? key_code
: keysym
);
819 if ( !event
.m_uniChar
&& event
.m_keyCode
<= WXK_DELETE
)
821 // Set Unicode key code to the ASCII equivalent for compatibility. E.g.
822 // let RETURN generate the key event with both key and Unicode key
824 event
.m_uniChar
= event
.m_keyCode
;
826 #endif // wxUSE_UNICODE
828 // now fill all the other fields
829 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
837 GtkIMContext
*context
;
838 GdkEventKey
*lastKeyEvent
;
842 context
= gtk_im_multicontext_new();
847 g_object_unref (context
);
854 // Send wxEVT_CHAR_HOOK event to the parent of the window and if it wasn't
855 // processed, send wxEVT_CHAR to the window itself. Return true if either of
858 SendCharHookAndCharEvents(const wxKeyEvent
& event
, wxWindow
*win
)
860 // wxEVT_CHAR_HOOK must be sent to the top level parent window to allow it
861 // to handle key events in all of its children unless the mouse is captured
862 // in which case we consider that the keyboard should be "captured" too.
863 if ( !g_captureWindow
)
865 wxWindow
* const parent
= wxGetTopLevelParent(win
);
868 // We need to make a copy of the event object because it is
869 // modified while it's handled, notably its WasProcessed() flag
870 // is set after it had been processed once.
871 wxKeyEvent
eventCharHook(event
);
872 eventCharHook
.SetEventType(wxEVT_CHAR_HOOK
);
873 if ( parent
->HandleWindowEvent(eventCharHook
) )
878 // As above, make a copy of the event first.
879 wxKeyEvent
eventChar(event
);
880 eventChar
.SetEventType(wxEVT_CHAR
);
881 return win
->HandleWindowEvent(eventChar
);
884 } // anonymous namespace
888 gtk_window_key_press_callback( GtkWidget
*WXUNUSED(widget
),
889 GdkEventKey
*gdk_event
,
894 if (g_blockEventsOnDrag
)
897 wxKeyEvent
event( wxEVT_KEY_DOWN
);
899 bool return_after_IM
= false;
901 if( wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
903 // Emit KEY_DOWN event
904 ret
= win
->HandleWindowEvent( event
);
908 // Return after IM processing as we cannot do
909 // anything with it anyhow.
910 return_after_IM
= true;
913 if (!ret
&& win
->m_imData
)
915 win
->m_imData
->lastKeyEvent
= gdk_event
;
917 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
918 // docs, if IM filter returns true, no further processing should be done.
919 // we should send the key_down event anyway.
920 bool intercepted_by_IM
= gtk_im_context_filter_keypress(win
->m_imData
->context
, gdk_event
);
921 win
->m_imData
->lastKeyEvent
= NULL
;
922 if (intercepted_by_IM
)
924 wxLogTrace(TRACE_KEYS
, wxT("Key event intercepted by IM"));
935 wxWindowGTK
*ancestor
= win
;
938 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
941 wxCommandEvent
menu_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
942 ret
= ancestor
->HandleWindowEvent( menu_event
);
946 // if the accelerator wasn't handled as menu event, try
947 // it as button click (for compatibility with other
949 wxCommandEvent
button_event( wxEVT_COMMAND_BUTTON_CLICKED
, command
);
950 ret
= ancestor
->HandleWindowEvent( button_event
);
955 if (ancestor
->IsTopLevel())
957 ancestor
= ancestor
->GetParent();
960 #endif // wxUSE_ACCEL
962 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
963 // will only be sent if it is not in an accelerator table.
967 KeySym keysym
= gdk_event
->keyval
;
968 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
969 key_code
= wxTranslateKeySymToWXKey(keysym
, true /* isChar */);
972 if ( wxIsAsciiKeysym(keysym
) )
975 key_code
= (unsigned char)keysym
;
977 // gdk_event->string is actually deprecated
978 else if ( gdk_event
->length
== 1 )
980 key_code
= (unsigned char)gdk_event
->string
[0];
986 wxLogTrace(TRACE_KEYS
, wxT("Char event: %ld"), key_code
);
988 event
.m_keyCode
= key_code
;
990 // To conform to the docs we need to translate Ctrl-alpha
991 // characters to values in the range 1-26.
992 if ( event
.ControlDown() &&
993 ( wxIsLowerChar(key_code
) || wxIsUpperChar(key_code
) ))
995 if ( wxIsLowerChar(key_code
) )
996 event
.m_keyCode
= key_code
- 'a' + 1;
997 if ( wxIsUpperChar(key_code
) )
998 event
.m_keyCode
= key_code
- 'A' + 1;
1000 event
.m_uniChar
= event
.m_keyCode
;
1004 ret
= SendCharHookAndCharEvents(event
, win
);
1014 gtk_wxwindow_commit_cb (GtkIMContext
* WXUNUSED(context
),
1018 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1020 // take modifiers, cursor position, timestamp etc. from the last
1021 // key_press_event that was fed into Input Method:
1022 if (window
->m_imData
->lastKeyEvent
)
1024 wxFillOtherKeyEventFields(event
,
1025 window
, window
->m_imData
->lastKeyEvent
);
1029 event
.SetEventObject( window
);
1032 const wxString
data(wxGTK_CONV_BACK_SYS(str
));
1036 for( wxString::const_iterator pstr
= data
.begin(); pstr
!= data
.end(); ++pstr
)
1039 event
.m_uniChar
= *pstr
;
1040 // Backward compatible for ISO-8859-1
1041 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
1042 wxLogTrace(TRACE_KEYS
, wxT("IM sent character '%c'"), event
.m_uniChar
);
1044 event
.m_keyCode
= (char)*pstr
;
1045 #endif // wxUSE_UNICODE
1047 // To conform to the docs we need to translate Ctrl-alpha
1048 // characters to values in the range 1-26.
1049 if ( event
.ControlDown() &&
1050 ( wxIsLowerChar(*pstr
) || wxIsUpperChar(*pstr
) ))
1052 if ( wxIsLowerChar(*pstr
) )
1053 event
.m_keyCode
= *pstr
- 'a' + 1;
1054 if ( wxIsUpperChar(*pstr
) )
1055 event
.m_keyCode
= *pstr
- 'A' + 1;
1057 event
.m_keyCode
= *pstr
- 'a' + 1;
1059 event
.m_uniChar
= event
.m_keyCode
;
1063 SendCharHookAndCharEvents(event
, window
);
1069 //-----------------------------------------------------------------------------
1070 // "key_release_event" from any window
1071 //-----------------------------------------------------------------------------
1075 gtk_window_key_release_callback( GtkWidget
* WXUNUSED(widget
),
1076 GdkEventKey
*gdk_event
,
1082 if (g_blockEventsOnDrag
)
1085 wxKeyEvent
event( wxEVT_KEY_UP
);
1086 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1088 // unknown key pressed, ignore (the event would be useless anyhow)
1092 return win
->GTKProcessEvent(event
);
1096 // ============================================================================
1098 // ============================================================================
1100 // ----------------------------------------------------------------------------
1101 // mouse event processing helpers
1102 // ----------------------------------------------------------------------------
1104 // init wxMouseEvent with the info from GdkEventXXX struct
1105 template<typename T
> void InitMouseEvent(wxWindowGTK
*win
,
1106 wxMouseEvent
& event
,
1109 event
.SetTimestamp( gdk_event
->time
);
1110 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
1111 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
1112 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
1113 event
.m_metaDown
= (gdk_event
->state
& GDK_META_MASK
) != 0;
1114 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
) != 0;
1115 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
) != 0;
1116 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
) != 0;
1118 // In gdk/win32 VK_XBUTTON1 is translated to GDK_BUTTON4_MASK
1119 // and VK_XBUTTON2 to GDK_BUTTON5_MASK. In x11/gdk buttons 4/5
1120 // are wheel rotation and buttons 8/9 don't change the state.
1121 event
.m_aux1Down
= (gdk_event
->state
& GDK_BUTTON4_MASK
) != 0;
1122 event
.m_aux2Down
= (gdk_event
->state
& GDK_BUTTON5_MASK
) != 0;
1124 wxPoint pt
= win
->GetClientAreaOrigin();
1125 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1126 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1128 if ((win
->m_wxwindow
) && (win
->GetLayoutDirection() == wxLayout_RightToLeft
))
1130 // origin in the upper right corner
1132 gtk_widget_get_allocation(win
->m_wxwindow
, &a
);
1133 int window_width
= a
.width
;
1134 event
.m_x
= window_width
- event
.m_x
;
1137 event
.SetEventObject( win
);
1138 event
.SetId( win
->GetId() );
1139 event
.SetTimestamp( gdk_event
->time
);
1142 static void AdjustEventButtonState(wxMouseEvent
& event
)
1144 // GDK reports the old state of the button for a button press event, but
1145 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1146 // for a LEFT_DOWN event, not FALSE, so we will invert
1147 // left/right/middleDown for the corresponding click events
1149 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1150 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1151 (event
.GetEventType() == wxEVT_LEFT_UP
))
1153 event
.m_leftDown
= !event
.m_leftDown
;
1157 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1158 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1159 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1161 event
.m_middleDown
= !event
.m_middleDown
;
1165 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1166 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1167 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1169 event
.m_rightDown
= !event
.m_rightDown
;
1173 if ((event
.GetEventType() == wxEVT_AUX1_DOWN
) ||
1174 (event
.GetEventType() == wxEVT_AUX1_DCLICK
))
1176 event
.m_aux1Down
= true;
1180 if ((event
.GetEventType() == wxEVT_AUX2_DOWN
) ||
1181 (event
.GetEventType() == wxEVT_AUX2_DCLICK
))
1183 event
.m_aux2Down
= true;
1188 // find the window to send the mouse event too
1190 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1195 if (win
->m_wxwindow
)
1197 wxPizza
* pizza
= WX_PIZZA(win
->m_wxwindow
);
1198 xx
+= pizza
->m_scroll_x
;
1199 yy
+= pizza
->m_scroll_y
;
1202 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
1205 wxWindowGTK
*child
= node
->GetData();
1207 node
= node
->GetNext();
1208 if (!child
->IsShown())
1211 if (child
->GTKIsTransparentForMouse())
1213 // wxStaticBox is transparent in the box itself
1214 int xx1
= child
->m_x
;
1215 int yy1
= child
->m_y
;
1216 int xx2
= child
->m_x
+ child
->m_width
;
1217 int yy2
= child
->m_y
+ child
->m_height
;
1220 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1222 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1224 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1226 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1237 if ((child
->m_wxwindow
== NULL
) &&
1238 (child
->m_x
<= xx
) &&
1239 (child
->m_y
<= yy
) &&
1240 (child
->m_x
+child
->m_width
>= xx
) &&
1241 (child
->m_y
+child
->m_height
>= yy
))
1254 // ----------------------------------------------------------------------------
1255 // common event handlers helpers
1256 // ----------------------------------------------------------------------------
1258 bool wxWindowGTK::GTKProcessEvent(wxEvent
& event
) const
1260 // nothing special at this level
1261 return HandleWindowEvent(event
);
1264 bool wxWindowGTK::GTKShouldIgnoreEvent() const
1266 return !m_hasVMT
|| g_blockEventsOnDrag
;
1269 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny
*event
) const
1273 if (g_blockEventsOnDrag
)
1275 if (g_blockEventsOnScroll
)
1278 if (!GTKIsOwnWindow(event
->window
))
1284 // overloads for all GDK event types we use here: we need to have this as
1285 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1286 // derives from it in the sense that the structs have the same layout
1287 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1288 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1290 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1293 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton
)
1294 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion
)
1295 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing
)
1297 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1299 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1300 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1304 // all event handlers must have C linkage as they're called from GTK+ C code
1308 //-----------------------------------------------------------------------------
1309 // "button_press_event"
1310 //-----------------------------------------------------------------------------
1313 gtk_window_button_press_callback( GtkWidget
*widget
,
1314 GdkEventButton
*gdk_event
,
1317 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1319 g_lastButtonNumber
= gdk_event
->button
;
1321 // GDK sends surplus button down events
1322 // before a double click event. We
1323 // need to filter these out.
1324 if ((gdk_event
->type
== GDK_BUTTON_PRESS
) && (win
->m_wxwindow
))
1326 GdkEvent
*peek_event
= gdk_event_peek();
1329 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1330 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1332 gdk_event_free( peek_event
);
1337 gdk_event_free( peek_event
);
1342 wxEventType event_type
= wxEVT_NULL
;
1344 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1345 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1347 // Reset GDK internal timestamp variables in order to disable GDK
1348 // triple click events. GDK will then next time believe no button has
1349 // been clicked just before, and send a normal button click event.
1350 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1351 display
->button_click_time
[1] = 0;
1352 display
->button_click_time
[0] = 0;
1355 if (gdk_event
->button
== 1)
1357 // note that GDK generates triple click events which are not supported
1358 // by wxWidgets but still have to be passed to the app as otherwise
1359 // clicks would simply go missing
1360 switch (gdk_event
->type
)
1362 // we shouldn't get triple clicks at all for GTK2 because we
1363 // suppress them artificially using the code above but we still
1364 // should map them to something for GTK1 and not just ignore them
1365 // as this would lose clicks
1366 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1367 case GDK_BUTTON_PRESS
:
1368 event_type
= wxEVT_LEFT_DOWN
;
1371 case GDK_2BUTTON_PRESS
:
1372 event_type
= wxEVT_LEFT_DCLICK
;
1376 // just to silence gcc warnings
1380 else if (gdk_event
->button
== 2)
1382 switch (gdk_event
->type
)
1384 case GDK_3BUTTON_PRESS
:
1385 case GDK_BUTTON_PRESS
:
1386 event_type
= wxEVT_MIDDLE_DOWN
;
1389 case GDK_2BUTTON_PRESS
:
1390 event_type
= wxEVT_MIDDLE_DCLICK
;
1397 else if (gdk_event
->button
== 3)
1399 switch (gdk_event
->type
)
1401 case GDK_3BUTTON_PRESS
:
1402 case GDK_BUTTON_PRESS
:
1403 event_type
= wxEVT_RIGHT_DOWN
;
1406 case GDK_2BUTTON_PRESS
:
1407 event_type
= wxEVT_RIGHT_DCLICK
;
1415 else if (gdk_event
->button
== 8)
1417 switch (gdk_event
->type
)
1419 case GDK_3BUTTON_PRESS
:
1420 case GDK_BUTTON_PRESS
:
1421 event_type
= wxEVT_AUX1_DOWN
;
1424 case GDK_2BUTTON_PRESS
:
1425 event_type
= wxEVT_AUX1_DCLICK
;
1433 else if (gdk_event
->button
== 9)
1435 switch (gdk_event
->type
)
1437 case GDK_3BUTTON_PRESS
:
1438 case GDK_BUTTON_PRESS
:
1439 event_type
= wxEVT_AUX2_DOWN
;
1442 case GDK_2BUTTON_PRESS
:
1443 event_type
= wxEVT_AUX2_DCLICK
;
1451 if ( event_type
== wxEVT_NULL
)
1453 // unknown mouse button or click type
1457 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1459 wxMouseEvent
event( event_type
);
1460 InitMouseEvent( win
, event
, gdk_event
);
1462 AdjustEventButtonState(event
);
1464 // find the correct window to send the event to: it may be a different one
1465 // from the one which got it at GTK+ level because some controls don't have
1466 // their own X window and thus cannot get any events.
1467 if ( !g_captureWindow
)
1468 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1470 // reset the event object and id in case win changed.
1471 event
.SetEventObject( win
);
1472 event
.SetId( win
->GetId() );
1474 bool ret
= win
->GTKProcessEvent( event
);
1475 g_lastMouseEvent
= NULL
;
1479 if ((event_type
== wxEVT_LEFT_DOWN
) && !win
->IsOfStandardClass() &&
1480 (gs_currentFocus
!= win
) /* && win->IsFocusable() */)
1485 if (event_type
== wxEVT_RIGHT_DOWN
)
1487 // generate a "context menu" event: this is similar to right mouse
1488 // click under many GUIs except that it is generated differently
1489 // (right up under MSW, ctrl-click under Mac, right down here) and
1491 // (a) it's a command event and so is propagated to the parent
1492 // (b) under some ports it can be generated from kbd too
1493 // (c) it uses screen coords (because of (a))
1494 wxContextMenuEvent
evtCtx(
1497 win
->ClientToScreen(event
.GetPosition()));
1498 evtCtx
.SetEventObject(win
);
1499 return win
->GTKProcessEvent(evtCtx
);
1505 //-----------------------------------------------------------------------------
1506 // "button_release_event"
1507 //-----------------------------------------------------------------------------
1510 gtk_window_button_release_callback( GtkWidget
*WXUNUSED(widget
),
1511 GdkEventButton
*gdk_event
,
1514 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1516 g_lastButtonNumber
= 0;
1518 wxEventType event_type
= wxEVT_NULL
;
1520 switch (gdk_event
->button
)
1523 event_type
= wxEVT_LEFT_UP
;
1527 event_type
= wxEVT_MIDDLE_UP
;
1531 event_type
= wxEVT_RIGHT_UP
;
1535 event_type
= wxEVT_AUX1_UP
;
1539 event_type
= wxEVT_AUX2_UP
;
1543 // unknown button, don't process
1547 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1549 wxMouseEvent
event( event_type
);
1550 InitMouseEvent( win
, event
, gdk_event
);
1552 AdjustEventButtonState(event
);
1554 if ( !g_captureWindow
)
1555 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1557 // reset the event object and id in case win changed.
1558 event
.SetEventObject( win
);
1559 event
.SetId( win
->GetId() );
1561 bool ret
= win
->GTKProcessEvent(event
);
1563 g_lastMouseEvent
= NULL
;
1568 //-----------------------------------------------------------------------------
1569 // "motion_notify_event"
1570 //-----------------------------------------------------------------------------
1573 gtk_window_motion_notify_callback( GtkWidget
* WXUNUSED(widget
),
1574 GdkEventMotion
*gdk_event
,
1577 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1579 if (gdk_event
->is_hint
)
1583 GdkModifierType state
;
1584 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1589 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1591 wxMouseEvent
event( wxEVT_MOTION
);
1592 InitMouseEvent(win
, event
, gdk_event
);
1594 if ( g_captureWindow
)
1596 // synthesise a mouse enter or leave event if needed
1597 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1598 // This seems to be necessary and actually been added to
1599 // GDK itself in version 2.0.X
1602 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1603 if ( hasMouse
!= g_captureWindowHasMouse
)
1605 // the mouse changed window
1606 g_captureWindowHasMouse
= hasMouse
;
1608 wxMouseEvent
eventM(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1609 : wxEVT_LEAVE_WINDOW
);
1610 InitMouseEvent(win
, eventM
, gdk_event
);
1611 eventM
.SetEventObject(win
);
1612 win
->GTKProcessEvent(eventM
);
1617 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1619 // reset the event object and id in case win changed.
1620 event
.SetEventObject( win
);
1621 event
.SetId( win
->GetId() );
1624 if ( !g_captureWindow
)
1626 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1627 if (win
->GTKProcessEvent( cevent
))
1629 win
->SetCursor( cevent
.GetCursor() );
1633 bool ret
= win
->GTKProcessEvent(event
);
1635 g_lastMouseEvent
= NULL
;
1640 //-----------------------------------------------------------------------------
1641 // "scroll_event" (mouse wheel event)
1642 //-----------------------------------------------------------------------------
1645 window_scroll_event_hscrollbar(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1647 if (gdk_event
->direction
!= GDK_SCROLL_LEFT
&&
1648 gdk_event
->direction
!= GDK_SCROLL_RIGHT
)
1653 GtkRange
*range
= win
->m_scrollBar
[wxWindow::ScrollDir_Horz
];
1655 if (range
&& gtk_widget_get_visible(GTK_WIDGET(range
)))
1657 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
1658 double delta
= gtk_adjustment_get_step_increment(adj
) * 3;
1659 if (gdk_event
->direction
== GDK_SCROLL_LEFT
)
1662 gtk_range_set_value(range
, gtk_adjustment_get_value(adj
) + delta
);
1671 window_scroll_event(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1673 if (gdk_event
->direction
!= GDK_SCROLL_UP
&&
1674 gdk_event
->direction
!= GDK_SCROLL_DOWN
)
1679 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1680 InitMouseEvent(win
, event
, gdk_event
);
1682 // FIXME: Get these values from GTK or GDK
1683 event
.m_linesPerAction
= 3;
1684 event
.m_wheelDelta
= 120;
1685 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1686 event
.m_wheelRotation
= 120;
1688 event
.m_wheelRotation
= -120;
1690 if (win
->GTKProcessEvent(event
))
1693 GtkRange
*range
= win
->m_scrollBar
[wxWindow::ScrollDir_Vert
];
1695 if (range
&& gtk_widget_get_visible(GTK_WIDGET(range
)))
1697 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
1698 double delta
= gtk_adjustment_get_step_increment(adj
) * 3;
1699 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1702 gtk_range_set_value(range
, gtk_adjustment_get_value(adj
) + delta
);
1710 //-----------------------------------------------------------------------------
1712 //-----------------------------------------------------------------------------
1714 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
1716 wxContextMenuEvent
event(wxEVT_CONTEXT_MENU
, win
->GetId(), wxPoint(-1, -1));
1717 event
.SetEventObject(win
);
1718 return win
->GTKProcessEvent(event
);
1721 //-----------------------------------------------------------------------------
1723 //-----------------------------------------------------------------------------
1726 gtk_window_focus_in_callback( GtkWidget
* WXUNUSED(widget
),
1727 GdkEventFocus
*WXUNUSED(event
),
1730 return win
->GTKHandleFocusIn();
1733 //-----------------------------------------------------------------------------
1734 // "focus_out_event"
1735 //-----------------------------------------------------------------------------
1738 gtk_window_focus_out_callback( GtkWidget
* WXUNUSED(widget
),
1739 GdkEventFocus
* WXUNUSED(gdk_event
),
1742 return win
->GTKHandleFocusOut();
1745 //-----------------------------------------------------------------------------
1747 //-----------------------------------------------------------------------------
1750 wx_window_focus_callback(GtkWidget
*widget
,
1751 GtkDirectionType
WXUNUSED(direction
),
1754 // the default handler for focus signal in GtkScrolledWindow sets
1755 // focus to the window itself even if it doesn't accept focus, i.e. has no
1756 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1757 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1758 // any children which might accept focus (we know we don't accept the focus
1759 // ourselves as this signal is only connected in this case)
1760 if ( win
->GetChildren().empty() )
1761 g_signal_stop_emission_by_name(widget
, "focus");
1763 // we didn't change the focus
1767 //-----------------------------------------------------------------------------
1768 // "enter_notify_event"
1769 //-----------------------------------------------------------------------------
1772 gtk_window_enter_callback( GtkWidget
*widget
,
1773 GdkEventCrossing
*gdk_event
,
1776 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1778 // Event was emitted after a grab
1779 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1783 GdkModifierType state
= (GdkModifierType
)0;
1785 gdk_window_get_pointer(gtk_widget_get_window(widget
), &x
, &y
, &state
);
1787 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1788 InitMouseEvent(win
, event
, gdk_event
);
1789 wxPoint pt
= win
->GetClientAreaOrigin();
1790 event
.m_x
= x
+ pt
.x
;
1791 event
.m_y
= y
+ pt
.y
;
1793 if ( !g_captureWindow
)
1795 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1796 if (win
->GTKProcessEvent( cevent
))
1798 win
->SetCursor( cevent
.GetCursor() );
1802 return win
->GTKProcessEvent(event
);
1805 //-----------------------------------------------------------------------------
1806 // "leave_notify_event"
1807 //-----------------------------------------------------------------------------
1810 gtk_window_leave_callback( GtkWidget
*widget
,
1811 GdkEventCrossing
*gdk_event
,
1814 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1816 // Event was emitted after an ungrab
1817 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1819 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1823 GdkModifierType state
= (GdkModifierType
)0;
1825 gdk_window_get_pointer(gtk_widget_get_window(widget
), &x
, &y
, &state
);
1827 InitMouseEvent(win
, event
, gdk_event
);
1829 return win
->GTKProcessEvent(event
);
1832 //-----------------------------------------------------------------------------
1833 // "value_changed" from scrollbar
1834 //-----------------------------------------------------------------------------
1837 gtk_scrollbar_value_changed(GtkRange
* range
, wxWindow
* win
)
1839 wxEventType eventType
= win
->GTKGetScrollEventType(range
);
1840 if (eventType
!= wxEVT_NULL
)
1842 // Convert scroll event type to scrollwin event type
1843 eventType
+= wxEVT_SCROLLWIN_TOP
- wxEVT_SCROLL_TOP
;
1845 // find the scrollbar which generated the event
1846 wxWindowGTK::ScrollDir dir
= win
->ScrollDirFromRange(range
);
1848 // generate the corresponding wx event
1849 const int orient
= wxWindow::OrientFromScrollDir(dir
);
1850 wxScrollWinEvent
event(eventType
, win
->GetScrollPos(orient
), orient
);
1851 event
.SetEventObject(win
);
1853 win
->GTKProcessEvent(event
);
1857 //-----------------------------------------------------------------------------
1858 // "button_press_event" from scrollbar
1859 //-----------------------------------------------------------------------------
1862 gtk_scrollbar_button_press_event(GtkRange
*, GdkEventButton
*, wxWindow
* win
)
1864 g_blockEventsOnScroll
= true;
1865 win
->m_mouseButtonDown
= true;
1870 //-----------------------------------------------------------------------------
1871 // "event_after" from scrollbar
1872 //-----------------------------------------------------------------------------
1875 gtk_scrollbar_event_after(GtkRange
* range
, GdkEvent
* event
, wxWindow
* win
)
1877 if (event
->type
== GDK_BUTTON_RELEASE
)
1879 g_signal_handlers_block_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1881 const int orient
= wxWindow::OrientFromScrollDir(
1882 win
->ScrollDirFromRange(range
));
1883 wxScrollWinEvent
evt(wxEVT_SCROLLWIN_THUMBRELEASE
,
1884 win
->GetScrollPos(orient
), orient
);
1885 evt
.SetEventObject(win
);
1886 win
->GTKProcessEvent(evt
);
1890 //-----------------------------------------------------------------------------
1891 // "button_release_event" from scrollbar
1892 //-----------------------------------------------------------------------------
1895 gtk_scrollbar_button_release_event(GtkRange
* range
, GdkEventButton
*, wxWindow
* win
)
1897 g_blockEventsOnScroll
= false;
1898 win
->m_mouseButtonDown
= false;
1899 // If thumb tracking
1900 if (win
->m_isScrolling
)
1902 win
->m_isScrolling
= false;
1903 // Hook up handler to send thumb release event after this emission is finished.
1904 // To allow setting scroll position from event handler, sending event must
1905 // be deferred until after the GtkRange handler for this signal has run
1906 g_signal_handlers_unblock_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1912 //-----------------------------------------------------------------------------
1913 // "realize" from m_widget
1914 //-----------------------------------------------------------------------------
1917 gtk_window_realized_callback(GtkWidget
* widget
, wxWindow
* win
)
1921 gtk_im_context_set_client_window( win
->m_imData
->context
,
1922 win
->m_wxwindow
? win
->GTKGetDrawingWindow() : gtk_widget_get_window(widget
));
1925 // We cannot set colours and fonts before the widget
1926 // been realized, so we do this directly after realization
1927 // or otherwise in idle time
1929 if (win
->m_needsStyleChange
)
1931 win
->SetBackgroundStyle(win
->GetBackgroundStyle());
1932 win
->m_needsStyleChange
= false;
1935 wxWindowCreateEvent
event( win
);
1936 event
.SetEventObject( win
);
1937 win
->GTKProcessEvent( event
);
1939 win
->GTKUpdateCursor(true, false);
1942 //-----------------------------------------------------------------------------
1943 // "size_allocate" from m_wxwindow or m_widget
1944 //-----------------------------------------------------------------------------
1947 size_allocate(GtkWidget
*, GtkAllocation
* alloc
, wxWindow
* win
)
1949 int w
= alloc
->width
;
1950 int h
= alloc
->height
;
1951 if (win
->m_wxwindow
)
1953 int border_x
, border_y
;
1954 WX_PIZZA(win
->m_wxwindow
)->get_border_widths(border_x
, border_y
);
1960 if (win
->m_oldClientWidth
!= w
|| win
->m_oldClientHeight
!= h
)
1962 win
->m_oldClientWidth
= w
;
1963 win
->m_oldClientHeight
= h
;
1964 // this callback can be connected to m_wxwindow,
1965 // so always get size from m_widget->allocation
1967 gtk_widget_get_allocation(win
->m_widget
, &a
);
1968 win
->m_width
= a
.width
;
1969 win
->m_height
= a
.height
;
1970 if (!win
->m_nativeSizeEvent
)
1972 wxSizeEvent
event(win
->GetSize(), win
->GetId());
1973 event
.SetEventObject(win
);
1974 win
->GTKProcessEvent(event
);
1979 //-----------------------------------------------------------------------------
1981 //-----------------------------------------------------------------------------
1983 #if GTK_CHECK_VERSION(2, 8, 0)
1985 gtk_window_grab_broken( GtkWidget
*,
1986 GdkEventGrabBroken
*event
,
1989 // Mouse capture has been lost involuntarily, notify the application
1990 if(!event
->keyboard
&& wxWindow::GetCapture() == win
)
1992 wxMouseCaptureLostEvent
evt( win
->GetId() );
1993 evt
.SetEventObject( win
);
1994 win
->HandleWindowEvent( evt
);
2000 //-----------------------------------------------------------------------------
2002 //-----------------------------------------------------------------------------
2005 void gtk_window_style_set_callback( GtkWidget
*WXUNUSED(widget
),
2006 GtkStyle
*previous_style
,
2009 if (win
&& previous_style
)
2011 wxSysColourChangedEvent event
;
2012 event
.SetEventObject(win
);
2014 win
->GTKProcessEvent( event
);
2020 // ----------------------------------------------------------------------------
2021 // this wxWindowBase function is implemented here (in platform-specific file)
2022 // because it is static and so couldn't be made virtual
2023 // ----------------------------------------------------------------------------
2025 wxWindow
*wxWindowBase::DoFindFocus()
2027 wxWindowGTK
*focus
= gs_pendingFocus
? gs_pendingFocus
: gs_currentFocus
;
2028 // the cast is necessary when we compile in wxUniversal mode
2029 return static_cast<wxWindow
*>(focus
);
2032 void wxWindowGTK::AddChildGTK(wxWindowGTK
* child
)
2034 wxASSERT_MSG(m_wxwindow
, "Cannot add a child to a window without a client area");
2036 // the window might have been scrolled already, we
2037 // have to adapt the position
2038 wxPizza
* pizza
= WX_PIZZA(m_wxwindow
);
2039 child
->m_x
+= pizza
->m_scroll_x
;
2040 child
->m_y
+= pizza
->m_scroll_y
;
2042 gtk_widget_set_size_request(
2043 child
->m_widget
, child
->m_width
, child
->m_height
);
2044 pizza
->put(child
->m_widget
, child
->m_x
, child
->m_y
);
2047 //-----------------------------------------------------------------------------
2049 //-----------------------------------------------------------------------------
2051 wxWindow
*wxGetActiveWindow()
2053 return wxWindow::FindFocus();
2057 wxMouseState
wxGetMouseState()
2063 GdkModifierType mask
;
2065 gdk_window_get_pointer(NULL
, &x
, &y
, &mask
);
2069 ms
.SetLeftDown((mask
& GDK_BUTTON1_MASK
) != 0);
2070 ms
.SetMiddleDown((mask
& GDK_BUTTON2_MASK
) != 0);
2071 ms
.SetRightDown((mask
& GDK_BUTTON3_MASK
) != 0);
2072 // see the comment in InitMouseEvent()
2073 ms
.SetAux1Down((mask
& GDK_BUTTON4_MASK
) != 0);
2074 ms
.SetAux2Down((mask
& GDK_BUTTON5_MASK
) != 0);
2076 ms
.SetControlDown((mask
& GDK_CONTROL_MASK
) != 0);
2077 ms
.SetShiftDown((mask
& GDK_SHIFT_MASK
) != 0);
2078 ms
.SetAltDown((mask
& GDK_MOD1_MASK
) != 0);
2079 ms
.SetMetaDown((mask
& GDK_META_MASK
) != 0);
2084 //-----------------------------------------------------------------------------
2086 //-----------------------------------------------------------------------------
2088 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2090 #ifdef __WXUNIVERSAL__
2091 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2092 #endif // __WXUNIVERSAL__
2094 void wxWindowGTK::Init()
2099 m_focusWidget
= NULL
;
2109 m_showOnIdle
= false;
2112 m_nativeSizeEvent
= false;
2114 m_isScrolling
= false;
2115 m_mouseButtonDown
= false;
2117 // initialize scrolling stuff
2118 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2120 m_scrollBar
[dir
] = NULL
;
2121 m_scrollPos
[dir
] = 0;
2125 m_oldClientHeight
= 0;
2127 m_clipPaintRegion
= false;
2129 m_needsStyleChange
= false;
2131 m_cursor
= *wxSTANDARD_CURSOR
;
2134 m_dirtyTabOrder
= false;
2137 wxWindowGTK::wxWindowGTK()
2142 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2147 const wxString
&name
)
2151 Create( parent
, id
, pos
, size
, style
, name
);
2154 bool wxWindowGTK::Create( wxWindow
*parent
,
2159 const wxString
&name
)
2161 // Get default border
2162 wxBorder border
= GetBorder(style
);
2164 style
&= ~wxBORDER_MASK
;
2167 if (!PreCreation( parent
, pos
, size
) ||
2168 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2170 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2174 // We should accept the native look
2176 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2177 scroll_class
->scrollbar_spacing
= 0;
2181 m_wxwindow
= wxPizza::New(m_windowStyle
);
2182 #ifndef __WXUNIVERSAL__
2183 if (HasFlag(wxPizza::BORDER_STYLES
))
2185 g_signal_connect(m_wxwindow
, "parent_set",
2186 G_CALLBACK(parent_set
), this);
2189 if (!HasFlag(wxHSCROLL
) && !HasFlag(wxVSCROLL
))
2190 m_widget
= m_wxwindow
;
2193 m_widget
= gtk_scrolled_window_new( NULL
, NULL
);
2195 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2197 // There is a conflict with default bindings at GTK+
2198 // level between scrolled windows and notebooks both of which want to use
2199 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2200 // direction and notebooks for changing pages -- we decide that if we don't
2201 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2202 // means we can get working keyboard navigation in notebooks
2203 if ( !HasFlag(wxHSCROLL
) )
2206 bindings
= gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget
));
2209 gtk_binding_entry_remove(bindings
, GDK_Page_Up
, GDK_CONTROL_MASK
);
2210 gtk_binding_entry_remove(bindings
, GDK_Page_Down
, GDK_CONTROL_MASK
);
2214 if (HasFlag(wxALWAYS_SHOW_SB
))
2216 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_ALWAYS
, GTK_POLICY_ALWAYS
);
2220 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2223 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow
));
2224 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow
));
2225 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2226 gtk_range_set_inverted( m_scrollBar
[ScrollDir_Horz
], TRUE
);
2228 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2230 // connect various scroll-related events
2231 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2233 // these handlers block mouse events to any window during scrolling
2234 // such as motion events and prevent GTK and wxWidgets from fighting
2235 // over where the slider should be
2236 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2237 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2238 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2239 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2241 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2242 G_CALLBACK(gtk_scrollbar_event_after
), this);
2243 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2245 // these handlers get notified when scrollbar slider moves
2246 g_signal_connect_after(m_scrollBar
[dir
], "value_changed",
2247 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2250 gtk_widget_show( m_wxwindow
);
2252 g_object_ref(m_widget
);
2255 m_parent
->DoAddChild( this );
2257 m_focusWidget
= m_wxwindow
;
2259 SetCanFocus(AcceptsFocus());
2266 wxWindowGTK::~wxWindowGTK()
2270 if (gs_currentFocus
== this)
2271 gs_currentFocus
= NULL
;
2272 if (gs_pendingFocus
== this)
2273 gs_pendingFocus
= NULL
;
2275 if ( gs_deferredFocusOut
== this )
2276 gs_deferredFocusOut
= NULL
;
2280 // destroy children before destroying this window itself
2283 // unhook focus handlers to prevent stray events being
2284 // propagated to this (soon to be) dead object
2285 if (m_focusWidget
!= NULL
)
2287 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2288 (gpointer
) gtk_window_focus_in_callback
,
2290 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2291 (gpointer
) gtk_window_focus_out_callback
,
2298 // delete before the widgets to avoid a crash on solaris
2301 // avoid problem with GTK+ 2.18 where a frozen window causes the whole
2302 // TLW to be frozen, and if the window is then destroyed, nothing ever
2303 // gets painted again
2309 // Note that gtk_widget_destroy() does not destroy the widget, it just
2310 // emits the "destroy" signal. The widget is not actually destroyed
2311 // until its reference count drops to zero.
2312 gtk_widget_destroy(m_widget
);
2313 // Release our reference, should be the last one
2314 g_object_unref(m_widget
);
2320 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2322 if ( GTKNeedsParent() )
2324 wxCHECK_MSG( parent
, false, wxT("Must have non-NULL parent") );
2327 // Use either the given size, or the default if -1 is given.
2328 // See wxWindowBase for these functions.
2329 m_width
= WidthDefault(size
.x
) ;
2330 m_height
= HeightDefault(size
.y
);
2338 void wxWindowGTK::PostCreation()
2340 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2346 // these get reported to wxWidgets -> wxPaintEvent
2348 g_signal_connect (m_wxwindow
, "expose_event",
2349 G_CALLBACK (gtk_window_expose_callback
), this);
2351 if (GetLayoutDirection() == wxLayout_LeftToRight
)
2352 gtk_widget_set_redraw_on_allocate(m_wxwindow
, HasFlag(wxFULL_REPAINT_ON_RESIZE
));
2355 // Create input method handler
2356 m_imData
= new wxGtkIMData
;
2358 // Cannot handle drawing preedited text yet
2359 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2361 g_signal_connect (m_imData
->context
, "commit",
2362 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2367 if (!GTK_IS_WINDOW(m_widget
))
2369 if (m_focusWidget
== NULL
)
2370 m_focusWidget
= m_widget
;
2374 g_signal_connect (m_focusWidget
, "focus_in_event",
2375 G_CALLBACK (gtk_window_focus_in_callback
), this);
2376 g_signal_connect (m_focusWidget
, "focus_out_event",
2377 G_CALLBACK (gtk_window_focus_out_callback
), this);
2381 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2382 G_CALLBACK (gtk_window_focus_in_callback
), this);
2383 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2384 G_CALLBACK (gtk_window_focus_out_callback
), this);
2388 if ( !AcceptsFocusFromKeyboard() )
2392 g_signal_connect(m_widget
, "focus",
2393 G_CALLBACK(wx_window_focus_callback
), this);
2396 // connect to the various key and mouse handlers
2398 GtkWidget
*connect_widget
= GetConnectWidget();
2400 ConnectWidget( connect_widget
);
2402 /* We cannot set colours, fonts and cursors before the widget has
2403 been realized, so we do this directly after realization */
2404 g_signal_connect (connect_widget
, "realize",
2405 G_CALLBACK (gtk_window_realized_callback
), this);
2409 g_signal_connect(m_wxwindow
? m_wxwindow
: m_widget
, "size_allocate",
2410 G_CALLBACK(size_allocate
), this);
2413 #if GTK_CHECK_VERSION(2, 8, 0)
2414 if ( gtk_check_version(2,8,0) == NULL
)
2416 // Make sure we can notify the app when mouse capture is lost
2419 g_signal_connect (m_wxwindow
, "grab_broken_event",
2420 G_CALLBACK (gtk_window_grab_broken
), this);
2423 if ( connect_widget
!= m_wxwindow
)
2425 g_signal_connect (connect_widget
, "grab_broken_event",
2426 G_CALLBACK (gtk_window_grab_broken
), this);
2429 #endif // GTK+ >= 2.8
2431 if ( GTKShouldConnectSizeRequest() )
2433 // This is needed if we want to add our windows into native
2434 // GTK controls, such as the toolbar. With this callback, the
2435 // toolbar gets to know the correct size (the one set by the
2436 // programmer). Sadly, it misbehaves for wxComboBox.
2437 g_signal_connect (m_widget
, "size_request",
2438 G_CALLBACK (wxgtk_window_size_request_callback
),
2442 InheritAttributes();
2446 SetLayoutDirection(wxLayout_Default
);
2448 // unless the window was created initially hidden (i.e. Hide() had been
2449 // called before Create()), we should show it at GTK+ level as well
2451 gtk_widget_show( m_widget
);
2454 unsigned long wxWindowGTK::GTKConnectWidget(const char *signal
, void (*callback
)())
2456 return g_signal_connect(m_widget
, signal
, callback
, this);
2459 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2461 g_signal_connect (widget
, "key_press_event",
2462 G_CALLBACK (gtk_window_key_press_callback
), this);
2463 g_signal_connect (widget
, "key_release_event",
2464 G_CALLBACK (gtk_window_key_release_callback
), this);
2465 g_signal_connect (widget
, "button_press_event",
2466 G_CALLBACK (gtk_window_button_press_callback
), this);
2467 g_signal_connect (widget
, "button_release_event",
2468 G_CALLBACK (gtk_window_button_release_callback
), this);
2469 g_signal_connect (widget
, "motion_notify_event",
2470 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2472 g_signal_connect (widget
, "scroll_event",
2473 G_CALLBACK (window_scroll_event
), this);
2474 if (m_scrollBar
[ScrollDir_Horz
])
2475 g_signal_connect (m_scrollBar
[ScrollDir_Horz
], "scroll_event",
2476 G_CALLBACK (window_scroll_event_hscrollbar
), this);
2477 if (m_scrollBar
[ScrollDir_Vert
])
2478 g_signal_connect (m_scrollBar
[ScrollDir_Vert
], "scroll_event",
2479 G_CALLBACK (window_scroll_event
), this);
2481 g_signal_connect (widget
, "popup_menu",
2482 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2483 g_signal_connect (widget
, "enter_notify_event",
2484 G_CALLBACK (gtk_window_enter_callback
), this);
2485 g_signal_connect (widget
, "leave_notify_event",
2486 G_CALLBACK (gtk_window_leave_callback
), this);
2488 if (IsTopLevel() && m_wxwindow
)
2489 g_signal_connect (m_wxwindow
, "style_set",
2490 G_CALLBACK (gtk_window_style_set_callback
), this);
2493 bool wxWindowGTK::Destroy()
2497 return wxWindowBase::Destroy();
2500 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2502 gtk_widget_set_size_request(m_widget
, width
, height
);
2504 // inform the parent to perform the move
2505 wxASSERT_MSG(m_parent
&& m_parent
->m_wxwindow
,
2506 "the parent window has no client area?");
2507 WX_PIZZA(m_parent
->m_wxwindow
)->move(m_widget
, x
, y
);
2510 void wxWindowGTK::ConstrainSize()
2513 // GPE's window manager doesn't like size hints at all, esp. when the user
2514 // has to use the virtual keyboard, so don't constrain size there
2518 const wxSize minSize
= GetMinSize();
2519 const wxSize maxSize
= GetMaxSize();
2520 if (minSize
.x
> 0 && m_width
< minSize
.x
) m_width
= minSize
.x
;
2521 if (minSize
.y
> 0 && m_height
< minSize
.y
) m_height
= minSize
.y
;
2522 if (maxSize
.x
> 0 && m_width
> maxSize
.x
) m_width
= maxSize
.x
;
2523 if (maxSize
.y
> 0 && m_height
> maxSize
.y
) m_height
= maxSize
.y
;
2527 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2529 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2530 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2532 int currentX
, currentY
;
2533 GetPosition(¤tX
, ¤tY
);
2534 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2536 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2538 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2540 // calculate the best size if we should auto size the window
2541 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2542 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2544 const wxSize sizeBest
= GetBestSize();
2545 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2547 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2548 height
= sizeBest
.y
;
2551 const wxSize
oldSize(m_width
, m_height
);
2557 if (m_parent
->m_wxwindow
)
2559 wxPizza
* pizza
= WX_PIZZA(m_parent
->m_wxwindow
);
2560 m_x
= x
+ pizza
->m_scroll_x
;
2561 m_y
= y
+ pizza
->m_scroll_y
;
2563 int left_border
= 0;
2564 int right_border
= 0;
2566 int bottom_border
= 0;
2568 /* the default button has a border around it */
2569 if (gtk_widget_get_can_default(m_widget
))
2571 GtkBorder
*default_border
= NULL
;
2572 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2575 left_border
+= default_border
->left
;
2576 right_border
+= default_border
->right
;
2577 top_border
+= default_border
->top
;
2578 bottom_border
+= default_border
->bottom
;
2579 gtk_border_free( default_border
);
2583 DoMoveWindow( m_x
- left_border
,
2585 m_width
+left_border
+right_border
,
2586 m_height
+top_border
+bottom_border
);
2589 if (m_width
!= oldSize
.x
|| m_height
!= oldSize
.y
)
2591 // update these variables to keep size_allocate handler
2592 // from sending another size event for this change
2593 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2595 gtk_widget_queue_resize(m_widget
);
2596 if (!m_nativeSizeEvent
)
2598 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2599 event
.SetEventObject( this );
2600 HandleWindowEvent( event
);
2603 if (sizeFlags
& wxSIZE_FORCE_EVENT
)
2605 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2606 event
.SetEventObject( this );
2607 HandleWindowEvent( event
);
2611 bool wxWindowGTK::GTKShowFromOnIdle()
2613 if (IsShown() && m_showOnIdle
&& !gtk_widget_get_visible (m_widget
))
2615 GtkAllocation alloc
;
2618 alloc
.width
= m_width
;
2619 alloc
.height
= m_height
;
2620 gtk_widget_size_allocate( m_widget
, &alloc
);
2621 gtk_widget_show( m_widget
);
2622 wxShowEvent
eventShow(GetId(), true);
2623 eventShow
.SetEventObject(this);
2624 HandleWindowEvent(eventShow
);
2625 m_showOnIdle
= false;
2632 void wxWindowGTK::OnInternalIdle()
2634 if ( gs_deferredFocusOut
)
2635 GTKHandleDeferredFocusOut();
2637 // Check if we have to show window now
2638 if (GTKShowFromOnIdle()) return;
2640 if ( m_dirtyTabOrder
)
2642 m_dirtyTabOrder
= false;
2646 // Update style if the window was not yet realized when
2647 // SetBackgroundStyle() was called
2648 if (m_needsStyleChange
)
2650 SetBackgroundStyle(GetBackgroundStyle());
2651 m_needsStyleChange
= false;
2654 wxWindowBase::OnInternalIdle();
2657 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
2659 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2661 if (width
) (*width
) = m_width
;
2662 if (height
) (*height
) = m_height
;
2665 void wxWindowGTK::DoSetClientSize( int width
, int height
)
2667 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2669 const wxSize size
= GetSize();
2670 const wxSize clientSize
= GetClientSize();
2671 SetSize(width
+ (size
.x
- clientSize
.x
), height
+ (size
.y
- clientSize
.y
));
2674 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
2676 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2683 // if window is scrollable, account for scrollbars
2684 if ( GTK_IS_SCROLLED_WINDOW(m_widget
) )
2686 GtkPolicyType policy
[ScrollDir_Max
];
2687 gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget
),
2688 &policy
[ScrollDir_Horz
],
2689 &policy
[ScrollDir_Vert
]);
2691 for ( int i
= 0; i
< ScrollDir_Max
; i
++ )
2693 // don't account for the scrollbars we don't have
2694 GtkRange
* const range
= m_scrollBar
[i
];
2698 // nor for the ones we have but don't current show
2699 switch ( policy
[i
] )
2701 case GTK_POLICY_NEVER
:
2702 // never shown so doesn't take any place
2705 case GTK_POLICY_ALWAYS
:
2706 // no checks necessary
2709 case GTK_POLICY_AUTOMATIC
:
2710 // may be shown or not, check
2711 GtkAdjustment
*adj
= gtk_range_get_adjustment(range
);
2712 if (gtk_adjustment_get_upper(adj
) <= gtk_adjustment_get_page_size(adj
))
2716 GtkScrolledWindowClass
*scroll_class
=
2717 GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2720 gtk_widget_size_request(GTK_WIDGET(range
), &req
);
2721 if (i
== ScrollDir_Horz
)
2722 h
-= req
.height
+ scroll_class
->scrollbar_spacing
;
2724 w
-= req
.width
+ scroll_class
->scrollbar_spacing
;
2728 const wxSize sizeBorders
= DoGetBorderSize();
2738 if (width
) *width
= w
;
2739 if (height
) *height
= h
;
2742 wxSize
wxWindowGTK::DoGetBorderSize() const
2745 return wxWindowBase::DoGetBorderSize();
2748 WX_PIZZA(m_wxwindow
)->get_border_widths(x
, y
);
2750 return 2*wxSize(x
, y
);
2753 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
2755 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2759 if (!IsTopLevel() && m_parent
&& m_parent
->m_wxwindow
)
2761 wxPizza
* pizza
= WX_PIZZA(m_parent
->m_wxwindow
);
2762 dx
= pizza
->m_scroll_x
;
2763 dy
= pizza
->m_scroll_y
;
2766 if (m_x
== -1 && m_y
== -1)
2768 GdkWindow
*source
= NULL
;
2770 source
= gtk_widget_get_window(m_wxwindow
);
2772 source
= gtk_widget_get_window(m_widget
);
2778 gdk_window_get_origin( source
, &org_x
, &org_y
);
2781 m_parent
->ScreenToClient(&org_x
, &org_y
);
2783 const_cast<wxWindowGTK
*>(this)->m_x
= org_x
;
2784 const_cast<wxWindowGTK
*>(this)->m_y
= org_y
;
2788 if (x
) (*x
) = m_x
- dx
;
2789 if (y
) (*y
) = m_y
- dy
;
2792 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
2794 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2796 if (gtk_widget_get_window(m_widget
) == NULL
) return;
2798 GdkWindow
*source
= NULL
;
2800 source
= gtk_widget_get_window(m_wxwindow
);
2802 source
= gtk_widget_get_window(m_widget
);
2806 gdk_window_get_origin( source
, &org_x
, &org_y
);
2810 if (!gtk_widget_get_has_window(m_widget
))
2813 gtk_widget_get_allocation(m_widget
, &a
);
2822 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2823 *x
= (GetClientSize().x
- *x
) + org_x
;
2831 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
2833 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2835 if (!gtk_widget_get_realized(m_widget
)) return;
2837 GdkWindow
*source
= NULL
;
2839 source
= gtk_widget_get_window(m_wxwindow
);
2841 source
= gtk_widget_get_window(m_widget
);
2845 gdk_window_get_origin( source
, &org_x
, &org_y
);
2849 if (!gtk_widget_get_has_window(m_widget
))
2852 gtk_widget_get_allocation(m_widget
, &a
);
2860 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2861 *x
= (GetClientSize().x
- *x
) - org_x
;
2868 bool wxWindowGTK::Show( bool show
)
2870 if ( !wxWindowBase::Show(show
) )
2876 // notice that we may call Hide() before the window is created and this is
2877 // actually useful to create it hidden initially -- but we can't call
2878 // Show() before it is created
2881 wxASSERT_MSG( !show
, "can't show invalid window" );
2889 // defer until later
2893 gtk_widget_show(m_widget
);
2897 gtk_widget_hide(m_widget
);
2900 wxShowEvent
eventShow(GetId(), show
);
2901 eventShow
.SetEventObject(this);
2902 HandleWindowEvent(eventShow
);
2907 void wxWindowGTK::DoEnable( bool enable
)
2909 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2911 gtk_widget_set_sensitive( m_widget
, enable
);
2912 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
2913 gtk_widget_set_sensitive( m_wxwindow
, enable
);
2916 int wxWindowGTK::GetCharHeight() const
2918 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
2920 wxFont font
= GetFont();
2921 wxCHECK_MSG( font
.IsOk(), 12, wxT("invalid font") );
2923 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
2928 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
2929 PangoLayout
*layout
= pango_layout_new(context
);
2930 pango_layout_set_font_description(layout
, desc
);
2931 pango_layout_set_text(layout
, "H", 1);
2932 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
2934 PangoRectangle rect
;
2935 pango_layout_line_get_extents(line
, NULL
, &rect
);
2937 g_object_unref (layout
);
2939 return (int) PANGO_PIXELS(rect
.height
);
2942 int wxWindowGTK::GetCharWidth() const
2944 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
2946 wxFont font
= GetFont();
2947 wxCHECK_MSG( font
.IsOk(), 8, wxT("invalid font") );
2949 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
2954 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
2955 PangoLayout
*layout
= pango_layout_new(context
);
2956 pango_layout_set_font_description(layout
, desc
);
2957 pango_layout_set_text(layout
, "g", 1);
2958 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
2960 PangoRectangle rect
;
2961 pango_layout_line_get_extents(line
, NULL
, &rect
);
2963 g_object_unref (layout
);
2965 return (int) PANGO_PIXELS(rect
.width
);
2968 void wxWindowGTK::DoGetTextExtent( const wxString
& string
,
2972 int *externalLeading
,
2973 const wxFont
*theFont
) const
2975 wxFont fontToUse
= theFont
? *theFont
: GetFont();
2977 wxCHECK_RET( fontToUse
.IsOk(), wxT("invalid font") );
2986 PangoContext
*context
= NULL
;
2988 context
= gtk_widget_get_pango_context( m_widget
);
2997 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
2998 PangoLayout
*layout
= pango_layout_new(context
);
2999 pango_layout_set_font_description(layout
, desc
);
3001 const wxCharBuffer data
= wxGTK_CONV( string
);
3003 pango_layout_set_text(layout
, data
, strlen(data
));
3006 PangoRectangle rect
;
3007 pango_layout_get_extents(layout
, NULL
, &rect
);
3009 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
3010 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
3013 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
3014 int baseline
= pango_layout_iter_get_baseline(iter
);
3015 pango_layout_iter_free(iter
);
3016 *descent
= *y
- PANGO_PIXELS(baseline
);
3018 if (externalLeading
) (*externalLeading
) = 0; // ??
3020 g_object_unref (layout
);
3023 void wxWindowGTK::GTKDisableFocusOutEvent()
3025 g_signal_handlers_block_by_func( m_focusWidget
,
3026 (gpointer
) gtk_window_focus_out_callback
, this);
3029 void wxWindowGTK::GTKEnableFocusOutEvent()
3031 g_signal_handlers_unblock_by_func( m_focusWidget
,
3032 (gpointer
) gtk_window_focus_out_callback
, this);
3035 bool wxWindowGTK::GTKHandleFocusIn()
3037 // Disable default focus handling for custom windows since the default GTK+
3038 // handler issues a repaint
3039 const bool retval
= m_wxwindow
? true : false;
3042 // NB: if there's still unprocessed deferred focus-out event (see
3043 // GTKHandleFocusOut() for explanation), we need to process it first so
3044 // that the order of focus events -- focus-out first, then focus-in
3045 // elsewhere -- is preserved
3046 if ( gs_deferredFocusOut
)
3048 if ( GTKNeedsToFilterSameWindowFocus() &&
3049 gs_deferredFocusOut
== this )
3051 // GTK+ focus changed from this wxWindow back to itself, so don't
3052 // emit any events at all
3053 wxLogTrace(TRACE_FOCUS
,
3054 "filtered out spurious focus change within %s(%p, %s)",
3055 GetClassInfo()->GetClassName(), this, GetLabel());
3056 gs_deferredFocusOut
= NULL
;
3060 // otherwise we need to send focus-out first
3061 wxASSERT_MSG ( gs_deferredFocusOut
!= this,
3062 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
3063 GTKHandleDeferredFocusOut();
3067 wxLogTrace(TRACE_FOCUS
,
3068 "handling focus_in event for %s(%p, %s)",
3069 GetClassInfo()->GetClassName(), this, GetLabel());
3072 gtk_im_context_focus_in(m_imData
->context
);
3074 gs_currentFocus
= this;
3075 gs_pendingFocus
= NULL
;
3078 // caret needs to be informed about focus change
3079 wxCaret
*caret
= GetCaret();
3082 caret
->OnSetFocus();
3084 #endif // wxUSE_CARET
3086 // Notify the parent keeping track of focus for the kbd navigation
3087 // purposes that we got it.
3088 wxChildFocusEvent
eventChildFocus(static_cast<wxWindow
*>(this));
3089 GTKProcessEvent(eventChildFocus
);
3091 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, GetId());
3092 eventFocus
.SetEventObject(this);
3093 GTKProcessEvent(eventFocus
);
3098 bool wxWindowGTK::GTKHandleFocusOut()
3100 // Disable default focus handling for custom windows since the default GTK+
3101 // handler issues a repaint
3102 const bool retval
= m_wxwindow
? true : false;
3105 // NB: If a control is composed of several GtkWidgets and when focus
3106 // changes from one of them to another within the same wxWindow, we get
3107 // a focus-out event followed by focus-in for another GtkWidget owned
3108 // by the same wx control. We don't want to generate two spurious
3109 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3110 // from GTKHandleFocusOut() until we know for sure it's not coming back
3111 // (i.e. in GTKHandleFocusIn() or at idle time).
3112 if ( GTKNeedsToFilterSameWindowFocus() )
3114 wxASSERT_MSG( gs_deferredFocusOut
== NULL
,
3115 "deferred focus out event already pending" );
3116 wxLogTrace(TRACE_FOCUS
,
3117 "deferring focus_out event for %s(%p, %s)",
3118 GetClassInfo()->GetClassName(), this, GetLabel());
3119 gs_deferredFocusOut
= this;
3123 GTKHandleFocusOutNoDeferring();
3128 void wxWindowGTK::GTKHandleFocusOutNoDeferring()
3130 wxLogTrace(TRACE_FOCUS
,
3131 "handling focus_out event for %s(%p, %s)",
3132 GetClassInfo()->GetClassName(), this, GetLabel());
3135 gtk_im_context_focus_out(m_imData
->context
);
3137 if ( gs_currentFocus
!= this )
3139 // Something is terribly wrong, gs_currentFocus is out of sync with the
3140 // real focus. We will reset it to NULL anyway, because after this
3141 // focus-out event is handled, one of the following with happen:
3143 // * either focus will go out of the app altogether, in which case
3144 // gs_currentFocus _should_ be NULL
3146 // * or it goes to another control, in which case focus-in event will
3147 // follow immediately and it will set gs_currentFocus to the right
3149 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3150 GetClassInfo()->GetClassName(), this, GetLabel());
3152 gs_currentFocus
= NULL
;
3155 // caret needs to be informed about focus change
3156 wxCaret
*caret
= GetCaret();
3159 caret
->OnKillFocus();
3161 #endif // wxUSE_CARET
3163 wxFocusEvent
event( wxEVT_KILL_FOCUS
, GetId() );
3164 event
.SetEventObject( this );
3165 GTKProcessEvent( event
);
3169 void wxWindowGTK::GTKHandleDeferredFocusOut()
3171 // NB: See GTKHandleFocusOut() for explanation. This function is called
3172 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3174 if ( gs_deferredFocusOut
)
3176 wxWindowGTK
*win
= gs_deferredFocusOut
;
3177 gs_deferredFocusOut
= NULL
;
3179 wxLogTrace(TRACE_FOCUS
,
3180 "processing deferred focus_out event for %s(%p, %s)",
3181 win
->GetClassInfo()->GetClassName(), win
, win
->GetLabel());
3183 win
->GTKHandleFocusOutNoDeferring();
3187 void wxWindowGTK::SetFocus()
3189 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3191 // Setting "physical" focus is not immediate in GTK+ and while
3192 // gtk_widget_is_focus ("determines if the widget is the focus widget
3193 // within its toplevel", i.e. returns true for one widget per TLW, not
3194 // globally) returns true immediately after grabbing focus,
3195 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3196 // has focus at the moment) takes effect only after the window is shown
3197 // (if it was hidden at the moment of the call) or at the next event loop
3200 // Because we want to FindFocus() call immediately following
3201 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3203 gs_pendingFocus
= this;
3205 GtkWidget
*widget
= m_wxwindow
? m_wxwindow
: m_focusWidget
;
3207 if ( GTK_IS_CONTAINER(widget
) &&
3208 !gtk_widget_get_can_focus(widget
) )
3210 wxLogTrace(TRACE_FOCUS
,
3211 wxT("Setting focus to a child of %s(%p, %s)"),
3212 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3213 gtk_widget_child_focus(widget
, GTK_DIR_TAB_FORWARD
);
3217 wxLogTrace(TRACE_FOCUS
,
3218 wxT("Setting focus to %s(%p, %s)"),
3219 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3220 gtk_widget_grab_focus(widget
);
3224 void wxWindowGTK::SetCanFocus(bool canFocus
)
3226 gtk_widget_set_can_focus(m_widget
, canFocus
);
3228 if ( m_wxwindow
&& (m_widget
!= m_wxwindow
) )
3230 gtk_widget_set_can_focus(m_wxwindow
, canFocus
);
3234 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3236 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3238 wxWindowGTK
* const newParent
= (wxWindowGTK
*)newParentBase
;
3240 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3242 if ( !wxWindowBase::Reparent(newParent
) )
3245 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3247 // Notice that old m_parent pointer might be non-NULL here but the widget
3248 // still not have any parent at GTK level if it's a notebook page that had
3249 // been removed from the notebook so test this at GTK level and not wx one.
3250 if ( GtkWidget
*parentGTK
= gtk_widget_get_parent(m_widget
) )
3251 gtk_container_remove(GTK_CONTAINER(parentGTK
), m_widget
);
3253 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3257 if (gtk_widget_get_visible (newParent
->m_widget
))
3259 m_showOnIdle
= true;
3260 gtk_widget_hide( m_widget
);
3262 /* insert GTK representation */
3263 newParent
->AddChildGTK(this);
3266 SetLayoutDirection(wxLayout_Default
);
3271 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3273 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3274 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3279 /* insert GTK representation */
3283 void wxWindowGTK::AddChild(wxWindowBase
*child
)
3285 wxWindowBase::AddChild(child
);
3286 m_dirtyTabOrder
= true;
3287 wxTheApp
->WakeUpIdle();
3290 void wxWindowGTK::RemoveChild(wxWindowBase
*child
)
3292 wxWindowBase::RemoveChild(child
);
3293 m_dirtyTabOrder
= true;
3294 wxTheApp
->WakeUpIdle();
3298 wxLayoutDirection
wxWindowGTK::GTKGetLayout(GtkWidget
*widget
)
3300 return gtk_widget_get_direction(widget
) == GTK_TEXT_DIR_RTL
3301 ? wxLayout_RightToLeft
3302 : wxLayout_LeftToRight
;
3306 void wxWindowGTK::GTKSetLayout(GtkWidget
*widget
, wxLayoutDirection dir
)
3308 wxASSERT_MSG( dir
!= wxLayout_Default
, wxT("invalid layout direction") );
3310 gtk_widget_set_direction(widget
,
3311 dir
== wxLayout_RightToLeft
? GTK_TEXT_DIR_RTL
3312 : GTK_TEXT_DIR_LTR
);
3315 wxLayoutDirection
wxWindowGTK::GetLayoutDirection() const
3317 return GTKGetLayout(m_widget
);
3320 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir
)
3322 if ( dir
== wxLayout_Default
)
3324 const wxWindow
*const parent
= GetParent();
3327 // inherit layout from parent.
3328 dir
= parent
->GetLayoutDirection();
3330 else // no parent, use global default layout
3332 dir
= wxTheApp
->GetLayoutDirection();
3336 if ( dir
== wxLayout_Default
)
3339 GTKSetLayout(m_widget
, dir
);
3341 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3342 GTKSetLayout(m_wxwindow
, dir
);
3346 wxWindowGTK::AdjustForLayoutDirection(wxCoord x
,
3347 wxCoord
WXUNUSED(width
),
3348 wxCoord
WXUNUSED(widthTotal
)) const
3350 // We now mirror the coordinates of RTL windows in wxPizza
3354 void wxWindowGTK::DoMoveInTabOrder(wxWindow
*win
, WindowOrder move
)
3356 wxWindowBase::DoMoveInTabOrder(win
, move
);
3357 m_dirtyTabOrder
= true;
3358 wxTheApp
->WakeUpIdle();
3361 bool wxWindowGTK::DoNavigateIn(int flags
)
3363 if ( flags
& wxNavigationKeyEvent::WinChange
)
3365 wxFAIL_MSG( wxT("not implemented") );
3369 else // navigate inside the container
3371 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3372 wxCHECK_MSG( parent
, false, wxT("every window must have a TLW parent") );
3374 GtkDirectionType dir
;
3375 dir
= flags
& wxNavigationKeyEvent::IsForward
? GTK_DIR_TAB_FORWARD
3376 : GTK_DIR_TAB_BACKWARD
;
3379 g_signal_emit_by_name(parent
->m_widget
, "focus", dir
, &rc
);
3385 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3387 // none needed by default
3391 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3393 // nothing to do by default since none is needed
3396 void wxWindowGTK::RealizeTabOrder()
3400 if ( !m_children
.empty() )
3402 // we don't only construct the correct focus chain but also use
3403 // this opportunity to update the mnemonic widgets for the widgets
3406 GList
*chain
= NULL
;
3407 wxWindowGTK
* mnemonicWindow
= NULL
;
3409 for ( wxWindowList::const_iterator i
= m_children
.begin();
3410 i
!= m_children
.end();
3413 wxWindowGTK
*win
= *i
;
3415 bool focusableFromKeyboard
= win
->AcceptsFocusFromKeyboard();
3417 if ( mnemonicWindow
)
3419 if ( focusableFromKeyboard
)
3421 // wxComboBox et al. needs to focus on on a different
3422 // widget than m_widget, so if the main widget isn't
3423 // focusable try the connect widget
3424 GtkWidget
* w
= win
->m_widget
;
3425 if ( !gtk_widget_get_can_focus(w
) )
3427 w
= win
->GetConnectWidget();
3428 if ( !gtk_widget_get_can_focus(w
) )
3434 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3435 mnemonicWindow
= NULL
;
3439 else if ( win
->GTKWidgetNeedsMnemonic() )
3441 mnemonicWindow
= win
;
3444 if ( focusableFromKeyboard
)
3445 chain
= g_list_prepend(chain
, win
->m_widget
);
3448 chain
= g_list_reverse(chain
);
3450 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3455 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3460 void wxWindowGTK::Raise()
3462 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3464 if (m_wxwindow
&& gtk_widget_get_window(m_wxwindow
))
3466 gdk_window_raise(gtk_widget_get_window(m_wxwindow
));
3468 else if (gtk_widget_get_window(m_widget
))
3470 gdk_window_raise(gtk_widget_get_window(m_widget
));
3474 void wxWindowGTK::Lower()
3476 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3478 if (m_wxwindow
&& gtk_widget_get_window(m_wxwindow
))
3480 gdk_window_lower(gtk_widget_get_window(m_wxwindow
));
3482 else if (gtk_widget_get_window(m_widget
))
3484 gdk_window_lower(gtk_widget_get_window(m_widget
));
3488 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3490 if ( !wxWindowBase::SetCursor(cursor
.IsOk() ? cursor
: *wxSTANDARD_CURSOR
) )
3498 void wxWindowGTK::GTKUpdateCursor(bool update_self
/*=true*/, bool recurse
/*=true*/)
3502 wxCursor
cursor(g_globalCursor
.IsOk() ? g_globalCursor
: GetCursor());
3503 if ( cursor
.IsOk() )
3505 wxArrayGdkWindows windowsThis
;
3506 GdkWindow
* window
= GTKGetWindow(windowsThis
);
3508 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3511 const size_t count
= windowsThis
.size();
3512 for ( size_t n
= 0; n
< count
; n
++ )
3514 GdkWindow
*win
= windowsThis
[n
];
3515 // It can be zero if the window has not been realized yet.
3518 gdk_window_set_cursor(win
, cursor
.GetCursor());
3527 for (wxWindowList::iterator it
= GetChildren().begin(); it
!= GetChildren().end(); ++it
)
3529 (*it
)->GTKUpdateCursor( true );
3534 void wxWindowGTK::WarpPointer( int x
, int y
)
3536 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3538 ClientToScreen(&x
, &y
);
3539 GdkDisplay
* display
= gtk_widget_get_display(m_widget
);
3540 GdkScreen
* screen
= gtk_widget_get_screen(m_widget
);
3542 GdkDeviceManager
* manager
= gdk_display_get_device_manager(display
);
3543 gdk_device_warp(gdk_device_manager_get_client_pointer(manager
), screen
, x
, y
);
3545 XWarpPointer(GDK_DISPLAY_XDISPLAY(display
),
3547 GDK_WINDOW_XID(gdk_screen_get_root_window(screen
)),
3552 wxWindowGTK::ScrollDir
wxWindowGTK::ScrollDirFromRange(GtkRange
*range
) const
3554 // find the scrollbar which generated the event
3555 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3557 if ( range
== m_scrollBar
[dir
] )
3558 return (ScrollDir
)dir
;
3561 wxFAIL_MSG( wxT("event from unknown scrollbar received") );
3563 return ScrollDir_Max
;
3566 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3568 bool changed
= false;
3569 GtkRange
* range
= m_scrollBar
[dir
];
3570 if ( range
&& units
)
3572 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
3573 double inc
= unit
== ScrollUnit_Line
? gtk_adjustment_get_step_increment(adj
)
3574 : gtk_adjustment_get_page_increment(adj
);
3576 const int posOld
= wxRound(gtk_adjustment_get_value(adj
));
3577 gtk_range_set_value(range
, posOld
+ units
*inc
);
3579 changed
= wxRound(gtk_adjustment_get_value(adj
)) != posOld
;
3585 bool wxWindowGTK::ScrollLines(int lines
)
3587 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3590 bool wxWindowGTK::ScrollPages(int pages
)
3592 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3595 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground
),
3600 // it is valid to call Refresh() for a window which hasn't been created
3601 // yet, it simply doesn't do anything in this case
3608 gtk_widget_queue_draw_area( m_widget
, rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3610 gtk_widget_queue_draw( m_widget
);
3614 // Just return if the widget or one of its ancestors isn't mapped
3616 for (w
= m_wxwindow
; w
!= NULL
; w
= gtk_widget_get_parent(w
))
3617 if (!gtk_widget_get_mapped (w
))
3620 GdkWindow
* window
= GTKGetDrawingWindow();
3624 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3625 x
= GetClientSize().x
- x
- rect
->width
;
3629 r
.width
= rect
->width
;
3630 r
.height
= rect
->height
;
3631 gdk_window_invalidate_rect(window
, &r
, true);
3634 gdk_window_invalidate_rect(window
, NULL
, true);
3638 void wxWindowGTK::Update()
3640 if (m_widget
&& gtk_widget_get_mapped(m_widget
))
3642 GdkDisplay
* display
= gtk_widget_get_display(m_widget
);
3643 // Flush everything out to the server, and wait for it to finish.
3644 // This ensures nothing will overwrite the drawing we are about to do.
3645 gdk_display_sync(display
);
3647 GdkWindow
* window
= GTKGetDrawingWindow();
3649 window
= gtk_widget_get_window(m_widget
);
3650 gdk_window_process_updates(window
, true);
3652 // Flush again, but no need to wait for it to finish
3653 gdk_display_flush(display
);
3657 bool wxWindowGTK::DoIsExposed( int x
, int y
) const
3659 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
3662 bool wxWindowGTK::DoIsExposed( int x
, int y
, int w
, int h
) const
3664 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3665 return m_updateRegion
.Contains(x
-w
, y
, w
, h
) != wxOutRegion
;
3667 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
3670 void wxWindowGTK::GtkSendPaintEvents()
3674 m_updateRegion
.Clear();
3678 // Clip to paint region in wxClientDC
3679 m_clipPaintRegion
= true;
3681 m_nativeUpdateRegion
= m_updateRegion
;
3683 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3685 // Transform m_updateRegion under RTL
3686 m_updateRegion
.Clear();
3689 gdk_drawable_get_size(gtk_widget_get_window(m_wxwindow
), &width
, NULL
);
3691 wxRegionIterator
upd( m_nativeUpdateRegion
);
3695 rect
.x
= upd
.GetX();
3696 rect
.y
= upd
.GetY();
3697 rect
.width
= upd
.GetWidth();
3698 rect
.height
= upd
.GetHeight();
3700 rect
.x
= width
- rect
.x
- rect
.width
;
3701 m_updateRegion
.Union( rect
);
3707 switch ( GetBackgroundStyle() )
3709 case wxBG_STYLE_ERASE
:
3711 wxWindowDC
dc( (wxWindow
*)this );
3712 dc
.SetDeviceClippingRegion( m_updateRegion
);
3714 // Work around gtk-qt <= 0.60 bug whereby the window colour
3718 GetOptionInt("gtk.window.force-background-colour") )
3720 dc
.SetBackground(GetBackgroundColour());
3724 wxEraseEvent
erase_event( GetId(), &dc
);
3725 erase_event
.SetEventObject( this );
3727 if ( HandleWindowEvent(erase_event
) )
3729 // background erased, don't do it again
3735 case wxBG_STYLE_SYSTEM
:
3736 if ( GetThemeEnabled() )
3738 // find ancestor from which to steal background
3739 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3741 parent
= (wxWindow
*)this;
3743 if (gtk_widget_get_mapped(parent
->m_widget
))
3745 wxRegionIterator
upd( m_nativeUpdateRegion
);
3749 rect
.x
= upd
.GetX();
3750 rect
.y
= upd
.GetY();
3751 rect
.width
= upd
.GetWidth();
3752 rect
.height
= upd
.GetHeight();
3754 gtk_paint_flat_box(gtk_widget_get_style(parent
->m_widget
),
3755 GTKGetDrawingWindow(),
3756 gtk_widget_get_state(m_wxwindow
),
3769 case wxBG_STYLE_PAINT
:
3770 // nothing to do: window will be painted over in EVT_PAINT
3774 wxFAIL_MSG( "unsupported background style" );
3777 wxNcPaintEvent
nc_paint_event( GetId() );
3778 nc_paint_event
.SetEventObject( this );
3779 HandleWindowEvent( nc_paint_event
);
3781 wxPaintEvent
paint_event( GetId() );
3782 paint_event
.SetEventObject( this );
3783 HandleWindowEvent( paint_event
);
3785 m_clipPaintRegion
= false;
3787 m_updateRegion
.Clear();
3788 m_nativeUpdateRegion
.Clear();
3791 void wxWindowGTK::SetDoubleBuffered( bool on
)
3793 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3796 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3799 bool wxWindowGTK::IsDoubleBuffered() const
3801 return gtk_widget_get_double_buffered( m_wxwindow
);
3804 void wxWindowGTK::ClearBackground()
3806 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3810 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3812 if (m_tooltip
!= tip
)
3814 wxWindowBase::DoSetToolTip(tip
);
3817 m_tooltip
->GTKSetWindow(static_cast<wxWindow
*>(this));
3819 GTKApplyToolTip(NULL
);
3823 void wxWindowGTK::GTKApplyToolTip(const char* tip
)
3825 wxToolTip::GTKApply(GetConnectWidget(), tip
);
3827 #endif // wxUSE_TOOLTIPS
3829 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
3831 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3833 if (!wxWindowBase::SetBackgroundColour(colour
))
3838 // We need the pixel value e.g. for background clearing.
3839 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3842 // apply style change (forceStyle=true so that new style is applied
3843 // even if the bg colour changed from valid to wxNullColour)
3844 GTKApplyWidgetStyle(true);
3849 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
3851 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3853 if (!wxWindowBase::SetForegroundColour(colour
))
3860 // We need the pixel value e.g. for background clearing.
3861 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3864 // apply style change (forceStyle=true so that new style is applied
3865 // even if the bg colour changed from valid to wxNullColour):
3866 GTKApplyWidgetStyle(true);
3871 PangoContext
*wxWindowGTK::GTKGetPangoDefaultContext()
3873 return gtk_widget_get_pango_context( m_widget
);
3876 GtkRcStyle
*wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle
)
3878 // do we need to apply any changes at all?
3881 !m_foregroundColour
.IsOk() && !m_backgroundColour
.IsOk() )
3886 GtkRcStyle
*style
= gtk_rc_style_new();
3888 if ( m_font
.IsOk() )
3891 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
3894 int flagsNormal
= 0,
3897 flagsInsensitive
= 0;
3899 if ( m_foregroundColour
.IsOk() )
3901 const GdkColor
*fg
= m_foregroundColour
.GetColor();
3903 style
->fg
[GTK_STATE_NORMAL
] =
3904 style
->text
[GTK_STATE_NORMAL
] = *fg
;
3905 flagsNormal
|= GTK_RC_FG
| GTK_RC_TEXT
;
3907 style
->fg
[GTK_STATE_PRELIGHT
] =
3908 style
->text
[GTK_STATE_PRELIGHT
] = *fg
;
3909 flagsPrelight
|= GTK_RC_FG
| GTK_RC_TEXT
;
3911 style
->fg
[GTK_STATE_ACTIVE
] =
3912 style
->text
[GTK_STATE_ACTIVE
] = *fg
;
3913 flagsActive
|= GTK_RC_FG
| GTK_RC_TEXT
;
3916 if ( m_backgroundColour
.IsOk() )
3918 const GdkColor
*bg
= m_backgroundColour
.GetColor();
3920 style
->bg
[GTK_STATE_NORMAL
] =
3921 style
->base
[GTK_STATE_NORMAL
] = *bg
;
3922 flagsNormal
|= GTK_RC_BG
| GTK_RC_BASE
;
3924 style
->bg
[GTK_STATE_PRELIGHT
] =
3925 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
3926 flagsPrelight
|= GTK_RC_BG
| GTK_RC_BASE
;
3928 style
->bg
[GTK_STATE_ACTIVE
] =
3929 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
3930 flagsActive
|= GTK_RC_BG
| GTK_RC_BASE
;
3932 style
->bg
[GTK_STATE_INSENSITIVE
] =
3933 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
3934 flagsInsensitive
|= GTK_RC_BG
| GTK_RC_BASE
;
3937 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)flagsNormal
;
3938 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)flagsPrelight
;
3939 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)flagsActive
;
3940 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)flagsInsensitive
;
3945 void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle
)
3947 GtkRcStyle
*style
= GTKCreateWidgetStyle(forceStyle
);
3950 DoApplyWidgetStyle(style
);
3951 g_object_unref(style
);
3954 // Style change may affect GTK+'s size calculation:
3955 InvalidateBestSize();
3958 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
3962 // block the signal temporarily to avoid sending
3963 // wxSysColourChangedEvents when we change the colours ourselves
3964 bool unblock
= false;
3968 g_signal_handlers_block_by_func(
3969 m_wxwindow
, (void *)gtk_window_style_set_callback
, this);
3972 gtk_widget_modify_style(m_wxwindow
, style
);
3976 g_signal_handlers_unblock_by_func(
3977 m_wxwindow
, (void *)gtk_window_style_set_callback
, this);
3982 gtk_widget_modify_style(m_widget
, style
);
3986 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style
)
3988 wxWindowBase::SetBackgroundStyle(style
);
3990 if ( style
== wxBG_STYLE_PAINT
)
3995 window
= GTKGetDrawingWindow();
3999 GtkWidget
* const w
= GetConnectWidget();
4000 window
= w
? gtk_widget_get_window(w
) : NULL
;
4005 // Make sure GDK/X11 doesn't refresh the window
4007 gdk_window_set_back_pixmap( window
, None
, False
);
4009 Display
* display
= GDK_WINDOW_DISPLAY(window
);
4012 m_needsStyleChange
= false;
4014 else // window not realized yet
4016 // Do in OnIdle, because the window is not yet available
4017 m_needsStyleChange
= true;
4020 // Don't apply widget style, or we get a grey background
4024 // apply style change (forceStyle=true so that new style is applied
4025 // even if the bg colour changed from valid to wxNullColour):
4026 GTKApplyWidgetStyle(true);
4032 // ----------------------------------------------------------------------------
4033 // Pop-up menu stuff
4034 // ----------------------------------------------------------------------------
4036 #if wxUSE_MENUS_NATIVE
4040 void wxPopupMenuPositionCallback( GtkMenu
*menu
,
4042 gboolean
* WXUNUSED(whatever
),
4043 gpointer user_data
)
4045 // ensure that the menu appears entirely on screen
4047 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
4049 wxSize sizeScreen
= wxGetDisplaySize();
4050 wxPoint
*pos
= (wxPoint
*)user_data
;
4052 gint xmax
= sizeScreen
.x
- req
.width
,
4053 ymax
= sizeScreen
.y
- req
.height
;
4055 *x
= pos
->x
< xmax
? pos
->x
: xmax
;
4056 *y
= pos
->y
< ymax
? pos
->y
: ymax
;
4060 bool wxWindowGTK::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
4062 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4068 GtkMenuPositionFunc posfunc
;
4069 if ( x
== -1 && y
== -1 )
4071 // use GTK's default positioning algorithm
4077 pos
= ClientToScreen(wxPoint(x
, y
));
4079 posfunc
= wxPopupMenuPositionCallback
;
4082 menu
->m_popupShown
= true;
4084 GTK_MENU(menu
->m_menu
),
4085 NULL
, // parent menu shell
4086 NULL
, // parent menu item
4087 posfunc
, // function to position it
4088 userdata
, // client data
4089 0, // button used to activate it
4090 gtk_get_current_event_time()
4093 while (menu
->m_popupShown
)
4095 gtk_main_iteration();
4101 #endif // wxUSE_MENUS_NATIVE
4103 #if wxUSE_DRAG_AND_DROP
4105 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4107 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4109 GtkWidget
*dnd_widget
= GetConnectWidget();
4111 if (m_dropTarget
) m_dropTarget
->GtkUnregisterWidget( dnd_widget
);
4113 if (m_dropTarget
) delete m_dropTarget
;
4114 m_dropTarget
= dropTarget
;
4116 if (m_dropTarget
) m_dropTarget
->GtkRegisterWidget( dnd_widget
);
4119 #endif // wxUSE_DRAG_AND_DROP
4121 GtkWidget
* wxWindowGTK::GetConnectWidget()
4123 GtkWidget
*connect_widget
= m_widget
;
4124 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4126 return connect_widget
;
4129 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow
*window
) const
4131 wxArrayGdkWindows windowsThis
;
4132 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
4134 return winThis
? window
== winThis
4135 : windowsThis
.Index(window
) != wxNOT_FOUND
;
4138 GdkWindow
*wxWindowGTK::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
4140 return m_wxwindow
? GTKGetDrawingWindow() : gtk_widget_get_window(m_widget
);
4143 bool wxWindowGTK::SetFont( const wxFont
&font
)
4145 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4147 if (!wxWindowBase::SetFont(font
))
4150 // apply style change (forceStyle=true so that new style is applied
4151 // even if the font changed from valid to wxNullFont):
4152 GTKApplyWidgetStyle(true);
4157 void wxWindowGTK::DoCaptureMouse()
4159 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4161 GdkWindow
*window
= NULL
;
4163 window
= GTKGetDrawingWindow();
4165 window
= gtk_widget_get_window(GetConnectWidget());
4167 wxCHECK_RET( window
, wxT("CaptureMouse() failed") );
4169 const wxCursor
* cursor
= &m_cursor
;
4170 if (!cursor
->IsOk())
4171 cursor
= wxSTANDARD_CURSOR
;
4173 gdk_pointer_grab( window
, FALSE
,
4175 (GDK_BUTTON_PRESS_MASK
|
4176 GDK_BUTTON_RELEASE_MASK
|
4177 GDK_POINTER_MOTION_HINT_MASK
|
4178 GDK_POINTER_MOTION_MASK
),
4180 cursor
->GetCursor(),
4181 (guint32
)GDK_CURRENT_TIME
);
4182 g_captureWindow
= this;
4183 g_captureWindowHasMouse
= true;
4186 void wxWindowGTK::DoReleaseMouse()
4188 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4190 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4192 g_captureWindow
= NULL
;
4194 GdkWindow
*window
= NULL
;
4196 window
= GTKGetDrawingWindow();
4198 window
= gtk_widget_get_window(GetConnectWidget());
4203 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4206 void wxWindowGTK::GTKReleaseMouseAndNotify()
4209 wxMouseCaptureLostEvent
evt(GetId());
4210 evt
.SetEventObject( this );
4211 HandleWindowEvent( evt
);
4215 wxWindow
*wxWindowBase::GetCapture()
4217 return (wxWindow
*)g_captureWindow
;
4220 bool wxWindowGTK::IsRetained() const
4225 void wxWindowGTK::SetScrollbar(int orient
,
4229 bool WXUNUSED(update
))
4231 const int dir
= ScrollDirFromOrient(orient
);
4232 GtkRange
* const sb
= m_scrollBar
[dir
];
4233 wxCHECK_RET( sb
, wxT("this window is not scrollable") );
4237 // GtkRange requires upper > lower
4242 g_signal_handlers_block_by_func(
4243 sb
, (void*)gtk_scrollbar_value_changed
, this);
4245 gtk_range_set_increments(sb
, 1, thumbVisible
);
4246 gtk_adjustment_set_page_size(gtk_range_get_adjustment(sb
), thumbVisible
);
4247 gtk_range_set_range(sb
, 0, range
);
4248 gtk_range_set_value(sb
, pos
);
4249 m_scrollPos
[dir
] = gtk_range_get_value(sb
);
4251 g_signal_handlers_unblock_by_func(
4252 sb
, (void*)gtk_scrollbar_value_changed
, this);
4255 void wxWindowGTK::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4257 const int dir
= ScrollDirFromOrient(orient
);
4258 GtkRange
* const sb
= m_scrollBar
[dir
];
4259 wxCHECK_RET( sb
, wxT("this window is not scrollable") );
4261 // This check is more than an optimization. Without it, the slider
4262 // will not move smoothly while tracking when using wxScrollHelper.
4263 if (GetScrollPos(orient
) != pos
)
4265 g_signal_handlers_block_by_func(
4266 sb
, (void*)gtk_scrollbar_value_changed
, this);
4268 gtk_range_set_value(sb
, pos
);
4269 m_scrollPos
[dir
] = gtk_range_get_value(sb
);
4271 g_signal_handlers_unblock_by_func(
4272 sb
, (void*)gtk_scrollbar_value_changed
, this);
4276 int wxWindowGTK::GetScrollThumb(int orient
) const
4278 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4279 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4281 return wxRound(gtk_adjustment_get_page_size(gtk_range_get_adjustment(sb
)));
4284 int wxWindowGTK::GetScrollPos( int orient
) const
4286 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4287 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4289 return wxRound(gtk_range_get_value(sb
));
4292 int wxWindowGTK::GetScrollRange( int orient
) const
4294 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4295 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4297 return wxRound(gtk_adjustment_get_upper(gtk_range_get_adjustment(sb
)));
4300 // Determine if increment is the same as +/-x, allowing for some small
4301 // difference due to possible inexactness in floating point arithmetic
4302 static inline bool IsScrollIncrement(double increment
, double x
)
4304 wxASSERT(increment
> 0);
4305 const double tolerance
= 1.0 / 1024;
4306 return fabs(increment
- fabs(x
)) < tolerance
;
4309 wxEventType
wxWindowGTK::GTKGetScrollEventType(GtkRange
* range
)
4311 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4313 const int barIndex
= range
== m_scrollBar
[1];
4315 const double value
= gtk_range_get_value(range
);
4317 // save previous position
4318 const double oldPos
= m_scrollPos
[barIndex
];
4319 // update current position
4320 m_scrollPos
[barIndex
] = value
;
4321 // If event should be ignored, or integral position has not changed
4322 if (!m_hasVMT
|| g_blockEventsOnDrag
|| wxRound(value
) == wxRound(oldPos
))
4327 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4330 // Difference from last change event
4331 const double diff
= value
- oldPos
;
4332 const bool isDown
= diff
> 0;
4334 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
4335 if (IsScrollIncrement(gtk_adjustment_get_step_increment(adj
), diff
))
4337 eventType
= isDown
? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4339 else if (IsScrollIncrement(gtk_adjustment_get_page_increment(adj
), diff
))
4341 eventType
= isDown
? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4343 else if (m_mouseButtonDown
)
4345 // Assume track event
4346 m_isScrolling
= true;
4352 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4354 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4356 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4358 // No scrolling requested.
4359 if ((dx
== 0) && (dy
== 0)) return;
4361 m_clipPaintRegion
= true;
4363 WX_PIZZA(m_wxwindow
)->scroll(dx
, dy
);
4365 m_clipPaintRegion
= false;
4368 bool restoreCaret
= (GetCaret() != NULL
&& GetCaret()->IsVisible());
4371 wxRect
caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4373 caretRect
.width
+= dx
;
4376 caretRect
.x
+= dx
; caretRect
.width
-= dx
;
4379 caretRect
.height
+= dy
;
4382 caretRect
.y
+= dy
; caretRect
.height
-= dy
;
4385 RefreshRect(caretRect
);
4387 #endif // wxUSE_CARET
4390 void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4392 //RN: Note that static controls usually have no border on gtk, so maybe
4393 //it makes sense to treat that as simply no border at the wx level
4395 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4397 GtkShadowType gtkstyle
;
4399 if(wxstyle
& wxBORDER_RAISED
)
4400 gtkstyle
= GTK_SHADOW_OUT
;
4401 else if ((wxstyle
& wxBORDER_SUNKEN
) || (wxstyle
& wxBORDER_THEME
))
4402 gtkstyle
= GTK_SHADOW_IN
;
4405 else if (wxstyle
& wxBORDER_DOUBLE
)
4406 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4409 gtkstyle
= GTK_SHADOW_IN
;
4411 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4416 void wxWindowGTK::SetWindowStyleFlag( long style
)
4418 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4419 wxWindowBase::SetWindowStyleFlag(style
);
4422 // Find the wxWindow at the current mouse position, also returning the mouse
4424 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4426 pt
= wxGetMousePosition();
4427 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4431 // Get the current mouse position.
4432 wxPoint
wxGetMousePosition()
4434 /* This crashes when used within wxHelpContext,
4435 so we have to use the X-specific implementation below.
4437 GdkModifierType *mask;
4438 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4440 return wxPoint(x, y);
4444 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4446 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4447 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4448 Window rootReturn
, childReturn
;
4449 int rootX
, rootY
, winX
, winY
;
4450 unsigned int maskReturn
;
4452 XQueryPointer (display
,
4456 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4457 return wxPoint(rootX
, rootY
);
4461 GdkWindow
* wxWindowGTK::GTKGetDrawingWindow() const
4463 GdkWindow
* window
= NULL
;
4465 window
= gtk_widget_get_window(m_wxwindow
);
4469 // ----------------------------------------------------------------------------
4471 // ----------------------------------------------------------------------------
4476 // this is called if we attempted to freeze unrealized widget when it finally
4477 // is realized (and so can be frozen):
4478 static void wx_frozen_widget_realize(GtkWidget
* w
, wxWindowGTK
* win
)
4480 wxASSERT( w
&& gtk_widget_get_has_window(w
) );
4481 wxASSERT( gtk_widget_get_realized(w
) );
4483 g_signal_handlers_disconnect_by_func
4486 (void*)wx_frozen_widget_realize
,
4491 if (w
== win
->m_wxwindow
)
4492 window
= win
->GTKGetDrawingWindow();
4494 window
= gtk_widget_get_window(w
);
4495 gdk_window_freeze_updates(window
);
4500 void wxWindowGTK::GTKFreezeWidget(GtkWidget
*w
)
4502 if ( !w
|| !gtk_widget_get_has_window(w
) )
4503 return; // window-less widget, cannot be frozen
4505 GdkWindow
* window
= gtk_widget_get_window(w
);
4508 // we can't thaw unrealized widgets because they don't have GdkWindow,
4509 // so set it up to be done immediately after realization:
4510 g_signal_connect_after
4514 G_CALLBACK(wx_frozen_widget_realize
),
4520 if (w
== m_wxwindow
)
4521 window
= GTKGetDrawingWindow();
4522 gdk_window_freeze_updates(window
);
4525 void wxWindowGTK::GTKThawWidget(GtkWidget
*w
)
4527 if ( !w
|| !gtk_widget_get_has_window(w
) )
4528 return; // window-less widget, cannot be frozen
4530 GdkWindow
* window
= gtk_widget_get_window(w
);
4533 // the widget wasn't realized yet, no need to thaw
4534 g_signal_handlers_disconnect_by_func
4537 (void*)wx_frozen_widget_realize
,
4543 if (w
== m_wxwindow
)
4544 window
= GTKGetDrawingWindow();
4545 gdk_window_thaw_updates(window
);
4548 void wxWindowGTK::DoFreeze()
4550 GTKFreezeWidget(m_widget
);
4551 if ( m_wxwindow
&& m_widget
!= m_wxwindow
)
4552 GTKFreezeWidget(m_wxwindow
);
4555 void wxWindowGTK::DoThaw()
4557 GTKThawWidget(m_widget
);
4558 if ( m_wxwindow
&& m_widget
!= m_wxwindow
)
4559 GTKThawWidget(m_wxwindow
);