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/scopeguard.h"
35 #include "wx/sysopt.h"
39 #include "wx/gtk/private.h"
40 #include "wx/gtk/private/win_gtk.h"
41 #include "wx/gtk/private/event.h"
42 using namespace wxGTKImpl
;
44 #ifdef GDK_WINDOWING_X11
50 #include <gdk/gdkkeysyms.h>
51 #if GTK_CHECK_VERSION(3,0,0)
52 #include <gdk/gdkkeysyms-compat.h>
55 // gdk_window_set_composited() is only supported since 2.12
56 #define wxGTK_VERSION_REQUIRED_FOR_COMPOSITING 2,12,0
57 #define wxGTK_HAS_COMPOSITING_SUPPORT GTK_CHECK_VERSION(2,12,0)
59 //-----------------------------------------------------------------------------
60 // documentation on internals
61 //-----------------------------------------------------------------------------
64 I have been asked several times about writing some documentation about
65 the GTK port of wxWidgets, especially its internal structures. Obviously,
66 you cannot understand wxGTK without knowing a little about the GTK, but
67 some more information about what the wxWindow, which is the base class
68 for all other window classes, does seems required as well.
72 What does wxWindow do? It contains the common interface for the following
73 jobs of its descendants:
75 1) Define the rudimentary behaviour common to all window classes, such as
76 resizing, intercepting user input (so as to make it possible to use these
77 events for special purposes in a derived class), window names etc.
79 2) Provide the possibility to contain and manage children, if the derived
80 class is allowed to contain children, which holds true for those window
81 classes which do not display a native GTK widget. To name them, these
82 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
83 work classes are a special case and are handled a bit differently from
84 the rest. The same holds true for the wxNotebook class.
86 3) Provide the possibility to draw into a client area of a window. This,
87 too, only holds true for classes that do not display a native GTK widget
90 4) Provide the entire mechanism for scrolling widgets. This actual inter-
91 face for this is usually in wxScrolledWindow, but the GTK implementation
94 5) A multitude of helper or extra methods for special purposes, such as
95 Drag'n'Drop, managing validators etc.
97 6) Display a border (sunken, raised, simple or none).
99 Normally one might expect, that one wxWidgets window would always correspond
100 to one GTK widget. Under GTK, there is no such all-round widget that has all
101 the functionality. Moreover, the GTK defines a client area as a different
102 widget from the actual widget you are handling. Last but not least some
103 special classes (e.g. wxFrame) handle different categories of widgets and
104 still have the possibility to draw something in the client area.
105 It was therefore required to write a special purpose GTK widget, that would
106 represent a client area in the sense of wxWidgets capable to do the jobs
107 2), 3) and 4). I have written this class and it resides in win_gtk.c of
110 All windows must have a widget, with which they interact with other under-
111 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
112 the wxWindow class has a member variable called m_widget which holds a
113 pointer to this widget. When the window class represents a GTK native widget,
114 this is (in most cases) the only GTK widget the class manages. E.g. the
115 wxStaticText class handles only a GtkLabel widget a pointer to which you
116 can find in m_widget (defined in wxWindow)
118 When the class has a client area for drawing into and for containing children
119 it has to handle the client area widget (of the type wxPizza, defined in
120 win_gtk.cpp), but there could be any number of widgets, handled by a class.
121 The common rule for all windows is only, that the widget that interacts with
122 the rest of GTK must be referenced in m_widget and all other widgets must be
123 children of this widget on the GTK level. The top-most widget, which also
124 represents the client area, must be in the m_wxwindow field and must be of
127 As I said, the window classes that display a GTK native widget only have
128 one widget, so in the case of e.g. the wxButton class m_widget holds a
129 pointer to a GtkButton widget. But windows with client areas (for drawing
130 and children) have a m_widget field that is a pointer to a GtkScrolled-
131 Window and a m_wxwindow field that is pointer to a wxPizza and this
132 one is (in the GTK sense) a child of the GtkScrolledWindow.
134 If the m_wxwindow field is set, then all input to this widget is inter-
135 cepted and sent to the wxWidgets class. If not, all input to the widget
136 that gets pointed to by m_widget gets intercepted and sent to the class.
140 The design of scrolling in wxWidgets is markedly different from that offered
141 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
142 clicking on a scrollbar belonging to scrolled window will inevitably move
143 the window. In wxWidgets, the scrollbar will only emit an event, send this
144 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
145 which actually moves the window and its sub-windows. Note that wxPizza
146 memorizes how much it has been scrolled but that wxWidgets forgets this
147 so that the two coordinates systems have to be kept in synch. This is done
148 in various places using the pizza->m_scroll_x and pizza->m_scroll_y values.
152 Singularly the most broken code in GTK is the code that is supposed to
153 inform subwindows (child windows) about new positions. Very often, duplicate
154 events are sent without changes in size or position, equally often no
155 events are sent at all (All this is due to a bug in the GtkContainer code
156 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
157 GTK's own system and it simply waits for size events for toplevel windows
158 and then iterates down the respective size events to all window. This has
159 the disadvantage that windows might get size events before the GTK widget
160 actually has the reported size. This doesn't normally pose any problem, but
161 the OpenGL drawing routines rely on correct behaviour. Therefore, I have
162 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
163 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
164 window that is used for OpenGL output really has that size (as reported by
169 If someone at some point of time feels the immense desire to have a look at,
170 change or attempt to optimise the Refresh() logic, this person will need an
171 intimate understanding of what "draw" and "expose" events are and what
172 they are used for, in particular when used in connection with GTK's
173 own windowless widgets. Beware.
177 Cursors, too, have been a constant source of pleasure. The main difficulty
178 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
179 for the parent. To prevent this from doing too much harm, SetCursor calls
180 GTKUpdateCursor, which will recursively re-set the cursors of all child windows.
181 Also don't forget that cursors (like much else) are connected to GdkWindows,
182 not GtkWidgets and that the "window" field of a GtkWidget might very well
183 point to the GdkWindow of the parent widget (-> "window-less widget") and
184 that the two obviously have very different meanings.
187 //-----------------------------------------------------------------------------
189 //-----------------------------------------------------------------------------
191 // Don't allow event propagation during drag
192 bool g_blockEventsOnDrag
;
193 // Don't allow mouse event propagation during scroll
194 bool g_blockEventsOnScroll
;
195 extern wxCursor g_globalCursor
;
197 // mouse capture state: the window which has it and if the mouse is currently
199 static wxWindowGTK
*g_captureWindow
= NULL
;
200 static bool g_captureWindowHasMouse
= false;
202 // The window that currently has focus:
203 static wxWindowGTK
*gs_currentFocus
= NULL
;
204 // The window that is scheduled to get focus in the next event loop iteration
205 // or NULL if there's no pending focus change:
206 static wxWindowGTK
*gs_pendingFocus
= NULL
;
208 // the window that has deferred focus-out event pending, if any (see
209 // GTKAddDeferredFocusOut() for details)
210 static wxWindowGTK
*gs_deferredFocusOut
= NULL
;
212 // global variables because GTK+ DnD want to have the
213 // mouse event that caused it
214 GdkEvent
*g_lastMouseEvent
= NULL
;
215 int g_lastButtonNumber
= 0;
217 //-----------------------------------------------------------------------------
219 //-----------------------------------------------------------------------------
221 // the trace mask used for the focus debugging messages
222 #define TRACE_FOCUS wxT("focus")
224 //-----------------------------------------------------------------------------
225 // "size_request" of m_widget
226 //-----------------------------------------------------------------------------
230 wxgtk_window_size_request_callback(GtkWidget
* WXUNUSED(widget
),
231 GtkRequisition
*requisition
,
235 win
->GetSize( &w
, &h
);
241 requisition
->height
= h
;
242 requisition
->width
= w
;
246 //-----------------------------------------------------------------------------
247 // "expose_event" of m_wxwindow
248 //-----------------------------------------------------------------------------
252 gtk_window_expose_callback( GtkWidget
*,
253 GdkEventExpose
*gdk_event
,
256 if (gdk_event
->window
== win
->GTKGetDrawingWindow())
258 win
->GetUpdateRegion() = wxRegion( gdk_event
->region
);
259 win
->GtkSendPaintEvents();
261 // Let parent window draw window-less widgets
266 #ifndef __WXUNIVERSAL__
267 //-----------------------------------------------------------------------------
268 // "expose_event" from m_wxwindow->parent, for drawing border
269 //-----------------------------------------------------------------------------
273 expose_event_border(GtkWidget
* widget
, GdkEventExpose
* gdk_event
, wxWindow
* win
)
275 if (gdk_event
->window
!= gtk_widget_get_parent_window(win
->m_wxwindow
))
282 gtk_widget_get_allocation(win
->m_wxwindow
, &alloc
);
283 const int x
= alloc
.x
;
284 const int y
= alloc
.y
;
285 const int w
= alloc
.width
;
286 const int h
= alloc
.height
;
288 if (w
<= 0 || h
<= 0)
291 if (win
->HasFlag(wxBORDER_SIMPLE
))
293 gdk_draw_rectangle(gdk_event
->window
,
294 gtk_widget_get_style(widget
)->black_gc
, false, x
, y
, w
- 1, h
- 1);
298 GtkShadowType shadow
= GTK_SHADOW_IN
;
299 if (win
->HasFlag(wxBORDER_RAISED
))
300 shadow
= GTK_SHADOW_OUT
;
302 // Style detail to use
304 if (win
->m_widget
== win
->m_wxwindow
)
305 // for non-scrollable wxWindows
308 // for scrollable ones
311 // clip rect is required to avoid painting background
312 // over upper left (w,h) of parent window
313 GdkRectangle clipRect
= { x
, y
, w
, h
};
315 gtk_widget_get_style(win
->m_wxwindow
), gdk_event
->window
, GTK_STATE_NORMAL
,
316 shadow
, &clipRect
, wxGTKPrivate
::GetEntryWidget(), detail
, x
, y
, w
, h
);
322 //-----------------------------------------------------------------------------
323 // "parent_set" from m_wxwindow
324 //-----------------------------------------------------------------------------
328 parent_set(GtkWidget
* widget
, GtkWidget
* old_parent
, wxWindow
* win
)
332 g_signal_handlers_disconnect_by_func(
333 old_parent
, (void*)expose_event_border
, win
);
335 GtkWidget
* parent
= gtk_widget_get_parent(widget
);
338 g_signal_connect_after(parent
, "expose_event",
339 G_CALLBACK(expose_event_border
), win
);
343 #endif // !__WXUNIVERSAL__
345 //-----------------------------------------------------------------------------
346 // "key_press_event" from any window
347 //-----------------------------------------------------------------------------
349 // set WXTRACE to this to see the key event codes on the console
350 #define TRACE_KEYS wxT("keyevent")
352 // translates an X key symbol to WXK_XXX value
354 // if isChar is true it means that the value returned will be used for EVT_CHAR
355 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
356 // for example, while if it is false it means that the value is going to be
357 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
359 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
365 // Shift, Control and Alt don't generate the CHAR events at all
368 key_code
= isChar ?
0 : WXK_SHIFT
;
372 key_code
= isChar ?
0 : WXK_CONTROL
;
380 key_code
= isChar ?
0 : WXK_ALT
;
383 // neither do the toggle modifies
384 case GDK_Scroll_Lock
:
385 key_code
= isChar ?
0 : WXK_SCROLL
;
389 key_code
= isChar ?
0 : WXK_CAPITAL
;
393 key_code
= isChar ?
0 : WXK_NUMLOCK
;
397 // various other special keys
410 case GDK_ISO_Left_Tab
:
417 key_code
= WXK_RETURN
;
421 key_code
= WXK_CLEAR
;
425 key_code
= WXK_PAUSE
;
429 key_code
= WXK_SELECT
;
433 key_code
= WXK_PRINT
;
437 key_code
= WXK_EXECUTE
;
441 key_code
= WXK_ESCAPE
;
444 // cursor and other extended keyboard keys
446 key_code
= WXK_DELETE
;
462 key_code
= WXK_RIGHT
;
469 case GDK_Prior
: // == GDK_Page_Up
470 key_code
= WXK_PAGEUP
;
473 case GDK_Next
: // == GDK_Page_Down
474 key_code
= WXK_PAGEDOWN
;
486 key_code
= WXK_INSERT
;
501 key_code
= (isChar ?
'0' : int(WXK_NUMPAD0
)) + keysym
- GDK_KP_0
;
505 key_code
= isChar ?
' ' : int(WXK_NUMPAD_SPACE
);
509 key_code
= isChar ? WXK_TAB
: WXK_NUMPAD_TAB
;
513 key_code
= isChar ? WXK_RETURN
: WXK_NUMPAD_ENTER
;
517 key_code
= isChar ? WXK_F1
: WXK_NUMPAD_F1
;
521 key_code
= isChar ? WXK_F2
: WXK_NUMPAD_F2
;
525 key_code
= isChar ? WXK_F3
: WXK_NUMPAD_F3
;
529 key_code
= isChar ? WXK_F4
: WXK_NUMPAD_F4
;
533 key_code
= isChar ? WXK_HOME
: WXK_NUMPAD_HOME
;
537 key_code
= isChar ? WXK_LEFT
: WXK_NUMPAD_LEFT
;
541 key_code
= isChar ? WXK_UP
: WXK_NUMPAD_UP
;
545 key_code
= isChar ? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
549 key_code
= isChar ? WXK_DOWN
: WXK_NUMPAD_DOWN
;
552 case GDK_KP_Prior
: // == GDK_KP_Page_Up
553 key_code
= isChar ? WXK_PAGEUP
: WXK_NUMPAD_PAGEUP
;
556 case GDK_KP_Next
: // == GDK_KP_Page_Down
557 key_code
= isChar ? WXK_PAGEDOWN
: WXK_NUMPAD_PAGEDOWN
;
561 key_code
= isChar ? WXK_END
: WXK_NUMPAD_END
;
565 key_code
= isChar ? WXK_HOME
: WXK_NUMPAD_BEGIN
;
569 key_code
= isChar ? WXK_INSERT
: WXK_NUMPAD_INSERT
;
573 key_code
= isChar ? WXK_DELETE
: WXK_NUMPAD_DELETE
;
577 key_code
= isChar ?
'=' : int(WXK_NUMPAD_EQUAL
);
580 case GDK_KP_Multiply
:
581 key_code
= isChar ?
'*' : int(WXK_NUMPAD_MULTIPLY
);
585 key_code
= isChar ?
'+' : int(WXK_NUMPAD_ADD
);
588 case GDK_KP_Separator
:
589 // FIXME: what is this?
590 key_code
= isChar ?
'.' : int(WXK_NUMPAD_SEPARATOR
);
593 case GDK_KP_Subtract
:
594 key_code
= isChar ?
'-' : int(WXK_NUMPAD_SUBTRACT
);
598 key_code
= isChar ?
'.' : int(WXK_NUMPAD_DECIMAL
);
602 key_code
= isChar ?
'/' : int(WXK_NUMPAD_DIVIDE
);
619 key_code
= WXK_F1
+ keysym
- GDK_F1
;
629 static inline bool wxIsAsciiKeysym(KeySym ks
)
634 static void wxFillOtherKeyEventFields(wxKeyEvent
& event
,
636 GdkEventKey
*gdk_event
)
638 event
.SetTimestamp( gdk_event
->time
);
639 event
.SetId(win
->GetId());
641 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
642 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
643 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
644 event
.m_metaDown
= (gdk_event
->state
& GDK_META_MASK
) != 0;
646 // Normally we take the state of modifiers directly from the low level GDK
647 // event but unfortunately GDK uses a different convention from MSW for the
648 // key events corresponding to the modifier keys themselves: in it, when
649 // e.g. Shift key is pressed, GDK_SHIFT_MASK is not set while it is set
650 // when Shift is released. Under MSW the situation is exactly reversed and
651 // the modifier corresponding to the key is set when it is pressed and
652 // unset when it is released. To ensure consistent behaviour between
653 // platforms (and because it seems to make slightly more sense, although
654 // arguably both behaviours are reasonable) we follow MSW here.
656 // Final notice: we set the flags to the desired value instead of just
657 // inverting them because they are not set correctly (i.e. in the same way
658 // as for the real events generated by the user) for wxUIActionSimulator-
659 // produced events and it seems better to keep that class code the same
660 // among all platforms and fix the discrepancy here instead of adding
661 // wxGTK-specific code to wxUIActionSimulator.
662 const bool isPress
= gdk_event
->type
== GDK_KEY_PRESS
;
663 switch ( gdk_event
->keyval
)
667 event
.m_shiftDown
= isPress
;
672 event
.m_controlDown
= isPress
;
677 event
.m_altDown
= isPress
;
684 event
.m_metaDown
= isPress
;
688 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
689 event
.m_rawFlags
= gdk_event
->hardware_keycode
;
691 wxGetMousePosition(&event
.m_x
, &event
.m_y
);
692 win
->ScreenToClient(&event
.m_x
, &event
.m_y
);
693 event
.SetEventObject( win
);
698 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
700 GdkEventKey
*gdk_event
)
702 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
703 // but only event->keyval which is quite useless to us, so remember
704 // the last character from GDK_KEY_PRESS and reuse it as last resort
706 // NB: should be MT-safe as we're always called from the main thread only
711 } s_lastKeyPress
= { 0, 0 };
713 KeySym keysym
= gdk_event
->keyval
;
715 wxLogTrace(TRACE_KEYS
, wxT("Key %s event: keysym = %ld"),
716 event
.GetEventType() == wxEVT_KEY_UP ?
wxT("release")
720 long key_code
= wxTranslateKeySymToWXKey(keysym
, false /* !isChar */);
724 // do we have the translation or is it a plain ASCII character?
725 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
727 // we should use keysym if it is ASCII as X does some translations
728 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
729 // which we don't want here (but which we do use for OnChar())
730 if ( !wxIsAsciiKeysym(keysym
) )
732 keysym
= (KeySym
)gdk_event
->string
[0];
735 #ifdef GDK_WINDOWING_X11
736 // we want to always get the same key code when the same key is
737 // pressed regardless of the state of the modifiers, i.e. on a
738 // standard US keyboard pressing '5' or '%' ('5' key with
739 // Shift) should result in the same key code in OnKeyDown():
740 // '5' (although OnChar() will get either '5' or '%').
742 // to do it we first translate keysym to keycode (== scan code)
743 // and then back but always using the lower register
744 Display
*dpy
= (Display
*)wxGetDisplay();
745 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
747 wxLogTrace(TRACE_KEYS
, wxT("\t-> keycode %d"), keycode
);
749 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
751 // use the normalized, i.e. lower register, keysym if we've
753 key_code
= keysymNormalized ? keysymNormalized
: keysym
;
758 // as explained above, we want to have lower register key codes
759 // normally but for the letter keys we want to have the upper ones
761 // NB: don't use XConvertCase() here, we want to do it for letters
763 key_code
= toupper(key_code
);
765 else // non ASCII key, what to do?
767 // by default, ignore it
770 // but if we have cached information from the last KEY_PRESS
771 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
774 if ( keysym
== s_lastKeyPress
.keysym
)
776 key_code
= s_lastKeyPress
.keycode
;
781 if ( gdk_event
->type
== GDK_KEY_PRESS
)
783 // remember it to be reused for KEY_UP event later
784 s_lastKeyPress
.keysym
= keysym
;
785 s_lastKeyPress
.keycode
= key_code
;
789 wxLogTrace(TRACE_KEYS
, wxT("\t-> wxKeyCode %ld"), key_code
);
791 // sending unknown key events doesn't really make sense
795 event
.m_keyCode
= key_code
;
798 event
.m_uniChar
= gdk_keyval_to_unicode(key_code ? key_code
: keysym
);
799 if ( !event
.m_uniChar
&& event
.m_keyCode
<= WXK_DELETE
)
801 // Set Unicode key code to the ASCII equivalent for compatibility. E.g.
802 // let RETURN generate the key event with both key and Unicode key
804 event
.m_uniChar
= event
.m_keyCode
;
806 #endif // wxUSE_UNICODE
808 // now fill all the other fields
809 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
817 GtkIMContext
*context
;
818 GdkEventKey
*lastKeyEvent
;
822 context
= gtk_im_multicontext_new();
827 g_object_unref (context
);
834 // Send wxEVT_CHAR_HOOK event to the parent of the window and return true only
835 // if it was processed (and not skipped).
836 bool SendCharHookEvent(const wxKeyEvent
& event
, wxWindow
*win
)
838 // wxEVT_CHAR_HOOK must be sent to allow the parent windows (e.g. a dialog
839 // which typically closes when Esc key is pressed in any of its controls)
840 // to handle key events in all of its children unless the mouse is captured
841 // in which case we consider that the keyboard should be "captured" too.
842 if ( !g_captureWindow
)
844 wxKeyEvent
eventCharHook(wxEVT_CHAR_HOOK
, event
);
845 if ( win
->HandleWindowEvent(eventCharHook
)
846 && !event
.IsNextEventAllowed() )
853 // Adjust wxEVT_CHAR event key code fields. This function takes care of two
855 // (a) Ctrl-letter key presses generate key codes in range 1..26
856 // (b) Unicode key codes are same as key codes for the codes in 1..255 range
857 void AdjustCharEventKeyCodes(wxKeyEvent
& event
)
859 const int code
= event
.m_keyCode
;
861 // Check for (a) above.
862 if ( event
.ControlDown() )
864 // We intentionally don't use isupper/lower() here, we really need
865 // ASCII letters only as it doesn't make sense to translate any other
866 // ones into this range which has only 26 slots.
867 if ( code
>= 'a' && code
<= 'z' )
868 event
.m_keyCode
= code
- 'a' + 1;
869 else if ( code
>= 'A' && code
<= 'Z' )
870 event
.m_keyCode
= code
- 'A' + 1;
873 // Adjust the Unicode equivalent in the same way too.
874 if ( event
.m_keyCode
!= code
)
875 event
.m_uniChar
= event
.m_keyCode
;
876 #endif // wxUSE_UNICODE
880 // Check for (b) from above.
882 // FIXME: Should we do it for key codes up to 255?
883 if ( !event
.m_uniChar
&& code
< WXK_DELETE
)
884 event
.m_uniChar
= code
;
885 #endif // wxUSE_UNICODE
888 } // anonymous namespace
890 // If a widget does not handle a key or mouse event, GTK+ sends it up the
891 // parent chain until it is handled. These events are not supposed to propagate
892 // in wxWidgets, so this code avoids handling them in any parent wxWindow,
893 // while still allowing the event to propagate so things like native keyboard
894 // navigation will work.
895 #define wxPROCESS_EVENT_ONCE(EventType, event) \
896 static EventType eventPrev; \
897 if (memcmp(&eventPrev, event, sizeof(EventType)) == 0) \
903 gtk_window_key_press_callback( GtkWidget
*WXUNUSED(widget
),
904 GdkEventKey
*gdk_event
,
909 if (g_blockEventsOnDrag
)
912 wxPROCESS_EVENT_ONCE(GdkEventKey
, gdk_event
);
914 wxKeyEvent
event( wxEVT_KEY_DOWN
);
916 bool return_after_IM
= false;
918 if( wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
920 // Send the CHAR_HOOK event first
921 if ( SendCharHookEvent(event
, win
) )
923 // Don't do anything at all with this event any more.
927 // Emit KEY_DOWN event
928 ret
= win
->HandleWindowEvent( event
);
932 // Return after IM processing as we cannot do
933 // anything with it anyhow.
934 return_after_IM
= true;
937 if (!ret
&& win
->m_imData
)
939 win
->m_imData
->lastKeyEvent
= gdk_event
;
941 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
942 // docs, if IM filter returns true, no further processing should be done.
943 // we should send the key_down event anyway.
944 bool intercepted_by_IM
= gtk_im_context_filter_keypress(win
->m_imData
->context
, gdk_event
);
945 win
->m_imData
->lastKeyEvent
= NULL
;
946 if (intercepted_by_IM
)
948 wxLogTrace(TRACE_KEYS
, wxT("Key event intercepted by IM"));
959 wxWindowGTK
*ancestor
= win
;
962 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
965 wxCommandEvent
menu_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
966 ret
= ancestor
->HandleWindowEvent( menu_event
);
970 // if the accelerator wasn't handled as menu event, try
971 // it as button click (for compatibility with other
973 wxCommandEvent
button_event( wxEVT_COMMAND_BUTTON_CLICKED
, command
);
974 ret
= ancestor
->HandleWindowEvent( button_event
);
979 if (ancestor
->IsTopLevel())
981 ancestor
= ancestor
->GetParent();
984 #endif // wxUSE_ACCEL
986 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
987 // will only be sent if it is not in an accelerator table.
991 KeySym keysym
= gdk_event
->keyval
;
992 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
993 key_code
= wxTranslateKeySymToWXKey(keysym
, true /* isChar */);
996 if ( wxIsAsciiKeysym(keysym
) )
999 key_code
= (unsigned char)keysym
;
1001 // gdk_event->string is actually deprecated
1002 else if ( gdk_event
->length
== 1 )
1004 key_code
= (unsigned char)gdk_event
->string
[0];
1010 wxKeyEvent
eventChar(wxEVT_CHAR
, event
);
1012 wxLogTrace(TRACE_KEYS
, wxT("Char event: %ld"), key_code
);
1014 eventChar
.m_keyCode
= key_code
;
1016 AdjustCharEventKeyCodes(eventChar
);
1018 ret
= win
->HandleWindowEvent(eventChar
);
1028 gtk_wxwindow_commit_cb (GtkIMContext
* WXUNUSED(context
),
1032 wxKeyEvent
event( wxEVT_CHAR
);
1034 // take modifiers, cursor position, timestamp etc. from the last
1035 // key_press_event that was fed into Input Method:
1036 if (window
->m_imData
->lastKeyEvent
)
1038 wxFillOtherKeyEventFields(event
,
1039 window
, window
->m_imData
->lastKeyEvent
);
1043 event
.SetEventObject( window
);
1046 const wxString
data(wxGTK_CONV_BACK_SYS(str
));
1050 for( wxString
::const_iterator pstr
= data
.begin(); pstr
!= data
.end(); ++pstr
)
1053 event
.m_uniChar
= *pstr
;
1054 // Backward compatible for ISO-8859-1
1055 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
1056 wxLogTrace(TRACE_KEYS
, wxT("IM sent character '%c'"), event
.m_uniChar
);
1058 event
.m_keyCode
= (char)*pstr
;
1059 #endif // wxUSE_UNICODE
1061 AdjustCharEventKeyCodes(event
);
1063 window
->HandleWindowEvent(event
);
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 wxPROCESS_EVENT_ONCE(GdkEventKey
, gdk_event
);
1087 wxKeyEvent
event( wxEVT_KEY_UP
);
1088 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1090 // unknown key pressed, ignore (the event would be useless anyhow)
1094 return win
->GTKProcessEvent(event
);
1098 // ============================================================================
1100 // ============================================================================
1102 // ----------------------------------------------------------------------------
1103 // mouse event processing helpers
1104 // ----------------------------------------------------------------------------
1106 static void AdjustEventButtonState(wxMouseEvent
& event
)
1108 // GDK reports the old state of the button for a button press event, but
1109 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1110 // for a LEFT_DOWN event, not FALSE, so we will invert
1111 // left/right/middleDown for the corresponding click events
1113 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1114 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1115 (event
.GetEventType() == wxEVT_LEFT_UP
))
1117 event
.m_leftDown
= !event
.m_leftDown
;
1121 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1122 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1123 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1125 event
.m_middleDown
= !event
.m_middleDown
;
1129 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1130 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1131 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1133 event
.m_rightDown
= !event
.m_rightDown
;
1137 if ((event
.GetEventType() == wxEVT_AUX1_DOWN
) ||
1138 (event
.GetEventType() == wxEVT_AUX1_DCLICK
))
1140 event
.m_aux1Down
= true;
1144 if ((event
.GetEventType() == wxEVT_AUX2_DOWN
) ||
1145 (event
.GetEventType() == wxEVT_AUX2_DCLICK
))
1147 event
.m_aux2Down
= true;
1152 // find the window to send the mouse event to
1154 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1159 if (win
->m_wxwindow
)
1161 wxPizza
* pizza
= WX_PIZZA(win
->m_wxwindow
);
1162 xx
+= pizza
->m_scroll_x
;
1163 yy
+= pizza
->m_scroll_y
;
1166 wxWindowList
::compatibility_iterator node
= win
->GetChildren().GetFirst();
1169 wxWindow
* child
= static_cast<wxWindow
*>(node
->GetData());
1171 node
= node
->GetNext();
1172 if (!child
->IsShown())
1175 if (child
->GTKIsTransparentForMouse())
1177 // wxStaticBox is transparent in the box itself
1178 int xx1
= child
->m_x
;
1179 int yy1
= child
->m_y
;
1180 int xx2
= child
->m_x
+ child
->m_width
;
1181 int yy2
= child
->m_y
+ child
->m_height
;
1184 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1186 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1188 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1190 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1201 if ((child
->m_wxwindow
== NULL
) &&
1202 win
->IsClientAreaChild(child
) &&
1203 (child
->m_x
<= xx
) &&
1204 (child
->m_y
<= yy
) &&
1205 (child
->m_x
+child
->m_width
>= xx
) &&
1206 (child
->m_y
+child
->m_height
>= yy
))
1219 // ----------------------------------------------------------------------------
1220 // common event handlers helpers
1221 // ----------------------------------------------------------------------------
1223 bool wxWindowGTK
::GTKProcessEvent(wxEvent
& event
) const
1225 // nothing special at this level
1226 return HandleWindowEvent(event
);
1229 bool wxWindowGTK
::GTKShouldIgnoreEvent() const
1231 return !m_hasVMT
|| g_blockEventsOnDrag
;
1234 int wxWindowGTK
::GTKCallbackCommonPrologue(GdkEventAny
*event
) const
1238 if (g_blockEventsOnDrag
)
1240 if (g_blockEventsOnScroll
)
1243 if (!GTKIsOwnWindow(event
->window
))
1249 // overloads for all GDK event types we use here: we need to have this as
1250 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1251 // derives from it in the sense that the structs have the same layout
1252 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1253 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1255 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1258 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton
)
1259 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion
)
1260 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing
)
1262 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1264 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1265 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1269 // all event handlers must have C linkage as they're called from GTK+ C code
1273 //-----------------------------------------------------------------------------
1274 // "button_press_event"
1275 //-----------------------------------------------------------------------------
1278 gtk_window_button_press_callback( GtkWidget
*widget
,
1279 GdkEventButton
*gdk_event
,
1282 wxPROCESS_EVENT_ONCE(GdkEventButton
, gdk_event
);
1284 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1286 g_lastButtonNumber
= gdk_event
->button
;
1288 // GDK sends surplus button down events
1289 // before a double click event. We
1290 // need to filter these out.
1291 if ((gdk_event
->type
== GDK_BUTTON_PRESS
) && (win
->m_wxwindow
))
1293 GdkEvent
*peek_event
= gdk_event_peek();
1296 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1297 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1299 gdk_event_free( peek_event
);
1304 gdk_event_free( peek_event
);
1309 wxEventType event_type
= wxEVT_NULL
;
1311 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1312 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1314 // Reset GDK internal timestamp variables in order to disable GDK
1315 // triple click events. GDK will then next time believe no button has
1316 // been clicked just before, and send a normal button click event.
1317 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1318 display
->button_click_time
[1] = 0;
1319 display
->button_click_time
[0] = 0;
1322 if (gdk_event
->button
== 1)
1324 // note that GDK generates triple click events which are not supported
1325 // by wxWidgets but still have to be passed to the app as otherwise
1326 // clicks would simply go missing
1327 switch (gdk_event
->type
)
1329 // we shouldn't get triple clicks at all for GTK2 because we
1330 // suppress them artificially using the code above but we still
1331 // should map them to something for GTK1 and not just ignore them
1332 // as this would lose clicks
1333 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1334 case GDK_BUTTON_PRESS
:
1335 event_type
= wxEVT_LEFT_DOWN
;
1338 case GDK_2BUTTON_PRESS
:
1339 event_type
= wxEVT_LEFT_DCLICK
;
1343 // just to silence gcc warnings
1347 else if (gdk_event
->button
== 2)
1349 switch (gdk_event
->type
)
1351 case GDK_3BUTTON_PRESS
:
1352 case GDK_BUTTON_PRESS
:
1353 event_type
= wxEVT_MIDDLE_DOWN
;
1356 case GDK_2BUTTON_PRESS
:
1357 event_type
= wxEVT_MIDDLE_DCLICK
;
1364 else if (gdk_event
->button
== 3)
1366 switch (gdk_event
->type
)
1368 case GDK_3BUTTON_PRESS
:
1369 case GDK_BUTTON_PRESS
:
1370 event_type
= wxEVT_RIGHT_DOWN
;
1373 case GDK_2BUTTON_PRESS
:
1374 event_type
= wxEVT_RIGHT_DCLICK
;
1382 else if (gdk_event
->button
== 8)
1384 switch (gdk_event
->type
)
1386 case GDK_3BUTTON_PRESS
:
1387 case GDK_BUTTON_PRESS
:
1388 event_type
= wxEVT_AUX1_DOWN
;
1391 case GDK_2BUTTON_PRESS
:
1392 event_type
= wxEVT_AUX1_DCLICK
;
1400 else if (gdk_event
->button
== 9)
1402 switch (gdk_event
->type
)
1404 case GDK_3BUTTON_PRESS
:
1405 case GDK_BUTTON_PRESS
:
1406 event_type
= wxEVT_AUX2_DOWN
;
1409 case GDK_2BUTTON_PRESS
:
1410 event_type
= wxEVT_AUX2_DCLICK
;
1418 if ( event_type
== wxEVT_NULL
)
1420 // unknown mouse button or click type
1424 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1426 wxMouseEvent
event( event_type
);
1427 InitMouseEvent( win
, event
, gdk_event
);
1429 AdjustEventButtonState(event
);
1431 // find the correct window to send the event to: it may be a different one
1432 // from the one which got it at GTK+ level because some controls don't have
1433 // their own X window and thus cannot get any events.
1434 if ( !g_captureWindow
)
1435 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1437 // reset the event object and id in case win changed.
1438 event
.SetEventObject( win
);
1439 event
.SetId( win
->GetId() );
1441 bool ret
= win
->GTKProcessEvent( event
);
1442 g_lastMouseEvent
= NULL
;
1446 if ((event_type
== wxEVT_LEFT_DOWN
) && !win
->IsOfStandardClass() &&
1447 (gs_currentFocus
!= win
) /* && win->IsFocusable() */)
1452 if (event_type
== wxEVT_RIGHT_DOWN
)
1454 // generate a "context menu" event: this is similar to right mouse
1455 // click under many GUIs except that it is generated differently
1456 // (right up under MSW, ctrl-click under Mac, right down here) and
1458 // (a) it's a command event and so is propagated to the parent
1459 // (b) under some ports it can be generated from kbd too
1460 // (c) it uses screen coords (because of (a))
1461 wxContextMenuEvent
evtCtx(
1464 win
->ClientToScreen(event
.GetPosition()));
1465 evtCtx
.SetEventObject(win
);
1466 return win
->GTKProcessEvent(evtCtx
);
1472 //-----------------------------------------------------------------------------
1473 // "button_release_event"
1474 //-----------------------------------------------------------------------------
1477 gtk_window_button_release_callback( GtkWidget
*WXUNUSED(widget
),
1478 GdkEventButton
*gdk_event
,
1481 wxPROCESS_EVENT_ONCE(GdkEventButton
, gdk_event
);
1483 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1485 g_lastButtonNumber
= 0;
1487 wxEventType event_type
= wxEVT_NULL
;
1489 switch (gdk_event
->button
)
1492 event_type
= wxEVT_LEFT_UP
;
1496 event_type
= wxEVT_MIDDLE_UP
;
1500 event_type
= wxEVT_RIGHT_UP
;
1504 event_type
= wxEVT_AUX1_UP
;
1508 event_type
= wxEVT_AUX2_UP
;
1512 // unknown button, don't process
1516 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1518 wxMouseEvent
event( event_type
);
1519 InitMouseEvent( win
, event
, gdk_event
);
1521 AdjustEventButtonState(event
);
1523 if ( !g_captureWindow
)
1524 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1526 // reset the event object and id in case win changed.
1527 event
.SetEventObject( win
);
1528 event
.SetId( win
->GetId() );
1530 bool ret
= win
->GTKProcessEvent(event
);
1532 g_lastMouseEvent
= NULL
;
1537 //-----------------------------------------------------------------------------
1538 // "motion_notify_event"
1539 //-----------------------------------------------------------------------------
1542 gtk_window_motion_notify_callback( GtkWidget
* WXUNUSED(widget
),
1543 GdkEventMotion
*gdk_event
,
1546 wxPROCESS_EVENT_ONCE(GdkEventMotion
, gdk_event
);
1548 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1550 if (gdk_event
->is_hint
)
1554 GdkModifierType state
;
1555 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1560 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1562 wxMouseEvent
event( wxEVT_MOTION
);
1563 InitMouseEvent(win
, event
, gdk_event
);
1565 if ( g_captureWindow
)
1567 // synthesise a mouse enter or leave event if needed
1568 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1569 // This seems to be necessary and actually been added to
1570 // GDK itself in version 2.0.X
1573 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1574 if ( hasMouse
!= g_captureWindowHasMouse
)
1576 // the mouse changed window
1577 g_captureWindowHasMouse
= hasMouse
;
1579 wxMouseEvent
eventM(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1580 : wxEVT_LEAVE_WINDOW
);
1581 InitMouseEvent(win
, eventM
, gdk_event
);
1582 eventM
.SetEventObject(win
);
1583 win
->GTKProcessEvent(eventM
);
1588 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1590 // reset the event object and id in case win changed.
1591 event
.SetEventObject( win
);
1592 event
.SetId( win
->GetId() );
1595 if ( !g_captureWindow
)
1597 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1598 if (win
->GTKProcessEvent( cevent
))
1600 win
->SetCursor( cevent
.GetCursor() );
1604 bool ret
= win
->GTKProcessEvent(event
);
1606 g_lastMouseEvent
= NULL
;
1611 //-----------------------------------------------------------------------------
1612 // "scroll_event" (mouse wheel event)
1613 //-----------------------------------------------------------------------------
1616 window_scroll_event_hscrollbar(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1618 if (gdk_event
->direction
!= GDK_SCROLL_LEFT
&&
1619 gdk_event
->direction
!= GDK_SCROLL_RIGHT
)
1624 GtkRange
*range
= win
->m_scrollBar
[wxWindow
::ScrollDir_Horz
];
1626 if (range
&& gtk_widget_get_visible(GTK_WIDGET(range
)))
1628 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
1629 double delta
= gtk_adjustment_get_step_increment(adj
) * 3;
1630 if (gdk_event
->direction
== GDK_SCROLL_LEFT
)
1633 gtk_range_set_value(range
, gtk_adjustment_get_value(adj
) + delta
);
1642 window_scroll_event(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1644 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1645 InitMouseEvent(win
, event
, gdk_event
);
1647 // FIXME: Get these values from GTK or GDK
1648 event
.m_linesPerAction
= 3;
1649 event
.m_wheelDelta
= 120;
1651 // Determine the scroll direction.
1652 switch (gdk_event
->direction
)
1655 case GDK_SCROLL_RIGHT
:
1656 event
.m_wheelRotation
= 120;
1659 case GDK_SCROLL_DOWN
:
1660 case GDK_SCROLL_LEFT
:
1661 event
.m_wheelRotation
= -120;
1665 return false; // Unknown/unhandled direction
1668 // And the scroll axis.
1669 switch (gdk_event
->direction
)
1672 case GDK_SCROLL_DOWN
:
1673 event
.m_wheelAxis
= wxMOUSE_WHEEL_VERTICAL
;
1676 case GDK_SCROLL_LEFT
:
1677 case GDK_SCROLL_RIGHT
:
1678 event
.m_wheelAxis
= wxMOUSE_WHEEL_HORIZONTAL
;
1682 if (win
->GTKProcessEvent(event
))
1685 GtkRange
*range
= win
->m_scrollBar
[wxWindow
::ScrollDir_Vert
];
1687 if (range
&& gtk_widget_get_visible(GTK_WIDGET(range
)))
1689 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
1690 double delta
= gtk_adjustment_get_step_increment(adj
) * 3;
1691 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1694 gtk_range_set_value(range
, gtk_adjustment_get_value(adj
) + delta
);
1702 //-----------------------------------------------------------------------------
1704 //-----------------------------------------------------------------------------
1706 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
1708 wxContextMenuEvent
event(wxEVT_CONTEXT_MENU
, win
->GetId(), wxPoint(-1, -1));
1709 event
.SetEventObject(win
);
1710 return win
->GTKProcessEvent(event
);
1713 //-----------------------------------------------------------------------------
1715 //-----------------------------------------------------------------------------
1718 gtk_window_focus_in_callback( GtkWidget
* WXUNUSED(widget
),
1719 GdkEventFocus
*WXUNUSED(event
),
1722 return win
->GTKHandleFocusIn();
1725 //-----------------------------------------------------------------------------
1726 // "focus_out_event"
1727 //-----------------------------------------------------------------------------
1730 gtk_window_focus_out_callback( GtkWidget
* WXUNUSED(widget
),
1731 GdkEventFocus
* WXUNUSED(gdk_event
),
1734 return win
->GTKHandleFocusOut();
1737 //-----------------------------------------------------------------------------
1739 //-----------------------------------------------------------------------------
1742 wx_window_focus_callback(GtkWidget
*widget
,
1743 GtkDirectionType
WXUNUSED(direction
),
1746 // the default handler for focus signal in GtkScrolledWindow sets
1747 // focus to the window itself even if it doesn't accept focus, i.e. has no
1748 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1749 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1750 // any children which might accept focus (we know we don't accept the focus
1751 // ourselves as this signal is only connected in this case)
1752 if ( win
->GetChildren().empty() )
1753 g_signal_stop_emission_by_name(widget
, "focus");
1755 // we didn't change the focus
1759 //-----------------------------------------------------------------------------
1760 // "enter_notify_event"
1761 //-----------------------------------------------------------------------------
1764 gtk_window_enter_callback( GtkWidget
*widget
,
1765 GdkEventCrossing
*gdk_event
,
1768 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1770 // Event was emitted after a grab
1771 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1775 GdkModifierType state
= (GdkModifierType
)0;
1777 gdk_window_get_pointer(gtk_widget_get_window(widget
), &x
, &y
, &state
);
1779 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1780 InitMouseEvent(win
, event
, gdk_event
);
1781 wxPoint pt
= win
->GetClientAreaOrigin();
1782 event
.m_x
= x
+ pt
.x
;
1783 event
.m_y
= y
+ pt
.y
;
1785 if ( !g_captureWindow
)
1787 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1788 if (win
->GTKProcessEvent( cevent
))
1790 win
->SetCursor( cevent
.GetCursor() );
1794 return win
->GTKProcessEvent(event
);
1797 //-----------------------------------------------------------------------------
1798 // "leave_notify_event"
1799 //-----------------------------------------------------------------------------
1802 gtk_window_leave_callback( GtkWidget
*widget
,
1803 GdkEventCrossing
*gdk_event
,
1806 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1808 // Event was emitted after an ungrab
1809 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1811 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1815 GdkModifierType state
= (GdkModifierType
)0;
1817 gdk_window_get_pointer(gtk_widget_get_window(widget
), &x
, &y
, &state
);
1819 InitMouseEvent(win
, event
, gdk_event
);
1821 return win
->GTKProcessEvent(event
);
1824 //-----------------------------------------------------------------------------
1825 // "value_changed" from scrollbar
1826 //-----------------------------------------------------------------------------
1829 gtk_scrollbar_value_changed(GtkRange
* range
, wxWindow
* win
)
1831 wxEventType eventType
= win
->GTKGetScrollEventType(range
);
1832 if (eventType
!= wxEVT_NULL
)
1834 // Convert scroll event type to scrollwin event type
1835 eventType
+= wxEVT_SCROLLWIN_TOP
- wxEVT_SCROLL_TOP
;
1837 // find the scrollbar which generated the event
1838 wxWindowGTK
::ScrollDir dir
= win
->ScrollDirFromRange(range
);
1840 // generate the corresponding wx event
1841 const int orient
= wxWindow
::OrientFromScrollDir(dir
);
1842 wxScrollWinEvent
event(eventType
, win
->GetScrollPos(orient
), orient
);
1843 event
.SetEventObject(win
);
1845 win
->GTKProcessEvent(event
);
1849 //-----------------------------------------------------------------------------
1850 // "button_press_event" from scrollbar
1851 //-----------------------------------------------------------------------------
1854 gtk_scrollbar_button_press_event(GtkRange
*, GdkEventButton
*, wxWindow
* win
)
1856 g_blockEventsOnScroll
= true;
1857 win
->m_mouseButtonDown
= true;
1862 //-----------------------------------------------------------------------------
1863 // "event_after" from scrollbar
1864 //-----------------------------------------------------------------------------
1867 gtk_scrollbar_event_after(GtkRange
* range
, GdkEvent
* event
, wxWindow
* win
)
1869 if (event
->type
== GDK_BUTTON_RELEASE
)
1871 g_signal_handlers_block_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1873 const int orient
= wxWindow
::OrientFromScrollDir(
1874 win
->ScrollDirFromRange(range
));
1875 wxScrollWinEvent
evt(wxEVT_SCROLLWIN_THUMBRELEASE
,
1876 win
->GetScrollPos(orient
), orient
);
1877 evt
.SetEventObject(win
);
1878 win
->GTKProcessEvent(evt
);
1882 //-----------------------------------------------------------------------------
1883 // "button_release_event" from scrollbar
1884 //-----------------------------------------------------------------------------
1887 gtk_scrollbar_button_release_event(GtkRange
* range
, GdkEventButton
*, wxWindow
* win
)
1889 g_blockEventsOnScroll
= false;
1890 win
->m_mouseButtonDown
= false;
1891 // If thumb tracking
1892 if (win
->m_isScrolling
)
1894 win
->m_isScrolling
= false;
1895 // Hook up handler to send thumb release event after this emission is finished.
1896 // To allow setting scroll position from event handler, sending event must
1897 // be deferred until after the GtkRange handler for this signal has run
1898 g_signal_handlers_unblock_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1904 //-----------------------------------------------------------------------------
1905 // "realize" from m_widget
1906 //-----------------------------------------------------------------------------
1909 gtk_window_realized_callback(GtkWidget
* WXUNUSED(widget
), wxWindowGTK
* win
)
1911 win
->GTKHandleRealized();
1914 //-----------------------------------------------------------------------------
1915 // "unrealize" from m_wxwindow
1916 //-----------------------------------------------------------------------------
1918 static void unrealize(GtkWidget
*, wxWindowGTK
* win
)
1921 gtk_im_context_set_client_window(win
->m_imData
->context
, NULL
);
1924 //-----------------------------------------------------------------------------
1925 // "size_allocate" from m_wxwindow or m_widget
1926 //-----------------------------------------------------------------------------
1929 size_allocate(GtkWidget
*, GtkAllocation
* alloc
, wxWindow
* win
)
1931 int w
= alloc
->width
;
1932 int h
= alloc
->height
;
1933 if (win
->m_wxwindow
)
1935 int border_x
, border_y
;
1936 WX_PIZZA(win
->m_wxwindow
)->get_border_widths(border_x
, border_y
);
1942 if (win
->m_oldClientWidth
!= w
|| win
->m_oldClientHeight
!= h
)
1944 win
->m_oldClientWidth
= w
;
1945 win
->m_oldClientHeight
= h
;
1946 // this callback can be connected to m_wxwindow,
1947 // so always get size from m_widget->allocation
1949 gtk_widget_get_allocation(win
->m_widget
, &a
);
1950 win
->m_width
= a
.width
;
1951 win
->m_height
= a
.height
;
1952 if (!win
->m_nativeSizeEvent
)
1954 wxSizeEvent
event(win
->GetSize(), win
->GetId());
1955 event
.SetEventObject(win
);
1956 win
->GTKProcessEvent(event
);
1961 //-----------------------------------------------------------------------------
1963 //-----------------------------------------------------------------------------
1965 #if GTK_CHECK_VERSION(2, 8, 0)
1967 gtk_window_grab_broken( GtkWidget
*,
1968 GdkEventGrabBroken
*event
,
1971 // Mouse capture has been lost involuntarily, notify the application
1972 if(!event
->keyboard
&& wxWindow
::GetCapture() == win
)
1974 wxMouseCaptureLostEvent
evt( win
->GetId() );
1975 evt
.SetEventObject( win
);
1976 win
->HandleWindowEvent( evt
);
1982 //-----------------------------------------------------------------------------
1984 //-----------------------------------------------------------------------------
1987 void gtk_window_style_set_callback( GtkWidget
*WXUNUSED(widget
),
1988 GtkStyle
*previous_style
,
1991 if (win
&& previous_style
)
1993 if (win
->IsTopLevel())
1995 wxSysColourChangedEvent event
;
1996 event
.SetEventObject(win
);
1997 win
->GTKProcessEvent(event
);
2001 // Border width could change, which will change client size.
2002 // Make sure size event occurs for this
2003 win
->m_oldClientWidth
= 0;
2010 void wxWindowGTK
::GTKHandleRealized()
2014 gtk_im_context_set_client_window
2017 m_wxwindow ?
GTKGetDrawingWindow()
2018 : gtk_widget_get_window(m_widget
)
2022 // Use composited window if background is transparent, if supported.
2023 if (m_backgroundStyle
== wxBG_STYLE_TRANSPARENT
)
2025 #if wxGTK_HAS_COMPOSITING_SUPPORT
2026 if (IsTransparentBackgroundSupported())
2028 GdkWindow
* const window
= GTKGetDrawingWindow();
2030 gdk_window_set_composited(window
, true);
2033 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
2035 // We revert to erase mode if transparency is not supported
2036 m_backgroundStyle
= wxBG_STYLE_ERASE
;
2041 // We cannot set colours and fonts before the widget
2042 // been realized, so we do this directly after realization
2043 // or otherwise in idle time
2045 if (m_needsStyleChange
)
2047 SetBackgroundStyle(GetBackgroundStyle());
2048 m_needsStyleChange
= false;
2051 wxWindowCreateEvent
event(static_cast<wxWindow
*>(this));
2052 event
.SetEventObject( this );
2053 GTKProcessEvent( event
);
2055 GTKUpdateCursor(true, false);
2058 // ----------------------------------------------------------------------------
2059 // this wxWindowBase function is implemented here (in platform-specific file)
2060 // because it is static and so couldn't be made virtual
2061 // ----------------------------------------------------------------------------
2063 wxWindow
*wxWindowBase
::DoFindFocus()
2065 wxWindowGTK
*focus
= gs_pendingFocus ? gs_pendingFocus
: gs_currentFocus
;
2066 // the cast is necessary when we compile in wxUniversal mode
2067 return static_cast<wxWindow
*>(focus
);
2070 void wxWindowGTK
::AddChildGTK(wxWindowGTK
* child
)
2072 wxASSERT_MSG(m_wxwindow
, "Cannot add a child to a window without a client area");
2074 // the window might have been scrolled already, we
2075 // have to adapt the position
2076 wxPizza
* pizza
= WX_PIZZA(m_wxwindow
);
2077 child
->m_x
+= pizza
->m_scroll_x
;
2078 child
->m_y
+= pizza
->m_scroll_y
;
2080 gtk_widget_set_size_request(
2081 child
->m_widget
, child
->m_width
, child
->m_height
);
2082 pizza
->put(child
->m_widget
, child
->m_x
, child
->m_y
);
2085 //-----------------------------------------------------------------------------
2087 //-----------------------------------------------------------------------------
2089 wxWindow
*wxGetActiveWindow()
2091 return wxWindow
::FindFocus();
2095 wxMouseState
wxGetMouseState()
2101 GdkModifierType mask
;
2103 gdk_window_get_pointer(NULL
, &x
, &y
, &mask
);
2107 ms
.SetLeftDown((mask
& GDK_BUTTON1_MASK
) != 0);
2108 ms
.SetMiddleDown((mask
& GDK_BUTTON2_MASK
) != 0);
2109 ms
.SetRightDown((mask
& GDK_BUTTON3_MASK
) != 0);
2110 // see the comment in InitMouseEvent()
2111 ms
.SetAux1Down((mask
& GDK_BUTTON4_MASK
) != 0);
2112 ms
.SetAux2Down((mask
& GDK_BUTTON5_MASK
) != 0);
2114 ms
.SetControlDown((mask
& GDK_CONTROL_MASK
) != 0);
2115 ms
.SetShiftDown((mask
& GDK_SHIFT_MASK
) != 0);
2116 ms
.SetAltDown((mask
& GDK_MOD1_MASK
) != 0);
2117 ms
.SetMetaDown((mask
& GDK_META_MASK
) != 0);
2122 //-----------------------------------------------------------------------------
2124 //-----------------------------------------------------------------------------
2126 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2128 #ifdef __WXUNIVERSAL__
2129 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2130 #endif // __WXUNIVERSAL__
2132 void wxWindowGTK
::Init()
2137 m_focusWidget
= NULL
;
2147 m_showOnIdle
= false;
2150 m_nativeSizeEvent
= false;
2152 m_isScrolling
= false;
2153 m_mouseButtonDown
= false;
2155 // initialize scrolling stuff
2156 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2158 m_scrollBar
[dir
] = NULL
;
2159 m_scrollPos
[dir
] = 0;
2163 m_oldClientHeight
= 0;
2165 m_clipPaintRegion
= false;
2167 m_needsStyleChange
= false;
2169 m_cursor
= *wxSTANDARD_CURSOR
;
2172 m_dirtyTabOrder
= false;
2175 wxWindowGTK
::wxWindowGTK()
2180 wxWindowGTK
::wxWindowGTK( wxWindow
*parent
,
2185 const wxString
&name
)
2189 Create( parent
, id
, pos
, size
, style
, name
);
2192 bool wxWindowGTK
::Create( wxWindow
*parent
,
2197 const wxString
&name
)
2199 // Get default border
2200 wxBorder border
= GetBorder(style
);
2202 style
&= ~wxBORDER_MASK
;
2205 if (!PreCreation( parent
, pos
, size
) ||
2206 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2208 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2212 // We should accept the native look
2214 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2215 scroll_class
->scrollbar_spacing
= 0;
2219 m_wxwindow
= wxPizza
::New(m_windowStyle
);
2220 #ifndef __WXUNIVERSAL__
2221 if (HasFlag(wxPizza
::BORDER_STYLES
))
2223 g_signal_connect(m_wxwindow
, "parent_set",
2224 G_CALLBACK(parent_set
), this);
2227 if (!HasFlag(wxHSCROLL
) && !HasFlag(wxVSCROLL
))
2228 m_widget
= m_wxwindow
;
2231 m_widget
= gtk_scrolled_window_new( NULL
, NULL
);
2233 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2235 // There is a conflict with default bindings at GTK+
2236 // level between scrolled windows and notebooks both of which want to use
2237 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2238 // direction and notebooks for changing pages -- we decide that if we don't
2239 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2240 // means we can get working keyboard navigation in notebooks
2241 if ( !HasFlag(wxHSCROLL
) )
2244 bindings
= gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget
));
2247 gtk_binding_entry_remove(bindings
, GDK_Page_Up
, GDK_CONTROL_MASK
);
2248 gtk_binding_entry_remove(bindings
, GDK_Page_Down
, GDK_CONTROL_MASK
);
2252 if (HasFlag(wxALWAYS_SHOW_SB
))
2254 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_ALWAYS
, GTK_POLICY_ALWAYS
);
2258 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2261 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow
));
2262 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow
));
2263 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2264 gtk_range_set_inverted( m_scrollBar
[ScrollDir_Horz
], TRUE
);
2266 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2268 // connect various scroll-related events
2269 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2271 // these handlers block mouse events to any window during scrolling
2272 // such as motion events and prevent GTK and wxWidgets from fighting
2273 // over where the slider should be
2274 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2275 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2276 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2277 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2279 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2280 G_CALLBACK(gtk_scrollbar_event_after
), this);
2281 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2283 // these handlers get notified when scrollbar slider moves
2284 g_signal_connect_after(m_scrollBar
[dir
], "value_changed",
2285 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2288 gtk_widget_show( m_wxwindow
);
2290 g_object_ref(m_widget
);
2293 m_parent
->DoAddChild( this );
2295 m_focusWidget
= m_wxwindow
;
2297 SetCanFocus(AcceptsFocus());
2304 wxWindowGTK
::~wxWindowGTK()
2308 if (gs_currentFocus
== this)
2309 gs_currentFocus
= NULL
;
2310 if (gs_pendingFocus
== this)
2311 gs_pendingFocus
= NULL
;
2313 if ( gs_deferredFocusOut
== this )
2314 gs_deferredFocusOut
= NULL
;
2318 // destroy children before destroying this window itself
2321 // unhook focus handlers to prevent stray events being
2322 // propagated to this (soon to be) dead object
2323 if (m_focusWidget
!= NULL
)
2325 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2326 (gpointer
) gtk_window_focus_in_callback
,
2328 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2329 (gpointer
) gtk_window_focus_out_callback
,
2336 // delete before the widgets to avoid a crash on solaris
2340 // avoid problem with GTK+ 2.18 where a frozen window causes the whole
2341 // TLW to be frozen, and if the window is then destroyed, nothing ever
2342 // gets painted again
2348 // Note that gtk_widget_destroy() does not destroy the widget, it just
2349 // emits the "destroy" signal. The widget is not actually destroyed
2350 // until its reference count drops to zero.
2351 gtk_widget_destroy(m_widget
);
2352 // Release our reference, should be the last one
2353 g_object_unref(m_widget
);
2359 bool wxWindowGTK
::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2361 if ( GTKNeedsParent() )
2363 wxCHECK_MSG( parent
, false, wxT("Must have non-NULL parent") );
2366 // Use either the given size, or the default if -1 is given.
2367 // See wxWindowBase for these functions.
2368 m_width
= WidthDefault(size
.x
) ;
2369 m_height
= HeightDefault(size
.y
);
2371 if (pos
!= wxDefaultPosition
)
2380 void wxWindowGTK
::PostCreation()
2382 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2384 #if wxGTK_HAS_COMPOSITING_SUPPORT
2385 // Set RGBA visual as soon as possible to minimize the possibility that
2386 // somebody uses the wrong one.
2387 if ( m_backgroundStyle
== wxBG_STYLE_TRANSPARENT
&&
2388 IsTransparentBackgroundSupported() )
2390 GdkScreen
*screen
= gtk_widget_get_screen (m_widget
);
2392 GdkColormap
*rgba_colormap
= gdk_screen_get_rgba_colormap (screen
);
2395 gtk_widget_set_colormap(m_widget
, rgba_colormap
);
2397 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
2403 // these get reported to wxWidgets -> wxPaintEvent
2405 g_signal_connect (m_wxwindow
, "expose_event",
2406 G_CALLBACK (gtk_window_expose_callback
), this);
2408 if (GetLayoutDirection() == wxLayout_LeftToRight
)
2409 gtk_widget_set_redraw_on_allocate(m_wxwindow
, HasFlag(wxFULL_REPAINT_ON_RESIZE
));
2412 // Create input method handler
2413 m_imData
= new wxGtkIMData
;
2415 // Cannot handle drawing preedited text yet
2416 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2418 g_signal_connect (m_imData
->context
, "commit",
2419 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2420 g_signal_connect(m_wxwindow
, "unrealize", G_CALLBACK(unrealize
), this);
2425 if (!GTK_IS_WINDOW(m_widget
))
2427 if (m_focusWidget
== NULL
)
2428 m_focusWidget
= m_widget
;
2432 g_signal_connect (m_focusWidget
, "focus_in_event",
2433 G_CALLBACK (gtk_window_focus_in_callback
), this);
2434 g_signal_connect (m_focusWidget
, "focus_out_event",
2435 G_CALLBACK (gtk_window_focus_out_callback
), this);
2439 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2440 G_CALLBACK (gtk_window_focus_in_callback
), this);
2441 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2442 G_CALLBACK (gtk_window_focus_out_callback
), this);
2446 if ( !AcceptsFocusFromKeyboard() )
2450 g_signal_connect(m_widget
, "focus",
2451 G_CALLBACK(wx_window_focus_callback
), this);
2454 // connect to the various key and mouse handlers
2456 GtkWidget
*connect_widget
= GetConnectWidget();
2458 ConnectWidget( connect_widget
);
2460 // We cannot set colours, fonts and cursors before the widget has been
2461 // realized, so we do this directly after realization -- unless the widget
2462 // was in fact realized already.
2463 if ( gtk_widget_get_realized(connect_widget
) )
2465 gtk_window_realized_callback(connect_widget
, this);
2469 g_signal_connect (connect_widget
, "realize",
2470 G_CALLBACK (gtk_window_realized_callback
), this);
2475 g_signal_connect(m_wxwindow ? m_wxwindow
: m_widget
, "size_allocate",
2476 G_CALLBACK(size_allocate
), this);
2479 #if GTK_CHECK_VERSION(2, 8, 0)
2480 if ( gtk_check_version(2,8,0) == NULL
)
2482 // Make sure we can notify the app when mouse capture is lost
2485 g_signal_connect (m_wxwindow
, "grab_broken_event",
2486 G_CALLBACK (gtk_window_grab_broken
), this);
2489 if ( connect_widget
!= m_wxwindow
)
2491 g_signal_connect (connect_widget
, "grab_broken_event",
2492 G_CALLBACK (gtk_window_grab_broken
), this);
2495 #endif // GTK+ >= 2.8
2497 if ( GTKShouldConnectSizeRequest() )
2499 // This is needed if we want to add our windows into native
2500 // GTK controls, such as the toolbar. With this callback, the
2501 // toolbar gets to know the correct size (the one set by the
2502 // programmer). Sadly, it misbehaves for wxComboBox.
2503 g_signal_connect (m_widget
, "size_request",
2504 G_CALLBACK (wxgtk_window_size_request_callback
),
2508 InheritAttributes();
2512 SetLayoutDirection(wxLayout_Default
);
2514 // unless the window was created initially hidden (i.e. Hide() had been
2515 // called before Create()), we should show it at GTK+ level as well
2517 gtk_widget_show( m_widget
);
2521 wxWindowGTK
::GTKConnectWidget(const char *signal
, wxGTKCallback callback
)
2523 return g_signal_connect(m_widget
, signal
, callback
, this);
2526 void wxWindowGTK
::ConnectWidget( GtkWidget
*widget
)
2528 g_signal_connect (widget
, "key_press_event",
2529 G_CALLBACK (gtk_window_key_press_callback
), this);
2530 g_signal_connect (widget
, "key_release_event",
2531 G_CALLBACK (gtk_window_key_release_callback
), this);
2532 g_signal_connect (widget
, "button_press_event",
2533 G_CALLBACK (gtk_window_button_press_callback
), this);
2534 g_signal_connect (widget
, "button_release_event",
2535 G_CALLBACK (gtk_window_button_release_callback
), this);
2536 g_signal_connect (widget
, "motion_notify_event",
2537 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2539 g_signal_connect (widget
, "scroll_event",
2540 G_CALLBACK (window_scroll_event
), this);
2541 if (m_scrollBar
[ScrollDir_Horz
])
2542 g_signal_connect (m_scrollBar
[ScrollDir_Horz
], "scroll_event",
2543 G_CALLBACK (window_scroll_event_hscrollbar
), this);
2544 if (m_scrollBar
[ScrollDir_Vert
])
2545 g_signal_connect (m_scrollBar
[ScrollDir_Vert
], "scroll_event",
2546 G_CALLBACK (window_scroll_event
), this);
2548 g_signal_connect (widget
, "popup_menu",
2549 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2550 g_signal_connect (widget
, "enter_notify_event",
2551 G_CALLBACK (gtk_window_enter_callback
), this);
2552 g_signal_connect (widget
, "leave_notify_event",
2553 G_CALLBACK (gtk_window_leave_callback
), this);
2555 if (m_wxwindow
&& (IsTopLevel() || HasFlag(wxBORDER_RAISED
| wxBORDER_SUNKEN
| wxBORDER_THEME
)))
2556 g_signal_connect (m_wxwindow
, "style_set",
2557 G_CALLBACK (gtk_window_style_set_callback
), this);
2560 bool wxWindowGTK
::Destroy()
2564 return wxWindowBase
::Destroy();
2567 void wxWindowGTK
::DoMoveWindow(int x
, int y
, int width
, int height
)
2569 gtk_widget_set_size_request(m_widget
, width
, height
);
2571 // inform the parent to perform the move
2572 wxASSERT_MSG(m_parent
&& m_parent
->m_wxwindow
,
2573 "the parent window has no client area?");
2574 WX_PIZZA(m_parent
->m_wxwindow
)->move(m_widget
, x
, y
);
2577 void wxWindowGTK
::ConstrainSize()
2580 // GPE's window manager doesn't like size hints at all, esp. when the user
2581 // has to use the virtual keyboard, so don't constrain size there
2585 const wxSize minSize
= GetMinSize();
2586 const wxSize maxSize
= GetMaxSize();
2587 if (minSize
.x
> 0 && m_width
< minSize
.x
) m_width
= minSize
.x
;
2588 if (minSize
.y
> 0 && m_height
< minSize
.y
) m_height
= minSize
.y
;
2589 if (maxSize
.x
> 0 && m_width
> maxSize
.x
) m_width
= maxSize
.x
;
2590 if (maxSize
.y
> 0 && m_height
> maxSize
.y
) m_height
= maxSize
.y
;
2594 void wxWindowGTK
::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2596 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2597 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2599 int scrollX
= 0, scrollY
= 0;
2600 GtkWidget
* parent
= gtk_widget_get_parent(m_widget
);
2601 if (WX_IS_PIZZA(parent
))
2603 wxPizza
* pizza
= WX_PIZZA(parent
);
2604 scrollX
= pizza
->m_scroll_x
;
2605 scrollY
= pizza
->m_scroll_y
;
2607 if (x
!= -1 || (sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2611 if (y
!= -1 || (sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2616 // calculate the best size if we should auto size the window
2617 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2618 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2620 const wxSize sizeBest
= GetBestSize();
2621 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2623 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2624 height
= sizeBest
.y
;
2632 const bool sizeChange
= m_width
!= width
|| m_height
!= height
;
2633 if (sizeChange
|| m_x
!= x
|| m_y
!= y
)
2641 if (m_parent
->m_wxwindow
)
2643 /* the default button has a border around it */
2644 if (gtk_widget_get_can_default(m_widget
))
2646 GtkBorder
*default_border
= NULL
;
2647 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2650 x
-= default_border
->left
;
2651 y
-= default_border
->top
;
2652 width
+= default_border
->left
+ default_border
->right
;
2653 height
+= default_border
->top
+ default_border
->bottom
;
2654 gtk_border_free( default_border
);
2658 DoMoveWindow(x
, y
, width
, height
);
2663 // update these variables to keep size_allocate handler
2664 // from sending another size event for this change
2665 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2667 gtk_widget_queue_resize(m_widget
);
2669 if ((sizeChange
&& !m_nativeSizeEvent
) || (sizeFlags
& wxSIZE_FORCE_EVENT
))
2671 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2672 event
.SetEventObject( this );
2673 HandleWindowEvent( event
);
2677 bool wxWindowGTK
::GTKShowFromOnIdle()
2679 if (IsShown() && m_showOnIdle
&& !gtk_widget_get_visible (m_widget
))
2681 GtkAllocation alloc
;
2684 alloc
.width
= m_width
;
2685 alloc
.height
= m_height
;
2686 gtk_widget_size_allocate( m_widget
, &alloc
);
2687 gtk_widget_show( m_widget
);
2688 wxShowEvent
eventShow(GetId(), true);
2689 eventShow
.SetEventObject(this);
2690 HandleWindowEvent(eventShow
);
2691 m_showOnIdle
= false;
2698 void wxWindowGTK
::OnInternalIdle()
2700 if ( gs_deferredFocusOut
)
2701 GTKHandleDeferredFocusOut();
2703 // Check if we have to show window now
2704 if (GTKShowFromOnIdle()) return;
2706 if ( m_dirtyTabOrder
)
2708 m_dirtyTabOrder
= false;
2712 wxWindowBase
::OnInternalIdle();
2715 void wxWindowGTK
::DoGetSize( int *width
, int *height
) const
2717 if (width
) (*width
) = m_width
;
2718 if (height
) (*height
) = m_height
;
2721 void wxWindowGTK
::DoSetClientSize( int width
, int height
)
2723 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2725 const wxSize size
= GetSize();
2726 const wxSize clientSize
= GetClientSize();
2727 SetSize(width
+ (size
.x
- clientSize
.x
), height
+ (size
.y
- clientSize
.y
));
2730 void wxWindowGTK
::DoGetClientSize( int *width
, int *height
) const
2732 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2739 // if window is scrollable, account for scrollbars
2740 if ( GTK_IS_SCROLLED_WINDOW(m_widget
) )
2742 GtkPolicyType policy
[ScrollDir_Max
];
2743 gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget
),
2744 &policy
[ScrollDir_Horz
],
2745 &policy
[ScrollDir_Vert
]);
2747 for ( int i
= 0; i
< ScrollDir_Max
; i
++ )
2749 // don't account for the scrollbars we don't have
2750 GtkRange
* const range
= m_scrollBar
[i
];
2754 // nor for the ones we have but don't current show
2755 switch ( policy
[i
] )
2757 case GTK_POLICY_NEVER
:
2758 // never shown so doesn't take any place
2761 case GTK_POLICY_ALWAYS
:
2762 // no checks necessary
2765 case GTK_POLICY_AUTOMATIC
:
2766 // may be shown or not, check
2767 GtkAdjustment
*adj
= gtk_range_get_adjustment(range
);
2768 if (gtk_adjustment_get_upper(adj
) <= gtk_adjustment_get_page_size(adj
))
2772 GtkScrolledWindowClass
*scroll_class
=
2773 GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2776 gtk_widget_size_request(GTK_WIDGET(range
), &req
);
2777 if (i
== ScrollDir_Horz
)
2778 h
-= req
.height
+ scroll_class
->scrollbar_spacing
;
2780 w
-= req
.width
+ scroll_class
->scrollbar_spacing
;
2784 const wxSize sizeBorders
= DoGetBorderSize();
2794 if (width
) *width
= w
;
2795 if (height
) *height
= h
;
2798 wxSize wxWindowGTK
::DoGetBorderSize() const
2801 return wxWindowBase
::DoGetBorderSize();
2804 WX_PIZZA(m_wxwindow
)->get_border_widths(x
, y
);
2806 return 2*wxSize(x
, y
);
2809 void wxWindowGTK
::DoGetPosition( int *x
, int *y
) const
2813 GtkWidget
* parent
= NULL
;
2815 parent
= gtk_widget_get_parent(m_widget
);
2816 if (WX_IS_PIZZA(parent
))
2818 wxPizza
* pizza
= WX_PIZZA(parent
);
2819 dx
= pizza
->m_scroll_x
;
2820 dy
= pizza
->m_scroll_y
;
2822 if (x
) (*x
) = m_x
- dx
;
2823 if (y
) (*y
) = m_y
- dy
;
2826 void wxWindowGTK
::DoClientToScreen( int *x
, int *y
) const
2828 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2830 if (gtk_widget_get_window(m_widget
) == NULL
) return;
2832 GdkWindow
*source
= NULL
;
2834 source
= gtk_widget_get_window(m_wxwindow
);
2836 source
= gtk_widget_get_window(m_widget
);
2840 gdk_window_get_origin( source
, &org_x
, &org_y
);
2844 if (!gtk_widget_get_has_window(m_widget
))
2847 gtk_widget_get_allocation(m_widget
, &a
);
2856 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2857 *x
= (GetClientSize().x
- *x
) + org_x
;
2865 void wxWindowGTK
::DoScreenToClient( int *x
, int *y
) const
2867 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2869 if (!gtk_widget_get_realized(m_widget
)) return;
2871 GdkWindow
*source
= NULL
;
2873 source
= gtk_widget_get_window(m_wxwindow
);
2875 source
= gtk_widget_get_window(m_widget
);
2879 gdk_window_get_origin( source
, &org_x
, &org_y
);
2883 if (!gtk_widget_get_has_window(m_widget
))
2886 gtk_widget_get_allocation(m_widget
, &a
);
2894 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2895 *x
= (GetClientSize().x
- *x
) - org_x
;
2902 bool wxWindowGTK
::Show( bool show
)
2904 if ( !wxWindowBase
::Show(show
) )
2910 // notice that we may call Hide() before the window is created and this is
2911 // actually useful to create it hidden initially -- but we can't call
2912 // Show() before it is created
2915 wxASSERT_MSG( !show
, "can't show invalid window" );
2923 // defer until later
2927 gtk_widget_show(m_widget
);
2931 gtk_widget_hide(m_widget
);
2934 wxShowEvent
eventShow(GetId(), show
);
2935 eventShow
.SetEventObject(this);
2936 HandleWindowEvent(eventShow
);
2941 void wxWindowGTK
::DoEnable( bool enable
)
2943 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2945 gtk_widget_set_sensitive( m_widget
, enable
);
2946 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
2947 gtk_widget_set_sensitive( m_wxwindow
, enable
);
2950 int wxWindowGTK
::GetCharHeight() const
2952 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
2954 wxFont font
= GetFont();
2955 wxCHECK_MSG( font
.IsOk(), 12, wxT("invalid font") );
2957 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
2962 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
2963 PangoLayout
*layout
= pango_layout_new(context
);
2964 pango_layout_set_font_description(layout
, desc
);
2965 pango_layout_set_text(layout
, "H", 1);
2966 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
2968 PangoRectangle rect
;
2969 pango_layout_line_get_extents(line
, NULL
, &rect
);
2971 g_object_unref (layout
);
2973 return (int) PANGO_PIXELS(rect
.height
);
2976 int wxWindowGTK
::GetCharWidth() const
2978 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
2980 wxFont font
= GetFont();
2981 wxCHECK_MSG( font
.IsOk(), 8, wxT("invalid font") );
2983 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
2988 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
2989 PangoLayout
*layout
= pango_layout_new(context
);
2990 pango_layout_set_font_description(layout
, desc
);
2991 pango_layout_set_text(layout
, "g", 1);
2992 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
2994 PangoRectangle rect
;
2995 pango_layout_line_get_extents(line
, NULL
, &rect
);
2997 g_object_unref (layout
);
2999 return (int) PANGO_PIXELS(rect
.width
);
3002 void wxWindowGTK
::DoGetTextExtent( const wxString
& string
,
3006 int *externalLeading
,
3007 const wxFont
*theFont
) const
3009 wxFont fontToUse
= theFont ?
*theFont
: GetFont();
3011 wxCHECK_RET( fontToUse
.IsOk(), wxT("invalid font") );
3020 PangoContext
*context
= NULL
;
3022 context
= gtk_widget_get_pango_context( m_widget
);
3031 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3032 PangoLayout
*layout
= pango_layout_new(context
);
3033 pango_layout_set_font_description(layout
, desc
);
3035 const wxCharBuffer data
= wxGTK_CONV( string
);
3037 pango_layout_set_text(layout
, data
, strlen(data
));
3040 PangoRectangle rect
;
3041 pango_layout_get_extents(layout
, NULL
, &rect
);
3043 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
3044 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
3047 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
3048 int baseline
= pango_layout_iter_get_baseline(iter
);
3049 pango_layout_iter_free(iter
);
3050 *descent
= *y
- PANGO_PIXELS(baseline
);
3052 if (externalLeading
) (*externalLeading
) = 0; // ??
3054 g_object_unref (layout
);
3057 void wxWindowGTK
::GTKDisableFocusOutEvent()
3059 g_signal_handlers_block_by_func( m_focusWidget
,
3060 (gpointer
) gtk_window_focus_out_callback
, this);
3063 void wxWindowGTK
::GTKEnableFocusOutEvent()
3065 g_signal_handlers_unblock_by_func( m_focusWidget
,
3066 (gpointer
) gtk_window_focus_out_callback
, this);
3069 bool wxWindowGTK
::GTKHandleFocusIn()
3071 // Disable default focus handling for custom windows since the default GTK+
3072 // handler issues a repaint
3073 const bool retval
= m_wxwindow ?
true : false;
3076 // NB: if there's still unprocessed deferred focus-out event (see
3077 // GTKHandleFocusOut() for explanation), we need to process it first so
3078 // that the order of focus events -- focus-out first, then focus-in
3079 // elsewhere -- is preserved
3080 if ( gs_deferredFocusOut
)
3082 if ( GTKNeedsToFilterSameWindowFocus() &&
3083 gs_deferredFocusOut
== this )
3085 // GTK+ focus changed from this wxWindow back to itself, so don't
3086 // emit any events at all
3087 wxLogTrace(TRACE_FOCUS
,
3088 "filtered out spurious focus change within %s(%p, %s)",
3089 GetClassInfo()->GetClassName(), this, GetLabel());
3090 gs_deferredFocusOut
= NULL
;
3094 // otherwise we need to send focus-out first
3095 wxASSERT_MSG ( gs_deferredFocusOut
!= this,
3096 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
3097 GTKHandleDeferredFocusOut();
3101 wxLogTrace(TRACE_FOCUS
,
3102 "handling focus_in event for %s(%p, %s)",
3103 GetClassInfo()->GetClassName(), this, GetLabel());
3106 gtk_im_context_focus_in(m_imData
->context
);
3108 gs_currentFocus
= this;
3109 gs_pendingFocus
= NULL
;
3112 // caret needs to be informed about focus change
3113 wxCaret
*caret
= GetCaret();
3116 caret
->OnSetFocus();
3118 #endif // wxUSE_CARET
3120 // Notify the parent keeping track of focus for the kbd navigation
3121 // purposes that we got it.
3122 wxChildFocusEvent
eventChildFocus(static_cast<wxWindow
*>(this));
3123 GTKProcessEvent(eventChildFocus
);
3125 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, GetId());
3126 eventFocus
.SetEventObject(this);
3127 GTKProcessEvent(eventFocus
);
3132 bool wxWindowGTK
::GTKHandleFocusOut()
3134 // Disable default focus handling for custom windows since the default GTK+
3135 // handler issues a repaint
3136 const bool retval
= m_wxwindow ?
true : false;
3139 // NB: If a control is composed of several GtkWidgets and when focus
3140 // changes from one of them to another within the same wxWindow, we get
3141 // a focus-out event followed by focus-in for another GtkWidget owned
3142 // by the same wx control. We don't want to generate two spurious
3143 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3144 // from GTKHandleFocusOut() until we know for sure it's not coming back
3145 // (i.e. in GTKHandleFocusIn() or at idle time).
3146 if ( GTKNeedsToFilterSameWindowFocus() )
3148 wxASSERT_MSG( gs_deferredFocusOut
== NULL
,
3149 "deferred focus out event already pending" );
3150 wxLogTrace(TRACE_FOCUS
,
3151 "deferring focus_out event for %s(%p, %s)",
3152 GetClassInfo()->GetClassName(), this, GetLabel());
3153 gs_deferredFocusOut
= this;
3157 GTKHandleFocusOutNoDeferring();
3162 void wxWindowGTK
::GTKHandleFocusOutNoDeferring()
3164 wxLogTrace(TRACE_FOCUS
,
3165 "handling focus_out event for %s(%p, %s)",
3166 GetClassInfo()->GetClassName(), this, GetLabel());
3169 gtk_im_context_focus_out(m_imData
->context
);
3171 if ( gs_currentFocus
!= this )
3173 // Something is terribly wrong, gs_currentFocus is out of sync with the
3174 // real focus. We will reset it to NULL anyway, because after this
3175 // focus-out event is handled, one of the following with happen:
3177 // * either focus will go out of the app altogether, in which case
3178 // gs_currentFocus _should_ be NULL
3180 // * or it goes to another control, in which case focus-in event will
3181 // follow immediately and it will set gs_currentFocus to the right
3183 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3184 GetClassInfo()->GetClassName(), this, GetLabel());
3186 gs_currentFocus
= NULL
;
3189 // caret needs to be informed about focus change
3190 wxCaret
*caret
= GetCaret();
3193 caret
->OnKillFocus();
3195 #endif // wxUSE_CARET
3197 wxFocusEvent
event( wxEVT_KILL_FOCUS
, GetId() );
3198 event
.SetEventObject( this );
3199 event
.SetWindow( FindFocus() );
3200 GTKProcessEvent( event
);
3204 void wxWindowGTK
::GTKHandleDeferredFocusOut()
3206 // NB: See GTKHandleFocusOut() for explanation. This function is called
3207 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3209 if ( gs_deferredFocusOut
)
3211 wxWindowGTK
*win
= gs_deferredFocusOut
;
3212 gs_deferredFocusOut
= NULL
;
3214 wxLogTrace(TRACE_FOCUS
,
3215 "processing deferred focus_out event for %s(%p, %s)",
3216 win
->GetClassInfo()->GetClassName(), win
, win
->GetLabel());
3218 win
->GTKHandleFocusOutNoDeferring();
3222 void wxWindowGTK
::SetFocus()
3224 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3226 // Setting "physical" focus is not immediate in GTK+ and while
3227 // gtk_widget_is_focus ("determines if the widget is the focus widget
3228 // within its toplevel", i.e. returns true for one widget per TLW, not
3229 // globally) returns true immediately after grabbing focus,
3230 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3231 // has focus at the moment) takes effect only after the window is shown
3232 // (if it was hidden at the moment of the call) or at the next event loop
3235 // Because we want to FindFocus() call immediately following
3236 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3238 gs_pendingFocus
= this;
3240 GtkWidget
*widget
= m_wxwindow ? m_wxwindow
: m_focusWidget
;
3242 if ( GTK_IS_CONTAINER(widget
) &&
3243 !gtk_widget_get_can_focus(widget
) )
3245 wxLogTrace(TRACE_FOCUS
,
3246 wxT("Setting focus to a child of %s(%p, %s)"),
3247 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3248 gtk_widget_child_focus(widget
, GTK_DIR_TAB_FORWARD
);
3252 wxLogTrace(TRACE_FOCUS
,
3253 wxT("Setting focus to %s(%p, %s)"),
3254 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3255 gtk_widget_grab_focus(widget
);
3259 void wxWindowGTK
::SetCanFocus(bool canFocus
)
3261 gtk_widget_set_can_focus(m_widget
, canFocus
);
3263 if ( m_wxwindow
&& (m_widget
!= m_wxwindow
) )
3265 gtk_widget_set_can_focus(m_wxwindow
, canFocus
);
3269 bool wxWindowGTK
::Reparent( wxWindowBase
*newParentBase
)
3271 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3273 wxWindowGTK
* const newParent
= (wxWindowGTK
*)newParentBase
;
3275 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3277 if ( !wxWindowBase
::Reparent(newParent
) )
3280 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3282 // Notice that old m_parent pointer might be non-NULL here but the widget
3283 // still not have any parent at GTK level if it's a notebook page that had
3284 // been removed from the notebook so test this at GTK level and not wx one.
3285 if ( GtkWidget
*parentGTK
= gtk_widget_get_parent(m_widget
) )
3286 gtk_container_remove(GTK_CONTAINER(parentGTK
), m_widget
);
3288 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3292 if (gtk_widget_get_visible (newParent
->m_widget
))
3294 m_showOnIdle
= true;
3295 gtk_widget_hide( m_widget
);
3297 /* insert GTK representation */
3298 newParent
->AddChildGTK(this);
3301 SetLayoutDirection(wxLayout_Default
);
3306 void wxWindowGTK
::DoAddChild(wxWindowGTK
*child
)
3308 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3309 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3314 /* insert GTK representation */
3318 void wxWindowGTK
::AddChild(wxWindowBase
*child
)
3320 wxWindowBase
::AddChild(child
);
3321 m_dirtyTabOrder
= true;
3322 wxTheApp
->WakeUpIdle();
3325 void wxWindowGTK
::RemoveChild(wxWindowBase
*child
)
3327 wxWindowBase
::RemoveChild(child
);
3328 m_dirtyTabOrder
= true;
3329 wxTheApp
->WakeUpIdle();
3333 wxLayoutDirection wxWindowGTK
::GTKGetLayout(GtkWidget
*widget
)
3335 return gtk_widget_get_direction(widget
) == GTK_TEXT_DIR_RTL
3336 ? wxLayout_RightToLeft
3337 : wxLayout_LeftToRight
;
3341 void wxWindowGTK
::GTKSetLayout(GtkWidget
*widget
, wxLayoutDirection dir
)
3343 wxASSERT_MSG( dir
!= wxLayout_Default
, wxT("invalid layout direction") );
3345 gtk_widget_set_direction(widget
,
3346 dir
== wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
3347 : GTK_TEXT_DIR_LTR
);
3350 wxLayoutDirection wxWindowGTK
::GetLayoutDirection() const
3352 return GTKGetLayout(m_widget
);
3355 void wxWindowGTK
::SetLayoutDirection(wxLayoutDirection dir
)
3357 if ( dir
== wxLayout_Default
)
3359 const wxWindow
*const parent
= GetParent();
3362 // inherit layout from parent.
3363 dir
= parent
->GetLayoutDirection();
3365 else // no parent, use global default layout
3367 dir
= wxTheApp
->GetLayoutDirection();
3371 if ( dir
== wxLayout_Default
)
3374 GTKSetLayout(m_widget
, dir
);
3376 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3377 GTKSetLayout(m_wxwindow
, dir
);
3381 wxWindowGTK
::AdjustForLayoutDirection(wxCoord x
,
3382 wxCoord
WXUNUSED(width
),
3383 wxCoord
WXUNUSED(widthTotal
)) const
3385 // We now mirror the coordinates of RTL windows in wxPizza
3389 void wxWindowGTK
::DoMoveInTabOrder(wxWindow
*win
, WindowOrder move
)
3391 wxWindowBase
::DoMoveInTabOrder(win
, move
);
3392 m_dirtyTabOrder
= true;
3393 wxTheApp
->WakeUpIdle();
3396 bool wxWindowGTK
::DoNavigateIn(int flags
)
3398 if ( flags
& wxNavigationKeyEvent
::WinChange
)
3400 wxFAIL_MSG( wxT("not implemented") );
3404 else // navigate inside the container
3406 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3407 wxCHECK_MSG( parent
, false, wxT("every window must have a TLW parent") );
3409 GtkDirectionType dir
;
3410 dir
= flags
& wxNavigationKeyEvent
::IsForward ? GTK_DIR_TAB_FORWARD
3411 : GTK_DIR_TAB_BACKWARD
;
3414 g_signal_emit_by_name(parent
->m_widget
, "focus", dir
, &rc
);
3420 bool wxWindowGTK
::GTKWidgetNeedsMnemonic() const
3422 // none needed by default
3426 void wxWindowGTK
::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3428 // nothing to do by default since none is needed
3431 void wxWindowGTK
::RealizeTabOrder()
3435 if ( !m_children
.empty() )
3437 // we don't only construct the correct focus chain but also use
3438 // this opportunity to update the mnemonic widgets for the widgets
3441 GList
*chain
= NULL
;
3442 wxWindowGTK
* mnemonicWindow
= NULL
;
3444 for ( wxWindowList
::const_iterator i
= m_children
.begin();
3445 i
!= m_children
.end();
3448 wxWindowGTK
*win
= *i
;
3450 bool focusableFromKeyboard
= win
->AcceptsFocusFromKeyboard();
3452 if ( mnemonicWindow
)
3454 if ( focusableFromKeyboard
)
3456 // wxComboBox et al. needs to focus on on a different
3457 // widget than m_widget, so if the main widget isn't
3458 // focusable try the connect widget
3459 GtkWidget
* w
= win
->m_widget
;
3460 if ( !gtk_widget_get_can_focus(w
) )
3462 w
= win
->GetConnectWidget();
3463 if ( !gtk_widget_get_can_focus(w
) )
3469 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3470 mnemonicWindow
= NULL
;
3474 else if ( win
->GTKWidgetNeedsMnemonic() )
3476 mnemonicWindow
= win
;
3479 if ( focusableFromKeyboard
)
3480 chain
= g_list_prepend(chain
, win
->m_widget
);
3483 chain
= g_list_reverse(chain
);
3485 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3490 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3495 void wxWindowGTK
::Raise()
3497 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3499 if (m_wxwindow
&& gtk_widget_get_window(m_wxwindow
))
3501 gdk_window_raise(gtk_widget_get_window(m_wxwindow
));
3503 else if (gtk_widget_get_window(m_widget
))
3505 gdk_window_raise(gtk_widget_get_window(m_widget
));
3509 void wxWindowGTK
::Lower()
3511 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3513 if (m_wxwindow
&& gtk_widget_get_window(m_wxwindow
))
3515 gdk_window_lower(gtk_widget_get_window(m_wxwindow
));
3517 else if (gtk_widget_get_window(m_widget
))
3519 gdk_window_lower(gtk_widget_get_window(m_widget
));
3523 bool wxWindowGTK
::SetCursor( const wxCursor
&cursor
)
3525 if ( !wxWindowBase
::SetCursor(cursor
.IsOk() ? cursor
: *wxSTANDARD_CURSOR
) )
3533 void wxWindowGTK
::GTKUpdateCursor(bool update_self
/*=true*/, bool recurse
/*=true*/)
3537 wxCursor
cursor(g_globalCursor
.IsOk() ? g_globalCursor
: GetCursor());
3538 if ( cursor
.IsOk() )
3540 wxArrayGdkWindows windowsThis
;
3541 GdkWindow
* window
= GTKGetWindow(windowsThis
);
3543 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3546 const size_t count
= windowsThis
.size();
3547 for ( size_t n
= 0; n
< count
; n
++ )
3549 GdkWindow
*win
= windowsThis
[n
];
3550 // It can be zero if the window has not been realized yet.
3553 gdk_window_set_cursor(win
, cursor
.GetCursor());
3562 for (wxWindowList
::iterator it
= GetChildren().begin(); it
!= GetChildren().end(); ++it
)
3564 (*it
)->GTKUpdateCursor( true );
3569 void wxWindowGTK
::WarpPointer( int x
, int y
)
3571 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3573 ClientToScreen(&x
, &y
);
3574 GdkDisplay
* display
= gtk_widget_get_display(m_widget
);
3575 GdkScreen
* screen
= gtk_widget_get_screen(m_widget
);
3577 GdkDeviceManager
* manager
= gdk_display_get_device_manager(display
);
3578 gdk_device_warp(gdk_device_manager_get_client_pointer(manager
), screen
, x
, y
);
3580 #ifdef GDK_WINDOWING_X11
3581 XWarpPointer(GDK_DISPLAY_XDISPLAY(display
),
3583 GDK_WINDOW_XID(gdk_screen_get_root_window(screen
)),
3589 wxWindowGTK
::ScrollDir wxWindowGTK
::ScrollDirFromRange(GtkRange
*range
) const
3591 // find the scrollbar which generated the event
3592 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3594 if ( range
== m_scrollBar
[dir
] )
3595 return (ScrollDir
)dir
;
3598 wxFAIL_MSG( wxT("event from unknown scrollbar received") );
3600 return ScrollDir_Max
;
3603 bool wxWindowGTK
::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3605 bool changed
= false;
3606 GtkRange
* range
= m_scrollBar
[dir
];
3607 if ( range
&& units
)
3609 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
3610 double inc
= unit
== ScrollUnit_Line ?
gtk_adjustment_get_step_increment(adj
)
3611 : gtk_adjustment_get_page_increment(adj
);
3613 const int posOld
= wxRound(gtk_adjustment_get_value(adj
));
3614 gtk_range_set_value(range
, posOld
+ units
*inc
);
3616 changed
= wxRound(gtk_adjustment_get_value(adj
)) != posOld
;
3622 bool wxWindowGTK
::ScrollLines(int lines
)
3624 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3627 bool wxWindowGTK
::ScrollPages(int pages
)
3629 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3632 void wxWindowGTK
::Refresh(bool WXUNUSED(eraseBackground
),
3637 if (gtk_widget_get_mapped(m_wxwindow
))
3639 GdkWindow
* window
= gtk_widget_get_window(m_wxwindow
);
3642 GdkRectangle r
= { rect
->x
, rect
->y
, rect
->width
, rect
->height
};
3643 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3644 r
.x
= gdk_window_get_width(window
) - r
.x
- rect
->width
;
3645 gdk_window_invalidate_rect(window
, &r
, true);
3648 gdk_window_invalidate_rect(window
, NULL
, true);
3653 if (gtk_widget_get_mapped(m_widget
))
3656 gtk_widget_queue_draw_area(m_widget
, rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3658 gtk_widget_queue_draw(m_widget
);
3663 void wxWindowGTK
::Update()
3665 if (m_widget
&& gtk_widget_get_mapped(m_widget
))
3667 GdkDisplay
* display
= gtk_widget_get_display(m_widget
);
3668 // Flush everything out to the server, and wait for it to finish.
3669 // This ensures nothing will overwrite the drawing we are about to do.
3670 gdk_display_sync(display
);
3672 GdkWindow
* window
= GTKGetDrawingWindow();
3674 window
= gtk_widget_get_window(m_widget
);
3675 gdk_window_process_updates(window
, true);
3677 // Flush again, but no need to wait for it to finish
3678 gdk_display_flush(display
);
3682 bool wxWindowGTK
::DoIsExposed( int x
, int y
) const
3684 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
3687 bool wxWindowGTK
::DoIsExposed( int x
, int y
, int w
, int h
) const
3689 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3690 return m_updateRegion
.Contains(x
-w
, y
, w
, h
) != wxOutRegion
;
3692 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
3695 void wxWindowGTK
::GtkSendPaintEvents()
3699 m_updateRegion
.Clear();
3702 #if wxGTK_HAS_COMPOSITING_SUPPORT
3705 // Clip to paint region in wxClientDC
3706 m_clipPaintRegion
= true;
3708 m_nativeUpdateRegion
= m_updateRegion
;
3710 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3712 // Transform m_updateRegion under RTL
3713 m_updateRegion
.Clear();
3716 gdk_drawable_get_size(gtk_widget_get_window(m_wxwindow
), &width
, NULL
);
3718 wxRegionIterator
upd( m_nativeUpdateRegion
);
3722 rect
.x
= upd
.GetX();
3723 rect
.y
= upd
.GetY();
3724 rect
.width
= upd
.GetWidth();
3725 rect
.height
= upd
.GetHeight();
3727 rect
.x
= width
- rect
.x
- rect
.width
;
3728 m_updateRegion
.Union( rect
);
3734 switch ( GetBackgroundStyle() )
3736 case wxBG_STYLE_TRANSPARENT
:
3737 #if wxGTK_HAS_COMPOSITING_SUPPORT
3738 if (IsTransparentBackgroundSupported())
3740 // Set a transparent background, so that overlaying in parent
3741 // might indeed let see through where this child did not
3742 // explicitly paint.
3743 // NB: it works also for top level windows (but this is the
3744 // windows manager which then does the compositing job)
3745 cr
= gdk_cairo_create(m_wxwindow
->window
);
3746 gdk_cairo_region(cr
, m_nativeUpdateRegion
.GetRegion());
3749 cairo_set_operator(cr
, CAIRO_OPERATOR_CLEAR
);
3751 cairo_set_operator(cr
, CAIRO_OPERATOR_OVER
);
3752 cairo_surface_flush(cairo_get_target(cr
));
3754 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
3757 case wxBG_STYLE_ERASE
:
3759 wxWindowDC
dc( (wxWindow
*)this );
3760 dc
.SetDeviceClippingRegion( m_updateRegion
);
3762 // Work around gtk-qt <= 0.60 bug whereby the window colour
3766 GetOptionInt("gtk.window.force-background-colour") )
3768 dc
.SetBackground(GetBackgroundColour());
3772 wxEraseEvent
erase_event( GetId(), &dc
);
3773 erase_event
.SetEventObject( this );
3775 if ( HandleWindowEvent(erase_event
) )
3777 // background erased, don't do it again
3783 case wxBG_STYLE_SYSTEM
:
3784 if ( GetThemeEnabled() )
3786 // find ancestor from which to steal background
3787 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3789 parent
= (wxWindow
*)this;
3791 if (gtk_widget_get_mapped(parent
->m_widget
))
3793 wxRegionIterator
upd( m_nativeUpdateRegion
);
3797 rect
.x
= upd
.GetX();
3798 rect
.y
= upd
.GetY();
3799 rect
.width
= upd
.GetWidth();
3800 rect
.height
= upd
.GetHeight();
3802 gtk_paint_flat_box(gtk_widget_get_style(parent
->m_widget
),
3803 GTKGetDrawingWindow(),
3804 gtk_widget_get_state(m_wxwindow
),
3817 case wxBG_STYLE_PAINT
:
3818 // nothing to do: window will be painted over in EVT_PAINT
3822 wxFAIL_MSG( "unsupported background style" );
3825 wxNcPaintEvent
nc_paint_event( GetId() );
3826 nc_paint_event
.SetEventObject( this );
3827 HandleWindowEvent( nc_paint_event
);
3829 wxPaintEvent
paint_event( GetId() );
3830 paint_event
.SetEventObject( this );
3831 HandleWindowEvent( paint_event
);
3833 #if wxGTK_HAS_COMPOSITING_SUPPORT
3834 if (IsTransparentBackgroundSupported())
3835 { // now composite children which need it
3836 // Overlay all our composite children on top of the painted area
3837 wxWindowList
::compatibility_iterator node
;
3838 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
3840 wxWindow
*compositeChild
= node
->GetData();
3841 if (compositeChild
->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT
)
3845 cr
= gdk_cairo_create(m_wxwindow
->window
);
3846 gdk_cairo_region(cr
, m_nativeUpdateRegion
.GetRegion());
3850 GtkWidget
*child
= compositeChild
->m_wxwindow
;
3851 GtkAllocation alloc
;
3852 gtk_widget_get_allocation(child
, &alloc
);
3854 // The source data is the (composited) child
3855 gdk_cairo_set_source_window(
3856 cr
, gtk_widget_get_window(child
), alloc
.x
, alloc
.y
);
3864 #endif // wxGTK_HAS_COMPOSITING_SUPPORT
3866 m_clipPaintRegion
= false;
3868 m_updateRegion
.Clear();
3869 m_nativeUpdateRegion
.Clear();
3872 void wxWindowGTK
::SetDoubleBuffered( bool on
)
3874 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3877 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3880 bool wxWindowGTK
::IsDoubleBuffered() const
3882 return gtk_widget_get_double_buffered( m_wxwindow
);
3885 void wxWindowGTK
::ClearBackground()
3887 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3891 void wxWindowGTK
::DoSetToolTip( wxToolTip
*tip
)
3893 if (m_tooltip
!= tip
)
3895 wxWindowBase
::DoSetToolTip(tip
);
3898 m_tooltip
->GTKSetWindow(static_cast<wxWindow
*>(this));
3900 GTKApplyToolTip(NULL
);
3904 void wxWindowGTK
::GTKApplyToolTip(const char* tip
)
3906 wxToolTip
::GTKApply(GetConnectWidget(), tip
);
3908 #endif // wxUSE_TOOLTIPS
3910 bool wxWindowGTK
::SetBackgroundColour( const wxColour
&colour
)
3912 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3914 if (!wxWindowBase
::SetBackgroundColour(colour
))
3919 // We need the pixel value e.g. for background clearing.
3920 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3923 // apply style change (forceStyle=true so that new style is applied
3924 // even if the bg colour changed from valid to wxNullColour)
3925 GTKApplyWidgetStyle(true);
3930 bool wxWindowGTK
::SetForegroundColour( const wxColour
&colour
)
3932 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3934 if (!wxWindowBase
::SetForegroundColour(colour
))
3941 // We need the pixel value e.g. for background clearing.
3942 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3945 // apply style change (forceStyle=true so that new style is applied
3946 // even if the bg colour changed from valid to wxNullColour):
3947 GTKApplyWidgetStyle(true);
3952 PangoContext
*wxWindowGTK
::GTKGetPangoDefaultContext()
3954 return gtk_widget_get_pango_context( m_widget
);
3957 GtkRcStyle
*wxWindowGTK
::GTKCreateWidgetStyle(bool forceStyle
)
3959 // do we need to apply any changes at all?
3962 !m_foregroundColour
.IsOk() && !m_backgroundColour
.IsOk() )
3967 GtkRcStyle
*style
= gtk_rc_style_new();
3969 if ( m_font
.IsOk() )
3972 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
3975 int flagsNormal
= 0,
3978 flagsInsensitive
= 0;
3980 if ( m_foregroundColour
.IsOk() )
3982 const GdkColor
*fg
= m_foregroundColour
.GetColor();
3984 style
->fg
[GTK_STATE_NORMAL
] =
3985 style
->text
[GTK_STATE_NORMAL
] = *fg
;
3986 flagsNormal
|= GTK_RC_FG
| GTK_RC_TEXT
;
3988 style
->fg
[GTK_STATE_PRELIGHT
] =
3989 style
->text
[GTK_STATE_PRELIGHT
] = *fg
;
3990 flagsPrelight
|= GTK_RC_FG
| GTK_RC_TEXT
;
3992 style
->fg
[GTK_STATE_ACTIVE
] =
3993 style
->text
[GTK_STATE_ACTIVE
] = *fg
;
3994 flagsActive
|= GTK_RC_FG
| GTK_RC_TEXT
;
3997 if ( m_backgroundColour
.IsOk() )
3999 const GdkColor
*bg
= m_backgroundColour
.GetColor();
4001 style
->bg
[GTK_STATE_NORMAL
] =
4002 style
->base
[GTK_STATE_NORMAL
] = *bg
;
4003 flagsNormal
|= GTK_RC_BG
| GTK_RC_BASE
;
4005 style
->bg
[GTK_STATE_PRELIGHT
] =
4006 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
4007 flagsPrelight
|= GTK_RC_BG
| GTK_RC_BASE
;
4009 style
->bg
[GTK_STATE_ACTIVE
] =
4010 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
4011 flagsActive
|= GTK_RC_BG
| GTK_RC_BASE
;
4013 style
->bg
[GTK_STATE_INSENSITIVE
] =
4014 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
4015 flagsInsensitive
|= GTK_RC_BG
| GTK_RC_BASE
;
4018 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)flagsNormal
;
4019 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)flagsPrelight
;
4020 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)flagsActive
;
4021 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)flagsInsensitive
;
4026 void wxWindowGTK
::GTKApplyWidgetStyle(bool forceStyle
)
4028 GtkRcStyle
*style
= GTKCreateWidgetStyle(forceStyle
);
4031 DoApplyWidgetStyle(style
);
4032 g_object_unref(style
);
4035 // Style change may affect GTK+'s size calculation:
4036 InvalidateBestSize();
4039 void wxWindowGTK
::DoApplyWidgetStyle(GtkRcStyle
*style
)
4043 // block the signal temporarily to avoid sending
4044 // wxSysColourChangedEvents when we change the colours ourselves
4045 bool unblock
= false;
4049 g_signal_handlers_block_by_func(
4050 m_wxwindow
, (void *)gtk_window_style_set_callback
, this);
4053 gtk_widget_modify_style(m_wxwindow
, style
);
4057 g_signal_handlers_unblock_by_func(
4058 m_wxwindow
, (void *)gtk_window_style_set_callback
, this);
4063 gtk_widget_modify_style(m_widget
, style
);
4067 bool wxWindowGTK
::SetBackgroundStyle(wxBackgroundStyle style
)
4069 if (!wxWindowBase
::SetBackgroundStyle(style
))
4075 window
= GTKGetDrawingWindow();
4079 GtkWidget
* const w
= GetConnectWidget();
4080 window
= w ?
gtk_widget_get_window(w
) : NULL
;
4083 bool wantNoBackPixmap
= style
== wxBG_STYLE_PAINT
|| style
== wxBG_STYLE_TRANSPARENT
;
4085 if ( wantNoBackPixmap
)
4089 // Make sure GDK/X11 doesn't refresh the window
4091 gdk_window_set_back_pixmap( window
, NULL
, FALSE
);
4092 m_needsStyleChange
= false;
4094 else // window not realized yet
4096 // Do when window is realized
4097 m_needsStyleChange
= true;
4100 // Don't apply widget style, or we get a grey background
4104 // apply style change (forceStyle=true so that new style is applied
4105 // even if the bg colour changed from valid to wxNullColour):
4106 GTKApplyWidgetStyle(true);
4112 bool wxWindowGTK
::IsTransparentBackgroundSupported(wxString
* reason
) const
4114 #if wxGTK_HAS_COMPOSITING_SUPPORT
4115 if (gtk_check_version(wxGTK_VERSION_REQUIRED_FOR_COMPOSITING
) != NULL
)
4119 *reason
= _("GTK+ installed on this machine is too old to "
4120 "support screen compositing, please install "
4121 "GTK+ 2.12 or later.");
4127 // NB: We don't check here if the particular kind of widget supports
4128 // transparency, we check only if it would be possible for a generic window
4130 wxCHECK_MSG ( m_widget
, false, "Window must be created first" );
4132 if (!gdk_screen_is_composited(gtk_widget_get_screen(m_widget
)))
4136 *reason
= _("Compositing not supported by this system, "
4137 "please enable it in your Window Manager.");
4147 *reason
= _("This program was compiled with a too old version of GTK+, "
4148 "please rebuild with GTK+ 2.12 or newer.");
4150 #endif // wxGTK_HAS_COMPOSITING_SUPPORT/!wxGTK_HAS_COMPOSITING_SUPPORT
4155 // ----------------------------------------------------------------------------
4156 // Pop-up menu stuff
4157 // ----------------------------------------------------------------------------
4159 #if wxUSE_MENUS_NATIVE
4163 void wxPopupMenuPositionCallback( GtkMenu
*menu
,
4165 gboolean
* WXUNUSED(whatever
),
4166 gpointer user_data
)
4168 // ensure that the menu appears entirely on screen
4170 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
4172 wxSize sizeScreen
= wxGetDisplaySize();
4173 wxPoint
*pos
= (wxPoint
*)user_data
;
4175 gint xmax
= sizeScreen
.x
- req
.width
,
4176 ymax
= sizeScreen
.y
- req
.height
;
4178 *x
= pos
->x
< xmax ? pos
->x
: xmax
;
4179 *y
= pos
->y
< ymax ? pos
->y
: ymax
;
4183 bool wxWindowGTK
::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
4185 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4187 // For compatibility with other ports, pretend that the window showing the
4188 // menu has focus while the menu is shown. This is needed because the popup
4189 // menu actually steals the focus from the window it's associated it in
4190 // wxGTK unlike, say, wxMSW.
4191 wxWindowGTK
* const oldPendingFocus
= gs_pendingFocus
;
4192 gs_pendingFocus
= this;
4193 wxON_BLOCK_EXIT_SET( gs_pendingFocus
, oldPendingFocus
);
4199 GtkMenuPositionFunc posfunc
;
4200 if ( x
== -1 && y
== -1 )
4202 // use GTK's default positioning algorithm
4208 pos
= ClientToScreen(wxPoint(x
, y
));
4210 posfunc
= wxPopupMenuPositionCallback
;
4213 menu
->m_popupShown
= true;
4215 GTK_MENU(menu
->m_menu
),
4216 NULL
, // parent menu shell
4217 NULL
, // parent menu item
4218 posfunc
, // function to position it
4219 userdata
, // client data
4220 0, // button used to activate it
4221 gtk_get_current_event_time()
4224 while (menu
->m_popupShown
)
4226 gtk_main_iteration();
4232 #endif // wxUSE_MENUS_NATIVE
4234 #if wxUSE_DRAG_AND_DROP
4236 void wxWindowGTK
::SetDropTarget( wxDropTarget
*dropTarget
)
4238 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4240 GtkWidget
*dnd_widget
= GetConnectWidget();
4242 if (m_dropTarget
) m_dropTarget
->GtkUnregisterWidget( dnd_widget
);
4244 if (m_dropTarget
) delete m_dropTarget
;
4245 m_dropTarget
= dropTarget
;
4247 if (m_dropTarget
) m_dropTarget
->GtkRegisterWidget( dnd_widget
);
4250 #endif // wxUSE_DRAG_AND_DROP
4252 GtkWidget
* wxWindowGTK
::GetConnectWidget()
4254 GtkWidget
*connect_widget
= m_widget
;
4255 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4257 return connect_widget
;
4260 bool wxWindowGTK
::GTKIsOwnWindow(GdkWindow
*window
) const
4262 wxArrayGdkWindows windowsThis
;
4263 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
4265 return winThis ? window
== winThis
4266 : windowsThis
.Index(window
) != wxNOT_FOUND
;
4269 GdkWindow
*wxWindowGTK
::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
4271 return m_wxwindow ?
GTKGetDrawingWindow() : gtk_widget_get_window(m_widget
);
4274 bool wxWindowGTK
::SetFont( const wxFont
&font
)
4276 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4278 if (!wxWindowBase
::SetFont(font
))
4281 // apply style change (forceStyle=true so that new style is applied
4282 // even if the font changed from valid to wxNullFont):
4283 GTKApplyWidgetStyle(true);
4288 void wxWindowGTK
::DoCaptureMouse()
4290 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4292 GdkWindow
*window
= NULL
;
4294 window
= GTKGetDrawingWindow();
4296 window
= gtk_widget_get_window(GetConnectWidget());
4298 wxCHECK_RET( window
, wxT("CaptureMouse() failed") );
4300 const wxCursor
* cursor
= &m_cursor
;
4301 if (!cursor
->IsOk())
4302 cursor
= wxSTANDARD_CURSOR
;
4304 gdk_pointer_grab( window
, FALSE
,
4306 (GDK_BUTTON_PRESS_MASK
|
4307 GDK_BUTTON_RELEASE_MASK
|
4308 GDK_POINTER_MOTION_HINT_MASK
|
4309 GDK_POINTER_MOTION_MASK
),
4311 cursor
->GetCursor(),
4312 (guint32
)GDK_CURRENT_TIME
);
4313 g_captureWindow
= this;
4314 g_captureWindowHasMouse
= true;
4317 void wxWindowGTK
::DoReleaseMouse()
4319 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4321 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4323 g_captureWindow
= NULL
;
4325 GdkWindow
*window
= NULL
;
4327 window
= GTKGetDrawingWindow();
4329 window
= gtk_widget_get_window(GetConnectWidget());
4334 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4337 void wxWindowGTK
::GTKReleaseMouseAndNotify()
4340 wxMouseCaptureLostEvent
evt(GetId());
4341 evt
.SetEventObject( this );
4342 HandleWindowEvent( evt
);
4346 wxWindow
*wxWindowBase
::GetCapture()
4348 return (wxWindow
*)g_captureWindow
;
4351 bool wxWindowGTK
::IsRetained() const
4356 void wxWindowGTK
::SetScrollbar(int orient
,
4360 bool WXUNUSED(update
))
4362 const int dir
= ScrollDirFromOrient(orient
);
4363 GtkRange
* const sb
= m_scrollBar
[dir
];
4364 wxCHECK_RET( sb
, wxT("this window is not scrollable") );
4368 // GtkRange requires upper > lower
4373 g_signal_handlers_block_by_func(
4374 sb
, (void*)gtk_scrollbar_value_changed
, this);
4376 gtk_range_set_increments(sb
, 1, thumbVisible
);
4377 gtk_adjustment_set_page_size(gtk_range_get_adjustment(sb
), thumbVisible
);
4378 gtk_range_set_range(sb
, 0, range
);
4379 gtk_range_set_value(sb
, pos
);
4380 m_scrollPos
[dir
] = gtk_range_get_value(sb
);
4382 g_signal_handlers_unblock_by_func(
4383 sb
, (void*)gtk_scrollbar_value_changed
, this);
4386 void wxWindowGTK
::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4388 const int dir
= ScrollDirFromOrient(orient
);
4389 GtkRange
* const sb
= m_scrollBar
[dir
];
4390 wxCHECK_RET( sb
, wxT("this window is not scrollable") );
4392 // This check is more than an optimization. Without it, the slider
4393 // will not move smoothly while tracking when using wxScrollHelper.
4394 if (GetScrollPos(orient
) != pos
)
4396 g_signal_handlers_block_by_func(
4397 sb
, (void*)gtk_scrollbar_value_changed
, this);
4399 gtk_range_set_value(sb
, pos
);
4400 m_scrollPos
[dir
] = gtk_range_get_value(sb
);
4402 g_signal_handlers_unblock_by_func(
4403 sb
, (void*)gtk_scrollbar_value_changed
, this);
4407 int wxWindowGTK
::GetScrollThumb(int orient
) const
4409 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4410 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4412 return wxRound(gtk_adjustment_get_page_size(gtk_range_get_adjustment(sb
)));
4415 int wxWindowGTK
::GetScrollPos( int orient
) const
4417 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4418 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4420 return wxRound(gtk_range_get_value(sb
));
4423 int wxWindowGTK
::GetScrollRange( int orient
) const
4425 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4426 wxCHECK_MSG( sb
, 0, wxT("this window is not scrollable") );
4428 return wxRound(gtk_adjustment_get_upper(gtk_range_get_adjustment(sb
)));
4431 // Determine if increment is the same as +/-x, allowing for some small
4432 // difference due to possible inexactness in floating point arithmetic
4433 static inline bool IsScrollIncrement(double increment
, double x
)
4435 wxASSERT(increment
> 0);
4436 const double tolerance
= 1.0 / 1024;
4437 return fabs(increment
- fabs(x
)) < tolerance
;
4440 wxEventType wxWindowGTK
::GTKGetScrollEventType(GtkRange
* range
)
4442 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4444 const int barIndex
= range
== m_scrollBar
[1];
4446 const double value
= gtk_range_get_value(range
);
4448 // save previous position
4449 const double oldPos
= m_scrollPos
[barIndex
];
4450 // update current position
4451 m_scrollPos
[barIndex
] = value
;
4452 // If event should be ignored, or integral position has not changed
4453 if (!m_hasVMT
|| g_blockEventsOnDrag
|| wxRound(value
) == wxRound(oldPos
))
4458 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4461 // Difference from last change event
4462 const double diff
= value
- oldPos
;
4463 const bool isDown
= diff
> 0;
4465 GtkAdjustment
* adj
= gtk_range_get_adjustment(range
);
4466 if (IsScrollIncrement(gtk_adjustment_get_step_increment(adj
), diff
))
4468 eventType
= isDown ? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4470 else if (IsScrollIncrement(gtk_adjustment_get_page_increment(adj
), diff
))
4472 eventType
= isDown ? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4474 else if (m_mouseButtonDown
)
4476 // Assume track event
4477 m_isScrolling
= true;
4483 void wxWindowGTK
::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4485 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4487 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4489 // No scrolling requested.
4490 if ((dx
== 0) && (dy
== 0)) return;
4492 m_clipPaintRegion
= true;
4494 WX_PIZZA(m_wxwindow
)->scroll(dx
, dy
);
4496 m_clipPaintRegion
= false;
4499 bool restoreCaret
= (GetCaret() != NULL
&& GetCaret()->IsVisible());
4502 wxRect
caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4504 caretRect
.width
+= dx
;
4507 caretRect
.x
+= dx
; caretRect
.width
-= dx
;
4510 caretRect
.height
+= dy
;
4513 caretRect
.y
+= dy
; caretRect
.height
-= dy
;
4516 RefreshRect(caretRect
);
4518 #endif // wxUSE_CARET
4521 void wxWindowGTK
::GTKScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4523 //RN: Note that static controls usually have no border on gtk, so maybe
4524 //it makes sense to treat that as simply no border at the wx level
4526 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4528 GtkShadowType gtkstyle
;
4530 if(wxstyle
& wxBORDER_RAISED
)
4531 gtkstyle
= GTK_SHADOW_OUT
;
4532 else if ((wxstyle
& wxBORDER_SUNKEN
) || (wxstyle
& wxBORDER_THEME
))
4533 gtkstyle
= GTK_SHADOW_IN
;
4536 else if (wxstyle
& wxBORDER_DOUBLE
)
4537 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4540 gtkstyle
= GTK_SHADOW_IN
;
4542 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4547 // Find the wxWindow at the current mouse position, also returning the mouse
4549 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4551 pt
= wxGetMousePosition();
4552 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4556 // Get the current mouse position.
4557 wxPoint
wxGetMousePosition()
4559 wxWindow
* tlw
= NULL
;
4560 if (!wxTopLevelWindows
.empty())
4561 tlw
= wxTopLevelWindows
.front();
4562 GdkDisplay
* display
;
4563 if (tlw
&& tlw
->m_widget
)
4564 display
= gtk_widget_get_display(tlw
->m_widget
);
4566 display
= gdk_display_get_default();
4569 gdk_display_get_pointer(display
, NULL
, &x
, &y
, NULL
);
4570 return wxPoint(x
, y
);
4573 GdkWindow
* wxWindowGTK
::GTKGetDrawingWindow() const
4575 GdkWindow
* window
= NULL
;
4577 window
= gtk_widget_get_window(m_wxwindow
);
4581 // ----------------------------------------------------------------------------
4583 // ----------------------------------------------------------------------------
4588 // this is called if we attempted to freeze unrealized widget when it finally
4589 // is realized (and so can be frozen):
4590 static void wx_frozen_widget_realize(GtkWidget
* w
, wxWindowGTK
* win
)
4592 wxASSERT( w
&& gtk_widget_get_has_window(w
) );
4593 wxASSERT( gtk_widget_get_realized(w
) );
4595 g_signal_handlers_disconnect_by_func
4598 (void*)wx_frozen_widget_realize
,
4603 if (w
== win
->m_wxwindow
)
4604 window
= win
->GTKGetDrawingWindow();
4606 window
= gtk_widget_get_window(w
);
4607 gdk_window_freeze_updates(window
);
4612 void wxWindowGTK
::GTKFreezeWidget(GtkWidget
*w
)
4614 if ( !w
|| !gtk_widget_get_has_window(w
) )
4615 return; // window-less widget, cannot be frozen
4617 GdkWindow
* window
= gtk_widget_get_window(w
);
4620 // we can't thaw unrealized widgets because they don't have GdkWindow,
4621 // so set it up to be done immediately after realization:
4622 g_signal_connect_after
4626 G_CALLBACK(wx_frozen_widget_realize
),
4632 if (w
== m_wxwindow
)
4633 window
= GTKGetDrawingWindow();
4634 gdk_window_freeze_updates(window
);
4637 void wxWindowGTK
::GTKThawWidget(GtkWidget
*w
)
4639 if ( !w
|| !gtk_widget_get_has_window(w
) )
4640 return; // window-less widget, cannot be frozen
4642 GdkWindow
* window
= gtk_widget_get_window(w
);
4645 // the widget wasn't realized yet, no need to thaw
4646 g_signal_handlers_disconnect_by_func
4649 (void*)wx_frozen_widget_realize
,
4655 if (w
== m_wxwindow
)
4656 window
= GTKGetDrawingWindow();
4657 gdk_window_thaw_updates(window
);
4660 void wxWindowGTK
::DoFreeze()
4662 GTKFreezeWidget(m_widget
);
4663 if ( m_wxwindow
&& m_widget
!= m_wxwindow
)
4664 GTKFreezeWidget(m_wxwindow
);
4667 void wxWindowGTK
::DoThaw()
4669 GTKThawWidget(m_widget
);
4670 if ( m_wxwindow
&& m_widget
!= m_wxwindow
)
4671 GTKThawWidget(m_wxwindow
);