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"
22 #include "wx/toplevel.h"
23 #include "wx/dcclient.h"
25 #include "wx/settings.h"
26 #include "wx/msgdlg.h"
31 #include "wx/tooltip.h"
33 #include "wx/fontutil.h"
34 #include "wx/sysopt.h"
37 #include "wx/thread.h"
42 // FIXME: Due to a hack we use GtkCombo in here, which is deprecated since gtk2.3.0
43 #include <gtk/gtkversion.h>
44 #if defined(GTK_DISABLE_DEPRECATED) && GTK_CHECK_VERSION(2,3,0)
45 #undef GTK_DISABLE_DEPRECATED
46 #include <gtk/gtkcombo.h>
47 #define GTK_DISABLE_DEPRECATED
50 #include "wx/gtk/private.h"
51 #include "wx/gtk/win_gtk.h"
52 #include <gdk/gdkkeysyms.h>
55 //-----------------------------------------------------------------------------
56 // documentation on internals
57 //-----------------------------------------------------------------------------
60 I have been asked several times about writing some documentation about
61 the GTK port of wxWidgets, especially its internal structures. Obviously,
62 you cannot understand wxGTK without knowing a little about the GTK, but
63 some more information about what the wxWindow, which is the base class
64 for all other window classes, does seems required as well.
68 What does wxWindow do? It contains the common interface for the following
69 jobs of its descendants:
71 1) Define the rudimentary behaviour common to all window classes, such as
72 resizing, intercepting user input (so as to make it possible to use these
73 events for special purposes in a derived class), window names etc.
75 2) Provide the possibility to contain and manage children, if the derived
76 class is allowed to contain children, which holds true for those window
77 classes which do not display a native GTK widget. To name them, these
78 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
79 work classes are a special case and are handled a bit differently from
80 the rest. The same holds true for the wxNotebook class.
82 3) Provide the possibility to draw into a client area of a window. This,
83 too, only holds true for classes that do not display a native GTK widget
86 4) Provide the entire mechanism for scrolling widgets. This actual inter-
87 face for this is usually in wxScrolledWindow, but the GTK implementation
90 5) A multitude of helper or extra methods for special purposes, such as
91 Drag'n'Drop, managing validators etc.
93 6) Display a border (sunken, raised, simple or none).
95 Normally one might expect, that one wxWidgets window would always correspond
96 to one GTK widget. Under GTK, there is no such all-round widget that has all
97 the functionality. Moreover, the GTK defines a client area as a different
98 widget from the actual widget you are handling. Last but not least some
99 special classes (e.g. wxFrame) handle different categories of widgets and
100 still have the possibility to draw something in the client area.
101 It was therefore required to write a special purpose GTK widget, that would
102 represent a client area in the sense of wxWidgets capable to do the jobs
103 2), 3) and 4). I have written this class and it resides in win_gtk.c of
106 All windows must have a widget, with which they interact with other under-
107 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
108 the wxWindow class has a member variable called m_widget which holds a
109 pointer to this widget. When the window class represents a GTK native widget,
110 this is (in most cases) the only GTK widget the class manages. E.g. the
111 wxStaticText class handles only a GtkLabel widget a pointer to which you
112 can find in m_widget (defined in wxWindow)
114 When the class has a client area for drawing into and for containing children
115 it has to handle the client area widget (of the type GtkPizza, defined in
116 win_gtk.c), but there could be any number of widgets, handled by a class
117 The common rule for all windows is only, that the widget that interacts with
118 the rest of GTK must be referenced in m_widget and all other widgets must be
119 children of this widget on the GTK level. The top-most widget, which also
120 represents the client area, must be in the m_wxwindow field and must be of
123 As I said, the window classes that display a GTK native widget only have
124 one widget, so in the case of e.g. the wxButton class m_widget holds a
125 pointer to a GtkButton widget. But windows with client areas (for drawing
126 and children) have a m_widget field that is a pointer to a GtkScrolled-
127 Window and a m_wxwindow field that is pointer to a GtkPizza and this
128 one is (in the GTK sense) a child of the GtkScrolledWindow.
130 If the m_wxwindow field is set, then all input to this widget is inter-
131 cepted and sent to the wxWidgets class. If not, all input to the widget
132 that gets pointed to by m_widget gets intercepted and sent to the class.
136 The design of scrolling in wxWidgets is markedly different from that offered
137 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
138 clicking on a scrollbar belonging to scrolled window will inevitably move
139 the window. In wxWidgets, the scrollbar will only emit an event, send this
140 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
141 which actually moves the window and its sub-windows. Note that GtkPizza
142 memorizes how much it has been scrolled but that wxWidgets forgets this
143 so that the two coordinates systems have to be kept in synch. This is done
144 in various places using the pizza->xoffset and pizza->yoffset values.
148 Singularly the most broken code in GTK is the code that is supposed to
149 inform subwindows (child windows) about new positions. Very often, duplicate
150 events are sent without changes in size or position, equally often no
151 events are sent at all (All this is due to a bug in the GtkContainer code
152 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
153 GTK's own system and it simply waits for size events for toplevel windows
154 and then iterates down the respective size events to all window. This has
155 the disadvantage that windows might get size events before the GTK widget
156 actually has the reported size. This doesn't normally pose any problem, but
157 the OpenGL drawing routines rely on correct behaviour. Therefore, I have
158 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
159 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
160 window that is used for OpenGL output really has that size (as reported by
165 If someone at some point of time feels the immense desire to have a look at,
166 change or attempt to optimise the Refresh() logic, this person will need an
167 intimate understanding of what "draw" and "expose" events are and what
168 they are used for, in particular when used in connection with GTK's
169 own windowless widgets. Beware.
173 Cursors, too, have been a constant source of pleasure. The main difficulty
174 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
175 for the parent. To prevent this from doing too much harm, I use idle time
176 to set the cursor over and over again, starting from the toplevel windows
177 and ending with the youngest generation (speaking of parent and child windows).
178 Also don't forget that cursors (like much else) are connected to GdkWindows,
179 not GtkWidgets and that the "window" field of a GtkWidget might very well
180 point to the GdkWindow of the parent widget (-> "window-less widget") and
181 that the two obviously have very different meanings.
185 //-----------------------------------------------------------------------------
187 //-----------------------------------------------------------------------------
189 // Don't allow event propagation during drag
190 bool g_blockEventsOnDrag
;
191 // Don't allow mouse event propagation during scroll
192 bool g_blockEventsOnScroll
;
193 extern wxCursor g_globalCursor
;
195 // mouse capture state: the window which has it and if the mouse is currently
197 static wxWindowGTK
*g_captureWindow
= (wxWindowGTK
*) NULL
;
198 static bool g_captureWindowHasMouse
= false;
200 wxWindowGTK
*g_focusWindow
= (wxWindowGTK
*) NULL
;
202 // the last window which had the focus - this is normally never NULL (except
203 // if we never had focus at all) as even when g_focusWindow is NULL it still
204 // keeps its previous value
205 wxWindowGTK
*g_focusWindowLast
= (wxWindowGTK
*) NULL
;
207 // If a window get the focus set but has not been realized
208 // yet, defer setting the focus to idle time.
209 wxWindowGTK
*g_delayedFocus
= (wxWindowGTK
*) NULL
;
211 // global variables because GTK+ DnD want to have the
212 // mouse event that caused it
213 GdkEvent
*g_lastMouseEvent
= (GdkEvent
*) NULL
;
214 int g_lastButtonNumber
= 0;
216 extern bool g_mainThreadLocked
;
218 //-----------------------------------------------------------------------------
220 //-----------------------------------------------------------------------------
225 # define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
227 # define DEBUG_MAIN_THREAD
230 #define DEBUG_MAIN_THREAD
233 // the trace mask used for the focus debugging messages
234 #define TRACE_FOCUS _T("focus")
236 //-----------------------------------------------------------------------------
237 // missing gdk functions
238 //-----------------------------------------------------------------------------
241 gdk_window_warp_pointer (GdkWindow
*window
,
246 window
= gdk_get_default_root_window();
248 if (!GDK_WINDOW_DESTROYED(window
))
250 XWarpPointer (GDK_WINDOW_XDISPLAY(window
),
251 None
, /* not source window -> move from anywhere */
252 GDK_WINDOW_XID(window
), /* dest window */
253 0, 0, 0, 0, /* not source window -> move from anywhere */
258 //-----------------------------------------------------------------------------
259 // local code (see below)
260 //-----------------------------------------------------------------------------
262 // returns the child of win which currently has focus or NULL if not found
264 // Note: can't be static, needed by textctrl.cpp.
265 wxWindow
*wxFindFocusedChild(wxWindowGTK
*win
)
267 wxWindow
*winFocus
= wxWindowGTK::FindFocus();
269 return (wxWindow
*)NULL
;
271 if ( winFocus
== win
)
272 return (wxWindow
*)win
;
274 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
276 node
= node
->GetNext() )
278 wxWindow
*child
= wxFindFocusedChild(node
->GetData());
283 return (wxWindow
*)NULL
;
286 static void GetScrollbarWidth(GtkWidget
* widget
, int& w
, int& h
)
288 GtkScrolledWindow
* scroll_window
= GTK_SCROLLED_WINDOW(widget
);
289 GtkScrolledWindowClass
* scroll_class
= GTK_SCROLLED_WINDOW_CLASS(GTK_OBJECT_GET_CLASS(scroll_window
));
290 GtkRequisition scroll_req
;
293 if (scroll_window
->vscrollbar_visible
)
295 scroll_req
.width
= 2;
296 scroll_req
.height
= 2;
297 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
298 (scroll_window
->vscrollbar
, &scroll_req
);
299 w
= scroll_req
.width
+
300 scroll_class
->scrollbar_spacing
;
304 if (scroll_window
->hscrollbar_visible
)
306 scroll_req
.width
= 2;
307 scroll_req
.height
= 2;
308 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
309 (scroll_window
->hscrollbar
, &scroll_req
);
310 h
= scroll_req
.height
+
311 scroll_class
->scrollbar_spacing
;
315 static void draw_frame( GtkWidget
*widget
, wxWindowGTK
*win
)
317 // wxUniversal widgets draw the borders and scrollbars themselves
318 #ifndef __WXUNIVERSAL__
324 if (GTK_WIDGET_NO_WINDOW (widget
))
326 dx
+= widget
->allocation
.x
;
327 dy
+= widget
->allocation
.y
;
335 if (win
->m_hasScrolling
)
337 GetScrollbarWidth(widget
, dw
, dh
);
339 if (win
->GetLayoutDirection() == wxLayout_RightToLeft
)
341 // This is actually wrong for old GTK+ version
342 // which do not display the scrollbar on the
348 int w
= widget
->allocation
.width
-dw
;
349 int h
= widget
->allocation
.height
-dh
;
351 if (win
->HasFlag(wxRAISED_BORDER
))
353 gtk_paint_shadow (widget
->style
,
357 NULL
, NULL
, NULL
, // FIXME: No clipping?
362 if (win
->HasFlag(wxSUNKEN_BORDER
))
364 gtk_paint_shadow (widget
->style
,
368 NULL
, NULL
, NULL
, // FIXME: No clipping?
373 if (win
->HasFlag(wxSIMPLE_BORDER
))
376 gc
= gdk_gc_new( widget
->window
);
377 gdk_gc_set_foreground( gc
, &widget
->style
->black
);
378 gdk_draw_rectangle( widget
->window
, gc
, FALSE
, x
, y
, w
-1, h
-1 );
382 #endif // __WXUNIVERSAL__
385 //-----------------------------------------------------------------------------
386 // "expose_event" of m_widget
387 //-----------------------------------------------------------------------------
391 gtk_window_own_expose_callback( GtkWidget
*widget
,
392 GdkEventExpose
*gdk_event
,
395 if (gdk_event
->count
== 0)
396 draw_frame(widget
, win
);
401 //-----------------------------------------------------------------------------
402 // "size_request" of m_widget
403 //-----------------------------------------------------------------------------
405 // make it extern because wxStaticText needs to disconnect this one
407 void wxgtk_window_size_request_callback(GtkWidget
* WXUNUSED(widget
),
408 GtkRequisition
*requisition
,
412 win
->GetSize( &w
, &h
);
418 requisition
->height
= h
;
419 requisition
->width
= w
;
427 void wxgtk_combo_size_request_callback(GtkWidget
* WXUNUSED(widget
),
428 GtkRequisition
*requisition
,
431 // This callback is actually hooked into the text entry
432 // of the combo box, not the GtkHBox.
435 win
->GetSize( &w
, &h
);
441 GtkCombo
*gcombo
= GTK_COMBO(win
->m_widget
);
443 GtkRequisition entry_req
;
445 entry_req
.height
= 2;
446 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo
->entry
) )->size_request
)
447 (gcombo
->entry
, &entry_req
);
449 GtkRequisition button_req
;
450 button_req
.width
= 2;
451 button_req
.height
= 2;
452 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo
->button
) )->size_request
)
453 (gcombo
->button
, &button_req
);
455 requisition
->width
= w
- button_req
.width
;
456 requisition
->height
= entry_req
.height
;
460 #endif // wxUSE_COMBOBOX
462 //-----------------------------------------------------------------------------
463 // "expose_event" of m_wxwindow
464 //-----------------------------------------------------------------------------
468 gtk_window_expose_callback( GtkWidget
*widget
,
469 GdkEventExpose
*gdk_event
,
474 // This callback gets called in drawing-idle time under
475 // GTK 2.0, so we don't need to defer anything to idle
478 GtkPizza
*pizza
= GTK_PIZZA( widget
);
479 if (gdk_event
->window
!= pizza
->bin_window
)
481 // block expose events on GTK_WIDGET(pizza)->window,
482 // all drawing is done on pizza->bin_window
490 wxPrintf( wxT("OnExpose from ") );
491 if (win
->GetClassInfo() && win
->GetClassInfo()->GetClassName())
492 wxPrintf( win
->GetClassInfo()->GetClassName() );
493 wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event
->area
.x
,
494 (int)gdk_event
->area
.y
,
495 (int)gdk_event
->area
.width
,
496 (int)gdk_event
->area
.height
);
501 win
->m_wxwindow
->style
,
505 (GdkRectangle
*) NULL
,
507 (char *)"button", // const_cast
512 win
->GetUpdateRegion() = wxRegion( gdk_event
->region
);
514 win
->GtkSendPaintEvents();
516 // Let parent window draw window-less widgets
521 //-----------------------------------------------------------------------------
522 // "key_press_event" from any window
523 //-----------------------------------------------------------------------------
525 // These are used when transforming Ctrl-alpha to ascii values 1-26
526 inline bool wxIsLowerChar(int code
)
528 return (code
>= 'a' && code
<= 'z' );
531 inline bool wxIsUpperChar(int code
)
533 return (code
>= 'A' && code
<= 'Z' );
537 // set WXTRACE to this to see the key event codes on the console
538 #define TRACE_KEYS _T("keyevent")
540 // translates an X key symbol to WXK_XXX value
542 // if isChar is true it means that the value returned will be used for EVT_CHAR
543 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
544 // for example, while if it is false it means that the value is going to be
545 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
547 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
553 // Shift, Control and Alt don't generate the CHAR events at all
556 key_code
= isChar
? 0 : WXK_SHIFT
;
560 key_code
= isChar
? 0 : WXK_CONTROL
;
568 key_code
= isChar
? 0 : WXK_ALT
;
571 // neither do the toggle modifies
572 case GDK_Scroll_Lock
:
573 key_code
= isChar
? 0 : WXK_SCROLL
;
577 key_code
= isChar
? 0 : WXK_CAPITAL
;
581 key_code
= isChar
? 0 : WXK_NUMLOCK
;
585 // various other special keys
598 case GDK_ISO_Left_Tab
:
605 key_code
= WXK_RETURN
;
609 key_code
= WXK_CLEAR
;
613 key_code
= WXK_PAUSE
;
617 key_code
= WXK_SELECT
;
621 key_code
= WXK_PRINT
;
625 key_code
= WXK_EXECUTE
;
629 key_code
= WXK_ESCAPE
;
632 // cursor and other extended keyboard keys
634 key_code
= WXK_DELETE
;
650 key_code
= WXK_RIGHT
;
657 case GDK_Prior
: // == GDK_Page_Up
658 key_code
= WXK_PAGEUP
;
661 case GDK_Next
: // == GDK_Page_Down
662 key_code
= WXK_PAGEDOWN
;
674 key_code
= WXK_INSERT
;
689 key_code
= (isChar
? '0' : WXK_NUMPAD0
) + keysym
- GDK_KP_0
;
693 key_code
= isChar
? ' ' : WXK_NUMPAD_SPACE
;
697 key_code
= isChar
? WXK_TAB
: WXK_NUMPAD_TAB
;
701 key_code
= isChar
? WXK_RETURN
: WXK_NUMPAD_ENTER
;
705 key_code
= isChar
? WXK_F1
: WXK_NUMPAD_F1
;
709 key_code
= isChar
? WXK_F2
: WXK_NUMPAD_F2
;
713 key_code
= isChar
? WXK_F3
: WXK_NUMPAD_F3
;
717 key_code
= isChar
? WXK_F4
: WXK_NUMPAD_F4
;
721 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_HOME
;
725 key_code
= isChar
? WXK_LEFT
: WXK_NUMPAD_LEFT
;
729 key_code
= isChar
? WXK_UP
: WXK_NUMPAD_UP
;
733 key_code
= isChar
? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
737 key_code
= isChar
? WXK_DOWN
: WXK_NUMPAD_DOWN
;
740 case GDK_KP_Prior
: // == GDK_KP_Page_Up
741 key_code
= isChar
? WXK_PAGEUP
: WXK_NUMPAD_PAGEUP
;
744 case GDK_KP_Next
: // == GDK_KP_Page_Down
745 key_code
= isChar
? WXK_PAGEDOWN
: WXK_NUMPAD_PAGEDOWN
;
749 key_code
= isChar
? WXK_END
: WXK_NUMPAD_END
;
753 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_BEGIN
;
757 key_code
= isChar
? WXK_INSERT
: WXK_NUMPAD_INSERT
;
761 key_code
= isChar
? WXK_DELETE
: WXK_NUMPAD_DELETE
;
765 key_code
= isChar
? '=' : WXK_NUMPAD_EQUAL
;
768 case GDK_KP_Multiply
:
769 key_code
= isChar
? '*' : WXK_NUMPAD_MULTIPLY
;
773 key_code
= isChar
? '+' : WXK_NUMPAD_ADD
;
776 case GDK_KP_Separator
:
777 // FIXME: what is this?
778 key_code
= isChar
? '.' : WXK_NUMPAD_SEPARATOR
;
781 case GDK_KP_Subtract
:
782 key_code
= isChar
? '-' : WXK_NUMPAD_SUBTRACT
;
786 key_code
= isChar
? '.' : WXK_NUMPAD_DECIMAL
;
790 key_code
= isChar
? '/' : WXK_NUMPAD_DIVIDE
;
807 key_code
= WXK_F1
+ keysym
- GDK_F1
;
817 static inline bool wxIsAsciiKeysym(KeySym ks
)
822 static void wxFillOtherKeyEventFields(wxKeyEvent
& event
,
824 GdkEventKey
*gdk_event
)
828 GdkModifierType state
;
829 if (gdk_event
->window
)
830 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
832 event
.SetTimestamp( gdk_event
->time
);
833 event
.SetId(win
->GetId());
834 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
835 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
836 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
837 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
) != 0;
838 event
.m_scanCode
= gdk_event
->keyval
;
839 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
840 event
.m_rawFlags
= 0;
842 event
.m_uniChar
= gdk_keyval_to_unicode(gdk_event
->keyval
);
844 wxGetMousePosition( &x
, &y
);
845 win
->ScreenToClient( &x
, &y
);
848 event
.SetEventObject( win
);
853 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
855 GdkEventKey
*gdk_event
)
857 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
858 // but only event->keyval which is quite useless to us, so remember
859 // the last character from GDK_KEY_PRESS and reuse it as last resort
861 // NB: should be MT-safe as we're always called from the main thread only
866 } s_lastKeyPress
= { 0, 0 };
868 KeySym keysym
= gdk_event
->keyval
;
870 wxLogTrace(TRACE_KEYS
, _T("Key %s event: keysym = %ld"),
871 event
.GetEventType() == wxEVT_KEY_UP
? _T("release")
875 long key_code
= wxTranslateKeySymToWXKey(keysym
, false /* !isChar */);
879 // do we have the translation or is it a plain ASCII character?
880 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
882 // we should use keysym if it is ASCII as X does some translations
883 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
884 // which we don't want here (but which we do use for OnChar())
885 if ( !wxIsAsciiKeysym(keysym
) )
887 keysym
= (KeySym
)gdk_event
->string
[0];
890 // we want to always get the same key code when the same key is
891 // pressed regardless of the state of the modifiers, i.e. on a
892 // standard US keyboard pressing '5' or '%' ('5' key with
893 // Shift) should result in the same key code in OnKeyDown():
894 // '5' (although OnChar() will get either '5' or '%').
896 // to do it we first translate keysym to keycode (== scan code)
897 // and then back but always using the lower register
898 Display
*dpy
= (Display
*)wxGetDisplay();
899 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
901 wxLogTrace(TRACE_KEYS
, _T("\t-> keycode %d"), keycode
);
903 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
905 // use the normalized, i.e. lower register, keysym if we've
907 key_code
= keysymNormalized
? keysymNormalized
: keysym
;
909 // as explained above, we want to have lower register key codes
910 // normally but for the letter keys we want to have the upper ones
912 // NB: don't use XConvertCase() here, we want to do it for letters
914 key_code
= toupper(key_code
);
916 else // non ASCII key, what to do?
918 // by default, ignore it
921 // but if we have cached information from the last KEY_PRESS
922 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
925 if ( keysym
== s_lastKeyPress
.keysym
)
927 key_code
= s_lastKeyPress
.keycode
;
932 if ( gdk_event
->type
== GDK_KEY_PRESS
)
934 // remember it to be reused for KEY_UP event later
935 s_lastKeyPress
.keysym
= keysym
;
936 s_lastKeyPress
.keycode
= key_code
;
940 wxLogTrace(TRACE_KEYS
, _T("\t-> wxKeyCode %ld"), key_code
);
942 // sending unknown key events doesn't really make sense
946 // now fill all the other fields
947 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
949 event
.m_keyCode
= key_code
;
951 if ( gdk_event
->type
== GDK_KEY_PRESS
|| gdk_event
->type
== GDK_KEY_RELEASE
)
953 event
.m_uniChar
= key_code
;
963 GtkIMContext
*context
;
964 GdkEventKey
*lastKeyEvent
;
968 context
= gtk_im_multicontext_new();
973 g_object_unref (context
);
979 gtk_window_key_press_callback( GtkWidget
*widget
,
980 GdkEventKey
*gdk_event
,
987 if (g_blockEventsOnDrag
)
990 // GTK+ sends keypress events to the focus widget and then
991 // to all its parent and grandparent widget. We only want
992 // the key events from the focus widget.
993 if (!GTK_WIDGET_HAS_FOCUS(widget
))
996 wxKeyEvent
event( wxEVT_KEY_DOWN
);
998 bool return_after_IM
= false;
1000 if( wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1002 // Emit KEY_DOWN event
1003 ret
= win
->GetEventHandler()->ProcessEvent( event
);
1007 // Return after IM processing as we cannot do
1008 // anything with it anyhow.
1009 return_after_IM
= true;
1012 if ((!ret
) && (win
->m_imData
!= NULL
))
1014 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
1015 // docs, if IM filter returns true, no further processing should be done.
1016 // we should send the key_down event anyway.
1017 bool intercepted_by_IM
= gtk_im_context_filter_keypress(win
->m_imData
->context
, gdk_event
);
1018 win
->m_imData
->lastKeyEvent
= NULL
;
1019 if (intercepted_by_IM
)
1021 wxLogTrace(TRACE_KEYS
, _T("Key event intercepted by IM"));
1026 if (return_after_IM
)
1032 wxWindowGTK
*ancestor
= win
;
1035 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
1038 wxCommandEvent
command_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
1039 ret
= ancestor
->GetEventHandler()->ProcessEvent( command_event
);
1042 if (ancestor
->IsTopLevel())
1044 ancestor
= ancestor
->GetParent();
1047 #endif // wxUSE_ACCEL
1049 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1050 // will only be sent if it is not in an accelerator table.
1054 KeySym keysym
= gdk_event
->keyval
;
1055 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1056 key_code
= wxTranslateKeySymToWXKey(keysym
, true /* isChar */);
1059 if ( wxIsAsciiKeysym(keysym
) )
1062 key_code
= (unsigned char)keysym
;
1064 // gdk_event->string is actually deprecated
1065 else if ( gdk_event
->length
== 1 )
1067 key_code
= (unsigned char)gdk_event
->string
[0];
1073 wxLogTrace(TRACE_KEYS
, _T("Char event: %ld"), key_code
);
1075 event
.m_keyCode
= key_code
;
1077 // To conform to the docs we need to translate Ctrl-alpha
1078 // characters to values in the range 1-26.
1079 if ( event
.ControlDown() &&
1080 ( wxIsLowerChar(key_code
) || wxIsUpperChar(key_code
) ))
1082 if ( wxIsLowerChar(key_code
) )
1083 event
.m_keyCode
= key_code
- 'a' + 1;
1084 if ( wxIsUpperChar(key_code
) )
1085 event
.m_keyCode
= key_code
- 'A' + 1;
1087 event
.m_uniChar
= event
.m_keyCode
;
1091 // Implement OnCharHook by checking ancestor top level windows
1092 wxWindow
*parent
= win
;
1093 while (parent
&& !parent
->IsTopLevel())
1094 parent
= parent
->GetParent();
1097 event
.SetEventType( wxEVT_CHAR_HOOK
);
1098 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1103 event
.SetEventType(wxEVT_CHAR
);
1104 ret
= win
->GetEventHandler()->ProcessEvent( event
);
1115 gtk_wxwindow_commit_cb (GtkIMContext
* WXUNUSED(context
),
1119 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1121 // take modifiers, cursor position, timestamp etc. from the last
1122 // key_press_event that was fed into Input Method:
1123 if (window
->m_imData
->lastKeyEvent
)
1125 wxFillOtherKeyEventFields(event
,
1126 window
, window
->m_imData
->lastKeyEvent
);
1130 event
.SetEventObject( window
);
1133 const wxString
data(wxGTK_CONV_BACK_SYS(str
));
1139 // Implement OnCharHook by checking ancestor top level windows
1140 wxWindow
*parent
= window
;
1141 while (parent
&& !parent
->IsTopLevel())
1142 parent
= parent
->GetParent();
1144 for( wxString::const_iterator pstr
= data
.begin(); pstr
!= data
.end(); ++pstr
)
1147 event
.m_uniChar
= *pstr
;
1148 // Backward compatible for ISO-8859-1
1149 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
1150 wxLogTrace(TRACE_KEYS
, _T("IM sent character '%c'"), event
.m_uniChar
);
1152 event
.m_keyCode
= (char)*pstr
;
1153 #endif // wxUSE_UNICODE
1155 // To conform to the docs we need to translate Ctrl-alpha
1156 // characters to values in the range 1-26.
1157 if ( event
.ControlDown() &&
1158 ( wxIsLowerChar(*pstr
) || wxIsUpperChar(*pstr
) ))
1160 if ( wxIsLowerChar(*pstr
) )
1161 event
.m_keyCode
= *pstr
- 'a' + 1;
1162 if ( wxIsUpperChar(*pstr
) )
1163 event
.m_keyCode
= *pstr
- 'A' + 1;
1165 event
.m_keyCode
= *pstr
- 'a' + 1;
1167 event
.m_uniChar
= event
.m_keyCode
;
1173 event
.SetEventType( wxEVT_CHAR_HOOK
);
1174 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1179 event
.SetEventType(wxEVT_CHAR
);
1180 ret
= window
->GetEventHandler()->ProcessEvent( event
);
1187 //-----------------------------------------------------------------------------
1188 // "key_release_event" from any window
1189 //-----------------------------------------------------------------------------
1193 gtk_window_key_release_callback( GtkWidget
* WXUNUSED(widget
),
1194 GdkEventKey
*gdk_event
,
1202 if (g_blockEventsOnDrag
)
1205 wxKeyEvent
event( wxEVT_KEY_UP
);
1206 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1208 // unknown key pressed, ignore (the event would be useless anyhow)
1212 return win
->GTKProcessEvent(event
);
1216 // ============================================================================
1218 // ============================================================================
1220 // ----------------------------------------------------------------------------
1221 // mouse event processing helpers
1222 // ----------------------------------------------------------------------------
1224 // init wxMouseEvent with the info from GdkEventXXX struct
1225 template<typename T
> void InitMouseEvent(wxWindowGTK
*win
,
1226 wxMouseEvent
& event
,
1229 event
.SetTimestamp( gdk_event
->time
);
1230 event
.m_shiftDown
= gdk_event
->state
& GDK_SHIFT_MASK
;
1231 event
.m_controlDown
= gdk_event
->state
& GDK_CONTROL_MASK
;
1232 event
.m_altDown
= gdk_event
->state
& GDK_MOD1_MASK
;
1233 event
.m_metaDown
= gdk_event
->state
& GDK_MOD2_MASK
;
1234 event
.m_leftDown
= gdk_event
->state
& GDK_BUTTON1_MASK
;
1235 event
.m_middleDown
= gdk_event
->state
& GDK_BUTTON2_MASK
;
1236 event
.m_rightDown
= gdk_event
->state
& GDK_BUTTON3_MASK
;
1237 event
.m_aux1Down
= gdk_event
->state
& GDK_BUTTON4_MASK
;
1238 event
.m_aux2Down
= gdk_event
->state
& GDK_BUTTON5_MASK
;
1240 wxPoint pt
= win
->GetClientAreaOrigin();
1241 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1242 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1244 if ((win
->m_wxwindow
) && (win
->GetLayoutDirection() == wxLayout_RightToLeft
))
1246 // origin in the upper right corner
1247 int window_width
= gtk_pizza_get_rtl_offset( GTK_PIZZA(win
->m_wxwindow
) );
1248 event
.m_x
= window_width
- event
.m_x
;
1251 event
.SetEventObject( win
);
1252 event
.SetId( win
->GetId() );
1253 event
.SetTimestamp( gdk_event
->time
);
1256 static void AdjustEventButtonState(wxMouseEvent
& event
)
1258 // GDK reports the old state of the button for a button press event, but
1259 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1260 // for a LEFT_DOWN event, not FALSE, so we will invert
1261 // left/right/middleDown for the corresponding click events
1263 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1264 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1265 (event
.GetEventType() == wxEVT_LEFT_UP
))
1267 event
.m_leftDown
= !event
.m_leftDown
;
1271 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1272 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1273 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1275 event
.m_middleDown
= !event
.m_middleDown
;
1279 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1280 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1281 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1283 event
.m_rightDown
= !event
.m_rightDown
;
1288 // find the window to send the mouse event too
1290 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1295 if (win
->m_wxwindow
)
1297 GtkPizza
*pizza
= GTK_PIZZA(win
->m_wxwindow
);
1298 xx
+= gtk_pizza_get_xoffset( pizza
);
1299 yy
+= gtk_pizza_get_yoffset( pizza
);
1302 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
1305 wxWindowGTK
*child
= node
->GetData();
1307 node
= node
->GetNext();
1308 if (!child
->IsShown())
1311 if (child
->IsTransparentForMouse())
1313 // wxStaticBox is transparent in the box itself
1314 int xx1
= child
->m_x
;
1315 int yy1
= child
->m_y
;
1316 int xx2
= child
->m_x
+ child
->m_width
;
1317 int yy2
= child
->m_y
+ child
->m_height
;
1320 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1322 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1324 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1326 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1337 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1338 (child
->m_x
<= xx
) &&
1339 (child
->m_y
<= yy
) &&
1340 (child
->m_x
+child
->m_width
>= xx
) &&
1341 (child
->m_y
+child
->m_height
>= yy
))
1354 // ----------------------------------------------------------------------------
1355 // common event handlers helpers
1356 // ----------------------------------------------------------------------------
1358 bool wxWindowGTK::GTKProcessEvent(wxEvent
& event
) const
1360 // nothing special at this level
1361 return GetEventHandler()->ProcessEvent(event
);
1364 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny
*event
) const
1370 if (g_blockEventsOnDrag
)
1372 if (g_blockEventsOnScroll
)
1375 if (!GTKIsOwnWindow(event
->window
))
1381 // overloads for all GDK event types we use here: we need to have this as
1382 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1383 // derives from it in the sense that the structs have the same layout
1384 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1385 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1387 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1390 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton
)
1391 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion
)
1392 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing
)
1394 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1396 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1397 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1401 // send the wxChildFocusEvent and wxFocusEvent, common code of
1402 // gtk_window_focus_in_callback() and SetFocus()
1403 static bool DoSendFocusEvents(wxWindow
*win
)
1405 // Notify the parent keeping track of focus for the kbd navigation
1406 // purposes that we got it.
1407 wxChildFocusEvent
eventChildFocus(win
);
1408 (void)win
->GetEventHandler()->ProcessEvent(eventChildFocus
);
1410 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, win
->GetId());
1411 eventFocus
.SetEventObject(win
);
1413 return win
->GetEventHandler()->ProcessEvent(eventFocus
);
1416 // all event handlers must have C linkage as they're called from GTK+ C code
1420 //-----------------------------------------------------------------------------
1421 // "button_press_event"
1422 //-----------------------------------------------------------------------------
1425 gtk_window_button_press_callback( GtkWidget
*widget
,
1426 GdkEventButton
*gdk_event
,
1429 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1431 g_lastButtonNumber
= gdk_event
->button
;
1433 // GDK sends surplus button down events
1434 // before a double click event. We
1435 // need to filter these out.
1436 if ((gdk_event
->type
== GDK_BUTTON_PRESS
) && (win
->m_wxwindow
))
1438 GdkEvent
*peek_event
= gdk_event_peek();
1441 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1442 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1444 gdk_event_free( peek_event
);
1449 gdk_event_free( peek_event
);
1454 wxEventType event_type
= wxEVT_NULL
;
1456 // GdkDisplay is a GTK+ 2.2.0 thing
1457 #if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0)
1458 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1459 !gtk_check_version(2,2,0) &&
1460 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1462 // Reset GDK internal timestamp variables in order to disable GDK
1463 // triple click events. GDK will then next time believe no button has
1464 // been clicked just before, and send a normal button click event.
1465 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1466 display
->button_click_time
[1] = 0;
1467 display
->button_click_time
[0] = 0;
1471 if (gdk_event
->button
== 1)
1473 // note that GDK generates triple click events which are not supported
1474 // by wxWidgets but still have to be passed to the app as otherwise
1475 // clicks would simply go missing
1476 switch (gdk_event
->type
)
1478 // we shouldn't get triple clicks at all for GTK2 because we
1479 // suppress them artificially using the code above but we still
1480 // should map them to something for GTK1 and not just ignore them
1481 // as this would lose clicks
1482 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1483 case GDK_BUTTON_PRESS
:
1484 event_type
= wxEVT_LEFT_DOWN
;
1487 case GDK_2BUTTON_PRESS
:
1488 event_type
= wxEVT_LEFT_DCLICK
;
1492 // just to silence gcc warnings
1496 else if (gdk_event
->button
== 2)
1498 switch (gdk_event
->type
)
1500 case GDK_3BUTTON_PRESS
:
1501 case GDK_BUTTON_PRESS
:
1502 event_type
= wxEVT_MIDDLE_DOWN
;
1505 case GDK_2BUTTON_PRESS
:
1506 event_type
= wxEVT_MIDDLE_DCLICK
;
1513 else if (gdk_event
->button
== 3)
1515 switch (gdk_event
->type
)
1517 case GDK_3BUTTON_PRESS
:
1518 case GDK_BUTTON_PRESS
:
1519 event_type
= wxEVT_RIGHT_DOWN
;
1522 case GDK_2BUTTON_PRESS
:
1523 event_type
= wxEVT_RIGHT_DCLICK
;
1531 if ( event_type
== wxEVT_NULL
)
1533 // unknown mouse button or click type
1537 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1539 wxMouseEvent
event( event_type
);
1540 InitMouseEvent( win
, event
, gdk_event
);
1542 AdjustEventButtonState(event
);
1544 // wxListBox actually gets mouse events from the item, so we need to give it
1545 // a chance to correct this
1546 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1548 // find the correct window to send the event to: it may be a different one
1549 // from the one which got it at GTK+ level because some controls don't have
1550 // their own X window and thus cannot get any events.
1551 if ( !g_captureWindow
)
1552 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1554 // reset the event object and id in case win changed.
1555 event
.SetEventObject( win
);
1556 event
.SetId( win
->GetId() );
1558 bool ret
= win
->GTKProcessEvent( event
);
1559 g_lastMouseEvent
= NULL
;
1563 if ((event_type
== wxEVT_LEFT_DOWN
) && !win
->IsOfStandardClass() &&
1564 (g_focusWindow
!= win
) /* && win->IsFocusable() */)
1569 if (event_type
== wxEVT_RIGHT_DOWN
)
1571 // generate a "context menu" event: this is similar to right mouse
1572 // click under many GUIs except that it is generated differently
1573 // (right up under MSW, ctrl-click under Mac, right down here) and
1575 // (a) it's a command event and so is propagated to the parent
1576 // (b) under some ports it can be generated from kbd too
1577 // (c) it uses screen coords (because of (a))
1578 wxContextMenuEvent
evtCtx(
1581 win
->ClientToScreen(event
.GetPosition()));
1582 evtCtx
.SetEventObject(win
);
1583 return win
->GTKProcessEvent(evtCtx
);
1589 //-----------------------------------------------------------------------------
1590 // "button_release_event"
1591 //-----------------------------------------------------------------------------
1594 gtk_window_button_release_callback( GtkWidget
*widget
,
1595 GdkEventButton
*gdk_event
,
1598 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1600 g_lastButtonNumber
= 0;
1602 wxEventType event_type
= wxEVT_NULL
;
1604 switch (gdk_event
->button
)
1607 event_type
= wxEVT_LEFT_UP
;
1611 event_type
= wxEVT_MIDDLE_UP
;
1615 event_type
= wxEVT_RIGHT_UP
;
1619 // unknown button, don't process
1623 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1625 wxMouseEvent
event( event_type
);
1626 InitMouseEvent( win
, event
, gdk_event
);
1628 AdjustEventButtonState(event
);
1630 // same wxListBox hack as above
1631 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1633 if ( !g_captureWindow
)
1634 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1636 // reset the event object and id in case win changed.
1637 event
.SetEventObject( win
);
1638 event
.SetId( win
->GetId() );
1640 bool ret
= win
->GTKProcessEvent(event
);
1642 g_lastMouseEvent
= NULL
;
1647 //-----------------------------------------------------------------------------
1648 // "motion_notify_event"
1649 //-----------------------------------------------------------------------------
1652 gtk_window_motion_notify_callback( GtkWidget
* WXUNUSED(widget
),
1653 GdkEventMotion
*gdk_event
,
1656 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1658 if (gdk_event
->is_hint
)
1662 GdkModifierType state
;
1663 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1668 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1670 wxMouseEvent
event( wxEVT_MOTION
);
1671 InitMouseEvent(win
, event
, gdk_event
);
1673 if ( g_captureWindow
)
1675 // synthesise a mouse enter or leave event if needed
1676 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1677 // This seems to be necessary and actually been added to
1678 // GDK itself in version 2.0.X
1681 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1682 if ( hasMouse
!= g_captureWindowHasMouse
)
1684 // the mouse changed window
1685 g_captureWindowHasMouse
= hasMouse
;
1687 wxMouseEvent
eventM(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1688 : wxEVT_LEAVE_WINDOW
);
1689 InitMouseEvent(win
, eventM
, gdk_event
);
1690 eventM
.SetEventObject(win
);
1691 win
->GTKProcessEvent(eventM
);
1696 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1698 // reset the event object and id in case win changed.
1699 event
.SetEventObject( win
);
1700 event
.SetId( win
->GetId() );
1703 if ( !g_captureWindow
)
1705 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1706 if (win
->GTKProcessEvent( cevent
))
1708 win
->SetCursor( cevent
.GetCursor() );
1712 bool ret
= win
->GTKProcessEvent(event
);
1714 g_lastMouseEvent
= NULL
;
1719 //-----------------------------------------------------------------------------
1720 // "scroll_event" (mouse wheel event)
1721 //-----------------------------------------------------------------------------
1724 window_scroll_event(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1728 if (gdk_event
->direction
!= GDK_SCROLL_UP
&&
1729 gdk_event
->direction
!= GDK_SCROLL_DOWN
)
1734 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1735 InitMouseEvent(win
, event
, gdk_event
);
1736 event
.m_linesPerAction
= 3;
1737 event
.m_wheelDelta
= 120;
1738 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1739 event
.m_wheelRotation
= 120;
1741 event
.m_wheelRotation
= -120;
1743 return win
->GTKProcessEvent(event
);
1746 //-----------------------------------------------------------------------------
1748 //-----------------------------------------------------------------------------
1750 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
1752 wxContextMenuEvent
event(wxEVT_CONTEXT_MENU
, win
->GetId(), wxPoint(-1, -1));
1753 event
.SetEventObject(win
);
1754 return win
->GTKProcessEvent(event
);
1757 //-----------------------------------------------------------------------------
1759 //-----------------------------------------------------------------------------
1762 gtk_window_focus_in_callback( GtkWidget
* WXUNUSED(widget
),
1763 GdkEventFocus
*WXUNUSED(event
),
1769 gtk_im_context_focus_in(win
->m_imData
->context
);
1772 g_focusWindow
= win
;
1774 wxLogTrace(TRACE_FOCUS
,
1775 _T("%s: focus in"), win
->GetName().c_str());
1778 // caret needs to be informed about focus change
1779 wxCaret
*caret
= win
->GetCaret();
1782 caret
->OnSetFocus();
1784 #endif // wxUSE_CARET
1786 gboolean ret
= FALSE
;
1788 // does the window itself think that it has the focus?
1789 if ( !win
->m_hasFocus
)
1791 // not yet, notify it
1792 win
->m_hasFocus
= true;
1794 (void)DoSendFocusEvents(win
);
1799 // Disable default focus handling for custom windows
1800 // since the default GTK+ handler issues a repaint
1801 if (win
->m_wxwindow
)
1807 //-----------------------------------------------------------------------------
1808 // "focus_out_event"
1809 //-----------------------------------------------------------------------------
1812 gtk_window_focus_out_callback( GtkWidget
* WXUNUSED(widget
),
1813 GdkEventFocus
* WXUNUSED(gdk_event
),
1819 gtk_im_context_focus_out(win
->m_imData
->context
);
1821 wxLogTrace( TRACE_FOCUS
,
1822 _T("%s: focus out"), win
->GetName().c_str() );
1825 wxWindowGTK
*winFocus
= wxFindFocusedChild(win
);
1829 g_focusWindow
= (wxWindowGTK
*)NULL
;
1832 // caret needs to be informed about focus change
1833 wxCaret
*caret
= win
->GetCaret();
1836 caret
->OnKillFocus();
1838 #endif // wxUSE_CARET
1840 // don't send the window a kill focus event if it thinks that it doesn't
1841 // have focus already
1842 if ( win
->m_hasFocus
)
1844 // the event handler might delete the window when it loses focus, so
1845 // check whether this is a custom window before calling it
1846 const bool has_wxwindow
= win
->m_wxwindow
!= NULL
;
1848 win
->m_hasFocus
= false;
1850 wxFocusEvent
event( wxEVT_KILL_FOCUS
, win
->GetId() );
1851 event
.SetEventObject( win
);
1853 (void)win
->GTKProcessEvent( event
);
1855 // Disable default focus handling for custom windows
1856 // since the default GTK+ handler issues a repaint
1861 // continue with normal processing
1866 wx_window_focus_callback(GtkWidget
*widget
,
1867 GtkDirectionType
WXUNUSED(direction
),
1870 // the default handler for focus signal in GtkPizza (or, rather, in
1871 // GtkScrolledWindow from which GtkPizza inherits this behaviour) sets
1872 // focus to the window itself even if it doesn't accept focus, i.e. has no
1873 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1874 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1875 // any children which might accept focus (we know we don't accept the focus
1876 // ourselves as this signal is only connected in this case)
1877 if ( win
->GetChildren().empty() )
1878 g_signal_stop_emission_by_name(widget
, "focus");
1880 // we didn't change the focus
1884 //-----------------------------------------------------------------------------
1885 // "enter_notify_event"
1886 //-----------------------------------------------------------------------------
1889 gtk_window_enter_callback( GtkWidget
*widget
,
1890 GdkEventCrossing
*gdk_event
,
1893 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1895 // Event was emitted after a grab
1896 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1900 GdkModifierType state
= (GdkModifierType
)0;
1902 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1904 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1905 InitMouseEvent(win
, event
, gdk_event
);
1906 wxPoint pt
= win
->GetClientAreaOrigin();
1907 event
.m_x
= x
+ pt
.x
;
1908 event
.m_y
= y
+ pt
.y
;
1910 if ( !g_captureWindow
)
1912 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1913 if (win
->GTKProcessEvent( cevent
))
1915 win
->SetCursor( cevent
.GetCursor() );
1919 return win
->GTKProcessEvent(event
);
1922 //-----------------------------------------------------------------------------
1923 // "leave_notify_event"
1924 //-----------------------------------------------------------------------------
1927 gtk_window_leave_callback( GtkWidget
*widget
,
1928 GdkEventCrossing
*gdk_event
,
1931 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1933 // Event was emitted after an ungrab
1934 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1936 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1940 GdkModifierType state
= (GdkModifierType
)0;
1942 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1944 InitMouseEvent(win
, event
, gdk_event
);
1946 return win
->GTKProcessEvent(event
);
1949 //-----------------------------------------------------------------------------
1950 // "value_changed" from scrollbar
1951 //-----------------------------------------------------------------------------
1954 gtk_scrollbar_value_changed(GtkRange
* range
, wxWindow
* win
)
1956 wxEventType eventType
= win
->GetScrollEventType(range
);
1957 if (eventType
!= wxEVT_NULL
)
1959 // Convert scroll event type to scrollwin event type
1960 eventType
+= wxEVT_SCROLLWIN_TOP
- wxEVT_SCROLL_TOP
;
1962 // find the scrollbar which generated the event
1963 wxWindowGTK::ScrollDir dir
= win
->ScrollDirFromRange(range
);
1965 // generate the corresponding wx event
1966 const int orient
= wxWindow::OrientFromScrollDir(dir
);
1967 wxScrollWinEvent
event(eventType
, win
->GetScrollPos(orient
), orient
);
1968 event
.SetEventObject(win
);
1970 win
->GTKProcessEvent(event
);
1974 //-----------------------------------------------------------------------------
1975 // "button_press_event" from scrollbar
1976 //-----------------------------------------------------------------------------
1979 gtk_scrollbar_button_press_event(GtkRange
*, GdkEventButton
*, wxWindow
* win
)
1983 g_blockEventsOnScroll
= true;
1984 win
->m_mouseButtonDown
= true;
1989 //-----------------------------------------------------------------------------
1990 // "event_after" from scrollbar
1991 //-----------------------------------------------------------------------------
1994 gtk_scrollbar_event_after(GtkRange
* range
, GdkEvent
* event
, wxWindow
* win
)
1996 if (event
->type
== GDK_BUTTON_RELEASE
)
1998 g_signal_handlers_block_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
2000 const int orient
= wxWindow::OrientFromScrollDir(
2001 win
->ScrollDirFromRange(range
));
2002 wxScrollWinEvent
evt(wxEVT_SCROLLWIN_THUMBRELEASE
,
2003 win
->GetScrollPos(orient
), orient
);
2004 evt
.SetEventObject(win
);
2005 win
->GTKProcessEvent(evt
);
2009 //-----------------------------------------------------------------------------
2010 // "button_release_event" from scrollbar
2011 //-----------------------------------------------------------------------------
2014 gtk_scrollbar_button_release_event(GtkRange
* range
, GdkEventButton
*, wxWindow
* win
)
2018 g_blockEventsOnScroll
= false;
2019 win
->m_mouseButtonDown
= false;
2020 // If thumb tracking
2021 if (win
->m_isScrolling
)
2023 win
->m_isScrolling
= false;
2024 // Hook up handler to send thumb release event after this emission is finished.
2025 // To allow setting scroll position from event handler, sending event must
2026 // be deferred until after the GtkRange handler for this signal has run
2027 g_signal_handlers_unblock_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
2033 //-----------------------------------------------------------------------------
2034 // "realize" from m_widget
2035 //-----------------------------------------------------------------------------
2038 gtk_window_realized_callback( GtkWidget
*m_widget
, wxWindow
*win
)
2044 GtkPizza
*pizza
= GTK_PIZZA( m_widget
);
2045 gtk_im_context_set_client_window( win
->m_imData
->context
,
2046 pizza
->bin_window
);
2049 // We cannot set colours and fonts before the widget
2050 // been realized, so we do this directly after realization
2051 // or otherwise in idle time
2053 if (win
->m_needsStyleChange
)
2055 win
->SetBackgroundStyle(win
->GetBackgroundStyle());
2056 win
->m_needsStyleChange
= false;
2059 wxWindowCreateEvent
event( win
);
2060 event
.SetEventObject( win
);
2061 win
->GTKProcessEvent( event
);
2064 //-----------------------------------------------------------------------------
2065 // "size_allocate" from m_wxwindow or m_widget
2066 //-----------------------------------------------------------------------------
2069 size_allocate(GtkWidget
*, GtkAllocation
* alloc
, wxWindow
* win
)
2071 int w
= alloc
->width
;
2072 int h
= alloc
->height
;
2073 if (win
->m_wxwindow
)
2075 const int border
= GTK_CONTAINER(win
->m_wxwindow
)->border_width
;
2081 if (win
->m_oldClientWidth
!= w
|| win
->m_oldClientHeight
!= h
)
2083 win
->m_oldClientWidth
= w
;
2084 win
->m_oldClientHeight
= h
;
2085 // this callback can be connected to m_wxwindow,
2086 // so always get size from m_widget->allocation
2087 win
->m_width
= win
->m_widget
->allocation
.width
;
2088 win
->m_height
= win
->m_widget
->allocation
.height
;
2089 if (!win
->m_nativeSizeEvent
)
2091 wxSizeEvent
event(win
->GetSize(), win
->GetId());
2092 event
.SetEventObject(win
);
2093 win
->GTKProcessEvent(event
);
2098 //-----------------------------------------------------------------------------
2100 //-----------------------------------------------------------------------------
2102 #if GTK_CHECK_VERSION(2, 8, 0)
2104 gtk_window_grab_broken( GtkWidget
*,
2105 GdkEventGrabBroken
*event
,
2108 // Mouse capture has been lost involuntarily, notify the application
2109 if(!event
->keyboard
&& wxWindow::GetCapture() == win
)
2111 wxMouseCaptureLostEvent
evt( win
->GetId() );
2112 evt
.SetEventObject( win
);
2113 win
->GetEventHandler()->ProcessEvent( evt
);
2119 //-----------------------------------------------------------------------------
2121 //-----------------------------------------------------------------------------
2124 void gtk_window_style_set_callback( GtkWidget
*WXUNUSED(widget
),
2125 GtkStyle
*previous_style
,
2128 //wxLogDebug(wxT("gtk_window_style_set_callback"));
2129 if (win
&& previous_style
)
2131 wxString
name(win
->GetName());
2132 //wxLogDebug(wxT("gtk_window_style_set_callback %s"), name.c_str());
2133 wxSysColourChangedEvent event
;
2134 event
.SetEventObject(win
);
2136 win
->GTKProcessEvent( event
);
2142 // Connect/disconnect style-set
2144 void wxConnectStyleSet(wxWindow
* win
)
2146 if (win
->m_wxwindow
)
2147 g_signal_connect (win
->m_wxwindow
, "style_set",
2148 G_CALLBACK (gtk_window_style_set_callback
), win
);
2151 void wxDisconnectStyleSet(wxWindow
* win
)
2153 if (win
->m_wxwindow
)
2154 g_signal_handlers_disconnect_by_func (win
->m_wxwindow
,
2155 (gpointer
) gtk_window_style_set_callback
,
2159 // Helper to suspend colour change event event processing while we change a widget's style
2160 class wxSuspendStyleEvents
2163 wxSuspendStyleEvents(wxWindow
* win
)
2166 if (win
->IsTopLevel())
2167 wxDisconnectStyleSet(win
);
2169 ~wxSuspendStyleEvents()
2171 if (m_win
->IsTopLevel())
2172 wxConnectStyleSet(m_win
);
2178 // ----------------------------------------------------------------------------
2179 // this wxWindowBase function is implemented here (in platform-specific file)
2180 // because it is static and so couldn't be made virtual
2181 // ----------------------------------------------------------------------------
2183 wxWindow
*wxWindowBase::DoFindFocus()
2185 // the cast is necessary when we compile in wxUniversal mode
2186 return (wxWindow
*)g_focusWindow
;
2189 //-----------------------------------------------------------------------------
2190 // InsertChild for wxWindowGTK.
2191 //-----------------------------------------------------------------------------
2193 /* Callback for wxWindowGTK. This very strange beast has to be used because
2194 * C++ has no virtual methods in a constructor. We have to emulate a
2195 * virtual function here as wxNotebook requires a different way to insert
2196 * a child in it. I had opted for creating a wxNotebookPage window class
2197 * which would have made this superfluous (such in the MDI window system),
2198 * but no-one was listening to me... */
2200 static void wxInsertChildInWindow( wxWindowGTK
* parent
, wxWindowGTK
* child
)
2202 /* the window might have been scrolled already, do we
2203 have to adapt the position */
2204 GtkPizza
*pizza
= GTK_PIZZA(parent
->m_wxwindow
);
2205 child
->m_x
+= gtk_pizza_get_xoffset( pizza
);
2206 child
->m_y
+= gtk_pizza_get_yoffset( pizza
);
2208 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
2216 //-----------------------------------------------------------------------------
2218 //-----------------------------------------------------------------------------
2220 wxWindow
*wxGetActiveWindow()
2222 return wxWindow::FindFocus();
2226 wxMouseState
wxGetMouseState()
2232 GdkModifierType mask
;
2234 gdk_window_get_pointer(NULL
, &x
, &y
, &mask
);
2238 ms
.SetLeftDown(mask
& GDK_BUTTON1_MASK
);
2239 ms
.SetMiddleDown(mask
& GDK_BUTTON2_MASK
);
2240 ms
.SetRightDown(mask
& GDK_BUTTON3_MASK
);
2241 ms
.SetAux1Down(mask
& GDK_BUTTON4_MASK
);
2242 ms
.SetAux2Down(mask
& GDK_BUTTON5_MASK
);
2244 ms
.SetControlDown(mask
& GDK_CONTROL_MASK
);
2245 ms
.SetShiftDown(mask
& GDK_SHIFT_MASK
);
2246 ms
.SetAltDown(mask
& GDK_MOD1_MASK
);
2247 ms
.SetMetaDown(mask
& GDK_MOD2_MASK
);
2252 //-----------------------------------------------------------------------------
2254 //-----------------------------------------------------------------------------
2256 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2258 #ifdef __WXUNIVERSAL__
2259 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2261 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
2262 #endif // __WXUNIVERSAL__/__WXGTK__
2264 void wxWindowGTK::Init()
2267 m_widget
= (GtkWidget
*) NULL
;
2268 m_wxwindow
= (GtkWidget
*) NULL
;
2269 m_focusWidget
= (GtkWidget
*) NULL
;
2278 m_isBeingDeleted
= false;
2280 m_showOnIdle
= false;
2283 m_nativeSizeEvent
= false;
2285 m_hasScrolling
= false;
2286 m_isScrolling
= false;
2287 m_mouseButtonDown
= false;
2289 // initialize scrolling stuff
2290 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2292 m_scrollBar
[dir
] = NULL
;
2293 m_scrollPos
[dir
] = 0;
2297 m_oldClientHeight
= 0;
2299 m_insertCallback
= wxInsertChildInWindow
;
2303 m_clipPaintRegion
= false;
2305 m_needsStyleChange
= false;
2307 m_cursor
= *wxSTANDARD_CURSOR
;
2310 m_dirtyTabOrder
= false;
2313 wxWindowGTK::wxWindowGTK()
2318 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2323 const wxString
&name
)
2327 Create( parent
, id
, pos
, size
, style
, name
);
2330 bool wxWindowGTK::Create( wxWindow
*parent
,
2335 const wxString
&name
)
2337 if (!PreCreation( parent
, pos
, size
) ||
2338 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2340 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2344 if (!HasFlag(wxHSCROLL
) && !HasFlag(wxVSCROLL
))
2346 m_wxwindow
= gtk_pizza_new_no_scroll();
2348 #ifndef __WXUNIVERSAL__
2349 if (HasFlag(wxSIMPLE_BORDER
))
2350 gtk_container_set_border_width((GtkContainer
*)m_wxwindow
, 1);
2351 else if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
2352 gtk_container_set_border_width((GtkContainer
*)m_wxwindow
, 2);
2353 #endif // __WXUNIVERSAL__
2355 m_widget
= m_wxwindow
;
2359 m_wxwindow
= gtk_pizza_new();
2361 #ifndef __WXUNIVERSAL__
2362 if (HasFlag(wxSIMPLE_BORDER
))
2363 gtk_container_set_border_width((GtkContainer
*)m_wxwindow
, 1);
2364 else if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
2365 gtk_container_set_border_width((GtkContainer
*)m_wxwindow
, 2);
2366 #endif // __WXUNIVERSAL__
2368 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
2370 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2372 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2373 scroll_class
->scrollbar_spacing
= 0;
2375 // There is a conflict with default bindings at GTK+
2376 // level between scrolled windows and notebooks both of which want to use
2377 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2378 // direction and notebooks for changing pages -- we decide that if we don't
2379 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2380 // means we can get working keyboard navigation in notebooks
2381 if ( !HasFlag(wxHSCROLL
) )
2384 bindings
= gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget
));
2387 gtk_binding_entry_remove(bindings
, GDK_Page_Up
, GDK_CONTROL_MASK
);
2388 gtk_binding_entry_remove(bindings
, GDK_Page_Down
, GDK_CONTROL_MASK
);
2392 if (HasFlag(wxALWAYS_SHOW_SB
))
2394 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_ALWAYS
, GTK_POLICY_ALWAYS
);
2396 scrolledWindow
->hscrollbar_visible
= TRUE
;
2397 scrolledWindow
->vscrollbar_visible
= TRUE
;
2401 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2404 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(scrolledWindow
->hscrollbar
);
2405 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(scrolledWindow
->vscrollbar
);
2406 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2407 gtk_range_set_inverted( m_scrollBar
[ScrollDir_Horz
], TRUE
);
2409 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2411 // connect various scroll-related events
2412 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2414 // these handlers block mouse events to any window during scrolling
2415 // such as motion events and prevent GTK and wxWidgets from fighting
2416 // over where the slider should be
2417 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2418 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2419 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2420 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2422 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2423 G_CALLBACK(gtk_scrollbar_event_after
), this);
2424 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2426 // these handlers get notified when scrollbar slider moves
2427 g_signal_connect_after(m_scrollBar
[dir
], "value_changed",
2428 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2431 gtk_widget_show( m_wxwindow
);
2435 m_parent
->DoAddChild( this );
2437 m_focusWidget
= m_wxwindow
;
2444 wxWindowGTK::~wxWindowGTK()
2448 if (g_focusWindow
== this)
2449 g_focusWindow
= NULL
;
2451 if ( g_delayedFocus
== this )
2452 g_delayedFocus
= NULL
;
2454 m_isBeingDeleted
= true;
2457 // destroy children before destroying this window itself
2460 // unhook focus handlers to prevent stray events being
2461 // propagated to this (soon to be) dead object
2462 if (m_focusWidget
!= NULL
)
2464 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2465 (gpointer
) gtk_window_focus_in_callback
,
2467 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2468 (gpointer
) gtk_window_focus_out_callback
,
2475 // delete before the widgets to avoid a crash on solaris
2478 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
2480 gtk_widget_destroy( m_wxwindow
);
2481 m_wxwindow
= (GtkWidget
*) NULL
;
2486 gtk_widget_destroy( m_widget
);
2487 m_widget
= (GtkWidget
*) NULL
;
2491 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2493 if ( GTKNeedsParent() )
2495 wxCHECK_MSG( parent
, false, wxT("Must have non-NULL parent") );
2498 // Use either the given size, or the default if -1 is given.
2499 // See wxWindowBase for these functions.
2500 m_width
= WidthDefault(size
.x
) ;
2501 m_height
= HeightDefault(size
.y
);
2509 void wxWindowGTK::PostCreation()
2511 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2517 // these get reported to wxWidgets -> wxPaintEvent
2519 g_signal_connect (m_wxwindow
, "expose_event",
2520 G_CALLBACK (gtk_window_expose_callback
), this);
2522 if (GetLayoutDirection() == wxLayout_LeftToRight
)
2523 gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow
), HasFlag( wxFULL_REPAINT_ON_RESIZE
) );
2526 // Create input method handler
2527 m_imData
= new wxGtkIMData
;
2529 // Cannot handle drawing preedited text yet
2530 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2532 g_signal_connect (m_imData
->context
, "commit",
2533 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2535 // these are called when the "sunken" or "raised" borders are drawn
2536 g_signal_connect (m_widget
, "expose_event",
2537 G_CALLBACK (gtk_window_own_expose_callback
), this);
2542 if (!GTK_IS_WINDOW(m_widget
))
2544 if (m_focusWidget
== NULL
)
2545 m_focusWidget
= m_widget
;
2549 g_signal_connect (m_focusWidget
, "focus_in_event",
2550 G_CALLBACK (gtk_window_focus_in_callback
), this);
2551 g_signal_connect (m_focusWidget
, "focus_out_event",
2552 G_CALLBACK (gtk_window_focus_out_callback
), this);
2556 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2557 G_CALLBACK (gtk_window_focus_in_callback
), this);
2558 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2559 G_CALLBACK (gtk_window_focus_out_callback
), this);
2563 if ( !AcceptsFocusFromKeyboard() )
2567 g_signal_connect(m_widget
, "focus",
2568 G_CALLBACK(wx_window_focus_callback
), this);
2571 // connect to the various key and mouse handlers
2573 GtkWidget
*connect_widget
= GetConnectWidget();
2575 ConnectWidget( connect_widget
);
2577 /* We cannot set colours, fonts and cursors before the widget has
2578 been realized, so we do this directly after realization */
2579 g_signal_connect (connect_widget
, "realize",
2580 G_CALLBACK (gtk_window_realized_callback
), this);
2584 g_signal_connect(m_wxwindow
? m_wxwindow
: m_widget
, "size_allocate",
2585 G_CALLBACK(size_allocate
), this);
2590 #if GTK_CHECK_VERSION(2, 8, 0)
2591 if (!gtk_check_version(2,8,0))
2593 // Make sure we can notify the app when mouse capture is lost
2594 g_signal_connect (m_wxwindow
, "grab_broken_event",
2595 G_CALLBACK (gtk_window_grab_broken
), this);
2600 if ( connect_widget
!= m_wxwindow
)
2602 #if GTK_CHECK_VERSION(2, 8, 0)
2603 if (!gtk_check_version(2,8,0))
2605 // Make sure we can notify app code when mouse capture is lost
2606 g_signal_connect (connect_widget
, "grab_broken_event",
2607 G_CALLBACK (gtk_window_grab_broken
), this);
2613 if (GTK_IS_COMBO(m_widget
))
2615 GtkCombo
*gcombo
= GTK_COMBO(m_widget
);
2617 g_signal_connect (gcombo
->entry
, "size_request",
2618 G_CALLBACK (wxgtk_combo_size_request_callback
),
2621 #endif // wxUSE_COMBOBOX
2622 #ifdef GTK_IS_FILE_CHOOSER_BUTTON
2623 if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget
))
2625 // If we connect to the "size_request" signal of a GtkFileChooserButton
2626 // then that control won't be sized properly when placed inside sizers
2627 // (this can be tested removing this elseif and running XRC or WIDGETS samples)
2628 // FIXME: what should be done here ?
2631 if ( !IsTopLevel() ) // top level windows use their own callback
2633 // This is needed if we want to add our windows into native
2634 // GTK controls, such as the toolbar. With this callback, the
2635 // toolbar gets to know the correct size (the one set by the
2636 // programmer). Sadly, it misbehaves for wxComboBox.
2637 g_signal_connect (m_widget
, "size_request",
2638 G_CALLBACK (wxgtk_window_size_request_callback
),
2642 InheritAttributes();
2646 SetLayoutDirection(wxLayout_Default
);
2648 // unless the window was created initially hidden (i.e. Hide() had been
2649 // called before Create()), we should show it at GTK+ level as well
2651 gtk_widget_show( m_widget
);
2654 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2656 g_signal_connect (widget
, "key_press_event",
2657 G_CALLBACK (gtk_window_key_press_callback
), this);
2658 g_signal_connect (widget
, "key_release_event",
2659 G_CALLBACK (gtk_window_key_release_callback
), this);
2660 g_signal_connect (widget
, "button_press_event",
2661 G_CALLBACK (gtk_window_button_press_callback
), this);
2662 g_signal_connect (widget
, "button_release_event",
2663 G_CALLBACK (gtk_window_button_release_callback
), this);
2664 g_signal_connect (widget
, "motion_notify_event",
2665 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2666 g_signal_connect (widget
, "scroll_event",
2667 G_CALLBACK (window_scroll_event
), this);
2668 g_signal_connect (widget
, "popup_menu",
2669 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2670 g_signal_connect (widget
, "enter_notify_event",
2671 G_CALLBACK (gtk_window_enter_callback
), this);
2672 g_signal_connect (widget
, "leave_notify_event",
2673 G_CALLBACK (gtk_window_leave_callback
), this);
2675 if (IsTopLevel() && m_wxwindow
)
2676 g_signal_connect (m_wxwindow
, "style_set",
2677 G_CALLBACK (gtk_window_style_set_callback
), this);
2680 bool wxWindowGTK::Destroy()
2682 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2686 return wxWindowBase::Destroy();
2689 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2691 // inform the parent to perform the move
2692 gtk_pizza_set_size( GTK_PIZZA(m_parent
->m_wxwindow
), m_widget
, x
, y
, width
, height
);
2696 void wxWindowGTK::ConstrainSize()
2699 // GPE's window manager doesn't like size hints at all, esp. when the user
2700 // has to use the virtual keyboard, so don't constrain size there
2704 const wxSize minSize
= GetMinSize();
2705 const wxSize maxSize
= GetMaxSize();
2706 if (minSize
.x
> 0 && m_width
< minSize
.x
) m_width
= minSize
.x
;
2707 if (minSize
.y
> 0 && m_height
< minSize
.y
) m_height
= minSize
.y
;
2708 if (maxSize
.x
> 0 && m_width
> maxSize
.x
) m_width
= maxSize
.x
;
2709 if (maxSize
.y
> 0 && m_height
> maxSize
.y
) m_height
= maxSize
.y
;
2713 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2715 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2716 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2718 int currentX
, currentY
;
2719 GetPosition(¤tX
, ¤tY
);
2720 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2722 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2724 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2726 // calculate the best size if we should auto size the window
2727 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2728 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2730 const wxSize sizeBest
= GetBestSize();
2731 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2733 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2734 height
= sizeBest
.y
;
2737 const wxSize
oldSize(m_width
, m_height
);
2745 if (m_parent
->m_wxwindow
)
2747 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
2748 m_x
= x
+ gtk_pizza_get_xoffset(pizza
);
2749 m_y
= y
+ gtk_pizza_get_yoffset(pizza
);
2751 int left_border
= 0;
2752 int right_border
= 0;
2754 int bottom_border
= 0;
2756 /* the default button has a border around it */
2757 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
2759 GtkBorder
*default_border
= NULL
;
2760 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2763 left_border
+= default_border
->left
;
2764 right_border
+= default_border
->right
;
2765 top_border
+= default_border
->top
;
2766 bottom_border
+= default_border
->bottom
;
2767 gtk_border_free( default_border
);
2771 DoMoveWindow( m_x
- left_border
,
2773 m_width
+left_border
+right_border
,
2774 m_height
+top_border
+bottom_border
);
2777 if (m_width
!= oldSize
.x
|| m_height
!= oldSize
.y
)
2779 // update these variables to keep size_allocate handler
2780 // from sending another size event for this change
2781 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2783 gtk_widget_queue_resize(m_widget
);
2784 if (!m_nativeSizeEvent
)
2786 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2787 event
.SetEventObject( this );
2788 GetEventHandler()->ProcessEvent( event
);
2793 bool wxWindowGTK::GtkShowFromOnIdle()
2795 if (IsShown() && m_showOnIdle
&& !GTK_WIDGET_VISIBLE (m_widget
))
2797 GtkAllocation alloc
;
2800 alloc
.width
= m_width
;
2801 alloc
.height
= m_height
;
2802 gtk_widget_size_allocate( m_widget
, &alloc
);
2803 gtk_widget_show( m_widget
);
2804 wxShowEvent
eventShow(GetId(), true);
2805 eventShow
.SetEventObject(this);
2806 GetEventHandler()->ProcessEvent(eventShow
);
2807 m_showOnIdle
= false;
2814 void wxWindowGTK::OnInternalIdle()
2816 // Check if we have to show window now
2817 if (GtkShowFromOnIdle()) return;
2819 if ( m_dirtyTabOrder
)
2821 m_dirtyTabOrder
= false;
2825 // Update style if the window was not yet realized
2826 // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
2827 if (m_needsStyleChange
)
2829 SetBackgroundStyle(GetBackgroundStyle());
2830 m_needsStyleChange
= false;
2833 wxCursor cursor
= m_cursor
;
2834 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
2838 /* I now set the cursor anew in every OnInternalIdle call
2839 as setting the cursor in a parent window also effects the
2840 windows above so that checking for the current cursor is
2843 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
2845 GdkWindow
*window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2847 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2849 if (!g_globalCursor
.Ok())
2850 cursor
= *wxSTANDARD_CURSOR
;
2852 window
= m_widget
->window
;
2853 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
2854 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2857 else if ( m_widget
)
2859 GdkWindow
*window
= m_widget
->window
;
2860 if ( window
&& !GTK_WIDGET_NO_WINDOW(m_widget
) )
2861 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2865 if (wxUpdateUIEvent::CanUpdate(this) && IsShown())
2866 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
2869 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
2871 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2873 if (width
) (*width
) = m_width
;
2874 if (height
) (*height
) = m_height
;
2877 void wxWindowGTK::DoSetClientSize( int width
, int height
)
2879 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2881 const wxSize size
= GetSize();
2882 const wxSize clientSize
= GetClientSize();
2883 SetSize(width
+ (size
.x
- clientSize
.x
), height
+ (size
.y
- clientSize
.y
));
2886 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
2888 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2899 GetScrollbarWidth(m_widget
, dw
, dh
);
2901 const int border
= GTK_CONTAINER(m_wxwindow
)->border_width
;
2913 if (width
) *width
= w
;
2914 if (height
) *height
= h
;
2917 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
2919 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2923 if (!IsTopLevel() && m_parent
&& m_parent
->m_wxwindow
)
2925 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
2926 dx
= gtk_pizza_get_xoffset( pizza
);
2927 dy
= gtk_pizza_get_yoffset( pizza
);
2930 if (m_x
== -1 && m_y
== -1)
2932 GdkWindow
*source
= (GdkWindow
*) NULL
;
2934 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2936 source
= m_widget
->window
;
2942 gdk_window_get_origin( source
, &org_x
, &org_y
);
2945 m_parent
->ScreenToClient(&org_x
, &org_y
);
2947 wx_const_cast(wxWindowGTK
*, this)->m_x
= org_x
;
2948 wx_const_cast(wxWindowGTK
*, this)->m_y
= org_y
;
2952 if (x
) (*x
) = m_x
- dx
;
2953 if (y
) (*y
) = m_y
- dy
;
2956 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
2958 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2960 if (!m_widget
->window
) return;
2962 GdkWindow
*source
= (GdkWindow
*) NULL
;
2964 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2966 source
= m_widget
->window
;
2970 gdk_window_get_origin( source
, &org_x
, &org_y
);
2974 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2976 org_x
+= m_widget
->allocation
.x
;
2977 org_y
+= m_widget
->allocation
.y
;
2984 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2985 *x
= (GetClientSize().x
- *x
) + org_x
;
2993 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
2995 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2997 if (!m_widget
->window
) return;
2999 GdkWindow
*source
= (GdkWindow
*) NULL
;
3001 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3003 source
= m_widget
->window
;
3007 gdk_window_get_origin( source
, &org_x
, &org_y
);
3011 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3013 org_x
+= m_widget
->allocation
.x
;
3014 org_y
+= m_widget
->allocation
.y
;
3020 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3021 *x
= (GetClientSize().x
- *x
) - org_x
;
3028 bool wxWindowGTK::Show( bool show
)
3030 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3032 if (!wxWindowBase::Show(show
))
3042 gtk_widget_show( m_widget
);
3043 wxShowEvent
eventShow(GetId(), show
);
3044 eventShow
.SetEventObject(this);
3045 GetEventHandler()->ProcessEvent(eventShow
);
3050 gtk_widget_hide( m_widget
);
3051 wxShowEvent
eventShow(GetId(), show
);
3052 eventShow
.SetEventObject(this);
3053 GetEventHandler()->ProcessEvent(eventShow
);
3059 void wxWindowGTK::DoEnable( bool enable
)
3061 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3063 gtk_widget_set_sensitive( m_widget
, enable
);
3064 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3065 gtk_widget_set_sensitive( m_wxwindow
, enable
);
3068 int wxWindowGTK::GetCharHeight() const
3070 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
3072 wxFont font
= GetFont();
3073 wxCHECK_MSG( font
.Ok(), 12, wxT("invalid font") );
3075 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
3080 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3081 PangoLayout
*layout
= pango_layout_new(context
);
3082 pango_layout_set_font_description(layout
, desc
);
3083 pango_layout_set_text(layout
, "H", 1);
3084 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3086 PangoRectangle rect
;
3087 pango_layout_line_get_extents(line
, NULL
, &rect
);
3089 g_object_unref (layout
);
3091 return (int) PANGO_PIXELS(rect
.height
);
3094 int wxWindowGTK::GetCharWidth() const
3096 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
3098 wxFont font
= GetFont();
3099 wxCHECK_MSG( font
.Ok(), 8, wxT("invalid font") );
3101 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
3106 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3107 PangoLayout
*layout
= pango_layout_new(context
);
3108 pango_layout_set_font_description(layout
, desc
);
3109 pango_layout_set_text(layout
, "g", 1);
3110 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3112 PangoRectangle rect
;
3113 pango_layout_line_get_extents(line
, NULL
, &rect
);
3115 g_object_unref (layout
);
3117 return (int) PANGO_PIXELS(rect
.width
);
3120 void wxWindowGTK::GetTextExtent( const wxString
& string
,
3124 int *externalLeading
,
3125 const wxFont
*theFont
) const
3127 wxFont fontToUse
= theFont
? *theFont
: GetFont();
3129 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
3138 PangoContext
*context
= NULL
;
3140 context
= gtk_widget_get_pango_context( m_widget
);
3149 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3150 PangoLayout
*layout
= pango_layout_new(context
);
3151 pango_layout_set_font_description(layout
, desc
);
3153 const wxCharBuffer data
= wxGTK_CONV( string
);
3155 pango_layout_set_text(layout
, data
, strlen(data
));
3158 PangoRectangle rect
;
3159 pango_layout_get_extents(layout
, NULL
, &rect
);
3161 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
3162 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
3165 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
3166 int baseline
= pango_layout_iter_get_baseline(iter
);
3167 pango_layout_iter_free(iter
);
3168 *descent
= *y
- PANGO_PIXELS(baseline
);
3170 if (externalLeading
) (*externalLeading
) = 0; // ??
3172 g_object_unref (layout
);
3175 bool wxWindowGTK::GTKSetDelayedFocusIfNeeded()
3177 if ( g_delayedFocus
== this )
3179 if ( GTK_WIDGET_REALIZED(m_widget
) )
3181 gtk_widget_grab_focus(m_widget
);
3182 g_delayedFocus
= NULL
;
3191 void wxWindowGTK::SetFocus()
3193 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3196 // don't do anything if we already have focus
3202 // wxWindow::SetFocus() should really set the focus to
3203 // this control, whatever the flags are
3204 if (!GTK_WIDGET_CAN_FOCUS(m_wxwindow
))
3205 GTK_WIDGET_SET_FLAGS(m_wxwindow
, GTK_CAN_FOCUS
);
3207 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow
))
3209 gtk_widget_grab_focus (m_wxwindow
);
3214 // wxWindow::SetFocus() should really set the focus to
3215 // this control, whatever the flags are
3216 if (!GTK_WIDGET_CAN_FOCUS(m_widget
))
3217 GTK_WIDGET_SET_FLAGS(m_widget
, GTK_CAN_FOCUS
);
3219 if (GTK_IS_CONTAINER(m_widget
))
3221 if (GTK_IS_RADIO_BUTTON(m_widget
))
3223 gtk_widget_grab_focus (m_widget
);
3227 gtk_widget_child_focus( m_widget
, GTK_DIR_TAB_FORWARD
);
3230 if (GTK_WIDGET_CAN_FOCUS(m_widget
) && !GTK_WIDGET_HAS_FOCUS (m_widget
) )
3233 if (!GTK_WIDGET_REALIZED(m_widget
))
3235 // we can't set the focus to the widget now so we remember that
3236 // it should be focused and will do it later, during the idle
3237 // time, as soon as we can
3238 wxLogTrace(TRACE_FOCUS
,
3239 _T("Delaying setting focus to %s(%s)"),
3240 GetClassInfo()->GetClassName(), GetLabel().c_str());
3242 g_delayedFocus
= this;
3246 wxLogTrace(TRACE_FOCUS
,
3247 _T("Setting focus to %s(%s)"),
3248 GetClassInfo()->GetClassName(), GetLabel().c_str());
3250 gtk_widget_grab_focus (m_widget
);
3255 wxLogTrace(TRACE_FOCUS
,
3256 _T("Can't set focus to %s(%s)"),
3257 GetClassInfo()->GetClassName(), GetLabel().c_str());
3262 void wxWindowGTK::SetCanFocus(bool canFocus
)
3265 GTK_WIDGET_SET_FLAGS(m_widget
, GTK_CAN_FOCUS
);
3267 GTK_WIDGET_UNSET_FLAGS(m_widget
, GTK_CAN_FOCUS
);
3269 if ( m_wxwindow
&& (m_widget
!= m_wxwindow
) )
3272 GTK_WIDGET_SET_FLAGS(m_wxwindow
, GTK_CAN_FOCUS
);
3274 GTK_WIDGET_UNSET_FLAGS(m_wxwindow
, GTK_CAN_FOCUS
);
3278 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3280 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3282 wxWindowGTK
*oldParent
= m_parent
,
3283 *newParent
= (wxWindowGTK
*)newParentBase
;
3285 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3287 if ( !wxWindowBase::Reparent(newParent
) )
3290 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3292 /* prevent GTK from deleting the widget arbitrarily */
3293 gtk_widget_ref( m_widget
);
3297 gtk_container_remove( GTK_CONTAINER(m_widget
->parent
), m_widget
);
3300 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3304 if (GTK_WIDGET_VISIBLE (newParent
->m_widget
))
3306 m_showOnIdle
= true;
3307 gtk_widget_hide( m_widget
);
3310 /* insert GTK representation */
3311 (*(newParent
->m_insertCallback
))(newParent
, this);
3314 /* reverse: prevent GTK from deleting the widget arbitrarily */
3315 gtk_widget_unref( m_widget
);
3317 SetLayoutDirection(wxLayout_Default
);
3322 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3324 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3325 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3330 /* insert GTK representation */
3331 (*m_insertCallback
)(this, child
);
3334 void wxWindowGTK::AddChild(wxWindowBase
*child
)
3336 wxWindowBase::AddChild(child
);
3337 m_dirtyTabOrder
= true;
3338 wxTheApp
->WakeUpIdle();
3341 void wxWindowGTK::RemoveChild(wxWindowBase
*child
)
3343 wxWindowBase::RemoveChild(child
);
3344 m_dirtyTabOrder
= true;
3345 wxTheApp
->WakeUpIdle();
3349 wxLayoutDirection
wxWindowGTK::GTKGetLayout(GtkWidget
*widget
)
3351 return gtk_widget_get_direction(widget
) == GTK_TEXT_DIR_RTL
3352 ? wxLayout_RightToLeft
3353 : wxLayout_LeftToRight
;
3357 void wxWindowGTK::GTKSetLayout(GtkWidget
*widget
, wxLayoutDirection dir
)
3359 wxASSERT_MSG( dir
!= wxLayout_Default
, _T("invalid layout direction") );
3361 gtk_widget_set_direction(widget
,
3362 dir
== wxLayout_RightToLeft
? GTK_TEXT_DIR_RTL
3363 : GTK_TEXT_DIR_LTR
);
3366 wxLayoutDirection
wxWindowGTK::GetLayoutDirection() const
3368 return GTKGetLayout(m_widget
);
3371 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir
)
3373 if ( dir
== wxLayout_Default
)
3375 const wxWindow
*const parent
= GetParent();
3378 // inherit layout from parent.
3379 dir
= parent
->GetLayoutDirection();
3381 else // no parent, use global default layout
3383 dir
= wxTheApp
->GetLayoutDirection();
3387 if ( dir
== wxLayout_Default
)
3390 GTKSetLayout(m_widget
, dir
);
3392 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3393 GTKSetLayout(m_wxwindow
, dir
);
3397 wxWindowGTK::AdjustForLayoutDirection(wxCoord x
,
3398 wxCoord
WXUNUSED(width
),
3399 wxCoord
WXUNUSED(widthTotal
)) const
3401 // We now mirrors the coordinates of RTL windows in GtkPizza
3405 void wxWindowGTK::DoMoveInTabOrder(wxWindow
*win
, MoveKind move
)
3407 wxWindowBase::DoMoveInTabOrder(win
, move
);
3408 m_dirtyTabOrder
= true;
3409 wxTheApp
->WakeUpIdle();
3412 bool wxWindowGTK::DoNavigateIn(int flags
)
3414 if ( flags
& wxNavigationKeyEvent::WinChange
)
3416 wxFAIL_MSG( _T("not implemented") );
3420 else // navigate inside the container
3422 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3423 wxCHECK_MSG( parent
, false, _T("every window must have a TLW parent") );
3425 GtkDirectionType dir
;
3426 dir
= flags
& wxNavigationKeyEvent::IsForward
? GTK_DIR_TAB_FORWARD
3427 : GTK_DIR_TAB_BACKWARD
;
3430 g_signal_emit_by_name(parent
->m_widget
, "focus", dir
, &rc
);
3436 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3438 // none needed by default
3442 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3444 // nothing to do by default since none is needed
3447 void wxWindowGTK::RealizeTabOrder()
3451 if ( !m_children
.empty() )
3453 // we don't only construct the correct focus chain but also use
3454 // this opportunity to update the mnemonic widgets for the widgets
3457 GList
*chain
= NULL
;
3458 wxWindowGTK
* mnemonicWindow
= NULL
;
3460 for ( wxWindowList::const_iterator i
= m_children
.begin();
3461 i
!= m_children
.end();
3464 wxWindowGTK
*win
= *i
;
3466 if ( mnemonicWindow
)
3468 if ( win
->AcceptsFocusFromKeyboard() )
3470 // wxComboBox et al. needs to focus on on a different
3471 // widget than m_widget, so if the main widget isn't
3472 // focusable try the connect widget
3473 GtkWidget
* w
= win
->m_widget
;
3474 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3476 w
= win
->GetConnectWidget();
3477 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3483 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3484 mnemonicWindow
= NULL
;
3488 else if ( win
->GTKWidgetNeedsMnemonic() )
3490 mnemonicWindow
= win
;
3493 chain
= g_list_prepend(chain
, win
->m_widget
);
3496 chain
= g_list_reverse(chain
);
3498 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3503 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3508 void wxWindowGTK::Raise()
3510 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3512 if (m_wxwindow
&& m_wxwindow
->window
)
3514 gdk_window_raise( m_wxwindow
->window
);
3516 else if (m_widget
->window
)
3518 gdk_window_raise( m_widget
->window
);
3522 void wxWindowGTK::Lower()
3524 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3526 if (m_wxwindow
&& m_wxwindow
->window
)
3528 gdk_window_lower( m_wxwindow
->window
);
3530 else if (m_widget
->window
)
3532 gdk_window_lower( m_widget
->window
);
3536 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3538 if ( !wxWindowBase::SetCursor(cursor
.Ok() ? cursor
: *wxSTANDARD_CURSOR
) )
3546 void wxWindowGTK::GTKUpdateCursor()
3548 wxCursor
cursor(g_globalCursor
.Ok() ? g_globalCursor
: GetCursor());
3551 wxArrayGdkWindows windowsThis
;
3552 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
3555 gdk_window_set_cursor(winThis
, cursor
.GetCursor());
3559 const size_t count
= windowsThis
.size();
3560 for ( size_t n
= 0; n
< count
; n
++ )
3562 GdkWindow
*win
= windowsThis
[n
];
3565 wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?"));
3569 gdk_window_set_cursor(win
, cursor
.GetCursor());
3575 void wxWindowGTK::WarpPointer( int x
, int y
)
3577 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3579 // We provide this function ourselves as it is
3580 // missing in GDK (top of this file).
3582 GdkWindow
*window
= (GdkWindow
*) NULL
;
3584 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3586 window
= GetConnectWidget()->window
;
3589 gdk_window_warp_pointer( window
, x
, y
);
3592 wxWindowGTK::ScrollDir
wxWindowGTK::ScrollDirFromRange(GtkRange
*range
) const
3594 // find the scrollbar which generated the event
3595 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3597 if ( range
== m_scrollBar
[dir
] )
3598 return (ScrollDir
)dir
;
3601 wxFAIL_MSG( _T("event from unknown scrollbar received") );
3603 return ScrollDir_Max
;
3606 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3608 bool changed
= false;
3609 GtkRange
* range
= m_scrollBar
[dir
];
3610 if ( range
&& units
)
3612 GtkAdjustment
* adj
= range
->adjustment
;
3613 gdouble inc
= unit
== ScrollUnit_Line
? adj
->step_increment
3614 : adj
->page_increment
;
3616 const int posOld
= int(adj
->value
+ 0.5);
3617 gtk_range_set_value(range
, posOld
+ units
*inc
);
3619 changed
= int(adj
->value
+ 0.5) != posOld
;
3625 bool wxWindowGTK::ScrollLines(int lines
)
3627 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3630 bool wxWindowGTK::ScrollPages(int pages
)
3632 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3635 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground
),
3640 if (!m_widget
->window
)
3645 if (!GTK_PIZZA(m_wxwindow
)->bin_window
) return;
3647 GdkRectangle gdk_rect
,
3651 gdk_rect
.x
= rect
->x
;
3652 gdk_rect
.y
= rect
->y
;
3653 gdk_rect
.width
= rect
->width
;
3654 gdk_rect
.height
= rect
->height
;
3655 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3656 gdk_rect
.x
= GetClientSize().x
- gdk_rect
.x
- gdk_rect
.width
;
3660 else // invalidate everything
3665 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, p
, TRUE
);
3669 void wxWindowGTK::Update()
3673 // when we call Update() we really want to update the window immediately on
3674 // screen, even if it means flushing the entire queue and hence slowing down
3675 // everything -- but it should still be done, it's just that Update() should
3676 // be called very rarely
3680 void wxWindowGTK::GtkUpdate()
3682 if (m_wxwindow
&& GTK_PIZZA(m_wxwindow
)->bin_window
)
3683 gdk_window_process_updates( GTK_PIZZA(m_wxwindow
)->bin_window
, FALSE
);
3684 if (m_widget
&& m_widget
->window
&& (m_wxwindow
!= m_widget
))
3685 gdk_window_process_updates( m_widget
->window
, FALSE
);
3687 // for consistency with other platforms (and also because it's convenient
3688 // to be able to update an entire TLW by calling Update() only once), we
3689 // should also update all our children here
3690 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3692 node
= node
->GetNext() )
3694 node
->GetData()->GtkUpdate();
3698 bool wxWindowGTK::DoIsExposed( int x
, int y
) const
3700 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
3704 bool wxWindowGTK::DoIsExposed( int x
, int y
, int w
, int h
) const
3706 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3707 return m_updateRegion
.Contains(x
-w
, y
, w
, h
) != wxOutRegion
;
3709 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
3712 void wxWindowGTK::GtkSendPaintEvents()
3716 m_updateRegion
.Clear();
3720 // Clip to paint region in wxClientDC
3721 m_clipPaintRegion
= true;
3723 m_nativeUpdateRegion
= m_updateRegion
;
3725 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3727 // Transform m_updateRegion under RTL
3728 m_updateRegion
.Clear();
3731 gdk_window_get_geometry( GTK_PIZZA(m_wxwindow
)->bin_window
,
3732 NULL
, NULL
, &width
, NULL
, NULL
);
3734 wxRegionIterator
upd( m_nativeUpdateRegion
);
3738 rect
.x
= upd
.GetX();
3739 rect
.y
= upd
.GetY();
3740 rect
.width
= upd
.GetWidth();
3741 rect
.height
= upd
.GetHeight();
3743 rect
.x
= width
- rect
.x
- rect
.width
;
3744 m_updateRegion
.Union( rect
);
3750 // widget to draw on
3751 GtkPizza
*pizza
= GTK_PIZZA (m_wxwindow
);
3753 if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM
))
3755 // find ancestor from which to steal background
3756 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3758 parent
= (wxWindow
*)this;
3760 if (GTK_WIDGET_MAPPED(parent
->m_widget
))
3762 wxRegionIterator
upd( m_nativeUpdateRegion
);
3766 rect
.x
= upd
.GetX();
3767 rect
.y
= upd
.GetY();
3768 rect
.width
= upd
.GetWidth();
3769 rect
.height
= upd
.GetHeight();
3771 gtk_paint_flat_box( parent
->m_widget
->style
,
3773 (GtkStateType
)GTK_WIDGET_STATE(m_wxwindow
),
3786 wxWindowDC
dc( (wxWindow
*)this );
3787 dc
.SetClippingRegion( m_updateRegion
);
3789 // Work around gtk-qt <= 0.60 bug whereby the window colour
3791 if (GetBackgroundStyle() == wxBG_STYLE_COLOUR
&& GetBackgroundColour().Ok() && wxSystemOptions::GetOptionInt(wxT("gtk.window.force-background-colour")) == 1)
3793 dc
.SetBackground(wxBrush(GetBackgroundColour()));
3797 wxEraseEvent
erase_event( GetId(), &dc
);
3798 erase_event
.SetEventObject( this );
3800 GetEventHandler()->ProcessEvent(erase_event
);
3803 wxNcPaintEvent
nc_paint_event( GetId() );
3804 nc_paint_event
.SetEventObject( this );
3805 GetEventHandler()->ProcessEvent( nc_paint_event
);
3807 wxPaintEvent
paint_event( GetId() );
3808 paint_event
.SetEventObject( this );
3809 GetEventHandler()->ProcessEvent( paint_event
);
3811 m_clipPaintRegion
= false;
3813 m_updateRegion
.Clear();
3814 m_nativeUpdateRegion
.Clear();
3817 void wxWindowGTK::SetDoubleBuffered( bool on
)
3819 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3822 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3825 bool wxWindowGTK::IsDoubleBuffered() const
3827 return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow
);
3830 void wxWindowGTK::ClearBackground()
3832 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3836 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3838 wxWindowBase::DoSetToolTip(tip
);
3841 m_tooltip
->Apply( (wxWindow
*)this );
3844 void wxWindowGTK::ApplyToolTip( GtkTooltips
*tips
, const gchar
*tip
)
3846 gtk_tooltips_set_tip(tips
, GetConnectWidget(), tip
, NULL
);
3848 #endif // wxUSE_TOOLTIPS
3850 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
3852 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3854 if (!wxWindowBase::SetBackgroundColour(colour
))
3859 // We need the pixel value e.g. for background clearing.
3860 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3863 // apply style change (forceStyle=true so that new style is applied
3864 // even if the bg colour changed from valid to wxNullColour)
3865 if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM
)
3866 ApplyWidgetStyle(true);
3871 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
3873 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3875 if (!wxWindowBase::SetForegroundColour(colour
))
3882 // We need the pixel value e.g. for background clearing.
3883 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3886 // apply style change (forceStyle=true so that new style is applied
3887 // even if the bg colour changed from valid to wxNullColour):
3888 ApplyWidgetStyle(true);
3893 PangoContext
*wxWindowGTK::GtkGetPangoDefaultContext()
3895 return gtk_widget_get_pango_context( m_widget
);
3898 GtkRcStyle
*wxWindowGTK::CreateWidgetStyle(bool forceStyle
)
3900 // do we need to apply any changes at all?
3903 !m_foregroundColour
.Ok() && !m_backgroundColour
.Ok() )
3908 GtkRcStyle
*style
= gtk_rc_style_new();
3913 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
3916 int flagsNormal
= 0,
3919 flagsInsensitive
= 0;
3921 if ( m_foregroundColour
.Ok() )
3923 const GdkColor
*fg
= m_foregroundColour
.GetColor();
3925 style
->fg
[GTK_STATE_NORMAL
] =
3926 style
->text
[GTK_STATE_NORMAL
] = *fg
;
3927 flagsNormal
|= GTK_RC_FG
| GTK_RC_TEXT
;
3929 style
->fg
[GTK_STATE_PRELIGHT
] =
3930 style
->text
[GTK_STATE_PRELIGHT
] = *fg
;
3931 flagsPrelight
|= GTK_RC_FG
| GTK_RC_TEXT
;
3933 style
->fg
[GTK_STATE_ACTIVE
] =
3934 style
->text
[GTK_STATE_ACTIVE
] = *fg
;
3935 flagsActive
|= GTK_RC_FG
| GTK_RC_TEXT
;
3938 if ( m_backgroundColour
.Ok() )
3940 const GdkColor
*bg
= m_backgroundColour
.GetColor();
3942 style
->bg
[GTK_STATE_NORMAL
] =
3943 style
->base
[GTK_STATE_NORMAL
] = *bg
;
3944 flagsNormal
|= GTK_RC_BG
| GTK_RC_BASE
;
3946 style
->bg
[GTK_STATE_PRELIGHT
] =
3947 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
3948 flagsPrelight
|= GTK_RC_BG
| GTK_RC_BASE
;
3950 style
->bg
[GTK_STATE_ACTIVE
] =
3951 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
3952 flagsActive
|= GTK_RC_BG
| GTK_RC_BASE
;
3954 style
->bg
[GTK_STATE_INSENSITIVE
] =
3955 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
3956 flagsInsensitive
|= GTK_RC_BG
| GTK_RC_BASE
;
3959 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)flagsNormal
;
3960 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)flagsPrelight
;
3961 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)flagsActive
;
3962 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)flagsInsensitive
;
3967 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle
)
3969 GtkRcStyle
*style
= CreateWidgetStyle(forceStyle
);
3972 DoApplyWidgetStyle(style
);
3973 gtk_rc_style_unref(style
);
3976 // Style change may affect GTK+'s size calculation:
3977 InvalidateBestSize();
3980 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
3982 wxSuspendStyleEvents
s(static_cast<wxWindow
*>(this));
3985 gtk_widget_modify_style(m_wxwindow
, style
);
3987 gtk_widget_modify_style(m_widget
, style
);
3990 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style
)
3992 wxWindowBase::SetBackgroundStyle(style
);
3994 if (style
== wxBG_STYLE_CUSTOM
)
3999 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4003 GtkWidget
* const w
= GetConnectWidget();
4004 window
= w
? w
->window
: NULL
;
4009 // Make sure GDK/X11 doesn't refresh the window
4011 gdk_window_set_back_pixmap( window
, None
, False
);
4013 Display
* display
= GDK_WINDOW_DISPLAY(window
);
4016 m_needsStyleChange
= false;
4018 else // window not realized yet
4020 // Do in OnIdle, because the window is not yet available
4021 m_needsStyleChange
= true;
4024 // Don't apply widget style, or we get a grey background
4028 // apply style change (forceStyle=true so that new style is applied
4029 // even if the bg colour changed from valid to wxNullColour):
4030 ApplyWidgetStyle(true);
4035 #if wxUSE_DRAG_AND_DROP
4037 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4039 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4041 GtkWidget
*dnd_widget
= GetConnectWidget();
4043 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
4045 if (m_dropTarget
) delete m_dropTarget
;
4046 m_dropTarget
= dropTarget
;
4048 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
4051 #endif // wxUSE_DRAG_AND_DROP
4053 GtkWidget
* wxWindowGTK::GetConnectWidget()
4055 GtkWidget
*connect_widget
= m_widget
;
4056 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4058 return connect_widget
;
4061 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow
*window
) const
4063 wxArrayGdkWindows windowsThis
;
4064 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
4066 return winThis
? window
== winThis
4067 : windowsThis
.Index(window
) != wxNOT_FOUND
;
4070 GdkWindow
*wxWindowGTK::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
4072 return m_wxwindow
? GTK_PIZZA(m_wxwindow
)->bin_window
: m_widget
->window
;
4075 bool wxWindowGTK::SetFont( const wxFont
&font
)
4077 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4079 if (!wxWindowBase::SetFont(font
))
4082 // apply style change (forceStyle=true so that new style is applied
4083 // even if the font changed from valid to wxNullFont):
4084 ApplyWidgetStyle(true);
4089 void wxWindowGTK::DoCaptureMouse()
4091 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4093 GdkWindow
*window
= (GdkWindow
*) NULL
;
4095 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4097 window
= GetConnectWidget()->window
;
4099 wxCHECK_RET( window
, _T("CaptureMouse() failed") );
4101 const wxCursor
* cursor
= &m_cursor
;
4103 cursor
= wxSTANDARD_CURSOR
;
4105 gdk_pointer_grab( window
, FALSE
,
4107 (GDK_BUTTON_PRESS_MASK
|
4108 GDK_BUTTON_RELEASE_MASK
|
4109 GDK_POINTER_MOTION_HINT_MASK
|
4110 GDK_POINTER_MOTION_MASK
),
4112 cursor
->GetCursor(),
4113 (guint32
)GDK_CURRENT_TIME
);
4114 g_captureWindow
= this;
4115 g_captureWindowHasMouse
= true;
4118 void wxWindowGTK::DoReleaseMouse()
4120 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4122 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4124 g_captureWindow
= (wxWindowGTK
*) NULL
;
4126 GdkWindow
*window
= (GdkWindow
*) NULL
;
4128 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4130 window
= GetConnectWidget()->window
;
4135 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4138 void wxWindowGTK::GTKReleaseMouseAndNotify()
4141 wxMouseCaptureLostEvent
evt(GetId());
4142 evt
.SetEventObject( this );
4143 GetEventHandler()->ProcessEvent( evt
);
4147 wxWindow
*wxWindowBase::GetCapture()
4149 return (wxWindow
*)g_captureWindow
;
4152 bool wxWindowGTK::IsRetained() const
4157 void wxWindowGTK::SetScrollbar(int orient
,
4161 bool WXUNUSED(update
))
4163 const int dir
= ScrollDirFromOrient(orient
);
4164 GtkRange
* const sb
= m_scrollBar
[dir
];
4165 wxCHECK_RET( sb
, _T("this window is not scrollable") );
4169 m_hasScrolling
= true;
4173 // GtkRange requires upper > lower
4178 GtkAdjustment
* const adj
= sb
->adjustment
;
4179 adj
->step_increment
= 1;
4180 adj
->page_increment
=
4181 adj
->page_size
= thumbVisible
;
4184 g_signal_handlers_block_by_func(
4185 sb
, (void*)gtk_scrollbar_value_changed
, this);
4187 gtk_range_set_range(sb
, 0, range
);
4188 m_scrollPos
[dir
] = sb
->adjustment
->value
;
4190 g_signal_handlers_unblock_by_func(
4191 sb
, (void*)gtk_scrollbar_value_changed
, this);
4194 void wxWindowGTK::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4196 const int dir
= ScrollDirFromOrient(orient
);
4197 GtkRange
* const sb
= m_scrollBar
[dir
];
4198 wxCHECK_RET( sb
, _T("this window is not scrollable") );
4200 // This check is more than an optimization. Without it, the slider
4201 // will not move smoothly while tracking when using wxScrollHelper.
4202 if (GetScrollPos(orient
) != pos
)
4204 g_signal_handlers_block_by_func(
4205 sb
, (void*)gtk_scrollbar_value_changed
, this);
4207 gtk_range_set_value(sb
, pos
);
4208 m_scrollPos
[dir
] = sb
->adjustment
->value
;
4210 g_signal_handlers_unblock_by_func(
4211 sb
, (void*)gtk_scrollbar_value_changed
, this);
4215 int wxWindowGTK::GetScrollThumb(int orient
) const
4217 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4218 wxCHECK_MSG( sb
, 0, _T("this window is not scrollable") );
4220 return int(sb
->adjustment
->page_size
);
4223 int wxWindowGTK::GetScrollPos( int orient
) const
4225 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4226 wxCHECK_MSG( sb
, 0, _T("this window is not scrollable") );
4228 return int(sb
->adjustment
->value
+ 0.5);
4231 int wxWindowGTK::GetScrollRange( int orient
) const
4233 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4234 wxCHECK_MSG( sb
, 0, _T("this window is not scrollable") );
4236 return int(sb
->adjustment
->upper
);
4239 // Determine if increment is the same as +/-x, allowing for some small
4240 // difference due to possible inexactness in floating point arithmetic
4241 static inline bool IsScrollIncrement(double increment
, double x
)
4243 wxASSERT(increment
> 0);
4244 const double tolerance
= 1.0 / 1024;
4245 return fabs(increment
- fabs(x
)) < tolerance
;
4248 wxEventType
wxWindowGTK::GetScrollEventType(GtkRange
* range
)
4252 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4254 const int barIndex
= range
== m_scrollBar
[1];
4255 GtkAdjustment
* adj
= range
->adjustment
;
4257 const int value
= int(adj
->value
+ 0.5);
4259 // save previous position
4260 const double oldPos
= m_scrollPos
[barIndex
];
4261 // update current position
4262 m_scrollPos
[barIndex
] = adj
->value
;
4263 // If event should be ignored, or integral position has not changed
4264 if (!m_hasVMT
|| g_blockEventsOnDrag
|| value
== int(oldPos
+ 0.5))
4269 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4272 // Difference from last change event
4273 const double diff
= adj
->value
- oldPos
;
4274 const bool isDown
= diff
> 0;
4276 if (IsScrollIncrement(adj
->step_increment
, diff
))
4278 eventType
= isDown
? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4280 else if (IsScrollIncrement(adj
->page_increment
, diff
))
4282 eventType
= isDown
? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4284 else if (m_mouseButtonDown
)
4286 // Assume track event
4287 m_isScrolling
= true;
4293 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4295 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4297 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4299 // No scrolling requested.
4300 if ((dx
== 0) && (dy
== 0)) return;
4302 m_clipPaintRegion
= true;
4304 if (GetLayoutDirection() == wxLayout_RightToLeft
)
4305 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), dx
, -dy
);
4307 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), -dx
, -dy
);
4309 m_clipPaintRegion
= false;
4312 bool restoreCaret
= (GetCaret() != NULL
&& GetCaret()->IsVisible());
4315 wxRect
caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4317 caretRect
.width
+= dx
;
4320 caretRect
.x
+= dx
; caretRect
.width
-= dx
;
4323 caretRect
.height
+= dy
;
4326 caretRect
.y
+= dy
; caretRect
.height
-= dy
;
4329 RefreshRect(caretRect
);
4331 #endif // wxUSE_CARET
4334 void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4336 //RN: Note that static controls usually have no border on gtk, so maybe
4337 //it makes sense to treat that as simply no border at the wx level
4339 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4341 GtkShadowType gtkstyle
;
4343 if(wxstyle
& wxBORDER_RAISED
)
4344 gtkstyle
= GTK_SHADOW_OUT
;
4345 else if (wxstyle
& wxBORDER_SUNKEN
)
4346 gtkstyle
= GTK_SHADOW_IN
;
4349 else if (wxstyle
& wxBORDER_DOUBLE
)
4350 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4353 gtkstyle
= GTK_SHADOW_IN
;
4355 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4360 void wxWindowGTK::SetWindowStyleFlag( long style
)
4362 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4363 wxWindowBase::SetWindowStyleFlag(style
);
4366 // Find the wxWindow at the current mouse position, also returning the mouse
4368 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4370 pt
= wxGetMousePosition();
4371 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4375 // Get the current mouse position.
4376 wxPoint
wxGetMousePosition()
4378 /* This crashes when used within wxHelpContext,
4379 so we have to use the X-specific implementation below.
4381 GdkModifierType *mask;
4382 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4384 return wxPoint(x, y);
4388 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4390 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4391 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4392 Window rootReturn
, childReturn
;
4393 int rootX
, rootY
, winX
, winY
;
4394 unsigned int maskReturn
;
4396 XQueryPointer (display
,
4400 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4401 return wxPoint(rootX
, rootY
);
4405 // Needed for implementing e.g. combobox on wxGTK within a modal dialog.
4406 void wxAddGrab(wxWindow
* window
)
4408 gtk_grab_add( (GtkWidget
*) window
->GetHandle() );
4411 void wxRemoveGrab(wxWindow
* window
)
4413 gtk_grab_remove( (GtkWidget
*) window
->GetHandle() );