1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/window.cpp
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"
23 #include "wx/dcclient.h"
25 #include "wx/settings.h"
26 #include "wx/msgdlg.h"
27 #include "wx/textctrl.h"
28 #include "wx/toolbar.h"
29 #include "wx/combobox.h"
30 #include "wx/layout.h"
35 #include "wx/tooltip.h"
37 #include "wx/fontutil.h"
40 #include "wx/thread.h"
45 // FIXME: Due to a hack we use GtkCombo in here, which is deprecated since gtk2.3.0
46 #include <gtk/gtkversion.h>
47 #if defined(GTK_DISABLE_DEPRECATED) && GTK_CHECK_VERSION(2,3,0)
48 #undef GTK_DISABLE_DEPRECATED
49 #include <gtk/gtkcombo.h>
50 #define GTK_DISABLE_DEPRECATED
53 #include "wx/gtk/private.h"
54 #include "wx/gtk/win_gtk.h"
55 #include <gdk/gdkkeysyms.h>
58 //-----------------------------------------------------------------------------
59 // documentation on internals
60 //-----------------------------------------------------------------------------
63 I have been asked several times about writing some documentation about
64 the GTK port of wxWidgets, especially its internal structures. Obviously,
65 you cannot understand wxGTK without knowing a little about the GTK, but
66 some more information about what the wxWindow, which is the base class
67 for all other window classes, does seems required as well.
71 What does wxWindow do? It contains the common interface for the following
72 jobs of its descendants:
74 1) Define the rudimentary behaviour common to all window classes, such as
75 resizing, intercepting user input (so as to make it possible to use these
76 events for special purposes in a derived class), window names etc.
78 2) Provide the possibility to contain and manage children, if the derived
79 class is allowed to contain children, which holds true for those window
80 classes which do not display a native GTK widget. To name them, these
81 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
82 work classes are a special case and are handled a bit differently from
83 the rest. The same holds true for the wxNotebook class.
85 3) Provide the possibility to draw into a client area of a window. This,
86 too, only holds true for classes that do not display a native GTK widget
89 4) Provide the entire mechanism for scrolling widgets. This actual inter-
90 face for this is usually in wxScrolledWindow, but the GTK implementation
93 5) A multitude of helper or extra methods for special purposes, such as
94 Drag'n'Drop, managing validators etc.
96 6) Display a border (sunken, raised, simple or none).
98 Normally one might expect, that one wxWidgets window would always correspond
99 to one GTK widget. Under GTK, there is no such all-round widget that has all
100 the functionality. Moreover, the GTK defines a client area as a different
101 widget from the actual widget you are handling. Last but not least some
102 special classes (e.g. wxFrame) handle different categories of widgets and
103 still have the possibility to draw something in the client area.
104 It was therefore required to write a special purpose GTK widget, that would
105 represent a client area in the sense of wxWidgets capable to do the jobs
106 2), 3) and 4). I have written this class and it resides in win_gtk.c of
109 All windows must have a widget, with which they interact with other under-
110 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
111 the wxWindow class has a member variable called m_widget which holds a
112 pointer to this widget. When the window class represents a GTK native widget,
113 this is (in most cases) the only GTK widget the class manages. E.g. the
114 wxStaticText class handles only a GtkLabel widget a pointer to which you
115 can find in m_widget (defined in wxWindow)
117 When the class has a client area for drawing into and for containing children
118 it has to handle the client area widget (of the type GtkPizza, defined in
119 win_gtk.c), but there could be any number of widgets, handled by a class
120 The common rule for all windows is only, that the widget that interacts with
121 the rest of GTK must be referenced in m_widget and all other widgets must be
122 children of this widget on the GTK level. The top-most widget, which also
123 represents the client area, must be in the m_wxwindow field and must be of
126 As I said, the window classes that display a GTK native widget only have
127 one widget, so in the case of e.g. the wxButton class m_widget holds a
128 pointer to a GtkButton widget. But windows with client areas (for drawing
129 and children) have a m_widget field that is a pointer to a GtkScrolled-
130 Window and a m_wxwindow field that is pointer to a GtkPizza and this
131 one is (in the GTK sense) a child of the GtkScrolledWindow.
133 If the m_wxwindow field is set, then all input to this widget is inter-
134 cepted and sent to the wxWidgets class. If not, all input to the widget
135 that gets pointed to by m_widget gets intercepted and sent to the class.
139 The design of scrolling in wxWidgets is markedly different from that offered
140 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
141 clicking on a scrollbar belonging to scrolled window will inevitably move
142 the window. In wxWidgets, the scrollbar will only emit an event, send this
143 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
144 which actually moves the window and its sub-windows. Note that GtkPizza
145 memorizes how much it has been scrolled but that wxWidgets forgets this
146 so that the two coordinates systems have to be kept in synch. This is done
147 in various places using the pizza->xoffset and pizza->yoffset values.
151 Singularly the most broken code in GTK is the code that is supposed to
152 inform subwindows (child windows) about new positions. Very often, duplicate
153 events are sent without changes in size or position, equally often no
154 events are sent at all (All this is due to a bug in the GtkContainer code
155 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
156 GTK's own system and it simply waits for size events for toplevel windows
157 and then iterates down the respective size events to all window. This has
158 the disadvantage that windows might get size events before the GTK widget
159 actually has the reported size. This doesn't normally pose any problem, but
160 the OpenGL drawing routines rely on correct behaviour. Therefore, I have
161 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
162 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
163 window that is used for OpenGL output really has that size (as reported by
168 If someone at some point of time feels the immense desire to have a look at,
169 change or attempt to optimise the Refresh() logic, this person will need an
170 intimate understanding of what "draw" and "expose" events are and what
171 they are used for, in particular when used in connection with GTK's
172 own windowless widgets. Beware.
176 Cursors, too, have been a constant source of pleasure. The main difficulty
177 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
178 for the parent. To prevent this from doing too much harm, I use idle time
179 to set the cursor over and over again, starting from the toplevel windows
180 and ending with the youngest generation (speaking of parent and 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.
188 //-----------------------------------------------------------------------------
190 //-----------------------------------------------------------------------------
192 // Don't allow event propagation during drag
193 bool g_blockEventsOnDrag
;
194 // Don't allow mouse event propagation during scroll
195 bool g_blockEventsOnScroll
;
196 extern wxCursor g_globalCursor
;
198 // mouse capture state: the window which has it and if the mouse is currently
200 static wxWindowGTK
*g_captureWindow
= (wxWindowGTK
*) NULL
;
201 static bool g_captureWindowHasMouse
= false;
203 wxWindowGTK
*g_focusWindow
= (wxWindowGTK
*) NULL
;
205 // the last window which had the focus - this is normally never NULL (except
206 // if we never had focus at all) as even when g_focusWindow is NULL it still
207 // keeps its previous value
208 wxWindowGTK
*g_focusWindowLast
= (wxWindowGTK
*) NULL
;
210 // If a window get the focus set but has not been realized
211 // yet, defer setting the focus to idle time.
212 wxWindowGTK
*g_delayedFocus
= (wxWindowGTK
*) NULL
;
214 // global variables because GTK+ DnD want to have the
215 // mouse event that caused it
216 GdkEvent
*g_lastMouseEvent
= (GdkEvent
*) NULL
;
217 int g_lastButtonNumber
= 0;
219 extern bool g_mainThreadLocked
;
221 //-----------------------------------------------------------------------------
223 //-----------------------------------------------------------------------------
228 # define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
230 # define DEBUG_MAIN_THREAD
233 #define DEBUG_MAIN_THREAD
236 // the trace mask used for the focus debugging messages
237 #define TRACE_FOCUS _T("focus")
239 //-----------------------------------------------------------------------------
240 // missing gdk functions
241 //-----------------------------------------------------------------------------
244 gdk_window_warp_pointer (GdkWindow
*window
,
249 window
= gdk_get_default_root_window();
251 if (!GDK_WINDOW_DESTROYED(window
))
253 XWarpPointer (GDK_WINDOW_XDISPLAY(window
),
254 None
, /* not source window -> move from anywhere */
255 GDK_WINDOW_XID(window
), /* dest window */
256 0, 0, 0, 0, /* not source window -> move from anywhere */
261 //-----------------------------------------------------------------------------
262 // local code (see below)
263 //-----------------------------------------------------------------------------
265 // returns the child of win which currently has focus or NULL if not found
267 // Note: can't be static, needed by textctrl.cpp.
268 wxWindow
*wxFindFocusedChild(wxWindowGTK
*win
)
270 wxWindow
*winFocus
= wxWindowGTK::FindFocus();
272 return (wxWindow
*)NULL
;
274 if ( winFocus
== win
)
275 return (wxWindow
*)win
;
277 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
279 node
= node
->GetNext() )
281 wxWindow
*child
= wxFindFocusedChild(node
->GetData());
286 return (wxWindow
*)NULL
;
289 static void GetScrollbarWidth(GtkWidget
* widget
, int& w
, int& h
)
291 GtkScrolledWindow
* scroll_window
= GTK_SCROLLED_WINDOW(widget
);
292 GtkScrolledWindowClass
* scroll_class
= GTK_SCROLLED_WINDOW_CLASS(GTK_OBJECT_GET_CLASS(scroll_window
));
293 GtkRequisition scroll_req
;
296 if (scroll_window
->vscrollbar_visible
)
298 scroll_req
.width
= 2;
299 scroll_req
.height
= 2;
300 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
301 (scroll_window
->vscrollbar
, &scroll_req
);
302 w
= scroll_req
.width
+
303 scroll_class
->scrollbar_spacing
;
307 if (scroll_window
->hscrollbar_visible
)
309 scroll_req
.width
= 2;
310 scroll_req
.height
= 2;
311 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
312 (scroll_window
->hscrollbar
, &scroll_req
);
313 h
= scroll_req
.height
+
314 scroll_class
->scrollbar_spacing
;
318 static void draw_frame( GtkWidget
*widget
, wxWindowGTK
*win
)
320 // wxUniversal widgets draw the borders and scrollbars themselves
321 #ifndef __WXUNIVERSAL__
327 if (GTK_WIDGET_NO_WINDOW (widget
))
329 dx
+= widget
->allocation
.x
;
330 dy
+= widget
->allocation
.y
;
338 if (win
->m_hasScrolling
)
340 GetScrollbarWidth(widget
, dw
, dh
);
342 if (win
->GetLayoutDirection() == wxLayout_RightToLeft
)
344 // This is actually wrong for old GTK+ version
345 // which do not display the scrollbar on the
351 int w
= widget
->allocation
.width
-dw
;
352 int h
= widget
->allocation
.height
-dh
;
354 if (win
->HasFlag(wxRAISED_BORDER
))
356 gtk_paint_shadow (widget
->style
,
360 NULL
, NULL
, NULL
, // FIXME: No clipping?
365 if (win
->HasFlag(wxSUNKEN_BORDER
))
367 gtk_paint_shadow (widget
->style
,
371 NULL
, NULL
, NULL
, // FIXME: No clipping?
376 if (win
->HasFlag(wxSIMPLE_BORDER
))
379 gc
= gdk_gc_new( widget
->window
);
380 gdk_gc_set_foreground( gc
, &widget
->style
->black
);
381 gdk_draw_rectangle( widget
->window
, gc
, FALSE
, x
, y
, w
-1, h
-1 );
385 #endif // __WXUNIVERSAL__
388 //-----------------------------------------------------------------------------
389 // "expose_event" of m_widget
390 //-----------------------------------------------------------------------------
394 gtk_window_own_expose_callback( GtkWidget
*widget
,
395 GdkEventExpose
*gdk_event
,
398 if (gdk_event
->count
== 0)
399 draw_frame(widget
, win
);
404 //-----------------------------------------------------------------------------
405 // "size_request" of m_widget
406 //-----------------------------------------------------------------------------
408 // make it extern because wxStaticText needs to disconnect this one
410 void wxgtk_window_size_request_callback(GtkWidget
* WXUNUSED(widget
),
411 GtkRequisition
*requisition
,
415 win
->GetSize( &w
, &h
);
421 requisition
->height
= h
;
422 requisition
->width
= w
;
430 void wxgtk_combo_size_request_callback(GtkWidget
* WXUNUSED(widget
),
431 GtkRequisition
*requisition
,
434 // This callback is actually hooked into the text entry
435 // of the combo box, not the GtkHBox.
438 win
->GetSize( &w
, &h
);
444 GtkCombo
*gcombo
= GTK_COMBO(win
->m_widget
);
446 GtkRequisition entry_req
;
448 entry_req
.height
= 2;
449 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo
->entry
) )->size_request
)
450 (gcombo
->entry
, &entry_req
);
452 GtkRequisition button_req
;
453 button_req
.width
= 2;
454 button_req
.height
= 2;
455 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo
->button
) )->size_request
)
456 (gcombo
->button
, &button_req
);
458 requisition
->width
= w
- button_req
.width
;
459 requisition
->height
= entry_req
.height
;
463 #endif // wxUSE_COMBOBOX
465 //-----------------------------------------------------------------------------
466 // "expose_event" of m_wxwindow
467 //-----------------------------------------------------------------------------
471 gtk_window_expose_callback( GtkWidget
*widget
,
472 GdkEventExpose
*gdk_event
,
477 // This callback gets called in drawing-idle time under
478 // GTK 2.0, so we don't need to defer anything to idle
481 GtkPizza
*pizza
= GTK_PIZZA( widget
);
482 if (gdk_event
->window
!= pizza
->bin_window
)
484 // block expose events on GTK_WIDGET(pizza)->window,
485 // all drawing is done on pizza->bin_window
493 wxPrintf( wxT("OnExpose from ") );
494 if (win
->GetClassInfo() && win
->GetClassInfo()->GetClassName())
495 wxPrintf( win
->GetClassInfo()->GetClassName() );
496 wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event
->area
.x
,
497 (int)gdk_event
->area
.y
,
498 (int)gdk_event
->area
.width
,
499 (int)gdk_event
->area
.height
);
504 win
->m_wxwindow
->style
,
508 (GdkRectangle
*) NULL
,
510 (char *)"button", // const_cast
515 win
->GetUpdateRegion() = wxRegion( gdk_event
->region
);
517 win
->GtkSendPaintEvents();
519 // Let parent window draw window-less widgets
524 //-----------------------------------------------------------------------------
525 // "key_press_event" from any window
526 //-----------------------------------------------------------------------------
528 // These are used when transforming Ctrl-alpha to ascii values 1-26
529 inline bool wxIsLowerChar(int code
)
531 return (code
>= 'a' && code
<= 'z' );
534 inline bool wxIsUpperChar(int code
)
536 return (code
>= 'A' && code
<= 'Z' );
540 // set WXTRACE to this to see the key event codes on the console
541 #define TRACE_KEYS _T("keyevent")
543 // translates an X key symbol to WXK_XXX value
545 // if isChar is true it means that the value returned will be used for EVT_CHAR
546 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
547 // for example, while if it is false it means that the value is going to be
548 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
550 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
556 // Shift, Control and Alt don't generate the CHAR events at all
559 key_code
= isChar
? 0 : WXK_SHIFT
;
563 key_code
= isChar
? 0 : WXK_CONTROL
;
571 key_code
= isChar
? 0 : WXK_ALT
;
574 // neither do the toggle modifies
575 case GDK_Scroll_Lock
:
576 key_code
= isChar
? 0 : WXK_SCROLL
;
580 key_code
= isChar
? 0 : WXK_CAPITAL
;
584 key_code
= isChar
? 0 : WXK_NUMLOCK
;
588 // various other special keys
601 case GDK_ISO_Left_Tab
:
608 key_code
= WXK_RETURN
;
612 key_code
= WXK_CLEAR
;
616 key_code
= WXK_PAUSE
;
620 key_code
= WXK_SELECT
;
624 key_code
= WXK_PRINT
;
628 key_code
= WXK_EXECUTE
;
632 key_code
= WXK_ESCAPE
;
635 // cursor and other extended keyboard keys
637 key_code
= WXK_DELETE
;
653 key_code
= WXK_RIGHT
;
660 case GDK_Prior
: // == GDK_Page_Up
661 key_code
= WXK_PAGEUP
;
664 case GDK_Next
: // == GDK_Page_Down
665 key_code
= WXK_PAGEDOWN
;
677 key_code
= WXK_INSERT
;
692 key_code
= (isChar
? '0' : WXK_NUMPAD0
) + keysym
- GDK_KP_0
;
696 key_code
= isChar
? ' ' : WXK_NUMPAD_SPACE
;
700 key_code
= isChar
? WXK_TAB
: WXK_NUMPAD_TAB
;
704 key_code
= isChar
? WXK_RETURN
: WXK_NUMPAD_ENTER
;
708 key_code
= isChar
? WXK_F1
: WXK_NUMPAD_F1
;
712 key_code
= isChar
? WXK_F2
: WXK_NUMPAD_F2
;
716 key_code
= isChar
? WXK_F3
: WXK_NUMPAD_F3
;
720 key_code
= isChar
? WXK_F4
: WXK_NUMPAD_F4
;
724 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_HOME
;
728 key_code
= isChar
? WXK_LEFT
: WXK_NUMPAD_LEFT
;
732 key_code
= isChar
? WXK_UP
: WXK_NUMPAD_UP
;
736 key_code
= isChar
? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
740 key_code
= isChar
? WXK_DOWN
: WXK_NUMPAD_DOWN
;
743 case GDK_KP_Prior
: // == GDK_KP_Page_Up
744 key_code
= isChar
? WXK_PAGEUP
: WXK_NUMPAD_PAGEUP
;
747 case GDK_KP_Next
: // == GDK_KP_Page_Down
748 key_code
= isChar
? WXK_PAGEDOWN
: WXK_NUMPAD_PAGEDOWN
;
752 key_code
= isChar
? WXK_END
: WXK_NUMPAD_END
;
756 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_BEGIN
;
760 key_code
= isChar
? WXK_INSERT
: WXK_NUMPAD_INSERT
;
764 key_code
= isChar
? WXK_DELETE
: WXK_NUMPAD_DELETE
;
768 key_code
= isChar
? '=' : WXK_NUMPAD_EQUAL
;
771 case GDK_KP_Multiply
:
772 key_code
= isChar
? '*' : WXK_NUMPAD_MULTIPLY
;
776 key_code
= isChar
? '+' : WXK_NUMPAD_ADD
;
779 case GDK_KP_Separator
:
780 // FIXME: what is this?
781 key_code
= isChar
? '.' : WXK_NUMPAD_SEPARATOR
;
784 case GDK_KP_Subtract
:
785 key_code
= isChar
? '-' : WXK_NUMPAD_SUBTRACT
;
789 key_code
= isChar
? '.' : WXK_NUMPAD_DECIMAL
;
793 key_code
= isChar
? '/' : WXK_NUMPAD_DIVIDE
;
810 key_code
= WXK_F1
+ keysym
- GDK_F1
;
820 static inline bool wxIsAsciiKeysym(KeySym ks
)
825 static void wxFillOtherKeyEventFields(wxKeyEvent
& event
,
827 GdkEventKey
*gdk_event
)
831 GdkModifierType state
;
832 if (gdk_event
->window
)
833 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
835 event
.SetTimestamp( gdk_event
->time
);
836 event
.SetId(win
->GetId());
837 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
838 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
839 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
840 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
) != 0;
841 event
.m_scanCode
= gdk_event
->keyval
;
842 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
843 event
.m_rawFlags
= 0;
845 event
.m_uniChar
= gdk_keyval_to_unicode(gdk_event
->keyval
);
847 wxGetMousePosition( &x
, &y
);
848 win
->ScreenToClient( &x
, &y
);
851 event
.SetEventObject( win
);
856 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
858 GdkEventKey
*gdk_event
)
860 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
861 // but only event->keyval which is quite useless to us, so remember
862 // the last character from GDK_KEY_PRESS and reuse it as last resort
864 // NB: should be MT-safe as we're always called from the main thread only
869 } s_lastKeyPress
= { 0, 0 };
871 KeySym keysym
= gdk_event
->keyval
;
873 wxLogTrace(TRACE_KEYS
, _T("Key %s event: keysym = %ld"),
874 event
.GetEventType() == wxEVT_KEY_UP
? _T("release")
878 long key_code
= wxTranslateKeySymToWXKey(keysym
, false /* !isChar */);
882 // do we have the translation or is it a plain ASCII character?
883 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
885 // we should use keysym if it is ASCII as X does some translations
886 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
887 // which we don't want here (but which we do use for OnChar())
888 if ( !wxIsAsciiKeysym(keysym
) )
890 keysym
= (KeySym
)gdk_event
->string
[0];
893 // we want to always get the same key code when the same key is
894 // pressed regardless of the state of the modifiers, i.e. on a
895 // standard US keyboard pressing '5' or '%' ('5' key with
896 // Shift) should result in the same key code in OnKeyDown():
897 // '5' (although OnChar() will get either '5' or '%').
899 // to do it we first translate keysym to keycode (== scan code)
900 // and then back but always using the lower register
901 Display
*dpy
= (Display
*)wxGetDisplay();
902 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
904 wxLogTrace(TRACE_KEYS
, _T("\t-> keycode %d"), keycode
);
906 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
908 // use the normalized, i.e. lower register, keysym if we've
910 key_code
= keysymNormalized
? keysymNormalized
: keysym
;
912 // as explained above, we want to have lower register key codes
913 // normally but for the letter keys we want to have the upper ones
915 // NB: don't use XConvertCase() here, we want to do it for letters
917 key_code
= toupper(key_code
);
919 else // non ASCII key, what to do?
921 // by default, ignore it
924 // but if we have cached information from the last KEY_PRESS
925 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
928 if ( keysym
== s_lastKeyPress
.keysym
)
930 key_code
= s_lastKeyPress
.keycode
;
935 if ( gdk_event
->type
== GDK_KEY_PRESS
)
937 // remember it to be reused for KEY_UP event later
938 s_lastKeyPress
.keysym
= keysym
;
939 s_lastKeyPress
.keycode
= key_code
;
943 wxLogTrace(TRACE_KEYS
, _T("\t-> wxKeyCode %ld"), key_code
);
945 // sending unknown key events doesn't really make sense
949 // now fill all the other fields
950 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
952 event
.m_keyCode
= key_code
;
954 if ( gdk_event
->type
== GDK_KEY_PRESS
|| gdk_event
->type
== GDK_KEY_RELEASE
)
956 event
.m_uniChar
= key_code
;
966 GtkIMContext
*context
;
967 GdkEventKey
*lastKeyEvent
;
971 context
= gtk_im_multicontext_new();
976 g_object_unref (context
);
982 gtk_window_key_press_callback( GtkWidget
*widget
,
983 GdkEventKey
*gdk_event
,
990 if (g_blockEventsOnDrag
)
993 // GTK+ sends keypress events to the focus widget and then
994 // to all its parent and grandparent widget. We only want
995 // the key events from the focus widget.
996 if (!GTK_WIDGET_HAS_FOCUS(widget
))
999 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1001 bool return_after_IM
= false;
1003 if( wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1005 // Emit KEY_DOWN event
1006 ret
= win
->GetEventHandler()->ProcessEvent( event
);
1010 // Return after IM processing as we cannot do
1011 // anything with it anyhow.
1012 return_after_IM
= true;
1015 if ((!ret
) && (win
->m_imData
!= NULL
))
1017 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
1018 // docs, if IM filter returns true, no further processing should be done.
1019 // we should send the key_down event anyway.
1020 bool intercepted_by_IM
= gtk_im_context_filter_keypress(win
->m_imData
->context
, gdk_event
);
1021 win
->m_imData
->lastKeyEvent
= NULL
;
1022 if (intercepted_by_IM
)
1024 wxLogTrace(TRACE_KEYS
, _T("Key event intercepted by IM"));
1029 if (return_after_IM
)
1035 wxWindowGTK
*ancestor
= win
;
1038 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
1041 wxCommandEvent
command_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
1042 ret
= ancestor
->GetEventHandler()->ProcessEvent( command_event
);
1045 if (ancestor
->IsTopLevel())
1047 ancestor
= ancestor
->GetParent();
1050 #endif // wxUSE_ACCEL
1052 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1053 // will only be sent if it is not in an accelerator table.
1057 KeySym keysym
= gdk_event
->keyval
;
1058 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1059 key_code
= wxTranslateKeySymToWXKey(keysym
, true /* isChar */);
1062 if ( wxIsAsciiKeysym(keysym
) )
1065 key_code
= (unsigned char)keysym
;
1067 // gdk_event->string is actually deprecated
1068 else if ( gdk_event
->length
== 1 )
1070 key_code
= (unsigned char)gdk_event
->string
[0];
1076 wxLogTrace(TRACE_KEYS
, _T("Char event: %ld"), key_code
);
1078 event
.m_keyCode
= key_code
;
1080 // To conform to the docs we need to translate Ctrl-alpha
1081 // characters to values in the range 1-26.
1082 if ( event
.ControlDown() &&
1083 ( wxIsLowerChar(key_code
) || wxIsUpperChar(key_code
) ))
1085 if ( wxIsLowerChar(key_code
) )
1086 event
.m_keyCode
= key_code
- 'a' + 1;
1087 if ( wxIsUpperChar(key_code
) )
1088 event
.m_keyCode
= key_code
- 'A' + 1;
1090 event
.m_uniChar
= event
.m_keyCode
;
1094 // Implement OnCharHook by checking ancestor top level windows
1095 wxWindow
*parent
= win
;
1096 while (parent
&& !parent
->IsTopLevel())
1097 parent
= parent
->GetParent();
1100 event
.SetEventType( wxEVT_CHAR_HOOK
);
1101 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1106 event
.SetEventType(wxEVT_CHAR
);
1107 ret
= win
->GetEventHandler()->ProcessEvent( event
);
1118 gtk_wxwindow_commit_cb (GtkIMContext
* WXUNUSED(context
),
1122 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1124 // take modifiers, cursor position, timestamp etc. from the last
1125 // key_press_event that was fed into Input Method:
1126 if (window
->m_imData
->lastKeyEvent
)
1128 wxFillOtherKeyEventFields(event
,
1129 window
, window
->m_imData
->lastKeyEvent
);
1133 event
.SetEventObject( window
);
1136 const wxString
data(wxGTK_CONV_BACK_SYS(str
));
1142 // Implement OnCharHook by checking ancestor top level windows
1143 wxWindow
*parent
= window
;
1144 while (parent
&& !parent
->IsTopLevel())
1145 parent
= parent
->GetParent();
1147 for( wxString::const_iterator pstr
= data
.begin(); pstr
!= data
.end(); ++pstr
)
1150 event
.m_uniChar
= *pstr
;
1151 // Backward compatible for ISO-8859-1
1152 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
1153 wxLogTrace(TRACE_KEYS
, _T("IM sent character '%c'"), event
.m_uniChar
);
1155 event
.m_keyCode
= (char)*pstr
;
1156 #endif // wxUSE_UNICODE
1158 // To conform to the docs we need to translate Ctrl-alpha
1159 // characters to values in the range 1-26.
1160 if ( event
.ControlDown() &&
1161 ( wxIsLowerChar(*pstr
) || wxIsUpperChar(*pstr
) ))
1163 if ( wxIsLowerChar(*pstr
) )
1164 event
.m_keyCode
= *pstr
- 'a' + 1;
1165 if ( wxIsUpperChar(*pstr
) )
1166 event
.m_keyCode
= *pstr
- 'A' + 1;
1168 event
.m_keyCode
= *pstr
- 'a' + 1;
1170 event
.m_uniChar
= event
.m_keyCode
;
1176 event
.SetEventType( wxEVT_CHAR_HOOK
);
1177 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1182 event
.SetEventType(wxEVT_CHAR
);
1183 ret
= window
->GetEventHandler()->ProcessEvent( event
);
1190 //-----------------------------------------------------------------------------
1191 // "key_release_event" from any window
1192 //-----------------------------------------------------------------------------
1196 gtk_window_key_release_callback( GtkWidget
* WXUNUSED(widget
),
1197 GdkEventKey
*gdk_event
,
1205 if (g_blockEventsOnDrag
)
1208 wxKeyEvent
event( wxEVT_KEY_UP
);
1209 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1211 // unknown key pressed, ignore (the event would be useless anyhow)
1215 return win
->GTKProcessEvent(event
);
1219 // ============================================================================
1221 // ============================================================================
1223 // ----------------------------------------------------------------------------
1224 // mouse event processing helpers
1225 // ----------------------------------------------------------------------------
1227 // init wxMouseEvent with the info from GdkEventXXX struct
1228 template<typename T
> void InitMouseEvent(wxWindowGTK
*win
,
1229 wxMouseEvent
& event
,
1232 event
.SetTimestamp( gdk_event
->time
);
1233 event
.m_shiftDown
= gdk_event
->state
& GDK_SHIFT_MASK
;
1234 event
.m_controlDown
= gdk_event
->state
& GDK_CONTROL_MASK
;
1235 event
.m_altDown
= gdk_event
->state
& GDK_MOD1_MASK
;
1236 event
.m_metaDown
= gdk_event
->state
& GDK_MOD2_MASK
;
1237 event
.m_leftDown
= gdk_event
->state
& GDK_BUTTON1_MASK
;
1238 event
.m_middleDown
= gdk_event
->state
& GDK_BUTTON2_MASK
;
1239 event
.m_rightDown
= gdk_event
->state
& GDK_BUTTON3_MASK
;
1240 event
.m_aux1Down
= gdk_event
->state
& GDK_BUTTON4_MASK
;
1241 event
.m_aux2Down
= gdk_event
->state
& GDK_BUTTON5_MASK
;
1243 wxPoint pt
= win
->GetClientAreaOrigin();
1244 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1245 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1247 if ((win
->m_wxwindow
) && (win
->GetLayoutDirection() == wxLayout_RightToLeft
))
1249 // origin in the upper right corner
1250 int window_width
= gtk_pizza_get_rtl_offset( GTK_PIZZA(win
->m_wxwindow
) );
1251 event
.m_x
= window_width
- event
.m_x
;
1254 event
.SetEventObject( win
);
1255 event
.SetId( win
->GetId() );
1256 event
.SetTimestamp( gdk_event
->time
);
1259 static void AdjustEventButtonState(wxMouseEvent
& event
)
1261 // GDK reports the old state of the button for a button press event, but
1262 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1263 // for a LEFT_DOWN event, not FALSE, so we will invert
1264 // left/right/middleDown for the corresponding click events
1266 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1267 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1268 (event
.GetEventType() == wxEVT_LEFT_UP
))
1270 event
.m_leftDown
= !event
.m_leftDown
;
1274 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1275 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1276 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1278 event
.m_middleDown
= !event
.m_middleDown
;
1282 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1283 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1284 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1286 event
.m_rightDown
= !event
.m_rightDown
;
1291 // find the window to send the mouse event too
1293 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1298 if (win
->m_wxwindow
)
1300 GtkPizza
*pizza
= GTK_PIZZA(win
->m_wxwindow
);
1301 xx
+= gtk_pizza_get_xoffset( pizza
);
1302 yy
+= gtk_pizza_get_yoffset( pizza
);
1305 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
1308 wxWindowGTK
*child
= node
->GetData();
1310 node
= node
->GetNext();
1311 if (!child
->IsShown())
1314 if (child
->IsTransparentForMouse())
1316 // wxStaticBox is transparent in the box itself
1317 int xx1
= child
->m_x
;
1318 int yy1
= child
->m_y
;
1319 int xx2
= child
->m_x
+ child
->m_width
;
1320 int yy2
= child
->m_y
+ child
->m_height
;
1323 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1325 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1327 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1329 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1340 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1341 (child
->m_x
<= xx
) &&
1342 (child
->m_y
<= yy
) &&
1343 (child
->m_x
+child
->m_width
>= xx
) &&
1344 (child
->m_y
+child
->m_height
>= yy
))
1357 // ----------------------------------------------------------------------------
1358 // common event handlers helpers
1359 // ----------------------------------------------------------------------------
1361 bool wxWindowGTK::GTKProcessEvent(wxEvent
& event
) const
1363 // nothing special at this level
1364 return GetEventHandler()->ProcessEvent(event
);
1367 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny
*event
) const
1373 if (g_blockEventsOnDrag
)
1375 if (g_blockEventsOnScroll
)
1378 if (!GTKIsOwnWindow(event
->window
))
1384 // overloads for all GDK event types we use here: we need to have this as
1385 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1386 // derives from it in the sense that the structs have the same layout
1387 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1388 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1390 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1393 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton
)
1394 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion
)
1395 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing
)
1397 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1399 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1400 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1404 // send the wxChildFocusEvent and wxFocusEvent, common code of
1405 // gtk_window_focus_in_callback() and SetFocus()
1406 static bool DoSendFocusEvents(wxWindow
*win
)
1408 // Notify the parent keeping track of focus for the kbd navigation
1409 // purposes that we got it.
1410 wxChildFocusEvent
eventChildFocus(win
);
1411 (void)win
->GetEventHandler()->ProcessEvent(eventChildFocus
);
1413 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, win
->GetId());
1414 eventFocus
.SetEventObject(win
);
1416 return win
->GetEventHandler()->ProcessEvent(eventFocus
);
1419 // all event handlers must have C linkage as they're called from GTK+ C code
1423 //-----------------------------------------------------------------------------
1424 // "button_press_event"
1425 //-----------------------------------------------------------------------------
1428 gtk_window_button_press_callback( GtkWidget
*widget
,
1429 GdkEventButton
*gdk_event
,
1432 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1434 g_lastButtonNumber
= gdk_event
->button
;
1436 // GDK sends surplus button down events
1437 // before a double click event. We
1438 // need to filter these out.
1439 if ((gdk_event
->type
== GDK_BUTTON_PRESS
) && (win
->m_wxwindow
))
1441 GdkEvent
*peek_event
= gdk_event_peek();
1444 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1445 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1447 gdk_event_free( peek_event
);
1452 gdk_event_free( peek_event
);
1457 wxEventType event_type
= wxEVT_NULL
;
1459 // GdkDisplay is a GTK+ 2.2.0 thing
1460 #if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0)
1461 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1462 !gtk_check_version(2,2,0) &&
1463 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1465 // Reset GDK internal timestamp variables in order to disable GDK
1466 // triple click events. GDK will then next time believe no button has
1467 // been clicked just before, and send a normal button click event.
1468 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1469 display
->button_click_time
[1] = 0;
1470 display
->button_click_time
[0] = 0;
1474 if (gdk_event
->button
== 1)
1476 // note that GDK generates triple click events which are not supported
1477 // by wxWidgets but still have to be passed to the app as otherwise
1478 // clicks would simply go missing
1479 switch (gdk_event
->type
)
1481 // we shouldn't get triple clicks at all for GTK2 because we
1482 // suppress them artificially using the code above but we still
1483 // should map them to something for GTK1 and not just ignore them
1484 // as this would lose clicks
1485 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1486 case GDK_BUTTON_PRESS
:
1487 event_type
= wxEVT_LEFT_DOWN
;
1490 case GDK_2BUTTON_PRESS
:
1491 event_type
= wxEVT_LEFT_DCLICK
;
1495 // just to silence gcc warnings
1499 else if (gdk_event
->button
== 2)
1501 switch (gdk_event
->type
)
1503 case GDK_3BUTTON_PRESS
:
1504 case GDK_BUTTON_PRESS
:
1505 event_type
= wxEVT_MIDDLE_DOWN
;
1508 case GDK_2BUTTON_PRESS
:
1509 event_type
= wxEVT_MIDDLE_DCLICK
;
1516 else if (gdk_event
->button
== 3)
1518 switch (gdk_event
->type
)
1520 case GDK_3BUTTON_PRESS
:
1521 case GDK_BUTTON_PRESS
:
1522 event_type
= wxEVT_RIGHT_DOWN
;
1525 case GDK_2BUTTON_PRESS
:
1526 event_type
= wxEVT_RIGHT_DCLICK
;
1534 if ( event_type
== wxEVT_NULL
)
1536 // unknown mouse button or click type
1540 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1542 wxMouseEvent
event( event_type
);
1543 InitMouseEvent( win
, event
, gdk_event
);
1545 AdjustEventButtonState(event
);
1547 // wxListBox actually gets mouse events from the item, so we need to give it
1548 // a chance to correct this
1549 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1551 // find the correct window to send the event to: it may be a different one
1552 // from the one which got it at GTK+ level because some controls don't have
1553 // their own X window and thus cannot get any events.
1554 if ( !g_captureWindow
)
1555 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1557 // reset the event object and id in case win changed.
1558 event
.SetEventObject( win
);
1559 event
.SetId( win
->GetId() );
1561 bool ret
= win
->GTKProcessEvent( event
);
1562 g_lastMouseEvent
= NULL
;
1566 if ((event_type
== wxEVT_LEFT_DOWN
) && !win
->IsOfStandardClass() &&
1567 (g_focusWindow
!= win
) /* && win->IsFocusable() */)
1572 if (event_type
== wxEVT_RIGHT_DOWN
)
1574 // generate a "context menu" event: this is similar to right mouse
1575 // click under many GUIs except that it is generated differently
1576 // (right up under MSW, ctrl-click under Mac, right down here) and
1578 // (a) it's a command event and so is propagated to the parent
1579 // (b) under some ports it can be generated from kbd too
1580 // (c) it uses screen coords (because of (a))
1581 wxContextMenuEvent
evtCtx(
1584 win
->ClientToScreen(event
.GetPosition()));
1585 evtCtx
.SetEventObject(win
);
1586 return win
->GTKProcessEvent(evtCtx
);
1592 //-----------------------------------------------------------------------------
1593 // "button_release_event"
1594 //-----------------------------------------------------------------------------
1597 gtk_window_button_release_callback( GtkWidget
*widget
,
1598 GdkEventButton
*gdk_event
,
1601 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1603 g_lastButtonNumber
= 0;
1605 wxEventType event_type
= wxEVT_NULL
;
1607 switch (gdk_event
->button
)
1610 event_type
= wxEVT_LEFT_UP
;
1614 event_type
= wxEVT_MIDDLE_UP
;
1618 event_type
= wxEVT_RIGHT_UP
;
1622 // unknown button, don't process
1626 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1628 wxMouseEvent
event( event_type
);
1629 InitMouseEvent( win
, event
, gdk_event
);
1631 AdjustEventButtonState(event
);
1633 // same wxListBox hack as above
1634 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1636 if ( !g_captureWindow
)
1637 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1639 // reset the event object and id in case win changed.
1640 event
.SetEventObject( win
);
1641 event
.SetId( win
->GetId() );
1643 bool ret
= win
->GTKProcessEvent(event
);
1645 g_lastMouseEvent
= NULL
;
1650 //-----------------------------------------------------------------------------
1651 // "motion_notify_event"
1652 //-----------------------------------------------------------------------------
1655 gtk_window_motion_notify_callback( GtkWidget
* WXUNUSED(widget
),
1656 GdkEventMotion
*gdk_event
,
1659 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1661 if (gdk_event
->is_hint
)
1665 GdkModifierType state
;
1666 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1671 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1673 wxMouseEvent
event( wxEVT_MOTION
);
1674 InitMouseEvent(win
, event
, gdk_event
);
1676 if ( g_captureWindow
)
1678 // synthesise a mouse enter or leave event if needed
1679 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1680 // This seems to be necessary and actually been added to
1681 // GDK itself in version 2.0.X
1684 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1685 if ( hasMouse
!= g_captureWindowHasMouse
)
1687 // the mouse changed window
1688 g_captureWindowHasMouse
= hasMouse
;
1690 wxMouseEvent
eventM(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1691 : wxEVT_LEAVE_WINDOW
);
1692 InitMouseEvent(win
, eventM
, gdk_event
);
1693 eventM
.SetEventObject(win
);
1694 win
->GTKProcessEvent(eventM
);
1699 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1701 // reset the event object and id in case win changed.
1702 event
.SetEventObject( win
);
1703 event
.SetId( win
->GetId() );
1706 if ( !g_captureWindow
)
1708 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1709 if (win
->GTKProcessEvent( cevent
))
1711 win
->SetCursor( cevent
.GetCursor() );
1715 bool ret
= win
->GTKProcessEvent(event
);
1717 g_lastMouseEvent
= NULL
;
1722 //-----------------------------------------------------------------------------
1723 // "scroll_event" (mouse wheel event)
1724 //-----------------------------------------------------------------------------
1727 window_scroll_event(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1731 if (gdk_event
->direction
!= GDK_SCROLL_UP
&&
1732 gdk_event
->direction
!= GDK_SCROLL_DOWN
)
1737 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1738 InitMouseEvent(win
, event
, gdk_event
);
1739 event
.m_linesPerAction
= 3;
1740 event
.m_wheelDelta
= 120;
1741 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1742 event
.m_wheelRotation
= 120;
1744 event
.m_wheelRotation
= -120;
1746 return win
->GTKProcessEvent(event
);
1749 //-----------------------------------------------------------------------------
1751 //-----------------------------------------------------------------------------
1753 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
1755 wxContextMenuEvent
event(wxEVT_CONTEXT_MENU
, win
->GetId(), wxPoint(-1, -1));
1756 event
.SetEventObject(win
);
1757 return win
->GTKProcessEvent(event
);
1760 //-----------------------------------------------------------------------------
1762 //-----------------------------------------------------------------------------
1765 gtk_window_focus_in_callback( GtkWidget
* WXUNUSED(widget
),
1766 GdkEventFocus
*WXUNUSED(event
),
1772 gtk_im_context_focus_in(win
->m_imData
->context
);
1775 g_focusWindow
= win
;
1777 wxLogTrace(TRACE_FOCUS
,
1778 _T("%s: focus in"), win
->GetName().c_str());
1781 // caret needs to be informed about focus change
1782 wxCaret
*caret
= win
->GetCaret();
1785 caret
->OnSetFocus();
1787 #endif // wxUSE_CARET
1789 gboolean ret
= FALSE
;
1791 // does the window itself think that it has the focus?
1792 if ( !win
->m_hasFocus
)
1794 // not yet, notify it
1795 win
->m_hasFocus
= true;
1797 (void)DoSendFocusEvents(win
);
1802 // Disable default focus handling for custom windows
1803 // since the default GTK+ handler issues a repaint
1804 if (win
->m_wxwindow
)
1810 //-----------------------------------------------------------------------------
1811 // "focus_out_event"
1812 //-----------------------------------------------------------------------------
1815 gtk_window_focus_out_callback( GtkWidget
* WXUNUSED(widget
),
1816 GdkEventFocus
* WXUNUSED(gdk_event
),
1822 gtk_im_context_focus_out(win
->m_imData
->context
);
1824 wxLogTrace( TRACE_FOCUS
,
1825 _T("%s: focus out"), win
->GetName().c_str() );
1828 wxWindowGTK
*winFocus
= wxFindFocusedChild(win
);
1832 g_focusWindow
= (wxWindowGTK
*)NULL
;
1835 // caret needs to be informed about focus change
1836 wxCaret
*caret
= win
->GetCaret();
1839 caret
->OnKillFocus();
1841 #endif // wxUSE_CARET
1843 // don't send the window a kill focus event if it thinks that it doesn't
1844 // have focus already
1845 if ( win
->m_hasFocus
)
1847 // the event handler might delete the window when it loses focus, so
1848 // check whether this is a custom window before calling it
1849 const bool has_wxwindow
= win
->m_wxwindow
!= NULL
;
1851 win
->m_hasFocus
= false;
1853 wxFocusEvent
event( wxEVT_KILL_FOCUS
, win
->GetId() );
1854 event
.SetEventObject( win
);
1856 (void)win
->GTKProcessEvent( event
);
1858 // Disable default focus handling for custom windows
1859 // since the default GTK+ handler issues a repaint
1864 // continue with normal processing
1869 wx_window_focus_callback(GtkWidget
*widget
,
1870 GtkDirectionType
WXUNUSED(direction
),
1873 // the default handler for focus signal in GtkPizza (or, rather, in
1874 // GtkScrolledWindow from which GtkPizza inherits this behaviour) sets
1875 // focus to the window itself even if it doesn't accept focus, i.e. has no
1876 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1877 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1878 // any children which might accept focus (we know we don't accept the focus
1879 // ourselves as this signal is only connected in this case)
1880 if ( win
->GetChildren().empty() )
1881 g_signal_stop_emission_by_name(widget
, "focus");
1883 // we didn't change the focus
1887 //-----------------------------------------------------------------------------
1888 // "enter_notify_event"
1889 //-----------------------------------------------------------------------------
1892 gtk_window_enter_callback( GtkWidget
*widget
,
1893 GdkEventCrossing
*gdk_event
,
1896 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1898 // Event was emitted after a grab
1899 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1903 GdkModifierType state
= (GdkModifierType
)0;
1905 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1907 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1908 InitMouseEvent(win
, event
, gdk_event
);
1909 wxPoint pt
= win
->GetClientAreaOrigin();
1910 event
.m_x
= x
+ pt
.x
;
1911 event
.m_y
= y
+ pt
.y
;
1913 if ( !g_captureWindow
)
1915 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1916 if (win
->GTKProcessEvent( cevent
))
1918 win
->SetCursor( cevent
.GetCursor() );
1922 return win
->GTKProcessEvent(event
);
1925 //-----------------------------------------------------------------------------
1926 // "leave_notify_event"
1927 //-----------------------------------------------------------------------------
1930 gtk_window_leave_callback( GtkWidget
*widget
,
1931 GdkEventCrossing
*gdk_event
,
1934 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1936 // Event was emitted after an ungrab
1937 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1939 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1943 GdkModifierType state
= (GdkModifierType
)0;
1945 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1947 InitMouseEvent(win
, event
, gdk_event
);
1949 return win
->GTKProcessEvent(event
);
1952 //-----------------------------------------------------------------------------
1953 // "value_changed" from scrollbar
1954 //-----------------------------------------------------------------------------
1957 gtk_scrollbar_value_changed(GtkRange
* range
, wxWindow
* win
)
1959 wxEventType eventType
= win
->GetScrollEventType(range
);
1960 if (eventType
!= wxEVT_NULL
)
1962 // Convert scroll event type to scrollwin event type
1963 eventType
+= wxEVT_SCROLLWIN_TOP
- wxEVT_SCROLL_TOP
;
1965 // find the scrollbar which generated the event
1966 wxWindowGTK::ScrollDir dir
= win
->ScrollDirFromRange(range
);
1968 // generate the corresponding wx event
1969 const int orient
= wxWindow::OrientFromScrollDir(dir
);
1970 wxScrollWinEvent
event(eventType
, win
->GetScrollPos(orient
), orient
);
1971 event
.SetEventObject(win
);
1973 win
->GTKProcessEvent(event
);
1977 //-----------------------------------------------------------------------------
1978 // "button_press_event" from scrollbar
1979 //-----------------------------------------------------------------------------
1982 gtk_scrollbar_button_press_event(GtkRange
*, GdkEventButton
*, wxWindow
* win
)
1986 g_blockEventsOnScroll
= true;
1987 win
->m_mouseButtonDown
= true;
1992 //-----------------------------------------------------------------------------
1993 // "event_after" from scrollbar
1994 //-----------------------------------------------------------------------------
1997 gtk_scrollbar_event_after(GtkRange
* range
, GdkEvent
* event
, wxWindow
* win
)
1999 if (event
->type
== GDK_BUTTON_RELEASE
)
2001 g_signal_handlers_block_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
2003 const int orient
= wxWindow::OrientFromScrollDir(
2004 win
->ScrollDirFromRange(range
));
2005 wxScrollWinEvent
evt(wxEVT_SCROLLWIN_THUMBRELEASE
,
2006 win
->GetScrollPos(orient
), orient
);
2007 evt
.SetEventObject(win
);
2008 win
->GTKProcessEvent(evt
);
2012 //-----------------------------------------------------------------------------
2013 // "button_release_event" from scrollbar
2014 //-----------------------------------------------------------------------------
2017 gtk_scrollbar_button_release_event(GtkRange
* range
, GdkEventButton
*, wxWindow
* win
)
2021 g_blockEventsOnScroll
= false;
2022 win
->m_mouseButtonDown
= false;
2023 // If thumb tracking
2024 if (win
->m_isScrolling
)
2026 win
->m_isScrolling
= false;
2027 // Hook up handler to send thumb release event after this emission is finished.
2028 // To allow setting scroll position from event handler, sending event must
2029 // be deferred until after the GtkRange handler for this signal has run
2030 g_signal_handlers_unblock_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
2036 //-----------------------------------------------------------------------------
2037 // "realize" from m_widget
2038 //-----------------------------------------------------------------------------
2041 gtk_window_realized_callback( GtkWidget
*m_widget
, wxWindow
*win
)
2047 GtkPizza
*pizza
= GTK_PIZZA( m_widget
);
2048 gtk_im_context_set_client_window( win
->m_imData
->context
,
2049 pizza
->bin_window
);
2052 // We cannot set colours and fonts before the widget
2053 // been realized, so we do this directly after realization
2054 // or otherwise in idle time
2056 if (win
->m_needsStyleChange
)
2058 win
->SetBackgroundStyle(win
->GetBackgroundStyle());
2059 win
->m_needsStyleChange
= false;
2062 wxWindowCreateEvent
event( win
);
2063 event
.SetEventObject( win
);
2064 win
->GTKProcessEvent( event
);
2067 //-----------------------------------------------------------------------------
2069 //-----------------------------------------------------------------------------
2072 void gtk_window_size_callback( GtkWidget
*WXUNUSED(widget
),
2073 GtkAllocation
* WXUNUSED(alloc
),
2076 int client_width
= 0;
2077 int client_height
= 0;
2078 win
->GetClientSize( &client_width
, &client_height
);
2079 if ((client_width
== win
->m_oldClientWidth
) && (client_height
== win
->m_oldClientHeight
))
2082 if ( !client_width
&& !client_height
)
2084 // the window is currently unmapped, don't generate size events
2088 win
->m_oldClientWidth
= client_width
;
2089 win
->m_oldClientHeight
= client_height
;
2091 if (!win
->m_nativeSizeEvent
)
2093 wxSizeEvent
event( win
->GetSize(), win
->GetId() );
2094 event
.SetEventObject( win
);
2095 win
->GTKProcessEvent( event
);
2099 //-----------------------------------------------------------------------------
2101 //-----------------------------------------------------------------------------
2103 #if GTK_CHECK_VERSION(2, 8, 0)
2105 gtk_window_grab_broken( GtkWidget
*,
2106 GdkEventGrabBroken
*event
,
2109 // Mouse capture has been lost involuntarily, notify the application
2110 if(!event
->keyboard
&& wxWindow::GetCapture() == win
)
2112 wxMouseCaptureLostEvent
evt( win
->GetId() );
2113 evt
.SetEventObject( win
);
2114 win
->GetEventHandler()->ProcessEvent( evt
);
2122 // ----------------------------------------------------------------------------
2123 // this wxWindowBase function is implemented here (in platform-specific file)
2124 // because it is static and so couldn't be made virtual
2125 // ----------------------------------------------------------------------------
2127 wxWindow
*wxWindowBase::DoFindFocus()
2129 // the cast is necessary when we compile in wxUniversal mode
2130 return (wxWindow
*)g_focusWindow
;
2133 //-----------------------------------------------------------------------------
2134 // InsertChild for wxWindowGTK.
2135 //-----------------------------------------------------------------------------
2137 /* Callback for wxWindowGTK. This very strange beast has to be used because
2138 * C++ has no virtual methods in a constructor. We have to emulate a
2139 * virtual function here as wxNotebook requires a different way to insert
2140 * a child in it. I had opted for creating a wxNotebookPage window class
2141 * which would have made this superfluous (such in the MDI window system),
2142 * but no-one was listening to me... */
2144 static void wxInsertChildInWindow( wxWindowGTK
* parent
, wxWindowGTK
* child
)
2146 /* the window might have been scrolled already, do we
2147 have to adapt the position */
2148 GtkPizza
*pizza
= GTK_PIZZA(parent
->m_wxwindow
);
2149 child
->m_x
+= gtk_pizza_get_xoffset( pizza
);
2150 child
->m_y
+= gtk_pizza_get_yoffset( pizza
);
2152 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
2160 //-----------------------------------------------------------------------------
2162 //-----------------------------------------------------------------------------
2164 wxWindow
*wxGetActiveWindow()
2166 return wxWindow::FindFocus();
2170 wxMouseState
wxGetMouseState()
2176 GdkModifierType mask
;
2178 gdk_window_get_pointer(NULL
, &x
, &y
, &mask
);
2182 ms
.SetLeftDown(mask
& GDK_BUTTON1_MASK
);
2183 ms
.SetMiddleDown(mask
& GDK_BUTTON2_MASK
);
2184 ms
.SetRightDown(mask
& GDK_BUTTON3_MASK
);
2185 ms
.SetAux1Down(mask
& GDK_BUTTON4_MASK
);
2186 ms
.SetAux2Down(mask
& GDK_BUTTON5_MASK
);
2188 ms
.SetControlDown(mask
& GDK_CONTROL_MASK
);
2189 ms
.SetShiftDown(mask
& GDK_SHIFT_MASK
);
2190 ms
.SetAltDown(mask
& GDK_MOD1_MASK
);
2191 ms
.SetMetaDown(mask
& GDK_MOD2_MASK
);
2196 //-----------------------------------------------------------------------------
2198 //-----------------------------------------------------------------------------
2200 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2202 #ifdef __WXUNIVERSAL__
2203 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2205 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
2206 #endif // __WXUNIVERSAL__/__WXGTK__
2208 void wxWindowGTK::Init()
2211 m_widget
= (GtkWidget
*) NULL
;
2212 m_wxwindow
= (GtkWidget
*) NULL
;
2213 m_focusWidget
= (GtkWidget
*) NULL
;
2222 m_isBeingDeleted
= false;
2224 m_showOnIdle
= false;
2227 m_nativeSizeEvent
= false;
2229 m_hasScrolling
= false;
2230 m_isScrolling
= false;
2231 m_mouseButtonDown
= false;
2233 // initialize scrolling stuff
2234 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2236 m_scrollBar
[dir
] = NULL
;
2237 m_scrollPos
[dir
] = 0;
2241 m_oldClientHeight
= 0;
2245 m_insertCallback
= wxInsertChildInWindow
;
2249 m_clipPaintRegion
= false;
2251 m_needsStyleChange
= false;
2253 m_cursor
= *wxSTANDARD_CURSOR
;
2256 m_dirtyTabOrder
= false;
2259 wxWindowGTK::wxWindowGTK()
2264 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2269 const wxString
&name
)
2273 Create( parent
, id
, pos
, size
, style
, name
);
2276 bool wxWindowGTK::Create( wxWindow
*parent
,
2281 const wxString
&name
)
2283 if (!PreCreation( parent
, pos
, size
) ||
2284 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2286 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2290 if (!HasFlag(wxHSCROLL
) && !HasFlag(wxVSCROLL
))
2292 m_wxwindow
= gtk_pizza_new_no_scroll();
2294 #ifndef __WXUNIVERSAL__
2295 if (HasFlag(wxSIMPLE_BORDER
))
2296 gtk_container_set_border_width((GtkContainer
*)m_wxwindow
, 1);
2297 else if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
2298 gtk_container_set_border_width((GtkContainer
*)m_wxwindow
, 2);
2299 #endif // __WXUNIVERSAL__
2301 m_widget
= m_wxwindow
;
2305 m_wxwindow
= gtk_pizza_new();
2307 #ifndef __WXUNIVERSAL__
2308 if (HasFlag(wxSIMPLE_BORDER
))
2309 gtk_container_set_border_width((GtkContainer
*)m_wxwindow
, 1);
2310 else if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
2311 gtk_container_set_border_width((GtkContainer
*)m_wxwindow
, 2);
2312 #endif // __WXUNIVERSAL__
2314 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
2316 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2318 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2319 scroll_class
->scrollbar_spacing
= 0;
2321 // There is a conflict with default bindings at GTK+
2322 // level between scrolled windows and notebooks both of which want to use
2323 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2324 // direction and notebooks for changing pages -- we decide that if we don't
2325 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2326 // means we can get working keyboard navigation in notebooks
2327 if ( !HasFlag(wxHSCROLL
) )
2330 bindings
= gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget
));
2333 gtk_binding_entry_remove(bindings
, GDK_Page_Up
, GDK_CONTROL_MASK
);
2334 gtk_binding_entry_remove(bindings
, GDK_Page_Down
, GDK_CONTROL_MASK
);
2338 if (HasFlag(wxALWAYS_SHOW_SB
))
2340 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_ALWAYS
, GTK_POLICY_ALWAYS
);
2342 scrolledWindow
->hscrollbar_visible
= TRUE
;
2343 scrolledWindow
->vscrollbar_visible
= TRUE
;
2347 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2350 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(scrolledWindow
->hscrollbar
);
2351 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(scrolledWindow
->vscrollbar
);
2352 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2353 gtk_range_set_inverted( m_scrollBar
[ScrollDir_Horz
], TRUE
);
2355 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2357 // connect various scroll-related events
2358 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2360 // these handlers block mouse events to any window during scrolling
2361 // such as motion events and prevent GTK and wxWidgets from fighting
2362 // over where the slider should be
2363 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2364 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2365 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2366 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2368 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2369 G_CALLBACK(gtk_scrollbar_event_after
), this);
2370 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2372 // these handlers get notified when scrollbar slider moves
2373 g_signal_connect_after(m_scrollBar
[dir
], "value_changed",
2374 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2377 gtk_widget_show( m_wxwindow
);
2381 m_parent
->DoAddChild( this );
2383 m_focusWidget
= m_wxwindow
;
2390 wxWindowGTK::~wxWindowGTK()
2394 if (g_focusWindow
== this)
2395 g_focusWindow
= NULL
;
2397 if ( g_delayedFocus
== this )
2398 g_delayedFocus
= NULL
;
2400 m_isBeingDeleted
= true;
2403 // destroy children before destroying this window itself
2406 // unhook focus handlers to prevent stray events being
2407 // propagated to this (soon to be) dead object
2408 if (m_focusWidget
!= NULL
)
2410 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2411 (gpointer
) gtk_window_focus_in_callback
,
2413 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2414 (gpointer
) gtk_window_focus_out_callback
,
2421 // delete before the widgets to avoid a crash on solaris
2424 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
2426 gtk_widget_destroy( m_wxwindow
);
2427 m_wxwindow
= (GtkWidget
*) NULL
;
2432 gtk_widget_destroy( m_widget
);
2433 m_widget
= (GtkWidget
*) NULL
;
2437 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2439 if ( GTKNeedsParent() )
2441 wxCHECK_MSG( parent
, false, wxT("Must have non-NULL parent") );
2444 // Use either the given size, or the default if -1 is given.
2445 // See wxWindowBase for these functions.
2446 m_width
= WidthDefault(size
.x
) ;
2447 m_height
= HeightDefault(size
.y
);
2455 void wxWindowGTK::PostCreation()
2457 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2463 // these get reported to wxWidgets -> wxPaintEvent
2465 g_signal_connect (m_wxwindow
, "expose_event",
2466 G_CALLBACK (gtk_window_expose_callback
), this);
2468 if (GetLayoutDirection() == wxLayout_LeftToRight
)
2469 gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow
), HasFlag( wxFULL_REPAINT_ON_RESIZE
) );
2472 // Create input method handler
2473 m_imData
= new wxGtkIMData
;
2475 // Cannot handle drawing preedited text yet
2476 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2478 g_signal_connect (m_imData
->context
, "commit",
2479 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2481 // these are called when the "sunken" or "raised" borders are drawn
2482 g_signal_connect (m_widget
, "expose_event",
2483 G_CALLBACK (gtk_window_own_expose_callback
), this);
2488 if (!GTK_IS_WINDOW(m_widget
))
2490 if (m_focusWidget
== NULL
)
2491 m_focusWidget
= m_widget
;
2495 g_signal_connect (m_focusWidget
, "focus_in_event",
2496 G_CALLBACK (gtk_window_focus_in_callback
), this);
2497 g_signal_connect (m_focusWidget
, "focus_out_event",
2498 G_CALLBACK (gtk_window_focus_out_callback
), this);
2502 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2503 G_CALLBACK (gtk_window_focus_in_callback
), this);
2504 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2505 G_CALLBACK (gtk_window_focus_out_callback
), this);
2509 if ( !AcceptsFocusFromKeyboard() )
2513 g_signal_connect(m_widget
, "focus",
2514 G_CALLBACK(wx_window_focus_callback
), this);
2517 // connect to the various key and mouse handlers
2519 GtkWidget
*connect_widget
= GetConnectWidget();
2521 ConnectWidget( connect_widget
);
2523 /* We cannot set colours, fonts and cursors before the widget has
2524 been realized, so we do this directly after realization */
2525 g_signal_connect (connect_widget
, "realize",
2526 G_CALLBACK (gtk_window_realized_callback
), this);
2530 // Catch native resize events
2531 g_signal_connect (m_wxwindow
, "size_allocate",
2532 G_CALLBACK (gtk_window_size_callback
), this);
2533 #if GTK_CHECK_VERSION(2, 8, 0)
2534 if (!gtk_check_version(2,8,0))
2536 // Make sure we can notify the app when mouse capture is lost
2537 g_signal_connect (m_wxwindow
, "grab_broken_event",
2538 G_CALLBACK (gtk_window_grab_broken
), this);
2543 if ( connect_widget
!= m_wxwindow
)
2545 #if GTK_CHECK_VERSION(2, 8, 0)
2546 if (!gtk_check_version(2,8,0))
2548 // Make sure we can notify app code when mouse capture is lost
2549 g_signal_connect (connect_widget
, "grab_broken_event",
2550 G_CALLBACK (gtk_window_grab_broken
), this);
2556 if (GTK_IS_COMBO(m_widget
))
2558 GtkCombo
*gcombo
= GTK_COMBO(m_widget
);
2560 g_signal_connect (gcombo
->entry
, "size_request",
2561 G_CALLBACK (wxgtk_combo_size_request_callback
),
2564 #endif // wxUSE_COMBOBOX
2565 #ifdef GTK_IS_FILE_CHOOSER_BUTTON
2566 if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget
))
2568 // If we connect to the "size_request" signal of a GtkFileChooserButton
2569 // then that control won't be sized properly when placed inside sizers
2570 // (this can be tested removing this elseif and running XRC or WIDGETS samples)
2571 // FIXME: what should be done here ?
2574 if ( !IsTopLevel() ) // top level windows use their own callback
2576 // This is needed if we want to add our windows into native
2577 // GTK controls, such as the toolbar. With this callback, the
2578 // toolbar gets to know the correct size (the one set by the
2579 // programmer). Sadly, it misbehaves for wxComboBox.
2580 g_signal_connect (m_widget
, "size_request",
2581 G_CALLBACK (wxgtk_window_size_request_callback
),
2585 InheritAttributes();
2589 SetLayoutDirection(wxLayout_Default
);
2591 // unless the window was created initially hidden (i.e. Hide() had been
2592 // called before Create()), we should show it at GTK+ level as well
2594 gtk_widget_show( m_widget
);
2597 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2599 g_signal_connect (widget
, "key_press_event",
2600 G_CALLBACK (gtk_window_key_press_callback
), this);
2601 g_signal_connect (widget
, "key_release_event",
2602 G_CALLBACK (gtk_window_key_release_callback
), this);
2603 g_signal_connect (widget
, "button_press_event",
2604 G_CALLBACK (gtk_window_button_press_callback
), this);
2605 g_signal_connect (widget
, "button_release_event",
2606 G_CALLBACK (gtk_window_button_release_callback
), this);
2607 g_signal_connect (widget
, "motion_notify_event",
2608 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2609 g_signal_connect (widget
, "scroll_event",
2610 G_CALLBACK (window_scroll_event
), this);
2611 g_signal_connect (widget
, "popup_menu",
2612 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2613 g_signal_connect (widget
, "enter_notify_event",
2614 G_CALLBACK (gtk_window_enter_callback
), this);
2615 g_signal_connect (widget
, "leave_notify_event",
2616 G_CALLBACK (gtk_window_leave_callback
), this);
2619 bool wxWindowGTK::Destroy()
2621 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2625 return wxWindowBase::Destroy();
2628 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2630 // inform the parent to perform the move
2631 gtk_pizza_set_size( GTK_PIZZA(m_parent
->m_wxwindow
), m_widget
, x
, y
, width
, height
);
2635 void wxWindowGTK::ConstrainSize()
2638 // GPE's window manager doesn't like size hints at all, esp. when the user
2639 // has to use the virtual keyboard, so don't constrain size there
2643 const wxSize minSize
= GetMinSize();
2644 const wxSize maxSize
= GetMaxSize();
2645 if (minSize
.x
> 0 && m_width
< minSize
.x
) m_width
= minSize
.x
;
2646 if (minSize
.y
> 0 && m_height
< minSize
.y
) m_height
= minSize
.y
;
2647 if (maxSize
.x
> 0 && m_width
> maxSize
.x
) m_width
= maxSize
.x
;
2648 if (maxSize
.y
> 0 && m_height
> maxSize
.y
) m_height
= maxSize
.y
;
2652 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2654 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2655 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2657 if (m_resizing
) return; /* I don't like recursions */
2660 int currentX
, currentY
;
2661 GetPosition(¤tX
, ¤tY
);
2662 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2664 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2666 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2668 // calculate the best size if we should auto size the window
2669 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2670 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2672 const wxSize sizeBest
= GetBestSize();
2673 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2675 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2676 height
= sizeBest
.y
;
2686 #if wxUSE_TOOLBAR_NATIVE
2687 if (wxDynamicCast(GetParent(), wxToolBar
))
2689 // don't take the x,y values, they're wrong because toolbar sets them
2690 GtkWidget
*widget
= m_widget
;
2691 gtk_widget_set_size_request (widget
, m_width
, m_height
);
2695 if (m_parent
->m_wxwindow
== NULL
) // i.e. wxNotebook
2697 // don't set the size for children of wxNotebook, just take the values.
2705 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
2706 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
2708 if (x
!= -1) m_x
= x
+ gtk_pizza_get_xoffset( pizza
);
2709 if (y
!= -1) m_y
= y
+ gtk_pizza_get_yoffset( pizza
);
2713 m_x
= x
+ gtk_pizza_get_xoffset( pizza
);
2714 m_y
= y
+ gtk_pizza_get_yoffset( pizza
);
2717 int left_border
= 0;
2718 int right_border
= 0;
2720 int bottom_border
= 0;
2722 /* the default button has a border around it */
2723 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
2725 GtkBorder
*default_border
= NULL
;
2726 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2729 left_border
+= default_border
->left
;
2730 right_border
+= default_border
->right
;
2731 top_border
+= default_border
->top
;
2732 bottom_border
+= default_border
->bottom
;
2733 gtk_border_free( default_border
);
2737 DoMoveWindow( m_x
- left_border
,
2739 m_width
+left_border
+right_border
,
2740 m_height
+top_border
+bottom_border
);
2745 /* Sometimes the client area changes size without the
2746 whole windows's size changing, but if the whole
2747 windows's size doesn't change, no wxSizeEvent will
2748 normally be sent. Here we add an extra test if
2749 the client test has been changed and this will
2751 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2755 wxPrintf( "OnSize sent from " );
2756 if (GetClassInfo() && GetClassInfo()->GetClassName())
2757 wxPrintf( GetClassInfo()->GetClassName() );
2758 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2761 if (!m_nativeSizeEvent
)
2763 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2764 event
.SetEventObject( this );
2765 GetEventHandler()->ProcessEvent( event
);
2771 bool wxWindowGTK::GtkShowFromOnIdle()
2773 if (IsShown() && m_showOnIdle
&& !GTK_WIDGET_VISIBLE (m_widget
))
2775 GtkAllocation alloc
;
2778 alloc
.width
= m_width
;
2779 alloc
.height
= m_height
;
2780 gtk_widget_size_allocate( m_widget
, &alloc
);
2781 gtk_widget_show( m_widget
);
2782 wxShowEvent
eventShow(GetId(), true);
2783 eventShow
.SetEventObject(this);
2784 GetEventHandler()->ProcessEvent(eventShow
);
2785 m_showOnIdle
= false;
2792 void wxWindowGTK::OnInternalIdle()
2794 // Check if we have to show window now
2795 if (GtkShowFromOnIdle()) return;
2797 if ( m_dirtyTabOrder
)
2799 m_dirtyTabOrder
= false;
2803 // Update style if the window was not yet realized
2804 // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
2805 if (m_needsStyleChange
)
2807 SetBackgroundStyle(GetBackgroundStyle());
2808 m_needsStyleChange
= false;
2811 wxCursor cursor
= m_cursor
;
2812 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
2816 /* I now set the cursor anew in every OnInternalIdle call
2817 as setting the cursor in a parent window also effects the
2818 windows above so that checking for the current cursor is
2821 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
2823 GdkWindow
*window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2825 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2827 if (!g_globalCursor
.Ok())
2828 cursor
= *wxSTANDARD_CURSOR
;
2830 window
= m_widget
->window
;
2831 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
2832 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2835 else if ( m_widget
)
2837 GdkWindow
*window
= m_widget
->window
;
2838 if ( window
&& !GTK_WIDGET_NO_WINDOW(m_widget
) )
2839 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2843 if (wxUpdateUIEvent::CanUpdate(this) && IsShown())
2844 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
2847 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
2849 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2851 if (width
) (*width
) = m_width
;
2852 if (height
) (*height
) = m_height
;
2855 void wxWindowGTK::DoSetClientSize( int width
, int height
)
2857 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2859 const wxSize size
= GetSize();
2860 const wxSize clientSize
= GetClientSize();
2861 SetSize(width
+ (size
.x
- clientSize
.x
), height
+ (size
.y
- clientSize
.y
));
2864 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
2866 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2877 GetScrollbarWidth(m_widget
, dw
, dh
);
2879 const int border
= GTK_CONTAINER(m_wxwindow
)->border_width
;
2891 if (width
) *width
= w
;
2892 if (height
) *height
= h
;
2895 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
2897 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2901 if (!IsTopLevel() && m_parent
&& m_parent
->m_wxwindow
)
2903 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
2904 dx
= gtk_pizza_get_xoffset( pizza
);
2905 dy
= gtk_pizza_get_yoffset( pizza
);
2908 if (m_x
== -1 && m_y
== -1)
2910 GdkWindow
*source
= (GdkWindow
*) NULL
;
2912 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2914 source
= m_widget
->window
;
2920 gdk_window_get_origin( source
, &org_x
, &org_y
);
2923 m_parent
->ScreenToClient(&org_x
, &org_y
);
2925 wx_const_cast(wxWindowGTK
*, this)->m_x
= org_x
;
2926 wx_const_cast(wxWindowGTK
*, this)->m_y
= org_y
;
2930 if (x
) (*x
) = m_x
- dx
;
2931 if (y
) (*y
) = m_y
- dy
;
2934 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
2936 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2938 if (!m_widget
->window
) return;
2940 GdkWindow
*source
= (GdkWindow
*) NULL
;
2942 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2944 source
= m_widget
->window
;
2948 gdk_window_get_origin( source
, &org_x
, &org_y
);
2952 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2954 org_x
+= m_widget
->allocation
.x
;
2955 org_y
+= m_widget
->allocation
.y
;
2962 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2963 *x
= (GetClientSize().x
- *x
) + org_x
;
2971 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
2973 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2975 if (!m_widget
->window
) return;
2977 GdkWindow
*source
= (GdkWindow
*) NULL
;
2979 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2981 source
= m_widget
->window
;
2985 gdk_window_get_origin( source
, &org_x
, &org_y
);
2989 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2991 org_x
+= m_widget
->allocation
.x
;
2992 org_y
+= m_widget
->allocation
.y
;
2998 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2999 *x
= (GetClientSize().x
- *x
) - org_x
;
3006 bool wxWindowGTK::Show( bool show
)
3008 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3010 if (!wxWindowBase::Show(show
))
3020 gtk_widget_show( m_widget
);
3021 wxShowEvent
eventShow(GetId(), show
);
3022 eventShow
.SetEventObject(this);
3023 GetEventHandler()->ProcessEvent(eventShow
);
3028 gtk_widget_hide( m_widget
);
3029 wxShowEvent
eventShow(GetId(), show
);
3030 eventShow
.SetEventObject(this);
3031 GetEventHandler()->ProcessEvent(eventShow
);
3037 void wxWindowGTK::DoEnable( bool enable
)
3039 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3041 gtk_widget_set_sensitive( m_widget
, enable
);
3042 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3043 gtk_widget_set_sensitive( m_wxwindow
, enable
);
3046 int wxWindowGTK::GetCharHeight() const
3048 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
3050 wxFont font
= GetFont();
3051 wxCHECK_MSG( font
.Ok(), 12, wxT("invalid font") );
3053 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
3058 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3059 PangoLayout
*layout
= pango_layout_new(context
);
3060 pango_layout_set_font_description(layout
, desc
);
3061 pango_layout_set_text(layout
, "H", 1);
3062 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3064 PangoRectangle rect
;
3065 pango_layout_line_get_extents(line
, NULL
, &rect
);
3067 g_object_unref (layout
);
3069 return (int) PANGO_PIXELS(rect
.height
);
3072 int wxWindowGTK::GetCharWidth() const
3074 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
3076 wxFont font
= GetFont();
3077 wxCHECK_MSG( font
.Ok(), 8, wxT("invalid font") );
3079 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
3084 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3085 PangoLayout
*layout
= pango_layout_new(context
);
3086 pango_layout_set_font_description(layout
, desc
);
3087 pango_layout_set_text(layout
, "g", 1);
3088 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3090 PangoRectangle rect
;
3091 pango_layout_line_get_extents(line
, NULL
, &rect
);
3093 g_object_unref (layout
);
3095 return (int) PANGO_PIXELS(rect
.width
);
3098 void wxWindowGTK::GetTextExtent( const wxString
& string
,
3102 int *externalLeading
,
3103 const wxFont
*theFont
) const
3105 wxFont fontToUse
= theFont
? *theFont
: GetFont();
3107 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
3116 PangoContext
*context
= NULL
;
3118 context
= gtk_widget_get_pango_context( m_widget
);
3127 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3128 PangoLayout
*layout
= pango_layout_new(context
);
3129 pango_layout_set_font_description(layout
, desc
);
3131 const wxCharBuffer data
= wxGTK_CONV( string
);
3133 pango_layout_set_text(layout
, data
, strlen(data
));
3136 PangoRectangle rect
;
3137 pango_layout_get_extents(layout
, NULL
, &rect
);
3139 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
3140 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
3143 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
3144 int baseline
= pango_layout_iter_get_baseline(iter
);
3145 pango_layout_iter_free(iter
);
3146 *descent
= *y
- PANGO_PIXELS(baseline
);
3148 if (externalLeading
) (*externalLeading
) = 0; // ??
3150 g_object_unref (layout
);
3153 bool wxWindowGTK::GTKSetDelayedFocusIfNeeded()
3155 if ( g_delayedFocus
== this )
3157 if ( GTK_WIDGET_REALIZED(m_widget
) )
3159 gtk_widget_grab_focus(m_widget
);
3160 g_delayedFocus
= NULL
;
3169 void wxWindowGTK::SetFocus()
3171 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3174 // don't do anything if we already have focus
3180 // wxWindow::SetFocus() should really set the focus to
3181 // this control, whatever the flags are
3182 if (!GTK_WIDGET_CAN_FOCUS(m_wxwindow
))
3183 GTK_WIDGET_SET_FLAGS(m_wxwindow
, GTK_CAN_FOCUS
);
3185 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow
))
3187 gtk_widget_grab_focus (m_wxwindow
);
3192 // wxWindow::SetFocus() should really set the focus to
3193 // this control, whatever the flags are
3194 if (!GTK_WIDGET_CAN_FOCUS(m_widget
))
3195 GTK_WIDGET_SET_FLAGS(m_widget
, GTK_CAN_FOCUS
);
3197 if (GTK_IS_CONTAINER(m_widget
))
3199 if (GTK_IS_RADIO_BUTTON(m_widget
))
3201 gtk_widget_grab_focus (m_widget
);
3205 gtk_widget_child_focus( m_widget
, GTK_DIR_TAB_FORWARD
);
3208 if (GTK_WIDGET_CAN_FOCUS(m_widget
) && !GTK_WIDGET_HAS_FOCUS (m_widget
) )
3211 if (!GTK_WIDGET_REALIZED(m_widget
))
3213 // we can't set the focus to the widget now so we remember that
3214 // it should be focused and will do it later, during the idle
3215 // time, as soon as we can
3216 wxLogTrace(TRACE_FOCUS
,
3217 _T("Delaying setting focus to %s(%s)"),
3218 GetClassInfo()->GetClassName(), GetLabel().c_str());
3220 g_delayedFocus
= this;
3224 wxLogTrace(TRACE_FOCUS
,
3225 _T("Setting focus to %s(%s)"),
3226 GetClassInfo()->GetClassName(), GetLabel().c_str());
3228 gtk_widget_grab_focus (m_widget
);
3233 wxLogTrace(TRACE_FOCUS
,
3234 _T("Can't set focus to %s(%s)"),
3235 GetClassInfo()->GetClassName(), GetLabel().c_str());
3240 void wxWindowGTK::SetCanFocus(bool canFocus
)
3243 GTK_WIDGET_SET_FLAGS(m_widget
, GTK_CAN_FOCUS
);
3245 GTK_WIDGET_UNSET_FLAGS(m_widget
, GTK_CAN_FOCUS
);
3247 if ( m_wxwindow
&& (m_widget
!= m_wxwindow
) )
3250 GTK_WIDGET_SET_FLAGS(m_wxwindow
, GTK_CAN_FOCUS
);
3252 GTK_WIDGET_UNSET_FLAGS(m_wxwindow
, GTK_CAN_FOCUS
);
3256 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3258 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3260 wxWindowGTK
*oldParent
= m_parent
,
3261 *newParent
= (wxWindowGTK
*)newParentBase
;
3263 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3265 if ( !wxWindowBase::Reparent(newParent
) )
3268 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3270 /* prevent GTK from deleting the widget arbitrarily */
3271 gtk_widget_ref( m_widget
);
3275 gtk_container_remove( GTK_CONTAINER(m_widget
->parent
), m_widget
);
3278 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3282 if (GTK_WIDGET_VISIBLE (newParent
->m_widget
))
3284 m_showOnIdle
= true;
3285 gtk_widget_hide( m_widget
);
3288 /* insert GTK representation */
3289 (*(newParent
->m_insertCallback
))(newParent
, this);
3292 /* reverse: prevent GTK from deleting the widget arbitrarily */
3293 gtk_widget_unref( m_widget
);
3295 SetLayoutDirection(wxLayout_Default
);
3300 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3302 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3303 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3308 /* insert GTK representation */
3309 (*m_insertCallback
)(this, child
);
3312 void wxWindowGTK::AddChild(wxWindowBase
*child
)
3314 wxWindowBase::AddChild(child
);
3315 m_dirtyTabOrder
= true;
3316 wxTheApp
->WakeUpIdle();
3319 void wxWindowGTK::RemoveChild(wxWindowBase
*child
)
3321 wxWindowBase::RemoveChild(child
);
3322 m_dirtyTabOrder
= true;
3323 wxTheApp
->WakeUpIdle();
3327 wxLayoutDirection
wxWindowGTK::GTKGetLayout(GtkWidget
*widget
)
3329 return gtk_widget_get_direction(widget
) == GTK_TEXT_DIR_RTL
3330 ? wxLayout_RightToLeft
3331 : wxLayout_LeftToRight
;
3335 void wxWindowGTK::GTKSetLayout(GtkWidget
*widget
, wxLayoutDirection dir
)
3337 wxASSERT_MSG( dir
!= wxLayout_Default
, _T("invalid layout direction") );
3339 gtk_widget_set_direction(widget
,
3340 dir
== wxLayout_RightToLeft
? GTK_TEXT_DIR_RTL
3341 : GTK_TEXT_DIR_LTR
);
3344 wxLayoutDirection
wxWindowGTK::GetLayoutDirection() const
3346 return GTKGetLayout(m_widget
);
3349 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir
)
3351 if ( dir
== wxLayout_Default
)
3353 const wxWindow
*const parent
= GetParent();
3356 // inherit layout from parent.
3357 dir
= parent
->GetLayoutDirection();
3359 else // no parent, use global default layout
3361 dir
= wxTheApp
->GetLayoutDirection();
3365 if ( dir
== wxLayout_Default
)
3368 GTKSetLayout(m_widget
, dir
);
3370 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3371 GTKSetLayout(m_wxwindow
, dir
);
3375 wxWindowGTK::AdjustForLayoutDirection(wxCoord x
,
3376 wxCoord
WXUNUSED(width
),
3377 wxCoord
WXUNUSED(widthTotal
)) const
3379 // We now mirrors the coordinates of RTL windows in GtkPizza
3383 void wxWindowGTK::DoMoveInTabOrder(wxWindow
*win
, MoveKind move
)
3385 wxWindowBase::DoMoveInTabOrder(win
, move
);
3386 m_dirtyTabOrder
= true;
3387 wxTheApp
->WakeUpIdle();
3390 bool wxWindowGTK::DoNavigateIn(int flags
)
3392 if ( flags
& wxNavigationKeyEvent::WinChange
)
3394 wxFAIL_MSG( _T("not implemented") );
3398 else // navigate inside the container
3400 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3401 wxCHECK_MSG( parent
, false, _T("every window must have a TLW parent") );
3403 GtkDirectionType dir
;
3404 dir
= flags
& wxNavigationKeyEvent::IsForward
? GTK_DIR_TAB_FORWARD
3405 : GTK_DIR_TAB_BACKWARD
;
3408 g_signal_emit_by_name(parent
->m_widget
, "focus", dir
, &rc
);
3414 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3416 // none needed by default
3420 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3422 // nothing to do by default since none is needed
3425 void wxWindowGTK::RealizeTabOrder()
3429 if ( !m_children
.empty() )
3431 // we don't only construct the correct focus chain but also use
3432 // this opportunity to update the mnemonic widgets for the widgets
3435 GList
*chain
= NULL
;
3436 wxWindowGTK
* mnemonicWindow
= NULL
;
3438 for ( wxWindowList::const_iterator i
= m_children
.begin();
3439 i
!= m_children
.end();
3442 wxWindowGTK
*win
= *i
;
3444 if ( mnemonicWindow
)
3446 if ( win
->AcceptsFocusFromKeyboard() )
3448 // wxComboBox et al. needs to focus on on a different
3449 // widget than m_widget, so if the main widget isn't
3450 // focusable try the connect widget
3451 GtkWidget
* w
= win
->m_widget
;
3452 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3454 w
= win
->GetConnectWidget();
3455 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3461 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3462 mnemonicWindow
= NULL
;
3466 else if ( win
->GTKWidgetNeedsMnemonic() )
3468 mnemonicWindow
= win
;
3471 chain
= g_list_prepend(chain
, win
->m_widget
);
3474 chain
= g_list_reverse(chain
);
3476 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3481 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3486 void wxWindowGTK::Raise()
3488 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3490 if (m_wxwindow
&& m_wxwindow
->window
)
3492 gdk_window_raise( m_wxwindow
->window
);
3494 else if (m_widget
->window
)
3496 gdk_window_raise( m_widget
->window
);
3500 void wxWindowGTK::Lower()
3502 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3504 if (m_wxwindow
&& m_wxwindow
->window
)
3506 gdk_window_lower( m_wxwindow
->window
);
3508 else if (m_widget
->window
)
3510 gdk_window_lower( m_widget
->window
);
3514 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3516 if ( !wxWindowBase::SetCursor(cursor
.Ok() ? cursor
: *wxSTANDARD_CURSOR
) )
3524 void wxWindowGTK::GTKUpdateCursor()
3526 wxCursor
cursor(g_globalCursor
.Ok() ? g_globalCursor
: GetCursor());
3529 wxArrayGdkWindows windowsThis
;
3530 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
3533 gdk_window_set_cursor(winThis
, cursor
.GetCursor());
3537 const size_t count
= windowsThis
.size();
3538 for ( size_t n
= 0; n
< count
; n
++ )
3540 GdkWindow
*win
= windowsThis
[n
];
3543 wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?"));
3547 gdk_window_set_cursor(win
, cursor
.GetCursor());
3553 void wxWindowGTK::WarpPointer( int x
, int y
)
3555 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3557 // We provide this function ourselves as it is
3558 // missing in GDK (top of this file).
3560 GdkWindow
*window
= (GdkWindow
*) NULL
;
3562 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3564 window
= GetConnectWidget()->window
;
3567 gdk_window_warp_pointer( window
, x
, y
);
3570 wxWindowGTK::ScrollDir
wxWindowGTK::ScrollDirFromRange(GtkRange
*range
) const
3572 // find the scrollbar which generated the event
3573 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3575 if ( range
== m_scrollBar
[dir
] )
3576 return (ScrollDir
)dir
;
3579 wxFAIL_MSG( _T("event from unknown scrollbar received") );
3581 return ScrollDir_Max
;
3584 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3586 bool changed
= false;
3587 GtkRange
* range
= m_scrollBar
[dir
];
3588 if ( range
&& units
)
3590 GtkAdjustment
* adj
= range
->adjustment
;
3591 gdouble inc
= unit
== ScrollUnit_Line
? adj
->step_increment
3592 : adj
->page_increment
;
3594 const int posOld
= int(adj
->value
+ 0.5);
3595 gtk_range_set_value(range
, posOld
+ units
*inc
);
3597 changed
= int(adj
->value
+ 0.5) != posOld
;
3603 bool wxWindowGTK::ScrollLines(int lines
)
3605 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3608 bool wxWindowGTK::ScrollPages(int pages
)
3610 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3613 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground
),
3618 if (!m_widget
->window
)
3623 if (!GTK_PIZZA(m_wxwindow
)->bin_window
) return;
3625 GdkRectangle gdk_rect
,
3629 gdk_rect
.x
= rect
->x
;
3630 gdk_rect
.y
= rect
->y
;
3631 gdk_rect
.width
= rect
->width
;
3632 gdk_rect
.height
= rect
->height
;
3633 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3634 gdk_rect
.x
= GetClientSize().x
- gdk_rect
.x
- gdk_rect
.width
;
3638 else // invalidate everything
3643 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, p
, TRUE
);
3647 void wxWindowGTK::Update()
3651 // when we call Update() we really want to update the window immediately on
3652 // screen, even if it means flushing the entire queue and hence slowing down
3653 // everything -- but it should still be done, it's just that Update() should
3654 // be called very rarely
3658 void wxWindowGTK::GtkUpdate()
3660 if (m_wxwindow
&& GTK_PIZZA(m_wxwindow
)->bin_window
)
3661 gdk_window_process_updates( GTK_PIZZA(m_wxwindow
)->bin_window
, FALSE
);
3662 if (m_widget
&& m_widget
->window
&& (m_wxwindow
!= m_widget
))
3663 gdk_window_process_updates( m_widget
->window
, FALSE
);
3665 // for consistency with other platforms (and also because it's convenient
3666 // to be able to update an entire TLW by calling Update() only once), we
3667 // should also update all our children here
3668 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3670 node
= node
->GetNext() )
3672 node
->GetData()->GtkUpdate();
3676 bool wxWindowGTK::DoIsExposed( int x
, int y
) const
3678 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
3682 bool wxWindowGTK::DoIsExposed( int x
, int y
, int w
, int h
) const
3684 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3685 return m_updateRegion
.Contains(x
-w
, y
, w
, h
) != wxOutRegion
;
3687 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
3690 void wxWindowGTK::GtkSendPaintEvents()
3694 m_updateRegion
.Clear();
3698 // Clip to paint region in wxClientDC
3699 m_clipPaintRegion
= true;
3701 m_nativeUpdateRegion
= m_updateRegion
;
3703 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3705 // Transform m_updateRegion under RTL
3706 m_updateRegion
.Clear();
3709 gdk_window_get_geometry( GTK_PIZZA(m_wxwindow
)->bin_window
,
3710 NULL
, NULL
, &width
, NULL
, NULL
);
3712 wxRegionIterator
upd( m_nativeUpdateRegion
);
3716 rect
.x
= upd
.GetX();
3717 rect
.y
= upd
.GetY();
3718 rect
.width
= upd
.GetWidth();
3719 rect
.height
= upd
.GetHeight();
3721 rect
.x
= width
- rect
.x
- rect
.width
;
3722 m_updateRegion
.Union( rect
);
3728 // widget to draw on
3729 GtkPizza
*pizza
= GTK_PIZZA (m_wxwindow
);
3731 if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM
))
3733 // find ancestor from which to steal background
3734 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3736 parent
= (wxWindow
*)this;
3738 if (GTK_WIDGET_MAPPED(parent
->m_widget
))
3740 wxRegionIterator
upd( m_nativeUpdateRegion
);
3744 rect
.x
= upd
.GetX();
3745 rect
.y
= upd
.GetY();
3746 rect
.width
= upd
.GetWidth();
3747 rect
.height
= upd
.GetHeight();
3749 gtk_paint_flat_box( parent
->m_widget
->style
,
3751 (GtkStateType
)GTK_WIDGET_STATE(m_wxwindow
),
3764 wxWindowDC
dc( (wxWindow
*)this );
3765 dc
.SetClippingRegion( m_updateRegion
);
3767 wxEraseEvent
erase_event( GetId(), &dc
);
3768 erase_event
.SetEventObject( this );
3770 GetEventHandler()->ProcessEvent(erase_event
);
3773 wxNcPaintEvent
nc_paint_event( GetId() );
3774 nc_paint_event
.SetEventObject( this );
3775 GetEventHandler()->ProcessEvent( nc_paint_event
);
3777 wxPaintEvent
paint_event( GetId() );
3778 paint_event
.SetEventObject( this );
3779 GetEventHandler()->ProcessEvent( paint_event
);
3781 m_clipPaintRegion
= false;
3783 m_updateRegion
.Clear();
3784 m_nativeUpdateRegion
.Clear();
3787 void wxWindowGTK::SetDoubleBuffered( bool on
)
3789 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3792 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3795 bool wxWindowGTK::IsDoubleBuffered() const
3797 return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow
);
3800 void wxWindowGTK::ClearBackground()
3802 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3806 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3808 wxWindowBase::DoSetToolTip(tip
);
3811 m_tooltip
->Apply( (wxWindow
*)this );
3814 void wxWindowGTK::ApplyToolTip( GtkTooltips
*tips
, const gchar
*tip
)
3816 gtk_tooltips_set_tip(tips
, GetConnectWidget(), tip
, NULL
);
3818 #endif // wxUSE_TOOLTIPS
3820 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
3822 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3824 if (!wxWindowBase::SetBackgroundColour(colour
))
3829 // We need the pixel value e.g. for background clearing.
3830 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3833 // apply style change (forceStyle=true so that new style is applied
3834 // even if the bg colour changed from valid to wxNullColour)
3835 if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM
)
3836 ApplyWidgetStyle(true);
3841 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
3843 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3845 if (!wxWindowBase::SetForegroundColour(colour
))
3852 // We need the pixel value e.g. for background clearing.
3853 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3856 // apply style change (forceStyle=true so that new style is applied
3857 // even if the bg colour changed from valid to wxNullColour):
3858 ApplyWidgetStyle(true);
3863 PangoContext
*wxWindowGTK::GtkGetPangoDefaultContext()
3865 return gtk_widget_get_pango_context( m_widget
);
3868 GtkRcStyle
*wxWindowGTK::CreateWidgetStyle(bool forceStyle
)
3870 // do we need to apply any changes at all?
3873 !m_foregroundColour
.Ok() && !m_backgroundColour
.Ok() )
3878 GtkRcStyle
*style
= gtk_rc_style_new();
3883 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
3886 int flagsNormal
= 0,
3889 flagsInsensitive
= 0;
3891 if ( m_foregroundColour
.Ok() )
3893 const GdkColor
*fg
= m_foregroundColour
.GetColor();
3895 style
->fg
[GTK_STATE_NORMAL
] =
3896 style
->text
[GTK_STATE_NORMAL
] = *fg
;
3897 flagsNormal
|= GTK_RC_FG
| GTK_RC_TEXT
;
3899 style
->fg
[GTK_STATE_PRELIGHT
] =
3900 style
->text
[GTK_STATE_PRELIGHT
] = *fg
;
3901 flagsPrelight
|= GTK_RC_FG
| GTK_RC_TEXT
;
3903 style
->fg
[GTK_STATE_ACTIVE
] =
3904 style
->text
[GTK_STATE_ACTIVE
] = *fg
;
3905 flagsActive
|= GTK_RC_FG
| GTK_RC_TEXT
;
3908 if ( m_backgroundColour
.Ok() )
3910 const GdkColor
*bg
= m_backgroundColour
.GetColor();
3912 style
->bg
[GTK_STATE_NORMAL
] =
3913 style
->base
[GTK_STATE_NORMAL
] = *bg
;
3914 flagsNormal
|= GTK_RC_BG
| GTK_RC_BASE
;
3916 style
->bg
[GTK_STATE_PRELIGHT
] =
3917 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
3918 flagsPrelight
|= GTK_RC_BG
| GTK_RC_BASE
;
3920 style
->bg
[GTK_STATE_ACTIVE
] =
3921 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
3922 flagsActive
|= GTK_RC_BG
| GTK_RC_BASE
;
3924 style
->bg
[GTK_STATE_INSENSITIVE
] =
3925 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
3926 flagsInsensitive
|= GTK_RC_BG
| GTK_RC_BASE
;
3929 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)flagsNormal
;
3930 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)flagsPrelight
;
3931 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)flagsActive
;
3932 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)flagsInsensitive
;
3937 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle
)
3939 GtkRcStyle
*style
= CreateWidgetStyle(forceStyle
);
3942 DoApplyWidgetStyle(style
);
3943 gtk_rc_style_unref(style
);
3946 // Style change may affect GTK+'s size calculation:
3947 InvalidateBestSize();
3950 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
3953 gtk_widget_modify_style(m_wxwindow
, style
);
3955 gtk_widget_modify_style(m_widget
, style
);
3958 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style
)
3960 wxWindowBase::SetBackgroundStyle(style
);
3962 if (style
== wxBG_STYLE_CUSTOM
)
3967 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3971 GtkWidget
* const w
= GetConnectWidget();
3972 window
= w
? w
->window
: NULL
;
3977 // Make sure GDK/X11 doesn't refresh the window
3979 gdk_window_set_back_pixmap( window
, None
, False
);
3981 Display
* display
= GDK_WINDOW_DISPLAY(window
);
3984 m_needsStyleChange
= false;
3986 else // window not realized yet
3988 // Do in OnIdle, because the window is not yet available
3989 m_needsStyleChange
= true;
3992 // Don't apply widget style, or we get a grey background
3996 // apply style change (forceStyle=true so that new style is applied
3997 // even if the bg colour changed from valid to wxNullColour):
3998 ApplyWidgetStyle(true);
4003 #if wxUSE_DRAG_AND_DROP
4005 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4007 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4009 GtkWidget
*dnd_widget
= GetConnectWidget();
4011 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
4013 if (m_dropTarget
) delete m_dropTarget
;
4014 m_dropTarget
= dropTarget
;
4016 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
4019 #endif // wxUSE_DRAG_AND_DROP
4021 GtkWidget
* wxWindowGTK::GetConnectWidget()
4023 GtkWidget
*connect_widget
= m_widget
;
4024 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4026 return connect_widget
;
4029 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow
*window
) const
4031 wxArrayGdkWindows windowsThis
;
4032 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
4034 return winThis
? window
== winThis
4035 : windowsThis
.Index(window
) != wxNOT_FOUND
;
4038 GdkWindow
*wxWindowGTK::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
4040 return m_wxwindow
? GTK_PIZZA(m_wxwindow
)->bin_window
: m_widget
->window
;
4043 bool wxWindowGTK::SetFont( const wxFont
&font
)
4045 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4047 if (!wxWindowBase::SetFont(font
))
4050 // apply style change (forceStyle=true so that new style is applied
4051 // even if the font changed from valid to wxNullFont):
4052 ApplyWidgetStyle(true);
4057 void wxWindowGTK::DoCaptureMouse()
4059 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4061 GdkWindow
*window
= (GdkWindow
*) NULL
;
4063 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4065 window
= GetConnectWidget()->window
;
4067 wxCHECK_RET( window
, _T("CaptureMouse() failed") );
4069 const wxCursor
* cursor
= &m_cursor
;
4071 cursor
= wxSTANDARD_CURSOR
;
4073 gdk_pointer_grab( window
, FALSE
,
4075 (GDK_BUTTON_PRESS_MASK
|
4076 GDK_BUTTON_RELEASE_MASK
|
4077 GDK_POINTER_MOTION_HINT_MASK
|
4078 GDK_POINTER_MOTION_MASK
),
4080 cursor
->GetCursor(),
4081 (guint32
)GDK_CURRENT_TIME
);
4082 g_captureWindow
= this;
4083 g_captureWindowHasMouse
= true;
4086 void wxWindowGTK::DoReleaseMouse()
4088 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4090 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4092 g_captureWindow
= (wxWindowGTK
*) NULL
;
4094 GdkWindow
*window
= (GdkWindow
*) NULL
;
4096 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4098 window
= GetConnectWidget()->window
;
4103 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4106 void wxWindowGTK::GTKReleaseMouseAndNotify()
4109 wxMouseCaptureLostEvent
evt(GetId());
4110 evt
.SetEventObject( this );
4111 GetEventHandler()->ProcessEvent( evt
);
4115 wxWindow
*wxWindowBase::GetCapture()
4117 return (wxWindow
*)g_captureWindow
;
4120 bool wxWindowGTK::IsRetained() const
4125 void wxWindowGTK::SetScrollbar(int orient
,
4129 bool WXUNUSED(update
))
4131 const int dir
= ScrollDirFromOrient(orient
);
4132 GtkRange
* const sb
= m_scrollBar
[dir
];
4133 wxCHECK_RET( sb
, _T("this window is not scrollable") );
4137 m_hasScrolling
= true;
4141 // GtkRange requires upper > lower
4146 GtkAdjustment
* const adj
= sb
->adjustment
;
4147 adj
->step_increment
= 1;
4148 adj
->page_increment
=
4149 adj
->page_size
= thumbVisible
;
4152 g_signal_handlers_block_by_func(
4153 sb
, (void*)gtk_scrollbar_value_changed
, this);
4155 gtk_range_set_range(sb
, 0, range
);
4156 m_scrollPos
[dir
] = sb
->adjustment
->value
;
4158 g_signal_handlers_unblock_by_func(
4159 sb
, (void*)gtk_scrollbar_value_changed
, this);
4162 void wxWindowGTK::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4164 const int dir
= ScrollDirFromOrient(orient
);
4165 GtkRange
* const sb
= m_scrollBar
[dir
];
4166 wxCHECK_RET( sb
, _T("this window is not scrollable") );
4168 // This check is more than an optimization. Without it, the slider
4169 // will not move smoothly while tracking when using wxScrollHelper.
4170 if (GetScrollPos(orient
) != pos
)
4172 g_signal_handlers_block_by_func(
4173 sb
, (void*)gtk_scrollbar_value_changed
, this);
4175 gtk_range_set_value(sb
, pos
);
4176 m_scrollPos
[dir
] = sb
->adjustment
->value
;
4178 g_signal_handlers_unblock_by_func(
4179 sb
, (void*)gtk_scrollbar_value_changed
, this);
4183 int wxWindowGTK::GetScrollThumb(int orient
) const
4185 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4186 wxCHECK_MSG( sb
, 0, _T("this window is not scrollable") );
4188 return int(sb
->adjustment
->page_size
);
4191 int wxWindowGTK::GetScrollPos( int orient
) const
4193 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4194 wxCHECK_MSG( sb
, 0, _T("this window is not scrollable") );
4196 return int(sb
->adjustment
->value
+ 0.5);
4199 int wxWindowGTK::GetScrollRange( int orient
) const
4201 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4202 wxCHECK_MSG( sb
, 0, _T("this window is not scrollable") );
4204 return int(sb
->adjustment
->upper
);
4207 // Determine if increment is the same as +/-x, allowing for some small
4208 // difference due to possible inexactness in floating point arithmetic
4209 static inline bool IsScrollIncrement(double increment
, double x
)
4211 wxASSERT(increment
> 0);
4212 const double tolerance
= 1.0 / 1024;
4213 return fabs(increment
- fabs(x
)) < tolerance
;
4216 wxEventType
wxWindowGTK::GetScrollEventType(GtkRange
* range
)
4220 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4222 const int barIndex
= range
== m_scrollBar
[1];
4223 GtkAdjustment
* adj
= range
->adjustment
;
4225 const int value
= int(adj
->value
+ 0.5);
4227 // save previous position
4228 const double oldPos
= m_scrollPos
[barIndex
];
4229 // update current position
4230 m_scrollPos
[barIndex
] = adj
->value
;
4231 // If event should be ignored, or integral position has not changed
4232 if (!m_hasVMT
|| g_blockEventsOnDrag
|| value
== int(oldPos
+ 0.5))
4237 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4240 // Difference from last change event
4241 const double diff
= adj
->value
- oldPos
;
4242 const bool isDown
= diff
> 0;
4244 if (IsScrollIncrement(adj
->step_increment
, diff
))
4246 eventType
= isDown
? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4248 else if (IsScrollIncrement(adj
->page_increment
, diff
))
4250 eventType
= isDown
? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4252 else if (m_mouseButtonDown
)
4254 // Assume track event
4255 m_isScrolling
= true;
4261 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4263 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4265 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4267 // No scrolling requested.
4268 if ((dx
== 0) && (dy
== 0)) return;
4270 m_clipPaintRegion
= true;
4272 if (GetLayoutDirection() == wxLayout_RightToLeft
)
4273 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), dx
, -dy
);
4275 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), -dx
, -dy
);
4277 m_clipPaintRegion
= false;
4280 bool restoreCaret
= (GetCaret() != NULL
&& GetCaret()->IsVisible());
4283 wxRect
caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4285 caretRect
.width
+= dx
;
4288 caretRect
.x
+= dx
; caretRect
.width
-= dx
;
4291 caretRect
.height
+= dy
;
4294 caretRect
.y
+= dy
; caretRect
.height
-= dy
;
4297 RefreshRect(caretRect
);
4299 #endif // wxUSE_CARET
4302 void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4304 //RN: Note that static controls usually have no border on gtk, so maybe
4305 //it makes sense to treat that as simply no border at the wx level
4307 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4309 GtkShadowType gtkstyle
;
4311 if(wxstyle
& wxBORDER_RAISED
)
4312 gtkstyle
= GTK_SHADOW_OUT
;
4313 else if (wxstyle
& wxBORDER_SUNKEN
)
4314 gtkstyle
= GTK_SHADOW_IN
;
4317 else if (wxstyle
& wxBORDER_DOUBLE
)
4318 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4321 gtkstyle
= GTK_SHADOW_IN
;
4323 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4328 void wxWindowGTK::SetWindowStyleFlag( long style
)
4330 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4331 wxWindowBase::SetWindowStyleFlag(style
);
4334 // Find the wxWindow at the current mouse position, also returning the mouse
4336 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4338 pt
= wxGetMousePosition();
4339 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4343 // Get the current mouse position.
4344 wxPoint
wxGetMousePosition()
4346 /* This crashes when used within wxHelpContext,
4347 so we have to use the X-specific implementation below.
4349 GdkModifierType *mask;
4350 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4352 return wxPoint(x, y);
4356 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4358 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4359 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4360 Window rootReturn
, childReturn
;
4361 int rootX
, rootY
, winX
, winY
;
4362 unsigned int maskReturn
;
4364 XQueryPointer (display
,
4368 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4369 return wxPoint(rootX
, rootY
);
4373 // Needed for implementing e.g. combobox on wxGTK within a modal dialog.
4374 void wxAddGrab(wxWindow
* window
)
4376 gtk_grab_add( (GtkWidget
*) window
->GetHandle() );
4379 void wxRemoveGrab(wxWindow
* window
)
4381 gtk_grab_remove( (GtkWidget
*) window
->GetHandle() );