1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/window.cpp
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling, Julian Smart
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
14 #define XWarpPointer XWARPPOINTER
17 #include "wx/window.h"
23 #include "wx/dcclient.h"
25 #include "wx/settings.h"
26 #include "wx/msgdlg.h"
27 #include "wx/textctrl.h"
28 #include "wx/radiobut.h"
29 #include "wx/toolbar.h"
30 #include "wx/combobox.h"
31 #include "wx/layout.h"
36 #include "wx/tooltip.h"
38 #include "wx/fontutil.h"
41 #include "wx/thread.h"
46 // FIXME: Due to a hack we use GtkCombo in here, which is deprecated since gtk2.3.0
47 #include <gtk/gtkversion.h>
48 #if defined(GTK_DISABLE_DEPRECATED) && GTK_CHECK_VERSION(2,3,0)
49 #undef GTK_DISABLE_DEPRECATED
50 #include <gtk/gtkcombo.h>
51 #define GTK_DISABLE_DEPRECATED
54 #include "wx/gtk/private.h"
55 #include "wx/gtk/win_gtk.h"
56 #include <gdk/gdkkeysyms.h>
59 //-----------------------------------------------------------------------------
60 // documentation on internals
61 //-----------------------------------------------------------------------------
64 I have been asked several times about writing some documentation about
65 the GTK port of wxWidgets, especially its internal structures. Obviously,
66 you cannot understand wxGTK without knowing a little about the GTK, but
67 some more information about what the wxWindow, which is the base class
68 for all other window classes, does seems required as well.
72 What does wxWindow do? It contains the common interface for the following
73 jobs of its descendants:
75 1) Define the rudimentary behaviour common to all window classes, such as
76 resizing, intercepting user input (so as to make it possible to use these
77 events for special purposes in a derived class), window names etc.
79 2) Provide the possibility to contain and manage children, if the derived
80 class is allowed to contain children, which holds true for those window
81 classes which do not display a native GTK widget. To name them, these
82 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
83 work classes are a special case and are handled a bit differently from
84 the rest. The same holds true for the wxNotebook class.
86 3) Provide the possibility to draw into a client area of a window. This,
87 too, only holds true for classes that do not display a native GTK widget
90 4) Provide the entire mechanism for scrolling widgets. This actual inter-
91 face for this is usually in wxScrolledWindow, but the GTK implementation
94 5) A multitude of helper or extra methods for special purposes, such as
95 Drag'n'Drop, managing validators etc.
97 6) Display a border (sunken, raised, simple or none).
99 Normally one might expect, that one wxWidgets window would always correspond
100 to one GTK widget. Under GTK, there is no such all-round widget that has all
101 the functionality. Moreover, the GTK defines a client area as a different
102 widget from the actual widget you are handling. Last but not least some
103 special classes (e.g. wxFrame) handle different categories of widgets and
104 still have the possibility to draw something in the client area.
105 It was therefore required to write a special purpose GTK widget, that would
106 represent a client area in the sense of wxWidgets capable to do the jobs
107 2), 3) and 4). I have written this class and it resides in win_gtk.c of
110 All windows must have a widget, with which they interact with other under-
111 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
112 the wxWindow class has a member variable called m_widget which holds a
113 pointer to this widget. When the window class represents a GTK native widget,
114 this is (in most cases) the only GTK widget the class manages. E.g. the
115 wxStaticText class handles only a GtkLabel widget a pointer to which you
116 can find in m_widget (defined in wxWindow)
118 When the class has a client area for drawing into and for containing children
119 it has to handle the client area widget (of the type GtkPizza, defined in
120 win_gtk.c), but there could be any number of widgets, handled by a class
121 The common rule for all windows is only, that the widget that interacts with
122 the rest of GTK must be referenced in m_widget and all other widgets must be
123 children of this widget on the GTK level. The top-most widget, which also
124 represents the client area, must be in the m_wxwindow field and must be of
127 As I said, the window classes that display a GTK native widget only have
128 one widget, so in the case of e.g. the wxButton class m_widget holds a
129 pointer to a GtkButton widget. But windows with client areas (for drawing
130 and children) have a m_widget field that is a pointer to a GtkScrolled-
131 Window and a m_wxwindow field that is pointer to a GtkPizza and this
132 one is (in the GTK sense) a child of the GtkScrolledWindow.
134 If the m_wxwindow field is set, then all input to this widget is inter-
135 cepted and sent to the wxWidgets class. If not, all input to the widget
136 that gets pointed to by m_widget gets intercepted and sent to the class.
140 The design of scrolling in wxWidgets is markedly different from that offered
141 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
142 clicking on a scrollbar belonging to scrolled window will inevitably move
143 the window. In wxWidgets, the scrollbar will only emit an event, send this
144 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
145 which actually moves the window and its sub-windows. Note that GtkPizza
146 memorizes how much it has been scrolled but that wxWidgets forgets this
147 so that the two coordinates systems have to be kept in synch. This is done
148 in various places using the pizza->xoffset and pizza->yoffset values.
152 Singularly the most broken code in GTK is the code that is supposed to
153 inform subwindows (child windows) about new positions. Very often, duplicate
154 events are sent without changes in size or position, equally often no
155 events are sent at all (All this is due to a bug in the GtkContainer code
156 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
157 GTK's own system and it simply waits for size events for toplevel windows
158 and then iterates down the respective size events to all window. This has
159 the disadvantage that windows might get size events before the GTK widget
160 actually has the reported size. This doesn't normally pose any problem, but
161 the OpenGL drawing routines rely on correct behaviour. Therefore, I have
162 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
163 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
164 window that is used for OpenGL output really has that size (as reported by
169 If someone at some point of time feels the immense desire to have a look at,
170 change or attempt to optimise the Refresh() logic, this person will need an
171 intimate understanding of what "draw" and "expose" events are and what
172 they are used for, in particular when used in connection with GTK's
173 own windowless widgets. Beware.
177 Cursors, too, have been a constant source of pleasure. The main difficulty
178 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
179 for the parent. To prevent this from doing too much harm, I use idle time
180 to set the cursor over and over again, starting from the toplevel windows
181 and ending with the youngest generation (speaking of parent and child windows).
182 Also don't forget that cursors (like much else) are connected to GdkWindows,
183 not GtkWidgets and that the "window" field of a GtkWidget might very well
184 point to the GdkWindow of the parent widget (-> "window-less widget") and
185 that the two obviously have very different meanings.
189 //-----------------------------------------------------------------------------
191 //-----------------------------------------------------------------------------
193 // Don't allow event propagation during drag
194 bool g_blockEventsOnDrag
;
195 // Don't allow mouse event propagation during scroll
196 bool g_blockEventsOnScroll
;
197 extern wxCursor g_globalCursor
;
199 // mouse capture state: the window which has it and if the mouse is currently
201 static wxWindowGTK
*g_captureWindow
= (wxWindowGTK
*) NULL
;
202 static bool g_captureWindowHasMouse
= false;
204 wxWindowGTK
*g_focusWindow
= (wxWindowGTK
*) NULL
;
206 // the last window which had the focus - this is normally never NULL (except
207 // if we never had focus at all) as even when g_focusWindow is NULL it still
208 // keeps its previous value
209 wxWindowGTK
*g_focusWindowLast
= (wxWindowGTK
*) NULL
;
211 // If a window get the focus set but has not been realized
212 // yet, defer setting the focus to idle time.
213 wxWindowGTK
*g_delayedFocus
= (wxWindowGTK
*) NULL
;
215 // global variables because GTK+ DnD want to have the
216 // mouse event that caused it
217 GdkEvent
*g_lastMouseEvent
= (GdkEvent
*) NULL
;
218 int g_lastButtonNumber
= 0;
220 extern bool g_mainThreadLocked
;
222 //-----------------------------------------------------------------------------
224 //-----------------------------------------------------------------------------
229 # define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
231 # define DEBUG_MAIN_THREAD
234 #define DEBUG_MAIN_THREAD
237 // the trace mask used for the focus debugging messages
238 #define TRACE_FOCUS _T("focus")
240 //-----------------------------------------------------------------------------
241 // missing gdk functions
242 //-----------------------------------------------------------------------------
245 gdk_window_warp_pointer (GdkWindow
*window
,
250 window
= gdk_get_default_root_window();
252 if (!GDK_WINDOW_DESTROYED(window
))
254 XWarpPointer (GDK_WINDOW_XDISPLAY(window
),
255 None
, /* not source window -> move from anywhere */
256 GDK_WINDOW_XID(window
), /* dest window */
257 0, 0, 0, 0, /* not source window -> move from anywhere */
262 //-----------------------------------------------------------------------------
263 // local code (see below)
264 //-----------------------------------------------------------------------------
266 // returns the child of win which currently has focus or NULL if not found
268 // Note: can't be static, needed by textctrl.cpp.
269 wxWindow
*wxFindFocusedChild(wxWindowGTK
*win
)
271 wxWindow
*winFocus
= wxWindowGTK
::FindFocus();
273 return (wxWindow
*)NULL
;
275 if ( winFocus
== win
)
276 return (wxWindow
*)win
;
278 for ( wxWindowList
::compatibility_iterator node
= win
->GetChildren().GetFirst();
280 node
= node
->GetNext() )
282 wxWindow
*child
= wxFindFocusedChild(node
->GetData());
287 return (wxWindow
*)NULL
;
290 static void GetScrollbarWidth(GtkWidget
* widget
, int& w
, int& h
)
292 GtkScrolledWindow
* scroll_window
= GTK_SCROLLED_WINDOW(widget
);
293 GtkScrolledWindowClass
* scroll_class
= GTK_SCROLLED_WINDOW_CLASS(GTK_OBJECT_GET_CLASS(scroll_window
));
294 GtkRequisition scroll_req
;
297 if (scroll_window
->vscrollbar_visible
)
299 scroll_req
.width
= 2;
300 scroll_req
.height
= 2;
301 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
302 (scroll_window
->vscrollbar
, &scroll_req
);
303 w
= scroll_req
.width
+
304 scroll_class
->scrollbar_spacing
;
308 if (scroll_window
->hscrollbar_visible
)
310 scroll_req
.width
= 2;
311 scroll_req
.height
= 2;
312 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
313 (scroll_window
->hscrollbar
, &scroll_req
);
314 h
= scroll_req
.height
+
315 scroll_class
->scrollbar_spacing
;
319 static void draw_frame( GtkWidget
*widget
, wxWindowGTK
*win
)
321 // wxUniversal widgets draw the borders and scrollbars themselves
322 #ifndef __WXUNIVERSAL__
328 if (GTK_WIDGET_NO_WINDOW (widget
))
330 dx
+= widget
->allocation
.x
;
331 dy
+= widget
->allocation
.y
;
339 if (win
->m_hasScrolling
)
341 GetScrollbarWidth(widget
, dw
, dh
);
343 if (win
->GetLayoutDirection() == wxLayout_RightToLeft
)
345 // This is actually wrong for old GTK+ version
346 // which do not display the scrollbar on the
352 int w
= widget
->allocation
.width
-dw
;
353 int h
= widget
->allocation
.height
-dh
;
355 if (win
->HasFlag(wxRAISED_BORDER
))
357 gtk_paint_shadow (widget
->style
,
361 NULL
, NULL
, NULL
, // FIXME: No clipping?
366 if (win
->HasFlag(wxSUNKEN_BORDER
))
368 gtk_paint_shadow (widget
->style
,
372 NULL
, NULL
, NULL
, // FIXME: No clipping?
377 if (win
->HasFlag(wxSIMPLE_BORDER
))
380 gc
= gdk_gc_new( widget
->window
);
381 gdk_gc_set_foreground( gc
, &widget
->style
->black
);
382 gdk_draw_rectangle( widget
->window
, gc
, FALSE
, x
, y
, w
-1, h
-1 );
386 #endif // __WXUNIVERSAL__
389 //-----------------------------------------------------------------------------
390 // "expose_event" of m_widget
391 //-----------------------------------------------------------------------------
395 gtk_window_own_expose_callback( GtkWidget
*widget
,
396 GdkEventExpose
*gdk_event
,
399 if (gdk_event
->count
== 0)
400 draw_frame(widget
, win
);
405 //-----------------------------------------------------------------------------
406 // "size_request" of m_widget
407 //-----------------------------------------------------------------------------
409 // make it extern because wxStaticText needs to disconnect this one
411 void wxgtk_window_size_request_callback(GtkWidget
*widget
,
412 GtkRequisition
*requisition
,
416 win
->GetSize( &w
, &h
);
422 requisition
->height
= h
;
423 requisition
->width
= w
;
431 void wxgtk_combo_size_request_callback(GtkWidget
*widget
,
432 GtkRequisition
*requisition
,
435 // This callback is actually hooked into the text entry
436 // of the combo box, not the GtkHBox.
439 win
->GetSize( &w
, &h
);
445 GtkCombo
*gcombo
= GTK_COMBO(win
->m_widget
);
447 GtkRequisition entry_req
;
449 entry_req
.height
= 2;
450 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo
->entry
) )->size_request
)
451 (gcombo
->entry
, &entry_req
);
453 GtkRequisition button_req
;
454 button_req
.width
= 2;
455 button_req
.height
= 2;
456 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo
->button
) )->size_request
)
457 (gcombo
->button
, &button_req
);
459 requisition
->width
= w
- button_req
.width
;
460 requisition
->height
= entry_req
.height
;
464 #endif // wxUSE_COMBOBOX
466 //-----------------------------------------------------------------------------
467 // "expose_event" of m_wxwindow
468 //-----------------------------------------------------------------------------
472 gtk_window_expose_callback( GtkWidget
*widget
,
473 GdkEventExpose
*gdk_event
,
478 // This callback gets called in drawing-idle time under
479 // GTK 2.0, so we don't need to defer anything to idle
482 GtkPizza
*pizza
= GTK_PIZZA( widget
);
483 if (gdk_event
->window
!= pizza
->bin_window
)
485 // block expose events on GTK_WIDGET(pizza)->window,
486 // all drawing is done on pizza->bin_window
494 wxPrintf( wxT("OnExpose from ") );
495 if (win
->GetClassInfo() && win
->GetClassInfo()->GetClassName())
496 wxPrintf( win
->GetClassInfo()->GetClassName() );
497 wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event
->area
.x
,
498 (int)gdk_event
->area
.y
,
499 (int)gdk_event
->area
.width
,
500 (int)gdk_event
->area
.height
);
505 win
->m_wxwindow
->style
,
509 (GdkRectangle
*) NULL
,
511 (char *)"button", // const_cast
516 win
->GetUpdateRegion() = wxRegion( gdk_event
->region
);
518 win
->GtkSendPaintEvents();
520 // Let parent window draw window-less widgets
525 //-----------------------------------------------------------------------------
526 // "key_press_event" from any window
527 //-----------------------------------------------------------------------------
529 // These are used when transforming Ctrl-alpha to ascii values 1-26
530 inline bool wxIsLowerChar(int code
)
532 return (code
>= 'a' && code
<= 'z' );
535 inline bool wxIsUpperChar(int code
)
537 return (code
>= 'A' && code
<= 'Z' );
541 // set WXTRACE to this to see the key event codes on the console
542 #define TRACE_KEYS _T("keyevent")
544 // translates an X key symbol to WXK_XXX value
546 // if isChar is true it means that the value returned will be used for EVT_CHAR
547 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
548 // for example, while if it is false it means that the value is going to be
549 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
551 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
557 // Shift, Control and Alt don't generate the CHAR events at all
560 key_code
= isChar ?
0 : WXK_SHIFT
;
564 key_code
= isChar ?
0 : WXK_CONTROL
;
572 key_code
= isChar ?
0 : WXK_ALT
;
575 // neither do the toggle modifies
576 case GDK_Scroll_Lock
:
577 key_code
= isChar ?
0 : WXK_SCROLL
;
581 key_code
= isChar ?
0 : WXK_CAPITAL
;
585 key_code
= isChar ?
0 : WXK_NUMLOCK
;
589 // various other special keys
602 case GDK_ISO_Left_Tab
:
609 key_code
= WXK_RETURN
;
613 key_code
= WXK_CLEAR
;
617 key_code
= WXK_PAUSE
;
621 key_code
= WXK_SELECT
;
625 key_code
= WXK_PRINT
;
629 key_code
= WXK_EXECUTE
;
633 key_code
= WXK_ESCAPE
;
636 // cursor and other extended keyboard keys
638 key_code
= WXK_DELETE
;
654 key_code
= WXK_RIGHT
;
661 case GDK_Prior
: // == GDK_Page_Up
662 key_code
= WXK_PAGEUP
;
665 case GDK_Next
: // == GDK_Page_Down
666 key_code
= WXK_PAGEDOWN
;
678 key_code
= WXK_INSERT
;
693 key_code
= (isChar ?
'0' : WXK_NUMPAD0
) + keysym
- GDK_KP_0
;
697 key_code
= isChar ?
' ' : WXK_NUMPAD_SPACE
;
701 key_code
= isChar ? WXK_TAB
: WXK_NUMPAD_TAB
;
705 key_code
= isChar ? WXK_RETURN
: WXK_NUMPAD_ENTER
;
709 key_code
= isChar ? WXK_F1
: WXK_NUMPAD_F1
;
713 key_code
= isChar ? WXK_F2
: WXK_NUMPAD_F2
;
717 key_code
= isChar ? WXK_F3
: WXK_NUMPAD_F3
;
721 key_code
= isChar ? WXK_F4
: WXK_NUMPAD_F4
;
725 key_code
= isChar ? WXK_HOME
: WXK_NUMPAD_HOME
;
729 key_code
= isChar ? WXK_LEFT
: WXK_NUMPAD_LEFT
;
733 key_code
= isChar ? WXK_UP
: WXK_NUMPAD_UP
;
737 key_code
= isChar ? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
741 key_code
= isChar ? WXK_DOWN
: WXK_NUMPAD_DOWN
;
744 case GDK_KP_Prior
: // == GDK_KP_Page_Up
745 key_code
= isChar ? WXK_PAGEUP
: WXK_NUMPAD_PAGEUP
;
748 case GDK_KP_Next
: // == GDK_KP_Page_Down
749 key_code
= isChar ? WXK_PAGEDOWN
: WXK_NUMPAD_PAGEDOWN
;
753 key_code
= isChar ? WXK_END
: WXK_NUMPAD_END
;
757 key_code
= isChar ? WXK_HOME
: WXK_NUMPAD_BEGIN
;
761 key_code
= isChar ? WXK_INSERT
: WXK_NUMPAD_INSERT
;
765 key_code
= isChar ? WXK_DELETE
: WXK_NUMPAD_DELETE
;
769 key_code
= isChar ?
'=' : WXK_NUMPAD_EQUAL
;
772 case GDK_KP_Multiply
:
773 key_code
= isChar ?
'*' : WXK_NUMPAD_MULTIPLY
;
777 key_code
= isChar ?
'+' : WXK_NUMPAD_ADD
;
780 case GDK_KP_Separator
:
781 // FIXME: what is this?
782 key_code
= isChar ?
'.' : WXK_NUMPAD_SEPARATOR
;
785 case GDK_KP_Subtract
:
786 key_code
= isChar ?
'-' : WXK_NUMPAD_SUBTRACT
;
790 key_code
= isChar ?
'.' : WXK_NUMPAD_DECIMAL
;
794 key_code
= isChar ?
'/' : WXK_NUMPAD_DIVIDE
;
811 key_code
= WXK_F1
+ keysym
- GDK_F1
;
821 static inline bool wxIsAsciiKeysym(KeySym ks
)
826 static void wxFillOtherKeyEventFields(wxKeyEvent
& event
,
828 GdkEventKey
*gdk_event
)
832 GdkModifierType state
;
833 if (gdk_event
->window
)
834 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
836 event
.SetTimestamp( gdk_event
->time
);
837 event
.SetId(win
->GetId());
838 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
839 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
840 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
841 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
) != 0;
842 event
.m_scanCode
= gdk_event
->keyval
;
843 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
844 event
.m_rawFlags
= 0;
846 event
.m_uniChar
= gdk_keyval_to_unicode(gdk_event
->keyval
);
848 wxGetMousePosition( &x
, &y
);
849 win
->ScreenToClient( &x
, &y
);
852 event
.SetEventObject( win
);
857 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
859 GdkEventKey
*gdk_event
)
861 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
862 // but only event->keyval which is quite useless to us, so remember
863 // the last character from GDK_KEY_PRESS and reuse it as last resort
865 // NB: should be MT-safe as we're always called from the main thread only
870 } s_lastKeyPress
= { 0, 0 };
872 KeySym keysym
= gdk_event
->keyval
;
874 wxLogTrace(TRACE_KEYS
, _T("Key %s event: keysym = %ld"),
875 event
.GetEventType() == wxEVT_KEY_UP ?
_T("release")
879 long key_code
= wxTranslateKeySymToWXKey(keysym
, false /* !isChar */);
883 // do we have the translation or is it a plain ASCII character?
884 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
886 // we should use keysym if it is ASCII as X does some translations
887 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
888 // which we don't want here (but which we do use for OnChar())
889 if ( !wxIsAsciiKeysym(keysym
) )
891 keysym
= (KeySym
)gdk_event
->string
[0];
894 // we want to always get the same key code when the same key is
895 // pressed regardless of the state of the modifiers, i.e. on a
896 // standard US keyboard pressing '5' or '%' ('5' key with
897 // Shift) should result in the same key code in OnKeyDown():
898 // '5' (although OnChar() will get either '5' or '%').
900 // to do it we first translate keysym to keycode (== scan code)
901 // and then back but always using the lower register
902 Display
*dpy
= (Display
*)wxGetDisplay();
903 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
905 wxLogTrace(TRACE_KEYS
, _T("\t-> keycode %d"), keycode
);
907 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
909 // use the normalized, i.e. lower register, keysym if we've
911 key_code
= keysymNormalized ? keysymNormalized
: keysym
;
913 // as explained above, we want to have lower register key codes
914 // normally but for the letter keys we want to have the upper ones
916 // NB: don't use XConvertCase() here, we want to do it for letters
918 key_code
= toupper(key_code
);
920 else // non ASCII key, what to do?
922 // by default, ignore it
925 // but if we have cached information from the last KEY_PRESS
926 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
929 if ( keysym
== s_lastKeyPress
.keysym
)
931 key_code
= s_lastKeyPress
.keycode
;
936 if ( gdk_event
->type
== GDK_KEY_PRESS
)
938 // remember it to be reused for KEY_UP event later
939 s_lastKeyPress
.keysym
= keysym
;
940 s_lastKeyPress
.keycode
= key_code
;
944 wxLogTrace(TRACE_KEYS
, _T("\t-> wxKeyCode %ld"), key_code
);
946 // sending unknown key events doesn't really make sense
950 // now fill all the other fields
951 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
953 event
.m_keyCode
= key_code
;
955 if ( gdk_event
->type
== GDK_KEY_PRESS
|| gdk_event
->type
== GDK_KEY_RELEASE
)
957 event
.m_uniChar
= key_code
;
967 GtkIMContext
*context
;
968 GdkEventKey
*lastKeyEvent
;
972 context
= gtk_im_multicontext_new();
977 g_object_unref (context
);
983 gtk_window_key_press_callback( GtkWidget
*widget
,
984 GdkEventKey
*gdk_event
,
991 if (g_blockEventsOnDrag
)
995 wxKeyEvent
event( wxEVT_KEY_DOWN
);
997 bool return_after_IM
= false;
999 if( wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1001 // Emit KEY_DOWN event
1002 ret
= win
->GetEventHandler()->ProcessEvent( event
);
1006 // Return after IM processing as we cannot do
1007 // anything with it anyhow.
1008 return_after_IM
= true;
1011 // 2005.01.26 modified by Hong Jen Yee (hzysoft@sina.com.tw):
1012 // When we get a key_press event here, it could be originate
1013 // from the current widget or its child widgets. However, only the widget
1014 // with the INPUT FOCUS can generate the INITIAL key_press event. That is,
1015 // if the CURRENT widget doesn't have the FOCUS at all, this event definitely
1016 // originated from its child widgets and shouldn't be passed to IM context.
1017 // In fact, what a GTK+ IM should do is filtering keyEvents and convert them
1018 // into text input ONLY WHEN THE WIDGET HAS INPUT FOCUS. Besides, when current
1019 // widgets has both IM context and input focus, the event should be filtered
1020 // by gtk_im_context_filter_keypress().
1021 // Then, we should, according to GTK+ 2.0 API doc, return whatever it returns.
1022 if ((!ret
) && (win
->m_imData
!= NULL
) && ( wxWindow
::FindFocus() == win
))
1024 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
1025 // docs, if IM filter returns true, no further processing should be done.
1026 // we should send the key_down event anyway.
1027 bool intercepted_by_IM
= gtk_im_context_filter_keypress(win
->m_imData
->context
, gdk_event
);
1028 win
->m_imData
->lastKeyEvent
= NULL
;
1029 if (intercepted_by_IM
)
1031 wxLogTrace(TRACE_KEYS
, _T("Key event intercepted by IM"));
1036 if (return_after_IM
)
1042 wxWindowGTK
*ancestor
= win
;
1045 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
1048 wxCommandEvent
command_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
1049 ret
= ancestor
->GetEventHandler()->ProcessEvent( command_event
);
1052 if (ancestor
->IsTopLevel())
1054 ancestor
= ancestor
->GetParent();
1057 #endif // wxUSE_ACCEL
1059 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1060 // will only be sent if it is not in an accelerator table.
1064 KeySym keysym
= gdk_event
->keyval
;
1065 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1066 key_code
= wxTranslateKeySymToWXKey(keysym
, true /* isChar */);
1069 if ( wxIsAsciiKeysym(keysym
) )
1072 key_code
= (unsigned char)keysym
;
1074 // gdk_event->string is actually deprecated
1075 else if ( gdk_event
->length
== 1 )
1077 key_code
= (unsigned char)gdk_event
->string
[0];
1083 wxLogTrace(TRACE_KEYS
, _T("Char event: %ld"), key_code
);
1085 event
.m_keyCode
= key_code
;
1087 // To conform to the docs we need to translate Ctrl-alpha
1088 // characters to values in the range 1-26.
1089 if ( event
.ControlDown() &&
1090 ( wxIsLowerChar(key_code
) || wxIsUpperChar(key_code
) ))
1092 if ( wxIsLowerChar(key_code
) )
1093 event
.m_keyCode
= key_code
- 'a' + 1;
1094 if ( wxIsUpperChar(key_code
) )
1095 event
.m_keyCode
= key_code
- 'A' + 1;
1097 event
.m_uniChar
= event
.m_keyCode
;
1101 // Implement OnCharHook by checking ancestor top level windows
1102 wxWindow
*parent
= win
;
1103 while (parent
&& !parent
->IsTopLevel())
1104 parent
= parent
->GetParent();
1107 event
.SetEventType( wxEVT_CHAR_HOOK
);
1108 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1113 event
.SetEventType(wxEVT_CHAR
);
1114 ret
= win
->GetEventHandler()->ProcessEvent( event
);
1125 gtk_wxwindow_commit_cb (GtkIMContext
*context
,
1129 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1131 // take modifiers, cursor position, timestamp etc. from the last
1132 // key_press_event that was fed into Input Method:
1133 if (window
->m_imData
->lastKeyEvent
)
1135 wxFillOtherKeyEventFields(event
,
1136 window
, window
->m_imData
->lastKeyEvent
);
1140 event
.SetEventObject( window
);
1143 const wxString
data(wxGTK_CONV_BACK_SYS(str
));
1149 // Implement OnCharHook by checking ancestor top level windows
1150 wxWindow
*parent
= window
;
1151 while (parent
&& !parent
->IsTopLevel())
1152 parent
= parent
->GetParent();
1154 for( wxString
::const_iterator pstr
= data
.begin(); pstr
!= data
.end(); ++pstr
)
1157 event
.m_uniChar
= *pstr
;
1158 // Backward compatible for ISO-8859-1
1159 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
1160 wxLogTrace(TRACE_KEYS
, _T("IM sent character '%c'"), event
.m_uniChar
);
1162 event
.m_keyCode
= (char)*pstr
;
1163 #endif // wxUSE_UNICODE
1165 // To conform to the docs we need to translate Ctrl-alpha
1166 // characters to values in the range 1-26.
1167 if ( event
.ControlDown() &&
1168 ( wxIsLowerChar(*pstr
) || wxIsUpperChar(*pstr
) ))
1170 if ( wxIsLowerChar(*pstr
) )
1171 event
.m_keyCode
= *pstr
- 'a' + 1;
1172 if ( wxIsUpperChar(*pstr
) )
1173 event
.m_keyCode
= *pstr
- 'A' + 1;
1175 event
.m_keyCode
= *pstr
- 'a' + 1;
1177 event
.m_uniChar
= event
.m_keyCode
;
1183 event
.SetEventType( wxEVT_CHAR_HOOK
);
1184 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1189 event
.SetEventType(wxEVT_CHAR
);
1190 ret
= window
->GetEventHandler()->ProcessEvent( event
);
1197 //-----------------------------------------------------------------------------
1198 // "key_release_event" from any window
1199 //-----------------------------------------------------------------------------
1203 gtk_window_key_release_callback( GtkWidget
*widget
,
1204 GdkEventKey
*gdk_event
,
1212 if (g_blockEventsOnDrag
)
1215 wxKeyEvent
event( wxEVT_KEY_UP
);
1216 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1218 // unknown key pressed, ignore (the event would be useless anyhow)
1222 return win
->GTKProcessEvent(event
);
1226 // ============================================================================
1228 // ============================================================================
1230 // ----------------------------------------------------------------------------
1231 // mouse event processing helpers
1232 // ----------------------------------------------------------------------------
1234 // init wxMouseEvent with the info from GdkEventXXX struct
1235 template<typename T
> void InitMouseEvent(wxWindowGTK
*win
,
1236 wxMouseEvent
& event
,
1239 event
.SetTimestamp( gdk_event
->time
);
1240 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1241 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1242 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1243 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1244 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1245 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1246 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1248 wxPoint pt
= win
->GetClientAreaOrigin();
1249 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1250 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1252 if ((win
->m_wxwindow
) && (win
->GetLayoutDirection() == wxLayout_RightToLeft
))
1254 // origin in the upper right corner
1255 int window_width
= gtk_pizza_get_rtl_offset( GTK_PIZZA(win
->m_wxwindow
) );
1256 event
.m_x
= window_width
- event
.m_x
;
1259 event
.SetEventObject( win
);
1260 event
.SetId( win
->GetId() );
1261 event
.SetTimestamp( gdk_event
->time
);
1264 static void AdjustEventButtonState(wxMouseEvent
& event
)
1266 // GDK reports the old state of the button for a button press event, but
1267 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1268 // for a LEFT_DOWN event, not FALSE, so we will invert
1269 // left/right/middleDown for the corresponding click events
1271 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1272 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1273 (event
.GetEventType() == wxEVT_LEFT_UP
))
1275 event
.m_leftDown
= !event
.m_leftDown
;
1279 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1280 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1281 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1283 event
.m_middleDown
= !event
.m_middleDown
;
1287 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1288 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1289 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1291 event
.m_rightDown
= !event
.m_rightDown
;
1296 // find the window to send the mouse event too
1298 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1303 if (win
->m_wxwindow
)
1305 GtkPizza
*pizza
= GTK_PIZZA(win
->m_wxwindow
);
1306 xx
+= gtk_pizza_get_xoffset( pizza
);
1307 yy
+= gtk_pizza_get_yoffset( pizza
);
1310 wxWindowList
::compatibility_iterator node
= win
->GetChildren().GetFirst();
1313 wxWindowGTK
*child
= node
->GetData();
1315 node
= node
->GetNext();
1316 if (!child
->IsShown())
1319 if (child
->IsTransparentForMouse())
1321 // wxStaticBox is transparent in the box itself
1322 int xx1
= child
->m_x
;
1323 int yy1
= child
->m_y
;
1324 int xx2
= child
->m_x
+ child
->m_width
;
1325 int yy2
= child
->m_y
+ child
->m_height
;
1328 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1330 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1332 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1334 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1345 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1346 (child
->m_x
<= xx
) &&
1347 (child
->m_y
<= yy
) &&
1348 (child
->m_x
+child
->m_width
>= xx
) &&
1349 (child
->m_y
+child
->m_height
>= yy
))
1362 // ----------------------------------------------------------------------------
1363 // common event handlers helpers
1364 // ----------------------------------------------------------------------------
1366 bool wxWindowGTK
::GTKProcessEvent(wxEvent
& event
) const
1368 // nothing special at this level
1369 return GetEventHandler()->ProcessEvent(event
);
1372 int wxWindowGTK
::GTKCallbackCommonPrologue(GdkEventAny
*event
) const
1378 if (g_blockEventsOnDrag
)
1380 if (g_blockEventsOnScroll
)
1383 if (!GTKIsOwnWindow(event
->window
))
1389 // overloads for all GDK event types we use here: we need to have this as
1390 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1391 // derives from it in the sense that the structs have the same layout
1392 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1393 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1395 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1398 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton
)
1399 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion
)
1400 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing
)
1402 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1404 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1405 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1409 // send the wxChildFocusEvent and wxFocusEvent, common code of
1410 // gtk_window_focus_in_callback() and SetFocus()
1411 static bool DoSendFocusEvents(wxWindow
*win
)
1413 // Notify the parent keeping track of focus for the kbd navigation
1414 // purposes that we got it.
1415 wxChildFocusEvent
eventChildFocus(win
);
1416 (void)win
->GetEventHandler()->ProcessEvent(eventChildFocus
);
1418 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, win
->GetId());
1419 eventFocus
.SetEventObject(win
);
1421 return win
->GetEventHandler()->ProcessEvent(eventFocus
);
1424 // all event handlers must have C linkage as they're called from GTK+ C code
1428 //-----------------------------------------------------------------------------
1429 // "button_press_event"
1430 //-----------------------------------------------------------------------------
1433 gtk_window_button_press_callback( GtkWidget
*widget
,
1434 GdkEventButton
*gdk_event
,
1437 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1439 g_lastButtonNumber
= gdk_event
->button
;
1441 if (win
->m_wxwindow
&& (g_focusWindow
!= win
) && win
->IsFocusable())
1443 gtk_widget_grab_focus( win
->m_wxwindow
);
1446 // GDK sends surplus button down events
1447 // before a double click event. We
1448 // need to filter these out.
1449 if ((gdk_event
->type
== GDK_BUTTON_PRESS
) && (win
->m_wxwindow
))
1451 GdkEvent
*peek_event
= gdk_event_peek();
1454 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1455 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1457 gdk_event_free( peek_event
);
1462 gdk_event_free( peek_event
);
1467 wxEventType event_type
= wxEVT_NULL
;
1469 // GdkDisplay is a GTK+ 2.2.0 thing
1470 #if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0)
1471 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1472 !gtk_check_version(2,2,0) &&
1473 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1475 // Reset GDK internal timestamp variables in order to disable GDK
1476 // triple click events. GDK will then next time believe no button has
1477 // been clicked just before, and send a normal button click event.
1478 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1479 display
->button_click_time
[1] = 0;
1480 display
->button_click_time
[0] = 0;
1484 if (gdk_event
->button
== 1)
1486 // note that GDK generates triple click events which are not supported
1487 // by wxWidgets but still have to be passed to the app as otherwise
1488 // clicks would simply go missing
1489 switch (gdk_event
->type
)
1491 // we shouldn't get triple clicks at all for GTK2 because we
1492 // suppress them artificially using the code above but we still
1493 // should map them to something for GTK1 and not just ignore them
1494 // as this would lose clicks
1495 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1496 case GDK_BUTTON_PRESS
:
1497 event_type
= wxEVT_LEFT_DOWN
;
1500 case GDK_2BUTTON_PRESS
:
1501 event_type
= wxEVT_LEFT_DCLICK
;
1505 // just to silence gcc warnings
1509 else if (gdk_event
->button
== 2)
1511 switch (gdk_event
->type
)
1513 case GDK_3BUTTON_PRESS
:
1514 case GDK_BUTTON_PRESS
:
1515 event_type
= wxEVT_MIDDLE_DOWN
;
1518 case GDK_2BUTTON_PRESS
:
1519 event_type
= wxEVT_MIDDLE_DCLICK
;
1526 else if (gdk_event
->button
== 3)
1528 switch (gdk_event
->type
)
1530 case GDK_3BUTTON_PRESS
:
1531 case GDK_BUTTON_PRESS
:
1532 event_type
= wxEVT_RIGHT_DOWN
;
1535 case GDK_2BUTTON_PRESS
:
1536 event_type
= wxEVT_RIGHT_DCLICK
;
1544 if ( event_type
== wxEVT_NULL
)
1546 // unknown mouse button or click type
1550 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1552 wxMouseEvent
event( event_type
);
1553 InitMouseEvent( win
, event
, gdk_event
);
1555 AdjustEventButtonState(event
);
1557 // wxListBox actually gets mouse events from the item, so we need to give it
1558 // a chance to correct this
1559 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1561 // find the correct window to send the event to: it may be a different one
1562 // from the one which got it at GTK+ level because some controls don't have
1563 // their own X window and thus cannot get any events.
1564 if ( !g_captureWindow
)
1565 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1567 // reset the event object and id in case win changed.
1568 event
.SetEventObject( win
);
1569 event
.SetId( win
->GetId() );
1571 bool ret
= win
->GTKProcessEvent( event
);
1572 g_lastMouseEvent
= NULL
;
1576 if ((event_type
== wxEVT_LEFT_DOWN
) && !win
->IsOfStandardClass() &&
1577 (g_focusWindow
!= win
) && win
->IsFocusable())
1579 gtk_widget_grab_focus( win
->m_wxwindow
);
1582 if (event_type
== wxEVT_RIGHT_DOWN
)
1584 // generate a "context menu" event: this is similar to right mouse
1585 // click under many GUIs except that it is generated differently
1586 // (right up under MSW, ctrl-click under Mac, right down here) and
1588 // (a) it's a command event and so is propagated to the parent
1589 // (b) under some ports it can be generated from kbd too
1590 // (c) it uses screen coords (because of (a))
1591 wxContextMenuEvent
evtCtx(
1594 win
->ClientToScreen(event
.GetPosition()));
1595 evtCtx
.SetEventObject(win
);
1596 return win
->GTKProcessEvent(evtCtx
);
1602 //-----------------------------------------------------------------------------
1603 // "button_release_event"
1604 //-----------------------------------------------------------------------------
1607 gtk_window_button_release_callback( GtkWidget
*widget
,
1608 GdkEventButton
*gdk_event
,
1611 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1613 g_lastButtonNumber
= 0;
1615 wxEventType event_type
= wxEVT_NULL
;
1617 switch (gdk_event
->button
)
1620 event_type
= wxEVT_LEFT_UP
;
1624 event_type
= wxEVT_MIDDLE_UP
;
1628 event_type
= wxEVT_RIGHT_UP
;
1632 // unknown button, don't process
1636 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1638 wxMouseEvent
event( event_type
);
1639 InitMouseEvent( win
, event
, gdk_event
);
1641 AdjustEventButtonState(event
);
1643 // same wxListBox hack as above
1644 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1646 if ( !g_captureWindow
)
1647 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1649 // reset the event object and id in case win changed.
1650 event
.SetEventObject( win
);
1651 event
.SetId( win
->GetId() );
1653 bool ret
= win
->GTKProcessEvent(event
);
1655 g_lastMouseEvent
= NULL
;
1660 //-----------------------------------------------------------------------------
1661 // "motion_notify_event"
1662 //-----------------------------------------------------------------------------
1665 gtk_window_motion_notify_callback( GtkWidget
*widget
,
1666 GdkEventMotion
*gdk_event
,
1669 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1671 if (gdk_event
->is_hint
)
1675 GdkModifierType state
;
1676 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1681 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1683 wxMouseEvent
event( wxEVT_MOTION
);
1684 InitMouseEvent(win
, event
, gdk_event
);
1686 if ( g_captureWindow
)
1688 // synthesise a mouse enter or leave event if needed
1689 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1690 // This seems to be necessary and actually been added to
1691 // GDK itself in version 2.0.X
1694 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1695 if ( hasMouse
!= g_captureWindowHasMouse
)
1697 // the mouse changed window
1698 g_captureWindowHasMouse
= hasMouse
;
1700 wxMouseEvent
eventM(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1701 : wxEVT_LEAVE_WINDOW
);
1702 InitMouseEvent(win
, eventM
, gdk_event
);
1703 eventM
.SetEventObject(win
);
1704 win
->GTKProcessEvent(eventM
);
1709 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1711 // reset the event object and id in case win changed.
1712 event
.SetEventObject( win
);
1713 event
.SetId( win
->GetId() );
1716 if ( !g_captureWindow
)
1718 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1719 if (win
->GTKProcessEvent( cevent
))
1721 win
->SetCursor( cevent
.GetCursor() );
1725 bool ret
= win
->GTKProcessEvent(event
);
1727 g_lastMouseEvent
= NULL
;
1732 //-----------------------------------------------------------------------------
1733 // "scroll_event" (mouse wheel event)
1734 //-----------------------------------------------------------------------------
1737 window_scroll_event(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1741 if (gdk_event
->direction
!= GDK_SCROLL_UP
&&
1742 gdk_event
->direction
!= GDK_SCROLL_DOWN
)
1747 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1748 // Can't use InitMouse macro because scroll events don't have button
1749 event
.SetTimestamp( gdk_event
->time
);
1750 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1751 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1752 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1753 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1754 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1755 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1756 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1757 event
.m_linesPerAction
= 3;
1758 event
.m_wheelDelta
= 120;
1759 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1760 event
.m_wheelRotation
= 120;
1762 event
.m_wheelRotation
= -120;
1764 wxPoint pt
= win
->GetClientAreaOrigin();
1765 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1766 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1768 event
.SetEventObject( win
);
1769 event
.SetId( win
->GetId() );
1770 event
.SetTimestamp( gdk_event
->time
);
1772 return win
->GTKProcessEvent(event
);
1775 //-----------------------------------------------------------------------------
1777 //-----------------------------------------------------------------------------
1779 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
1781 wxContextMenuEvent
event(wxEVT_CONTEXT_MENU
, win
->GetId(), wxPoint(-1, -1));
1782 event
.SetEventObject(win
);
1783 return win
->GTKProcessEvent(event
);
1786 //-----------------------------------------------------------------------------
1788 //-----------------------------------------------------------------------------
1791 gtk_window_focus_in_callback( GtkWidget
*widget
,
1792 GdkEventFocus
*WXUNUSED(event
),
1798 gtk_im_context_focus_in(win
->m_imData
->context
);
1801 g_focusWindow
= win
;
1803 wxLogTrace(TRACE_FOCUS
,
1804 _T("%s: focus in"), win
->GetName().c_str());
1807 // caret needs to be informed about focus change
1808 wxCaret
*caret
= win
->GetCaret();
1811 caret
->OnSetFocus();
1813 #endif // wxUSE_CARET
1815 gboolean ret
= FALSE
;
1817 // does the window itself think that it has the focus?
1818 if ( !win
->m_hasFocus
)
1820 // not yet, notify it
1821 win
->m_hasFocus
= true;
1823 (void)DoSendFocusEvents(win
);
1828 // Disable default focus handling for custom windows
1829 // since the default GTK+ handler issues a repaint
1830 if (win
->m_wxwindow
)
1836 //-----------------------------------------------------------------------------
1837 // "focus_out_event"
1838 //-----------------------------------------------------------------------------
1841 gtk_window_focus_out_callback( GtkWidget
*widget
,
1842 GdkEventFocus
*gdk_event
,
1848 gtk_im_context_focus_out(win
->m_imData
->context
);
1850 wxLogTrace( TRACE_FOCUS
,
1851 _T("%s: focus out"), win
->GetName().c_str() );
1854 wxWindowGTK
*winFocus
= wxFindFocusedChild(win
);
1858 g_focusWindow
= (wxWindowGTK
*)NULL
;
1861 // caret needs to be informed about focus change
1862 wxCaret
*caret
= win
->GetCaret();
1865 caret
->OnKillFocus();
1867 #endif // wxUSE_CARET
1869 // don't send the window a kill focus event if it thinks that it doesn't
1870 // have focus already
1871 if ( win
->m_hasFocus
)
1873 // the event handler might delete the window when it loses focus, so
1874 // check whether this is a custom window before calling it
1875 const bool has_wxwindow
= win
->m_wxwindow
!= NULL
;
1877 win
->m_hasFocus
= false;
1879 wxFocusEvent
event( wxEVT_KILL_FOCUS
, win
->GetId() );
1880 event
.SetEventObject( win
);
1882 (void)win
->GTKProcessEvent( event
);
1884 // Disable default focus handling for custom windows
1885 // since the default GTK+ handler issues a repaint
1890 // continue with normal processing
1895 wx_window_focus_callback(GtkWidget
*widget
,
1896 GtkDirectionType direction
,
1899 // the default handler for focus signal in GtkPizza (or, rather, in
1900 // GtkScrolledWindow from which GtkPizza inherits this behaviour) sets
1901 // focus to the window itself even if it doesn't accept focus, i.e. has no
1902 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1903 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1904 // any children which might accept focus (we know we don't accept the focus
1905 // ourselves as this signal is only connected in this case)
1906 if ( win
->GetChildren().empty() )
1907 g_signal_stop_emission_by_name(widget
, "focus");
1909 // we didn't change the focus
1913 //-----------------------------------------------------------------------------
1914 // "enter_notify_event"
1915 //-----------------------------------------------------------------------------
1918 gtk_window_enter_callback( GtkWidget
*widget
,
1919 GdkEventCrossing
*gdk_event
,
1922 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1924 // Event was emitted after a grab
1925 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1929 GdkModifierType state
= (GdkModifierType
)0;
1931 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1933 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1934 InitMouseEvent(win
, event
, gdk_event
);
1935 wxPoint pt
= win
->GetClientAreaOrigin();
1936 event
.m_x
= x
+ pt
.x
;
1937 event
.m_y
= y
+ pt
.y
;
1939 if ( !g_captureWindow
)
1941 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1942 if (win
->GTKProcessEvent( cevent
))
1944 win
->SetCursor( cevent
.GetCursor() );
1948 return win
->GTKProcessEvent(event
);
1951 //-----------------------------------------------------------------------------
1952 // "leave_notify_event"
1953 //-----------------------------------------------------------------------------
1956 gtk_window_leave_callback( GtkWidget
*widget
,
1957 GdkEventCrossing
*gdk_event
,
1960 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1962 // Event was emitted after an ungrab
1963 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1965 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1966 event
.SetTimestamp( gdk_event
->time
);
1967 event
.SetEventObject( win
);
1971 GdkModifierType state
= (GdkModifierType
)0;
1973 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1975 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
) != 0;
1976 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
) != 0;
1977 event
.m_altDown
= (state
& GDK_MOD1_MASK
) != 0;
1978 event
.m_metaDown
= (state
& GDK_MOD2_MASK
) != 0;
1979 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
) != 0;
1980 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
) != 0;
1981 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
) != 0;
1983 wxPoint pt
= win
->GetClientAreaOrigin();
1984 event
.m_x
= x
+ pt
.x
;
1985 event
.m_y
= y
+ pt
.y
;
1987 return win
->GTKProcessEvent(event
);
1990 //-----------------------------------------------------------------------------
1991 // "value_changed" from scrollbar
1992 //-----------------------------------------------------------------------------
1995 gtk_scrollbar_value_changed(GtkRange
* range
, wxWindow
* win
)
1997 wxEventType eventType
= win
->GetScrollEventType(range
);
1998 if (eventType
!= wxEVT_NULL
)
2000 // Convert scroll event type to scrollwin event type
2001 eventType
+= wxEVT_SCROLLWIN_TOP
- wxEVT_SCROLL_TOP
;
2003 // find the scrollbar which generated the event
2004 wxWindowGTK
::ScrollDir dir
= win
->ScrollDirFromRange(range
);
2006 // generate the corresponding wx event
2007 const int orient
= wxWindow
::OrientFromScrollDir(dir
);
2008 wxScrollWinEvent
event(eventType
, win
->GetScrollPos(orient
), orient
);
2009 event
.SetEventObject(win
);
2011 win
->GTKProcessEvent(event
);
2015 //-----------------------------------------------------------------------------
2016 // "button_press_event" from scrollbar
2017 //-----------------------------------------------------------------------------
2020 gtk_scrollbar_button_press_event(GtkRange
*, GdkEventButton
*, wxWindow
* win
)
2024 g_blockEventsOnScroll
= true;
2025 win
->m_mouseButtonDown
= true;
2030 //-----------------------------------------------------------------------------
2031 // "event_after" from scrollbar
2032 //-----------------------------------------------------------------------------
2035 gtk_scrollbar_event_after(GtkRange
* range
, GdkEvent
* event
, wxWindow
* win
)
2037 if (event
->type
== GDK_BUTTON_RELEASE
)
2039 g_signal_handlers_block_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
2041 const int orient
= wxWindow
::OrientFromScrollDir(
2042 win
->ScrollDirFromRange(range
));
2043 wxScrollWinEvent
event(wxEVT_SCROLLWIN_THUMBRELEASE
, win
->GetScrollPos(orient
), orient
);
2044 event
.SetEventObject(win
);
2045 win
->GTKProcessEvent(event
);
2049 //-----------------------------------------------------------------------------
2050 // "button_release_event" from scrollbar
2051 //-----------------------------------------------------------------------------
2054 gtk_scrollbar_button_release_event(GtkRange
* range
, GdkEventButton
*, wxWindow
* win
)
2058 g_blockEventsOnScroll
= false;
2059 win
->m_mouseButtonDown
= false;
2060 // If thumb tracking
2061 if (win
->m_isScrolling
)
2063 win
->m_isScrolling
= false;
2064 // Hook up handler to send thumb release event after this emission is finished.
2065 // To allow setting scroll position from event handler, sending event must
2066 // be deferred until after the GtkRange handler for this signal has run
2067 g_signal_handlers_unblock_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
2073 //-----------------------------------------------------------------------------
2074 // "realize" from m_widget
2075 //-----------------------------------------------------------------------------
2078 gtk_window_realized_callback( GtkWidget
*m_widget
, wxWindow
*win
)
2084 GtkPizza
*pizza
= GTK_PIZZA( m_widget
);
2085 gtk_im_context_set_client_window( win
->m_imData
->context
,
2086 pizza
->bin_window
);
2089 // We cannot set colours and fonts before the widget
2090 // been realized, so we do this directly after realization
2091 // or otherwise in idle time
2093 if (win
->m_needsStyleChange
)
2095 win
->SetBackgroundStyle(win
->GetBackgroundStyle());
2096 win
->m_needsStyleChange
= false;
2099 wxWindowCreateEvent
event( win
);
2100 event
.SetEventObject( win
);
2101 win
->GTKProcessEvent( event
);
2104 //-----------------------------------------------------------------------------
2106 //-----------------------------------------------------------------------------
2109 void gtk_window_size_callback( GtkWidget
*WXUNUSED(widget
),
2110 GtkAllocation
*alloc
,
2113 int client_width
= 0;
2114 int client_height
= 0;
2115 win
->GetClientSize( &client_width
, &client_height
);
2116 if ((client_width
== win
->m_oldClientWidth
) && (client_height
== win
->m_oldClientHeight
))
2119 if ( !client_width
&& !client_height
)
2121 // the window is currently unmapped, don't generate size events
2125 win
->m_oldClientWidth
= client_width
;
2126 win
->m_oldClientHeight
= client_height
;
2128 if (!win
->m_nativeSizeEvent
)
2130 wxSizeEvent
event( win
->GetSize(), win
->GetId() );
2131 event
.SetEventObject( win
);
2132 win
->GTKProcessEvent( event
);
2138 // ----------------------------------------------------------------------------
2139 // this wxWindowBase function is implemented here (in platform-specific file)
2140 // because it is static and so couldn't be made virtual
2141 // ----------------------------------------------------------------------------
2143 wxWindow
*wxWindowBase
::DoFindFocus()
2145 // the cast is necessary when we compile in wxUniversal mode
2146 return (wxWindow
*)g_focusWindow
;
2149 //-----------------------------------------------------------------------------
2150 // InsertChild for wxWindowGTK.
2151 //-----------------------------------------------------------------------------
2153 /* Callback for wxWindowGTK. This very strange beast has to be used because
2154 * C++ has no virtual methods in a constructor. We have to emulate a
2155 * virtual function here as wxNotebook requires a different way to insert
2156 * a child in it. I had opted for creating a wxNotebookPage window class
2157 * which would have made this superfluous (such in the MDI window system),
2158 * but no-one was listening to me... */
2160 static void wxInsertChildInWindow( wxWindowGTK
* parent
, wxWindowGTK
* child
)
2162 /* the window might have been scrolled already, do we
2163 have to adapt the position */
2164 GtkPizza
*pizza
= GTK_PIZZA(parent
->m_wxwindow
);
2165 child
->m_x
+= gtk_pizza_get_xoffset( pizza
);
2166 child
->m_y
+= gtk_pizza_get_yoffset( pizza
);
2168 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
2176 //-----------------------------------------------------------------------------
2178 //-----------------------------------------------------------------------------
2180 wxWindow
*wxGetActiveWindow()
2182 return wxWindow
::FindFocus();
2186 wxMouseState
wxGetMouseState()
2192 GdkModifierType mask
;
2194 gdk_window_get_pointer(NULL
, &x
, &y
, &mask
);
2198 ms
.SetLeftDown(mask
& GDK_BUTTON1_MASK
);
2199 ms
.SetMiddleDown(mask
& GDK_BUTTON2_MASK
);
2200 ms
.SetRightDown(mask
& GDK_BUTTON3_MASK
);
2202 ms
.SetControlDown(mask
& GDK_CONTROL_MASK
);
2203 ms
.SetShiftDown(mask
& GDK_SHIFT_MASK
);
2204 ms
.SetAltDown(mask
& GDK_MOD1_MASK
);
2205 ms
.SetMetaDown(mask
& GDK_MOD2_MASK
);
2210 //-----------------------------------------------------------------------------
2212 //-----------------------------------------------------------------------------
2214 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2216 #ifdef __WXUNIVERSAL__
2217 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2219 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
2220 #endif // __WXUNIVERSAL__/__WXGTK__
2222 void wxWindowGTK
::Init()
2225 m_widget
= (GtkWidget
*) NULL
;
2226 m_wxwindow
= (GtkWidget
*) NULL
;
2227 m_focusWidget
= (GtkWidget
*) NULL
;
2236 m_isBeingDeleted
= false;
2238 m_showOnIdle
= false;
2241 m_nativeSizeEvent
= false;
2243 m_hasScrolling
= false;
2244 m_isScrolling
= false;
2245 m_mouseButtonDown
= false;
2246 m_blockScrollEvent
= false;
2248 // initialize scrolling stuff
2249 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2251 m_scrollBar
[dir
] = NULL
;
2252 m_scrollPos
[dir
] = 0;
2256 m_oldClientHeight
= 0;
2260 m_insertCallback
= wxInsertChildInWindow
;
2264 m_clipPaintRegion
= false;
2266 m_needsStyleChange
= false;
2268 m_cursor
= *wxSTANDARD_CURSOR
;
2271 m_dirtyTabOrder
= false;
2274 wxWindowGTK
::wxWindowGTK()
2279 wxWindowGTK
::wxWindowGTK( wxWindow
*parent
,
2284 const wxString
&name
)
2288 Create( parent
, id
, pos
, size
, style
, name
);
2291 bool wxWindowGTK
::Create( wxWindow
*parent
,
2296 const wxString
&name
)
2298 if (!PreCreation( parent
, pos
, size
) ||
2299 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2301 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2305 if (!HasFlag(wxHSCROLL
) && !HasFlag(wxVSCROLL
))
2307 m_wxwindow
= gtk_pizza_new_no_scroll();
2309 #ifndef __WXUNIVERSAL__
2310 if (HasFlag(wxSIMPLE_BORDER
))
2311 gtk_container_set_border_width((GtkContainer
*)m_wxwindow
, 1);
2312 else if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
2313 gtk_container_set_border_width((GtkContainer
*)m_wxwindow
, 2);
2314 #endif // __WXUNIVERSAL__
2316 m_widget
= m_wxwindow
;
2320 m_wxwindow
= gtk_pizza_new();
2322 #ifndef __WXUNIVERSAL__
2323 if (HasFlag(wxSIMPLE_BORDER
))
2324 gtk_container_set_border_width((GtkContainer
*)m_wxwindow
, 1);
2325 else if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
2326 gtk_container_set_border_width((GtkContainer
*)m_wxwindow
, 2);
2327 #endif // __WXUNIVERSAL__
2329 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
2331 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2333 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2334 scroll_class
->scrollbar_spacing
= 0;
2336 // There is a conflict with default bindings at GTK+
2337 // level between scrolled windows and notebooks both of which want to use
2338 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2339 // direction and notebooks for changing pages -- we decide that if we don't
2340 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2341 // means we can get working keyboard navigation in notebooks
2342 if ( !HasFlag(wxHSCROLL
) )
2345 bindings
= gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget
));
2348 gtk_binding_entry_remove(bindings
, GDK_Page_Up
, GDK_CONTROL_MASK
);
2349 gtk_binding_entry_remove(bindings
, GDK_Page_Down
, GDK_CONTROL_MASK
);
2353 if (HasFlag(wxALWAYS_SHOW_SB
))
2355 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_ALWAYS
, GTK_POLICY_ALWAYS
);
2357 scrolledWindow
->hscrollbar_visible
= TRUE
;
2358 scrolledWindow
->vscrollbar_visible
= TRUE
;
2362 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2365 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(scrolledWindow
->hscrollbar
);
2366 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(scrolledWindow
->vscrollbar
);
2367 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2368 gtk_range_set_inverted( m_scrollBar
[ScrollDir_Horz
], TRUE
);
2370 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2372 // connect various scroll-related events
2373 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2375 // these handlers block mouse events to any window during scrolling
2376 // such as motion events and prevent GTK and wxWidgets from fighting
2377 // over where the slider should be
2378 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2379 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2380 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2381 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2383 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2384 G_CALLBACK(gtk_scrollbar_event_after
), this);
2385 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2387 // these handlers get notified when scrollbar slider moves
2388 g_signal_connect_after(m_scrollBar
[dir
], "value_changed",
2389 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2392 gtk_widget_show( m_wxwindow
);
2396 m_parent
->DoAddChild( this );
2398 m_focusWidget
= m_wxwindow
;
2405 wxWindowGTK
::~wxWindowGTK()
2409 if (g_focusWindow
== this)
2410 g_focusWindow
= NULL
;
2412 if ( g_delayedFocus
== this )
2413 g_delayedFocus
= NULL
;
2415 m_isBeingDeleted
= true;
2418 // destroy children before destroying this window itself
2421 // unhook focus handlers to prevent stray events being
2422 // propagated to this (soon to be) dead object
2423 if (m_focusWidget
!= NULL
)
2425 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2426 (gpointer
) gtk_window_focus_in_callback
,
2428 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2429 (gpointer
) gtk_window_focus_out_callback
,
2436 // delete before the widgets to avoid a crash on solaris
2439 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
2441 gtk_widget_destroy( m_wxwindow
);
2442 m_wxwindow
= (GtkWidget
*) NULL
;
2447 gtk_widget_destroy( m_widget
);
2448 m_widget
= (GtkWidget
*) NULL
;
2452 bool wxWindowGTK
::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2454 if ( GTKNeedsParent() )
2456 wxCHECK_MSG( parent
, false, wxT("Must have non-NULL parent") );
2459 // Use either the given size, or the default if -1 is given.
2460 // See wxWindowBase for these functions.
2461 m_width
= WidthDefault(size
.x
) ;
2462 m_height
= HeightDefault(size
.y
);
2470 void wxWindowGTK
::PostCreation()
2472 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2478 // these get reported to wxWidgets -> wxPaintEvent
2480 g_signal_connect (m_wxwindow
, "expose_event",
2481 G_CALLBACK (gtk_window_expose_callback
), this);
2483 if (GetLayoutDirection() == wxLayout_LeftToRight
)
2484 gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow
), HasFlag( wxFULL_REPAINT_ON_RESIZE
) );
2487 // Create input method handler
2488 m_imData
= new wxGtkIMData
;
2490 // Cannot handle drawing preedited text yet
2491 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2493 g_signal_connect (m_imData
->context
, "commit",
2494 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2496 // these are called when the "sunken" or "raised" borders are drawn
2497 g_signal_connect (m_widget
, "expose_event",
2498 G_CALLBACK (gtk_window_own_expose_callback
), this);
2503 if (!GTK_IS_WINDOW(m_widget
))
2505 if (m_focusWidget
== NULL
)
2506 m_focusWidget
= m_widget
;
2510 g_signal_connect (m_focusWidget
, "focus_in_event",
2511 G_CALLBACK (gtk_window_focus_in_callback
), this);
2512 g_signal_connect (m_focusWidget
, "focus_out_event",
2513 G_CALLBACK (gtk_window_focus_out_callback
), this);
2517 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2518 G_CALLBACK (gtk_window_focus_in_callback
), this);
2519 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2520 G_CALLBACK (gtk_window_focus_out_callback
), this);
2524 if ( !AcceptsFocusFromKeyboard() )
2528 g_signal_connect(m_widget
, "focus",
2529 G_CALLBACK(wx_window_focus_callback
), this);
2532 // connect to the various key and mouse handlers
2534 GtkWidget
*connect_widget
= GetConnectWidget();
2536 ConnectWidget( connect_widget
);
2538 /* We cannot set colours, fonts and cursors before the widget has
2539 been realized, so we do this directly after realization */
2540 g_signal_connect (connect_widget
, "realize",
2541 G_CALLBACK (gtk_window_realized_callback
), this);
2545 // Catch native resize events
2546 g_signal_connect (m_wxwindow
, "size_allocate",
2547 G_CALLBACK (gtk_window_size_callback
), this);
2551 if (GTK_IS_COMBO(m_widget
))
2553 GtkCombo
*gcombo
= GTK_COMBO(m_widget
);
2555 g_signal_connect (gcombo
->entry
, "size_request",
2556 G_CALLBACK (wxgtk_combo_size_request_callback
),
2560 #endif // wxUSE_COMBOBOX
2561 #ifdef GTK_IS_FILE_CHOOSER_BUTTON
2562 if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget
))
2564 // If we connect to the "size_request" signal of a GtkFileChooserButton
2565 // then that control won't be sized properly when placed inside sizers
2566 // (this can be tested removing this elseif and running XRC or WIDGETS samples)
2567 // FIXME: what should be done here ?
2570 else if ( !IsTopLevel() ) // top level windows use their own callback
2572 // This is needed if we want to add our windows into native
2573 // GTK controls, such as the toolbar. With this callback, the
2574 // toolbar gets to know the correct size (the one set by the
2575 // programmer). Sadly, it misbehaves for wxComboBox.
2576 g_signal_connect (m_widget
, "size_request",
2577 G_CALLBACK (wxgtk_window_size_request_callback
),
2581 InheritAttributes();
2585 SetLayoutDirection(wxLayout_Default
);
2587 // unless the window was created initially hidden (i.e. Hide() had been
2588 // called before Create()), we should show it at GTK+ level as well
2590 gtk_widget_show( m_widget
);
2593 void wxWindowGTK
::ConnectWidget( GtkWidget
*widget
)
2595 g_signal_connect (widget
, "key_press_event",
2596 G_CALLBACK (gtk_window_key_press_callback
), this);
2597 g_signal_connect (widget
, "key_release_event",
2598 G_CALLBACK (gtk_window_key_release_callback
), this);
2599 g_signal_connect (widget
, "button_press_event",
2600 G_CALLBACK (gtk_window_button_press_callback
), this);
2601 g_signal_connect (widget
, "button_release_event",
2602 G_CALLBACK (gtk_window_button_release_callback
), this);
2603 g_signal_connect (widget
, "motion_notify_event",
2604 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2605 g_signal_connect (widget
, "scroll_event",
2606 G_CALLBACK (window_scroll_event
), this);
2607 g_signal_connect (widget
, "popup_menu",
2608 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2609 g_signal_connect (widget
, "enter_notify_event",
2610 G_CALLBACK (gtk_window_enter_callback
), this);
2611 g_signal_connect (widget
, "leave_notify_event",
2612 G_CALLBACK (gtk_window_leave_callback
), this);
2615 bool wxWindowGTK
::Destroy()
2617 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2621 return wxWindowBase
::Destroy();
2624 void wxWindowGTK
::DoMoveWindow(int x
, int y
, int width
, int height
)
2626 // inform the parent to perform the move
2627 gtk_pizza_set_size( GTK_PIZZA(m_parent
->m_wxwindow
), m_widget
, x
, y
, width
, height
);
2631 void wxWindowGTK
::ConstrainSize()
2634 // GPE's window manager doesn't like size hints at all, esp. when the user
2635 // has to use the virtual keyboard, so don't constrain size there
2639 const wxSize minSize
= GetMinSize();
2640 const wxSize maxSize
= GetMaxSize();
2641 if (minSize
.x
> 0 && m_width
< minSize
.x
) m_width
= minSize
.x
;
2642 if (minSize
.y
> 0 && m_height
< minSize
.y
) m_height
= minSize
.y
;
2643 if (maxSize
.x
> 0 && m_width
> maxSize
.x
) m_width
= maxSize
.x
;
2644 if (maxSize
.y
> 0 && m_height
> maxSize
.y
) m_height
= maxSize
.y
;
2648 void wxWindowGTK
::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2650 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2651 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2653 if (m_resizing
) return; /* I don't like recursions */
2656 int currentX
, currentY
;
2657 GetPosition(¤tX
, ¤tY
);
2658 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2660 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2662 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2664 // calculate the best size if we should auto size the window
2665 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2666 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2668 const wxSize sizeBest
= GetBestSize();
2669 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2671 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2672 height
= sizeBest
.y
;
2682 #if wxUSE_TOOLBAR_NATIVE
2683 if (wxDynamicCast(GetParent(), wxToolBar
))
2685 // don't take the x,y values, they're wrong because toolbar sets them
2686 GtkWidget
*widget
= m_widget
;
2687 gtk_widget_set_size_request (widget
, m_width
, m_height
);
2691 if (m_parent
->m_wxwindow
== NULL
) // i.e. wxNotebook
2693 // don't set the size for children of wxNotebook, just take the values.
2701 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
2702 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
2704 if (x
!= -1) m_x
= x
+ gtk_pizza_get_xoffset( pizza
);
2705 if (y
!= -1) m_y
= y
+ gtk_pizza_get_yoffset( pizza
);
2709 m_x
= x
+ gtk_pizza_get_xoffset( pizza
);
2710 m_y
= y
+ gtk_pizza_get_yoffset( pizza
);
2713 int left_border
= 0;
2714 int right_border
= 0;
2716 int bottom_border
= 0;
2718 /* the default button has a border around it */
2719 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
2721 GtkBorder
*default_border
= NULL
;
2722 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2725 left_border
+= default_border
->left
;
2726 right_border
+= default_border
->right
;
2727 top_border
+= default_border
->top
;
2728 bottom_border
+= default_border
->bottom
;
2729 gtk_border_free( default_border
);
2733 DoMoveWindow( m_x
- left_border
,
2735 m_width
+left_border
+right_border
,
2736 m_height
+top_border
+bottom_border
);
2741 /* Sometimes the client area changes size without the
2742 whole windows's size changing, but if the whole
2743 windows's size doesn't change, no wxSizeEvent will
2744 normally be sent. Here we add an extra test if
2745 the client test has been changed and this will
2747 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2751 wxPrintf( "OnSize sent from " );
2752 if (GetClassInfo() && GetClassInfo()->GetClassName())
2753 wxPrintf( GetClassInfo()->GetClassName() );
2754 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2757 if (!m_nativeSizeEvent
)
2759 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2760 event
.SetEventObject( this );
2761 GetEventHandler()->ProcessEvent( event
);
2767 bool wxWindowGTK
::GtkShowFromOnIdle()
2769 if (IsShown() && m_showOnIdle
&& !GTK_WIDGET_VISIBLE (m_widget
))
2771 GtkAllocation alloc
;
2774 alloc
.width
= m_width
;
2775 alloc
.height
= m_height
;
2776 gtk_widget_size_allocate( m_widget
, &alloc
);
2777 gtk_widget_show( m_widget
);
2778 wxShowEvent
eventShow(GetId(), true);
2779 eventShow
.SetEventObject(this);
2780 GetEventHandler()->ProcessEvent(eventShow
);
2781 m_showOnIdle
= false;
2788 void wxWindowGTK
::OnInternalIdle()
2790 // Check if we have to show window now
2791 if (GtkShowFromOnIdle()) return;
2793 if ( m_dirtyTabOrder
)
2795 m_dirtyTabOrder
= false;
2799 // Update style if the window was not yet realized
2800 // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
2801 if (m_needsStyleChange
)
2803 SetBackgroundStyle(GetBackgroundStyle());
2804 m_needsStyleChange
= false;
2807 wxCursor cursor
= m_cursor
;
2808 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
2812 /* I now set the cursor anew in every OnInternalIdle call
2813 as setting the cursor in a parent window also effects the
2814 windows above so that checking for the current cursor is
2817 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
2819 GdkWindow
*window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2821 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2823 if (!g_globalCursor
.Ok())
2824 cursor
= *wxSTANDARD_CURSOR
;
2826 window
= m_widget
->window
;
2827 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
2828 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2831 else if ( m_widget
)
2833 GdkWindow
*window
= m_widget
->window
;
2834 if ( window
&& !GTK_WIDGET_NO_WINDOW(m_widget
) )
2835 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2839 if (wxUpdateUIEvent
::CanUpdate(this))
2840 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
2843 void wxWindowGTK
::DoGetSize( int *width
, int *height
) const
2845 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2847 if (width
) (*width
) = m_width
;
2848 if (height
) (*height
) = m_height
;
2851 void wxWindowGTK
::DoSetClientSize( int width
, int height
)
2853 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2855 const wxSize size
= GetSize();
2856 const wxSize clientSize
= GetClientSize();
2857 SetSize(width
+ (size
.x
- clientSize
.x
), height
+ (size
.y
- clientSize
.y
));
2860 void wxWindowGTK
::DoGetClientSize( int *width
, int *height
) const
2862 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2873 GetScrollbarWidth(m_widget
, dw
, dh
);
2875 const int border
= GTK_CONTAINER(m_wxwindow
)->border_width
;
2887 if (width
) *width
= w
;
2888 if (height
) *height
= h
;
2891 void wxWindowGTK
::DoGetPosition( int *x
, int *y
) const
2893 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2897 if (m_parent
&& m_parent
->m_wxwindow
)
2899 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
2900 dx
= gtk_pizza_get_xoffset( pizza
);
2901 dy
= gtk_pizza_get_yoffset( pizza
);
2904 if (m_x
== -1 && m_y
== -1)
2906 GdkWindow
*source
= (GdkWindow
*) NULL
;
2908 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2910 source
= m_widget
->window
;
2916 gdk_window_get_origin( source
, &org_x
, &org_y
);
2919 m_parent
->ScreenToClient(&org_x
, &org_y
);
2921 wx_const_cast(wxWindowGTK
*, this)->m_x
= org_x
;
2922 wx_const_cast(wxWindowGTK
*, this)->m_y
= org_y
;
2926 if (x
) (*x
) = m_x
- dx
;
2927 if (y
) (*y
) = m_y
- dy
;
2930 void wxWindowGTK
::DoClientToScreen( int *x
, int *y
) const
2932 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2934 if (!m_widget
->window
) return;
2936 GdkWindow
*source
= (GdkWindow
*) NULL
;
2938 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2940 source
= m_widget
->window
;
2944 gdk_window_get_origin( source
, &org_x
, &org_y
);
2948 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2950 org_x
+= m_widget
->allocation
.x
;
2951 org_y
+= m_widget
->allocation
.y
;
2958 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2959 *x
= (GetClientSize().x
- *x
) + org_x
;
2967 void wxWindowGTK
::DoScreenToClient( int *x
, int *y
) const
2969 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2971 if (!m_widget
->window
) return;
2973 GdkWindow
*source
= (GdkWindow
*) NULL
;
2975 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2977 source
= m_widget
->window
;
2981 gdk_window_get_origin( source
, &org_x
, &org_y
);
2985 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2987 org_x
+= m_widget
->allocation
.x
;
2988 org_y
+= m_widget
->allocation
.y
;
2994 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2995 *x
= (GetClientSize().x
- *x
) - org_x
;
3002 bool wxWindowGTK
::Show( bool show
)
3004 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3006 if (!wxWindowBase
::Show(show
))
3016 gtk_widget_show( m_widget
);
3017 wxShowEvent
eventShow(GetId(), show
);
3018 eventShow
.SetEventObject(this);
3019 GetEventHandler()->ProcessEvent(eventShow
);
3024 gtk_widget_hide( m_widget
);
3025 wxShowEvent
eventShow(GetId(), show
);
3026 eventShow
.SetEventObject(this);
3027 GetEventHandler()->ProcessEvent(eventShow
);
3033 void wxWindowGTK
::DoEnable( bool enable
)
3035 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3037 gtk_widget_set_sensitive( m_widget
, enable
);
3038 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3039 gtk_widget_set_sensitive( m_wxwindow
, enable
);
3042 int wxWindowGTK
::GetCharHeight() const
3044 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
3046 wxFont font
= GetFont();
3047 wxCHECK_MSG( font
.Ok(), 12, wxT("invalid font") );
3049 PangoContext
*context
= NULL
;
3051 context
= gtk_widget_get_pango_context( m_widget
);
3056 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3057 PangoLayout
*layout
= pango_layout_new(context
);
3058 pango_layout_set_font_description(layout
, desc
);
3059 pango_layout_set_text(layout
, "H", 1);
3060 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3062 PangoRectangle rect
;
3063 pango_layout_line_get_extents(line
, NULL
, &rect
);
3065 g_object_unref (layout
);
3067 return (int) PANGO_PIXELS(rect
.height
);
3070 int wxWindowGTK
::GetCharWidth() const
3072 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
3074 wxFont font
= GetFont();
3075 wxCHECK_MSG( font
.Ok(), 8, wxT("invalid font") );
3077 PangoContext
*context
= NULL
;
3079 context
= gtk_widget_get_pango_context( m_widget
);
3084 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3085 PangoLayout
*layout
= pango_layout_new(context
);
3086 pango_layout_set_font_description(layout
, desc
);
3087 pango_layout_set_text(layout
, "g", 1);
3088 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3090 PangoRectangle rect
;
3091 pango_layout_line_get_extents(line
, NULL
, &rect
);
3093 g_object_unref (layout
);
3095 return (int) PANGO_PIXELS(rect
.width
);
3098 void wxWindowGTK
::GetTextExtent( const wxString
& string
,
3102 int *externalLeading
,
3103 const wxFont
*theFont
) const
3105 wxFont fontToUse
= theFont ?
*theFont
: GetFont();
3107 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
3116 PangoContext
*context
= NULL
;
3118 context
= gtk_widget_get_pango_context( m_widget
);
3127 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3128 PangoLayout
*layout
= pango_layout_new(context
);
3129 pango_layout_set_font_description(layout
, desc
);
3131 const wxCharBuffer data
= wxGTK_CONV( string
);
3133 pango_layout_set_text(layout
, data
, strlen(data
));
3136 PangoRectangle rect
;
3137 pango_layout_get_extents(layout
, NULL
, &rect
);
3139 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
3140 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
3143 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
3144 int baseline
= pango_layout_iter_get_baseline(iter
);
3145 pango_layout_iter_free(iter
);
3146 *descent
= *y
- PANGO_PIXELS(baseline
);
3148 if (externalLeading
) (*externalLeading
) = 0; // ??
3150 g_object_unref (layout
);
3153 bool wxWindowGTK
::GTKSetDelayedFocusIfNeeded()
3155 if ( g_delayedFocus
== this )
3157 if ( GTK_WIDGET_REALIZED(m_widget
) )
3159 gtk_widget_grab_focus(m_widget
);
3160 g_delayedFocus
= NULL
;
3169 void wxWindowGTK
::SetFocus()
3171 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3174 // don't do anything if we already have focus
3180 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow
))
3182 gtk_widget_grab_focus (m_wxwindow
);
3187 if (GTK_IS_CONTAINER(m_widget
))
3190 if (IsKindOf(CLASSINFO(wxRadioButton
)))
3192 gtk_widget_grab_focus (m_widget
);
3195 #endif // wxUSE_RADIOBTN
3197 gtk_widget_child_focus( m_widget
, GTK_DIR_TAB_FORWARD
);
3200 if (GTK_WIDGET_CAN_FOCUS(m_widget
) && !GTK_WIDGET_HAS_FOCUS (m_widget
) )
3203 if (!GTK_WIDGET_REALIZED(m_widget
))
3205 // we can't set the focus to the widget now so we remember that
3206 // it should be focused and will do it later, during the idle
3207 // time, as soon as we can
3208 wxLogTrace(TRACE_FOCUS
,
3209 _T("Delaying setting focus to %s(%s)"),
3210 GetClassInfo()->GetClassName(), GetLabel().c_str());
3212 g_delayedFocus
= this;
3216 wxLogTrace(TRACE_FOCUS
,
3217 _T("Setting focus to %s(%s)"),
3218 GetClassInfo()->GetClassName(), GetLabel().c_str());
3220 gtk_widget_grab_focus (m_widget
);
3225 wxLogTrace(TRACE_FOCUS
,
3226 _T("Can't set focus to %s(%s)"),
3227 GetClassInfo()->GetClassName(), GetLabel().c_str());
3232 void wxWindowGTK
::SetCanFocus(bool canFocus
)
3235 GTK_WIDGET_SET_FLAGS(m_widget
, GTK_CAN_FOCUS
);
3237 GTK_WIDGET_UNSET_FLAGS(m_widget
, GTK_CAN_FOCUS
);
3239 if ( m_wxwindow
&& (m_widget
!= m_wxwindow
) )
3242 GTK_WIDGET_SET_FLAGS(m_wxwindow
, GTK_CAN_FOCUS
);
3244 GTK_WIDGET_UNSET_FLAGS(m_wxwindow
, GTK_CAN_FOCUS
);
3248 bool wxWindowGTK
::Reparent( wxWindowBase
*newParentBase
)
3250 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3252 wxWindowGTK
*oldParent
= m_parent
,
3253 *newParent
= (wxWindowGTK
*)newParentBase
;
3255 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3257 if ( !wxWindowBase
::Reparent(newParent
) )
3260 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3262 /* prevent GTK from deleting the widget arbitrarily */
3263 gtk_widget_ref( m_widget
);
3267 gtk_container_remove( GTK_CONTAINER(m_widget
->parent
), m_widget
);
3270 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3274 if (GTK_WIDGET_VISIBLE (newParent
->m_widget
))
3276 m_showOnIdle
= true;
3277 gtk_widget_hide( m_widget
);
3280 /* insert GTK representation */
3281 (*(newParent
->m_insertCallback
))(newParent
, this);
3284 /* reverse: prevent GTK from deleting the widget arbitrarily */
3285 gtk_widget_unref( m_widget
);
3287 SetLayoutDirection(wxLayout_Default
);
3292 void wxWindowGTK
::DoAddChild(wxWindowGTK
*child
)
3294 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3295 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3300 /* insert GTK representation */
3301 (*m_insertCallback
)(this, child
);
3304 void wxWindowGTK
::AddChild(wxWindowBase
*child
)
3306 wxWindowBase
::AddChild(child
);
3307 m_dirtyTabOrder
= true;
3308 wxTheApp
->WakeUpIdle();
3311 void wxWindowGTK
::RemoveChild(wxWindowBase
*child
)
3313 wxWindowBase
::RemoveChild(child
);
3314 m_dirtyTabOrder
= true;
3315 wxTheApp
->WakeUpIdle();
3319 wxLayoutDirection wxWindowGTK
::GTKGetLayout(GtkWidget
*widget
)
3321 return gtk_widget_get_direction(widget
) == GTK_TEXT_DIR_RTL
3322 ? wxLayout_RightToLeft
3323 : wxLayout_LeftToRight
;
3327 void wxWindowGTK
::GTKSetLayout(GtkWidget
*widget
, wxLayoutDirection dir
)
3329 wxASSERT_MSG( dir
!= wxLayout_Default
, _T("invalid layout direction") );
3331 gtk_widget_set_direction(widget
,
3332 dir
== wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
3333 : GTK_TEXT_DIR_LTR
);
3336 wxLayoutDirection wxWindowGTK
::GetLayoutDirection() const
3338 return GTKGetLayout(m_widget
);
3341 void wxWindowGTK
::SetLayoutDirection(wxLayoutDirection dir
)
3343 if ( dir
== wxLayout_Default
)
3345 const wxWindow
*const parent
= GetParent();
3348 // inherit layout from parent.
3349 dir
= parent
->GetLayoutDirection();
3351 else // no parent, use global default layout
3353 dir
= wxTheApp
->GetLayoutDirection();
3357 if ( dir
== wxLayout_Default
)
3360 GTKSetLayout(m_widget
, dir
);
3362 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3363 GTKSetLayout(m_wxwindow
, dir
);
3367 wxWindowGTK
::AdjustForLayoutDirection(wxCoord x
,
3368 wxCoord
WXUNUSED(width
),
3369 wxCoord
WXUNUSED(widthTotal
)) const
3371 // We now mirrors the coordinates of RTL windows in GtkPizza
3375 void wxWindowGTK
::DoMoveInTabOrder(wxWindow
*win
, MoveKind move
)
3377 wxWindowBase
::DoMoveInTabOrder(win
, move
);
3378 m_dirtyTabOrder
= true;
3379 wxTheApp
->WakeUpIdle();
3382 bool wxWindowGTK
::DoNavigateIn(int flags
)
3384 if ( flags
& wxNavigationKeyEvent
::WinChange
)
3386 wxFAIL_MSG( _T("not implemented") );
3390 else // navigate inside the container
3392 wxWindow
*parent
= wxGetTopLevelParent(this);
3393 wxCHECK_MSG( parent
, false, _T("every window must have a TLW parent") );
3395 GtkDirectionType dir
;
3396 dir
= flags
& wxNavigationKeyEvent
::IsForward ? GTK_DIR_TAB_FORWARD
3397 : GTK_DIR_TAB_BACKWARD
;
3400 g_signal_emit_by_name(parent
->m_widget
, "focus", dir
, &rc
);
3406 bool wxWindowGTK
::GTKWidgetNeedsMnemonic() const
3408 // none needed by default
3412 void wxWindowGTK
::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3414 // nothing to do by default since none is needed
3417 void wxWindowGTK
::RealizeTabOrder()
3421 if ( !m_children
.empty() )
3423 // we don't only construct the correct focus chain but also use
3424 // this opportunity to update the mnemonic widgets for the widgets
3427 GList
*chain
= NULL
;
3428 wxWindowGTK
* mnemonicWindow
= NULL
;
3430 for ( wxWindowList
::const_iterator i
= m_children
.begin();
3431 i
!= m_children
.end();
3434 wxWindowGTK
*win
= *i
;
3436 if ( mnemonicWindow
)
3438 if ( win
->AcceptsFocusFromKeyboard() )
3440 // wxComboBox et al. needs to focus on on a different
3441 // widget than m_widget, so if the main widget isn't
3442 // focusable try the connect widget
3443 GtkWidget
* w
= win
->m_widget
;
3444 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3446 w
= win
->GetConnectWidget();
3447 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3453 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3454 mnemonicWindow
= NULL
;
3458 else if ( win
->GTKWidgetNeedsMnemonic() )
3460 mnemonicWindow
= win
;
3463 chain
= g_list_prepend(chain
, win
->m_widget
);
3466 chain
= g_list_reverse(chain
);
3468 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3473 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3478 void wxWindowGTK
::Raise()
3480 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3482 if (m_wxwindow
&& m_wxwindow
->window
)
3484 gdk_window_raise( m_wxwindow
->window
);
3486 else if (m_widget
->window
)
3488 gdk_window_raise( m_widget
->window
);
3492 void wxWindowGTK
::Lower()
3494 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3496 if (m_wxwindow
&& m_wxwindow
->window
)
3498 gdk_window_lower( m_wxwindow
->window
);
3500 else if (m_widget
->window
)
3502 gdk_window_lower( m_widget
->window
);
3506 bool wxWindowGTK
::SetCursor( const wxCursor
&cursor
)
3508 if ( !wxWindowBase
::SetCursor(cursor
.Ok() ? cursor
: *wxSTANDARD_CURSOR
) )
3516 void wxWindowGTK
::GTKUpdateCursor()
3518 wxCursor
cursor(g_globalCursor
.Ok() ? g_globalCursor
: GetCursor());
3521 wxArrayGdkWindows windowsThis
;
3522 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
3525 gdk_window_set_cursor(winThis
, cursor
.GetCursor());
3529 const size_t count
= windowsThis
.size();
3530 for ( size_t n
= 0; n
< count
; n
++ )
3532 GdkWindow
*win
= windowsThis
[n
];
3535 wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?"));
3539 gdk_window_set_cursor(win
, cursor
.GetCursor());
3545 void wxWindowGTK
::WarpPointer( int x
, int y
)
3547 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3549 // We provide this function ourselves as it is
3550 // missing in GDK (top of this file).
3552 GdkWindow
*window
= (GdkWindow
*) NULL
;
3554 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3556 window
= GetConnectWidget()->window
;
3559 gdk_window_warp_pointer( window
, x
, y
);
3562 wxWindowGTK
::ScrollDir wxWindowGTK
::ScrollDirFromRange(GtkRange
*range
) const
3564 // find the scrollbar which generated the event
3565 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3567 if ( range
== m_scrollBar
[dir
] )
3568 return (ScrollDir
)dir
;
3571 wxFAIL_MSG( _T("event from unknown scrollbar received") );
3573 return ScrollDir_Max
;
3576 bool wxWindowGTK
::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3578 bool changed
= false;
3579 GtkRange
* range
= m_scrollBar
[dir
];
3580 if ( range
&& units
)
3582 GtkAdjustment
* adj
= range
->adjustment
;
3583 gdouble inc
= unit
== ScrollUnit_Line ? adj
->step_increment
3584 : adj
->page_increment
;
3586 const int posOld
= int(adj
->value
+ 0.5);
3587 gtk_range_set_value(range
, posOld
+ units
*inc
);
3589 changed
= int(adj
->value
+ 0.5) != posOld
;
3595 bool wxWindowGTK
::ScrollLines(int lines
)
3597 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3600 bool wxWindowGTK
::ScrollPages(int pages
)
3602 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3605 void wxWindowGTK
::Refresh( bool eraseBackground
, const wxRect
*rect
)
3609 if (!m_widget
->window
)
3614 if (!GTK_PIZZA(m_wxwindow
)->bin_window
) return;
3616 GdkRectangle gdk_rect
,
3620 gdk_rect
.x
= rect
->x
;
3621 gdk_rect
.y
= rect
->y
;
3622 gdk_rect
.width
= rect
->width
;
3623 gdk_rect
.height
= rect
->height
;
3624 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3625 gdk_rect
.x
= GetClientSize().x
- gdk_rect
.x
- gdk_rect
.width
;
3629 else // invalidate everything
3634 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, p
, TRUE
);
3638 void wxWindowGTK
::Update()
3642 // when we call Update() we really want to update the window immediately on
3643 // screen, even if it means flushing the entire queue and hence slowing down
3644 // everything -- but it should still be done, it's just that Update() should
3645 // be called very rarely
3649 void wxWindowGTK
::GtkUpdate()
3651 if (m_wxwindow
&& GTK_PIZZA(m_wxwindow
)->bin_window
)
3652 gdk_window_process_updates( GTK_PIZZA(m_wxwindow
)->bin_window
, FALSE
);
3653 if (m_widget
&& m_widget
->window
&& (m_wxwindow
!= m_widget
))
3654 gdk_window_process_updates( m_widget
->window
, FALSE
);
3656 // for consistency with other platforms (and also because it's convenient
3657 // to be able to update an entire TLW by calling Update() only once), we
3658 // should also update all our children here
3659 for ( wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
3661 node
= node
->GetNext() )
3663 node
->GetData()->GtkUpdate();
3667 bool wxWindowGTK
::DoIsExposed( int x
, int y
) const
3669 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
3673 bool wxWindowGTK
::DoIsExposed( int x
, int y
, int w
, int h
) const
3675 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3676 return m_updateRegion
.Contains(x
-w
, y
, w
, h
) != wxOutRegion
;
3678 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
3681 void wxWindowGTK
::GtkSendPaintEvents()
3685 m_updateRegion
.Clear();
3689 // Clip to paint region in wxClientDC
3690 m_clipPaintRegion
= true;
3692 m_nativeUpdateRegion
= m_updateRegion
;
3694 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3696 // Transform m_updateRegion under RTL
3697 m_updateRegion
.Clear();
3700 gdk_window_get_geometry( GTK_PIZZA(m_wxwindow
)->bin_window
,
3701 NULL
, NULL
, &width
, NULL
, NULL
);
3703 wxRegionIterator
upd( m_nativeUpdateRegion
);
3707 rect
.x
= upd
.GetX();
3708 rect
.y
= upd
.GetY();
3709 rect
.width
= upd
.GetWidth();
3710 rect
.height
= upd
.GetHeight();
3712 rect
.x
= width
- rect
.x
- rect
.width
;
3713 m_updateRegion
.Union( rect
);
3719 // widget to draw on
3720 GtkPizza
*pizza
= GTK_PIZZA (m_wxwindow
);
3722 if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM
))
3724 // find ancestor from which to steal background
3725 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3727 parent
= (wxWindow
*)this;
3729 if (GTK_WIDGET_MAPPED(parent
->m_widget
))
3731 wxRegionIterator
upd( m_nativeUpdateRegion
);
3735 rect
.x
= upd
.GetX();
3736 rect
.y
= upd
.GetY();
3737 rect
.width
= upd
.GetWidth();
3738 rect
.height
= upd
.GetHeight();
3740 gtk_paint_flat_box( parent
->m_widget
->style
,
3742 (GtkStateType
)GTK_WIDGET_STATE(m_wxwindow
),
3755 wxWindowDC
dc( (wxWindow
*)this );
3756 dc
.SetClippingRegion( m_updateRegion
);
3758 wxEraseEvent
erase_event( GetId(), &dc
);
3759 erase_event
.SetEventObject( this );
3761 GetEventHandler()->ProcessEvent(erase_event
);
3764 wxNcPaintEvent
nc_paint_event( GetId() );
3765 nc_paint_event
.SetEventObject( this );
3766 GetEventHandler()->ProcessEvent( nc_paint_event
);
3768 wxPaintEvent
paint_event( GetId() );
3769 paint_event
.SetEventObject( this );
3770 GetEventHandler()->ProcessEvent( paint_event
);
3772 m_clipPaintRegion
= false;
3774 m_updateRegion
.Clear();
3775 m_nativeUpdateRegion
.Clear();
3778 void wxWindowGTK
::SetDoubleBuffered( bool on
)
3780 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3783 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3786 bool wxWindowGTK
::IsDoubleBuffered() const
3788 return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow
);
3791 void wxWindowGTK
::ClearBackground()
3793 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3797 void wxWindowGTK
::DoSetToolTip( wxToolTip
*tip
)
3799 wxWindowBase
::DoSetToolTip(tip
);
3802 m_tooltip
->Apply( (wxWindow
*)this );
3805 void wxWindowGTK
::ApplyToolTip( GtkTooltips
*tips
, const gchar
*tip
)
3807 gtk_tooltips_set_tip(tips
, GetConnectWidget(), tip
, NULL
);
3809 #endif // wxUSE_TOOLTIPS
3811 bool wxWindowGTK
::SetBackgroundColour( const wxColour
&colour
)
3813 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3815 if (!wxWindowBase
::SetBackgroundColour(colour
))
3820 // We need the pixel value e.g. for background clearing.
3821 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3824 // apply style change (forceStyle=true so that new style is applied
3825 // even if the bg colour changed from valid to wxNullColour)
3826 if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM
)
3827 ApplyWidgetStyle(true);
3832 bool wxWindowGTK
::SetForegroundColour( const wxColour
&colour
)
3834 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3836 if (!wxWindowBase
::SetForegroundColour(colour
))
3843 // We need the pixel value e.g. for background clearing.
3844 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3847 // apply style change (forceStyle=true so that new style is applied
3848 // even if the bg colour changed from valid to wxNullColour):
3849 ApplyWidgetStyle(true);
3854 PangoContext
*wxWindowGTK
::GtkGetPangoDefaultContext()
3856 return gtk_widget_get_pango_context( m_widget
);
3859 GtkRcStyle
*wxWindowGTK
::CreateWidgetStyle(bool forceStyle
)
3861 // do we need to apply any changes at all?
3864 !m_foregroundColour
.Ok() && !m_backgroundColour
.Ok() )
3869 GtkRcStyle
*style
= gtk_rc_style_new();
3874 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
3877 int flagsNormal
= 0,
3880 flagsInsensitive
= 0;
3882 if ( m_foregroundColour
.Ok() )
3884 const GdkColor
*fg
= m_foregroundColour
.GetColor();
3886 style
->fg
[GTK_STATE_NORMAL
] =
3887 style
->text
[GTK_STATE_NORMAL
] = *fg
;
3888 flagsNormal
|= GTK_RC_FG
| GTK_RC_TEXT
;
3890 style
->fg
[GTK_STATE_PRELIGHT
] =
3891 style
->text
[GTK_STATE_PRELIGHT
] = *fg
;
3892 flagsPrelight
|= GTK_RC_FG
| GTK_RC_TEXT
;
3894 style
->fg
[GTK_STATE_ACTIVE
] =
3895 style
->text
[GTK_STATE_ACTIVE
] = *fg
;
3896 flagsActive
|= GTK_RC_FG
| GTK_RC_TEXT
;
3899 if ( m_backgroundColour
.Ok() )
3901 const GdkColor
*bg
= m_backgroundColour
.GetColor();
3903 style
->bg
[GTK_STATE_NORMAL
] =
3904 style
->base
[GTK_STATE_NORMAL
] = *bg
;
3905 flagsNormal
|= GTK_RC_BG
| GTK_RC_BASE
;
3907 style
->bg
[GTK_STATE_PRELIGHT
] =
3908 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
3909 flagsPrelight
|= GTK_RC_BG
| GTK_RC_BASE
;
3911 style
->bg
[GTK_STATE_ACTIVE
] =
3912 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
3913 flagsActive
|= GTK_RC_BG
| GTK_RC_BASE
;
3915 style
->bg
[GTK_STATE_INSENSITIVE
] =
3916 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
3917 flagsInsensitive
|= GTK_RC_BG
| GTK_RC_BASE
;
3920 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)flagsNormal
;
3921 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)flagsPrelight
;
3922 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)flagsActive
;
3923 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)flagsInsensitive
;
3928 void wxWindowGTK
::ApplyWidgetStyle(bool forceStyle
)
3930 GtkRcStyle
*style
= CreateWidgetStyle(forceStyle
);
3933 DoApplyWidgetStyle(style
);
3934 gtk_rc_style_unref(style
);
3937 // Style change may affect GTK+'s size calculation:
3938 InvalidateBestSize();
3941 void wxWindowGTK
::DoApplyWidgetStyle(GtkRcStyle
*style
)
3944 gtk_widget_modify_style(m_wxwindow
, style
);
3946 gtk_widget_modify_style(m_widget
, style
);
3949 bool wxWindowGTK
::SetBackgroundStyle(wxBackgroundStyle style
)
3951 wxWindowBase
::SetBackgroundStyle(style
);
3953 if (style
== wxBG_STYLE_CUSTOM
)
3958 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3962 GtkWidget
* const w
= GetConnectWidget();
3963 window
= w ? w
->window
: NULL
;
3968 // Make sure GDK/X11 doesn't refresh the window
3970 gdk_window_set_back_pixmap( window
, None
, False
);
3972 Display
* display
= GDK_WINDOW_DISPLAY(window
);
3975 m_needsStyleChange
= false;
3977 else // window not realized yet
3979 // Do in OnIdle, because the window is not yet available
3980 m_needsStyleChange
= true;
3983 // Don't apply widget style, or we get a grey background
3987 // apply style change (forceStyle=true so that new style is applied
3988 // even if the bg colour changed from valid to wxNullColour):
3989 ApplyWidgetStyle(true);
3994 #if wxUSE_DRAG_AND_DROP
3996 void wxWindowGTK
::SetDropTarget( wxDropTarget
*dropTarget
)
3998 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4000 GtkWidget
*dnd_widget
= GetConnectWidget();
4002 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
4004 if (m_dropTarget
) delete m_dropTarget
;
4005 m_dropTarget
= dropTarget
;
4007 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
4010 #endif // wxUSE_DRAG_AND_DROP
4012 GtkWidget
* wxWindowGTK
::GetConnectWidget()
4014 GtkWidget
*connect_widget
= m_widget
;
4015 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4017 return connect_widget
;
4020 bool wxWindowGTK
::GTKIsOwnWindow(GdkWindow
*window
) const
4022 wxArrayGdkWindows windowsThis
;
4023 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
4025 return winThis ? window
== winThis
4026 : windowsThis
.Index(window
) != wxNOT_FOUND
;
4029 GdkWindow
*wxWindowGTK
::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
4031 return m_wxwindow ?
GTK_PIZZA(m_wxwindow
)->bin_window
: m_widget
->window
;
4034 bool wxWindowGTK
::SetFont( const wxFont
&font
)
4036 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4038 if (!wxWindowBase
::SetFont(font
))
4041 // apply style change (forceStyle=true so that new style is applied
4042 // even if the font changed from valid to wxNullFont):
4043 ApplyWidgetStyle(true);
4048 void wxWindowGTK
::DoCaptureMouse()
4050 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4052 GdkWindow
*window
= (GdkWindow
*) NULL
;
4054 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4056 window
= GetConnectWidget()->window
;
4058 wxCHECK_RET( window
, _T("CaptureMouse() failed") );
4060 const wxCursor
* cursor
= &m_cursor
;
4062 cursor
= wxSTANDARD_CURSOR
;
4064 gdk_pointer_grab( window
, FALSE
,
4066 (GDK_BUTTON_PRESS_MASK
|
4067 GDK_BUTTON_RELEASE_MASK
|
4068 GDK_POINTER_MOTION_HINT_MASK
|
4069 GDK_POINTER_MOTION_MASK
),
4071 cursor
->GetCursor(),
4072 (guint32
)GDK_CURRENT_TIME
);
4073 g_captureWindow
= this;
4074 g_captureWindowHasMouse
= true;
4077 void wxWindowGTK
::DoReleaseMouse()
4079 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4081 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4083 g_captureWindow
= (wxWindowGTK
*) NULL
;
4085 GdkWindow
*window
= (GdkWindow
*) NULL
;
4087 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4089 window
= GetConnectWidget()->window
;
4094 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4098 wxWindow
*wxWindowBase
::GetCapture()
4100 return (wxWindow
*)g_captureWindow
;
4103 bool wxWindowGTK
::IsRetained() const
4108 void wxWindowGTK
::BlockScrollEvent()
4110 wxASSERT(!m_blockScrollEvent
);
4111 m_blockScrollEvent
= true;
4114 void wxWindowGTK
::UnblockScrollEvent()
4116 wxASSERT(m_blockScrollEvent
);
4117 m_blockScrollEvent
= false;
4120 void wxWindowGTK
::SetScrollbar(int orient
,
4124 bool WXUNUSED(update
))
4126 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4127 wxCHECK_RET( sb
, _T("this window is not scrollable") );
4131 m_hasScrolling
= true;
4135 // GtkRange requires upper > lower
4140 if (pos
> range
- thumbVisible
)
4141 pos
= range
- thumbVisible
;
4144 GtkAdjustment
* const adj
= sb
->adjustment
;
4145 adj
->step_increment
= 1;
4146 adj
->page_increment
=
4147 adj
->page_size
= thumbVisible
;
4149 SetScrollPos(orient
, pos
);
4150 gtk_adjustment_changed(adj
);
4153 void wxWindowGTK
::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4155 const int dir
= ScrollDirFromOrient(orient
);
4156 GtkRange
* const sb
= m_scrollBar
[dir
];
4157 wxCHECK_RET( sb
, _T("this window is not scrollable") );
4159 // This check is more than an optimization. Without it, the slider
4160 // will not move smoothly while tracking when using wxScrollHelper.
4161 if (GetScrollPos(orient
) != pos
)
4163 GtkAdjustment
* adj
= sb
->adjustment
;
4164 const int max
= int(adj
->upper
- adj
->page_size
);
4169 m_scrollPos
[dir
] = adj
->value
= pos
;
4171 g_signal_handlers_block_by_func(m_scrollBar
[dir
],
4172 (gpointer
)gtk_scrollbar_value_changed
, this);
4174 gtk_adjustment_value_changed(adj
);
4176 g_signal_handlers_unblock_by_func(m_scrollBar
[dir
],
4177 (gpointer
)gtk_scrollbar_value_changed
, this);
4181 int wxWindowGTK
::GetScrollThumb(int orient
) const
4183 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4184 wxCHECK_MSG( sb
, 0, _T("this window is not scrollable") );
4186 return int(sb
->adjustment
->page_size
);
4189 int wxWindowGTK
::GetScrollPos( int orient
) const
4191 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4192 wxCHECK_MSG( sb
, 0, _T("this window is not scrollable") );
4194 return int(sb
->adjustment
->value
+ 0.5);
4197 int wxWindowGTK
::GetScrollRange( int orient
) const
4199 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4200 wxCHECK_MSG( sb
, 0, _T("this window is not scrollable") );
4202 return int(sb
->adjustment
->upper
);
4205 // Determine if increment is the same as +/-x, allowing for some small
4206 // difference due to possible inexactness in floating point arithmetic
4207 static inline bool IsScrollIncrement(double increment
, double x
)
4209 wxASSERT(increment
> 0);
4210 const double tolerance
= 1.0 / 1024;
4211 return fabs(increment
- fabs(x
)) < tolerance
;
4214 wxEventType wxWindowGTK
::GetScrollEventType(GtkRange
* range
)
4218 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4220 const int barIndex
= range
== m_scrollBar
[1];
4221 GtkAdjustment
* adj
= range
->adjustment
;
4223 const int value
= int(adj
->value
+ 0.5);
4225 // save previous position
4226 const double oldPos
= m_scrollPos
[barIndex
];
4227 // update current position
4228 m_scrollPos
[barIndex
] = adj
->value
;
4229 // If event should be ignored, or integral position has not changed
4230 if (!m_hasVMT
|| g_blockEventsOnDrag
|| value
== int(oldPos
+ 0.5))
4235 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4238 // Difference from last change event
4239 const double diff
= adj
->value
- oldPos
;
4240 const bool isDown
= diff
> 0;
4242 if (IsScrollIncrement(adj
->step_increment
, diff
))
4244 eventType
= isDown ? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4246 else if (IsScrollIncrement(adj
->page_increment
, diff
))
4248 eventType
= isDown ? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4250 else if (m_mouseButtonDown
)
4252 // Assume track event
4253 m_isScrolling
= true;
4259 void wxWindowGTK
::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4261 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4263 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4265 // No scrolling requested.
4266 if ((dx
== 0) && (dy
== 0)) return;
4268 m_clipPaintRegion
= true;
4270 if (GetLayoutDirection() == wxLayout_RightToLeft
)
4271 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), dx
, -dy
);
4273 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), -dx
, -dy
);
4275 m_clipPaintRegion
= false;
4278 bool restoreCaret
= (GetCaret() != NULL
&& GetCaret()->IsVisible());
4281 wxRect
caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4283 caretRect
.width
+= dx
;
4286 caretRect
.x
+= dx
; caretRect
.width
-= dx
;
4289 caretRect
.height
+= dy
;
4292 caretRect
.y
+= dy
; caretRect
.height
-= dy
;
4295 RefreshRect(caretRect
);
4297 #endif // wxUSE_CARET
4300 void wxWindowGTK
::GtkScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4302 //RN: Note that static controls usually have no border on gtk, so maybe
4303 //it makes sense to treat that as simply no border at the wx level
4305 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4307 GtkShadowType gtkstyle
;
4309 if(wxstyle
& wxBORDER_RAISED
)
4310 gtkstyle
= GTK_SHADOW_OUT
;
4311 else if (wxstyle
& wxBORDER_SUNKEN
)
4312 gtkstyle
= GTK_SHADOW_IN
;
4313 else if (wxstyle
& wxBORDER_DOUBLE
)
4314 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4316 gtkstyle
= GTK_SHADOW_IN
;
4318 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4323 void wxWindowGTK
::SetWindowStyleFlag( long style
)
4325 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4326 wxWindowBase
::SetWindowStyleFlag(style
);
4329 // Find the wxWindow at the current mouse position, also returning the mouse
4331 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4333 pt
= wxGetMousePosition();
4334 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4338 // Get the current mouse position.
4339 wxPoint
wxGetMousePosition()
4341 /* This crashes when used within wxHelpContext,
4342 so we have to use the X-specific implementation below.
4344 GdkModifierType *mask;
4345 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4347 return wxPoint(x, y);
4351 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4353 Display
*display
= windowAtPtr ?
GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4354 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4355 Window rootReturn
, childReturn
;
4356 int rootX
, rootY
, winX
, winY
;
4357 unsigned int maskReturn
;
4359 XQueryPointer (display
,
4363 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4364 return wxPoint(rootX
, rootY
);
4368 // Needed for implementing e.g. combobox on wxGTK within a modal dialog.
4369 void wxAddGrab(wxWindow
* window
)
4371 gtk_grab_add( (GtkWidget
*) window
->GetHandle() );
4374 void wxRemoveGrab(wxWindow
* window
)
4376 gtk_grab_remove( (GtkWidget
*) window
->GetHandle() );