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"
25 #include "wx/dcclient.h"
27 #include "wx/dialog.h"
28 #include "wx/settings.h"
29 #include "wx/msgdlg.h"
30 #include "wx/textctrl.h"
31 #include "wx/toolbar.h"
32 #include "wx/combobox.h"
33 #include "wx/layout.h"
34 #include "wx/statusbr.h"
36 #include "wx/module.h"
39 #if wxUSE_DRAG_AND_DROP
44 #include "wx/tooltip.h"
51 #include "wx/fontutil.h"
54 #include "wx/thread.h"
59 // FIXME: Due to a hack we use GtkCombo in here, which is deprecated since gtk2.3.0
60 #include <gtk/gtkversion.h>
61 #if defined(GTK_DISABLE_DEPRECATED) && GTK_CHECK_VERSION(2,3,0)
62 #undef GTK_DISABLE_DEPRECATED
65 #include "wx/gtk/private.h"
66 #include <gdk/gdkprivate.h>
67 #include <gdk/gdkkeysyms.h>
71 #include <gtk/gtkprivate.h>
73 #include "wx/gtk/win_gtk.h"
75 #include <pango/pangox.h>
81 //-----------------------------------------------------------------------------
82 // documentation on internals
83 //-----------------------------------------------------------------------------
86 I have been asked several times about writing some documentation about
87 the GTK port of wxWidgets, especially its internal structures. Obviously,
88 you cannot understand wxGTK without knowing a little about the GTK, but
89 some more information about what the wxWindow, which is the base class
90 for all other window classes, does seems required as well.
94 What does wxWindow do? It contains the common interface for the following
95 jobs of its descendants:
97 1) Define the rudimentary behaviour common to all window classes, such as
98 resizing, intercepting user input (so as to make it possible to use these
99 events for special purposes in a derived class), window names etc.
101 2) Provide the possibility to contain and manage children, if the derived
102 class is allowed to contain children, which holds true for those window
103 classes which do not display a native GTK widget. To name them, these
104 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
105 work classes are a special case and are handled a bit differently from
106 the rest. The same holds true for the wxNotebook class.
108 3) Provide the possibility to draw into a client area of a window. This,
109 too, only holds true for classes that do not display a native GTK widget
112 4) Provide the entire mechanism for scrolling widgets. This actual inter-
113 face for this is usually in wxScrolledWindow, but the GTK implementation
116 5) A multitude of helper or extra methods for special purposes, such as
117 Drag'n'Drop, managing validators etc.
119 6) Display a border (sunken, raised, simple or none).
121 Normally one might expect, that one wxWidgets window would always correspond
122 to one GTK widget. Under GTK, there is no such all-round widget that has all
123 the functionality. Moreover, the GTK defines a client area as a different
124 widget from the actual widget you are handling. Last but not least some
125 special classes (e.g. wxFrame) handle different categories of widgets and
126 still have the possibility to draw something in the client area.
127 It was therefore required to write a special purpose GTK widget, that would
128 represent a client area in the sense of wxWidgets capable to do the jobs
129 2), 3) and 4). I have written this class and it resides in win_gtk.c of
132 All windows must have a widget, with which they interact with other under-
133 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
134 the wxWindow class has a member variable called m_widget which holds a
135 pointer to this widget. When the window class represents a GTK native widget,
136 this is (in most cases) the only GTK widget the class manages. E.g. the
137 wxStaticText class handles only a GtkLabel widget a pointer to which you
138 can find in m_widget (defined in wxWindow)
140 When the class has a client area for drawing into and for containing children
141 it has to handle the client area widget (of the type GtkPizza, defined in
142 win_gtk.c), but there could be any number of widgets, handled by a class
143 The common rule for all windows is only, that the widget that interacts with
144 the rest of GTK must be referenced in m_widget and all other widgets must be
145 children of this widget on the GTK level. The top-most widget, which also
146 represents the client area, must be in the m_wxwindow field and must be of
149 As I said, the window classes that display a GTK native widget only have
150 one widget, so in the case of e.g. the wxButton class m_widget holds a
151 pointer to a GtkButton widget. But windows with client areas (for drawing
152 and children) have a m_widget field that is a pointer to a GtkScrolled-
153 Window and a m_wxwindow field that is pointer to a GtkPizza and this
154 one is (in the GTK sense) a child of the GtkScrolledWindow.
156 If the m_wxwindow field is set, then all input to this widget is inter-
157 cepted and sent to the wxWidgets class. If not, all input to the widget
158 that gets pointed to by m_widget gets intercepted and sent to the class.
162 The design of scrolling in wxWidgets is markedly different from that offered
163 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
164 clicking on a scrollbar belonging to scrolled window will inevitably move
165 the window. In wxWidgets, the scrollbar will only emit an event, send this
166 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
167 which actually moves the window and its sub-windows. Note that GtkPizza
168 memorizes how much it has been scrolled but that wxWidgets forgets this
169 so that the two coordinates systems have to be kept in synch. This is done
170 in various places using the pizza->xoffset and pizza->yoffset values.
174 Singularly the most broken code in GTK is the code that is supposed to
175 inform subwindows (child windows) about new positions. Very often, duplicate
176 events are sent without changes in size or position, equally often no
177 events are sent at all (All this is due to a bug in the GtkContainer code
178 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
179 GTK's own system and it simply waits for size events for toplevel windows
180 and then iterates down the respective size events to all window. This has
181 the disadvantage that windows might get size events before the GTK widget
182 actually has the reported size. This doesn't normally pose any problem, but
183 the OpenGL drawing routines rely on correct behaviour. Therefore, I have
184 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
185 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
186 window that is used for OpenGL output really has that size (as reported by
191 If someone at some point of time feels the immense desire to have a look at,
192 change or attempt to optimise the Refresh() logic, this person will need an
193 intimate understanding of what "draw" and "expose" events are and what
194 they are used for, in particular when used in connection with GTK's
195 own windowless widgets. Beware.
199 Cursors, too, have been a constant source of pleasure. The main difficulty
200 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
201 for the parent. To prevent this from doing too much harm, I use idle time
202 to set the cursor over and over again, starting from the toplevel windows
203 and ending with the youngest generation (speaking of parent and child windows).
204 Also don't forget that cursors (like much else) are connected to GdkWindows,
205 not GtkWidgets and that the "window" field of a GtkWidget might very well
206 point to the GdkWindow of the parent widget (-> "window-less widget") and
207 that the two obviously have very different meanings.
211 //-----------------------------------------------------------------------------
213 //-----------------------------------------------------------------------------
215 extern bool g_blockEventsOnDrag
;
216 extern bool g_blockEventsOnScroll
;
217 extern wxCursor g_globalCursor
;
219 // mouse capture state: the window which has it and if the mouse is currently
221 static wxWindowGTK
*g_captureWindow
= (wxWindowGTK
*) NULL
;
222 static bool g_captureWindowHasMouse
= false;
224 wxWindowGTK
*g_focusWindow
= (wxWindowGTK
*) NULL
;
226 // the last window which had the focus - this is normally never NULL (except
227 // if we never had focus at all) as even when g_focusWindow is NULL it still
228 // keeps its previous value
229 wxWindowGTK
*g_focusWindowLast
= (wxWindowGTK
*) NULL
;
231 // If a window get the focus set but has not been realized
232 // yet, defer setting the focus to idle time.
233 wxWindowGTK
*g_delayedFocus
= (wxWindowGTK
*) NULL
;
235 extern bool g_mainThreadLocked
;
237 //-----------------------------------------------------------------------------
239 //-----------------------------------------------------------------------------
244 # define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
246 # define DEBUG_MAIN_THREAD
249 #define DEBUG_MAIN_THREAD
252 // the trace mask used for the focus debugging messages
253 #define TRACE_FOCUS _T("focus")
255 //-----------------------------------------------------------------------------
256 // missing gdk functions
257 //-----------------------------------------------------------------------------
260 gdk_window_warp_pointer (GdkWindow
*window
,
265 window
= gdk_get_default_root_window();
267 if (!GDK_WINDOW_DESTROYED(window
))
269 XWarpPointer (GDK_WINDOW_XDISPLAY(window
),
270 None
, /* not source window -> move from anywhere */
271 GDK_WINDOW_XID(window
), /* dest window */
272 0, 0, 0, 0, /* not source window -> move from anywhere */
277 //-----------------------------------------------------------------------------
278 // local code (see below)
279 //-----------------------------------------------------------------------------
281 // returns the child of win which currently has focus or NULL if not found
283 // Note: can't be static, needed by textctrl.cpp.
284 wxWindow
*wxFindFocusedChild(wxWindowGTK
*win
)
286 wxWindow
*winFocus
= wxWindowGTK::FindFocus();
288 return (wxWindow
*)NULL
;
290 if ( winFocus
== win
)
291 return (wxWindow
*)win
;
293 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
295 node
= node
->GetNext() )
297 wxWindow
*child
= wxFindFocusedChild(node
->GetData());
302 return (wxWindow
*)NULL
;
305 static void GetScrollbarWidth(GtkWidget
* widget
, int& w
, int& h
)
307 GtkScrolledWindow
* scroll_window
= GTK_SCROLLED_WINDOW(widget
);
308 GtkScrolledWindowClass
* scroll_class
= GTK_SCROLLED_WINDOW_CLASS(GTK_OBJECT_GET_CLASS(scroll_window
));
309 GtkRequisition scroll_req
;
312 if (scroll_window
->vscrollbar_visible
)
314 scroll_req
.width
= 2;
315 scroll_req
.height
= 2;
316 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
317 (scroll_window
->vscrollbar
, &scroll_req
);
318 w
= scroll_req
.width
+
319 scroll_class
->scrollbar_spacing
;
323 if (scroll_window
->hscrollbar_visible
)
325 scroll_req
.width
= 2;
326 scroll_req
.height
= 2;
327 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
328 (scroll_window
->hscrollbar
, &scroll_req
);
329 h
= scroll_req
.height
+
330 scroll_class
->scrollbar_spacing
;
334 static void draw_frame( GtkWidget
*widget
, wxWindowGTK
*win
)
336 // wxUniversal widgets draw the borders and scrollbars themselves
337 #ifndef __WXUNIVERSAL__
343 if (GTK_WIDGET_NO_WINDOW (widget
))
345 dx
+= widget
->allocation
.x
;
346 dy
+= widget
->allocation
.y
;
354 if (win
->m_hasScrolling
)
356 GetScrollbarWidth(widget
, dw
, dh
);
358 if (win
->GetLayoutDirection() == wxLayout_RightToLeft
)
360 // This is actually wrong for old GTK+ version
361 // which do not display the scrollbar on the
367 int w
= widget
->allocation
.width
-dw
;
368 int h
= widget
->allocation
.height
-dh
;
370 if (win
->HasFlag(wxRAISED_BORDER
))
372 gtk_paint_shadow (widget
->style
,
376 NULL
, NULL
, NULL
, // FIXME: No clipping?
381 if (win
->HasFlag(wxSUNKEN_BORDER
))
383 gtk_paint_shadow (widget
->style
,
387 NULL
, NULL
, NULL
, // FIXME: No clipping?
392 if (win
->HasFlag(wxSIMPLE_BORDER
))
395 gc
= gdk_gc_new( widget
->window
);
396 gdk_gc_set_foreground( gc
, &widget
->style
->black
);
397 gdk_draw_rectangle( widget
->window
, gc
, FALSE
, x
, y
, w
-1, h
-1 );
401 #endif // __WXUNIVERSAL__
404 //-----------------------------------------------------------------------------
405 // "expose_event" of m_widget
406 //-----------------------------------------------------------------------------
410 gtk_window_own_expose_callback( GtkWidget
*widget
,
411 GdkEventExpose
*gdk_event
,
414 if (gdk_event
->count
== 0)
415 draw_frame(widget
, win
);
420 //-----------------------------------------------------------------------------
421 // "size_request" of m_widget
422 //-----------------------------------------------------------------------------
424 // make it extern because wxStaticText needs to disconnect this one
426 void wxgtk_window_size_request_callback(GtkWidget
*widget
,
427 GtkRequisition
*requisition
,
431 win
->GetSize( &w
, &h
);
437 requisition
->height
= h
;
438 requisition
->width
= w
;
444 void wxgtk_combo_size_request_callback(GtkWidget
*widget
,
445 GtkRequisition
*requisition
,
448 // This callback is actually hooked into the text entry
449 // of the combo box, not the GtkHBox.
452 win
->GetSize( &w
, &h
);
458 GtkCombo
*gcombo
= GTK_COMBO(win
->m_widget
);
460 GtkRequisition entry_req
;
462 entry_req
.height
= 2;
463 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo
->button
) )->size_request
)
464 (gcombo
->button
, &entry_req
);
466 requisition
->width
= w
- entry_req
.width
;
467 requisition
->height
= entry_req
.height
;
471 //-----------------------------------------------------------------------------
472 // "expose_event" of m_wxwindow
473 //-----------------------------------------------------------------------------
477 gtk_window_expose_callback( GtkWidget
*widget
,
478 GdkEventExpose
*gdk_event
,
483 // don't need to install idle handler, its done from "event" signal
485 // This callback gets called in drawing-idle time under
486 // GTK 2.0, so we don't need to defer anything to idle
489 GtkPizza
*pizza
= GTK_PIZZA( widget
);
490 if (gdk_event
->window
!= pizza
->bin_window
) return FALSE
;
496 wxPrintf( wxT("OnExpose from ") );
497 if (win
->GetClassInfo() && win
->GetClassInfo()->GetClassName())
498 wxPrintf( win
->GetClassInfo()->GetClassName() );
499 wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event
->area
.x
,
500 (int)gdk_event
->area
.y
,
501 (int)gdk_event
->area
.width
,
502 (int)gdk_event
->area
.height
);
507 win
->m_wxwindow
->style
,
511 (GdkRectangle
*) NULL
,
513 (char *)"button", // const_cast
518 win
->GetUpdateRegion() = wxRegion( gdk_event
->region
);
520 win
->GtkSendPaintEvents();
522 // Let parent window draw window-less widgets
527 //-----------------------------------------------------------------------------
528 // "key_press_event" from any window
529 //-----------------------------------------------------------------------------
531 // These are used when transforming Ctrl-alpha to ascii values 1-26
532 inline bool wxIsLowerChar(int code
)
534 return (code
>= 'a' && code
<= 'z' );
537 inline bool wxIsUpperChar(int code
)
539 return (code
>= 'A' && code
<= 'Z' );
543 // set WXTRACE to this to see the key event codes on the console
544 #define TRACE_KEYS _T("keyevent")
546 // translates an X key symbol to WXK_XXX value
548 // if isChar is true it means that the value returned will be used for EVT_CHAR
549 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
550 // for example, while if it is false it means that the value is going to be
551 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
553 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
559 // Shift, Control and Alt don't generate the CHAR events at all
562 key_code
= isChar
? 0 : WXK_SHIFT
;
566 key_code
= isChar
? 0 : WXK_CONTROL
;
574 key_code
= isChar
? 0 : WXK_ALT
;
577 // neither do the toggle modifies
578 case GDK_Scroll_Lock
:
579 key_code
= isChar
? 0 : WXK_SCROLL
;
583 key_code
= isChar
? 0 : WXK_CAPITAL
;
587 key_code
= isChar
? 0 : WXK_NUMLOCK
;
591 // various other special keys
604 case GDK_ISO_Left_Tab
:
611 key_code
= WXK_RETURN
;
615 key_code
= WXK_CLEAR
;
619 key_code
= WXK_PAUSE
;
623 key_code
= WXK_SELECT
;
627 key_code
= WXK_PRINT
;
631 key_code
= WXK_EXECUTE
;
635 key_code
= WXK_ESCAPE
;
638 // cursor and other extended keyboard keys
640 key_code
= WXK_DELETE
;
656 key_code
= WXK_RIGHT
;
663 case GDK_Prior
: // == GDK_Page_Up
664 key_code
= WXK_PAGEUP
;
667 case GDK_Next
: // == GDK_Page_Down
668 key_code
= WXK_PAGEDOWN
;
680 key_code
= WXK_INSERT
;
695 key_code
= (isChar
? '0' : WXK_NUMPAD0
) + keysym
- GDK_KP_0
;
699 key_code
= isChar
? ' ' : WXK_NUMPAD_SPACE
;
703 key_code
= isChar
? WXK_TAB
: WXK_NUMPAD_TAB
;
707 key_code
= isChar
? WXK_RETURN
: WXK_NUMPAD_ENTER
;
711 key_code
= isChar
? WXK_F1
: WXK_NUMPAD_F1
;
715 key_code
= isChar
? WXK_F2
: WXK_NUMPAD_F2
;
719 key_code
= isChar
? WXK_F3
: WXK_NUMPAD_F3
;
723 key_code
= isChar
? WXK_F4
: WXK_NUMPAD_F4
;
727 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_HOME
;
731 key_code
= isChar
? WXK_LEFT
: WXK_NUMPAD_LEFT
;
735 key_code
= isChar
? WXK_UP
: WXK_NUMPAD_UP
;
739 key_code
= isChar
? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
743 key_code
= isChar
? WXK_DOWN
: WXK_NUMPAD_DOWN
;
746 case GDK_KP_Prior
: // == GDK_KP_Page_Up
747 key_code
= isChar
? WXK_PAGEUP
: WXK_NUMPAD_PAGEUP
;
750 case GDK_KP_Next
: // == GDK_KP_Page_Down
751 key_code
= isChar
? WXK_PAGEDOWN
: WXK_NUMPAD_PAGEDOWN
;
755 key_code
= isChar
? WXK_END
: WXK_NUMPAD_END
;
759 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_BEGIN
;
763 key_code
= isChar
? WXK_INSERT
: WXK_NUMPAD_INSERT
;
767 key_code
= isChar
? WXK_DELETE
: WXK_NUMPAD_DELETE
;
771 key_code
= isChar
? '=' : WXK_NUMPAD_EQUAL
;
774 case GDK_KP_Multiply
:
775 key_code
= isChar
? '*' : WXK_NUMPAD_MULTIPLY
;
779 key_code
= isChar
? '+' : WXK_NUMPAD_ADD
;
782 case GDK_KP_Separator
:
783 // FIXME: what is this?
784 key_code
= isChar
? '.' : WXK_NUMPAD_SEPARATOR
;
787 case GDK_KP_Subtract
:
788 key_code
= isChar
? '-' : WXK_NUMPAD_SUBTRACT
;
792 key_code
= isChar
? '.' : WXK_NUMPAD_DECIMAL
;
796 key_code
= isChar
? '/' : WXK_NUMPAD_DIVIDE
;
813 key_code
= WXK_F1
+ keysym
- GDK_F1
;
823 static inline bool wxIsAsciiKeysym(KeySym ks
)
828 static void wxFillOtherKeyEventFields(wxKeyEvent
& event
,
830 GdkEventKey
*gdk_event
)
834 GdkModifierType state
;
835 if (gdk_event
->window
)
836 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
838 event
.SetTimestamp( gdk_event
->time
);
839 event
.SetId(win
->GetId());
840 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
841 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
842 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
843 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
) != 0;
844 event
.m_scanCode
= gdk_event
->keyval
;
845 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
846 event
.m_rawFlags
= 0;
848 event
.m_uniChar
= gdk_keyval_to_unicode(gdk_event
->keyval
);
850 wxGetMousePosition( &x
, &y
);
851 win
->ScreenToClient( &x
, &y
);
854 event
.SetEventObject( win
);
859 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
861 GdkEventKey
*gdk_event
)
863 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
864 // but only event->keyval which is quite useless to us, so remember
865 // the last character from GDK_KEY_PRESS and reuse it as last resort
867 // NB: should be MT-safe as we're always called from the main thread only
872 } s_lastKeyPress
= { 0, 0 };
874 KeySym keysym
= gdk_event
->keyval
;
876 wxLogTrace(TRACE_KEYS
, _T("Key %s event: keysym = %ld"),
877 event
.GetEventType() == wxEVT_KEY_UP
? _T("release")
881 long key_code
= wxTranslateKeySymToWXKey(keysym
, false /* !isChar */);
885 // do we have the translation or is it a plain ASCII character?
886 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
888 // we should use keysym if it is ASCII as X does some translations
889 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
890 // which we don't want here (but which we do use for OnChar())
891 if ( !wxIsAsciiKeysym(keysym
) )
893 keysym
= (KeySym
)gdk_event
->string
[0];
896 // we want to always get the same key code when the same key is
897 // pressed regardless of the state of the modifiers, i.e. on a
898 // standard US keyboard pressing '5' or '%' ('5' key with
899 // Shift) should result in the same key code in OnKeyDown():
900 // '5' (although OnChar() will get either '5' or '%').
902 // to do it we first translate keysym to keycode (== scan code)
903 // and then back but always using the lower register
904 Display
*dpy
= (Display
*)wxGetDisplay();
905 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
907 wxLogTrace(TRACE_KEYS
, _T("\t-> keycode %d"), keycode
);
909 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
911 // use the normalized, i.e. lower register, keysym if we've
913 key_code
= keysymNormalized
? keysymNormalized
: keysym
;
915 // as explained above, we want to have lower register key codes
916 // normally but for the letter keys we want to have the upper ones
918 // NB: don't use XConvertCase() here, we want to do it for letters
920 key_code
= toupper(key_code
);
922 else // non ASCII key, what to do?
924 // by default, ignore it
927 // but if we have cached information from the last KEY_PRESS
928 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
931 if ( keysym
== s_lastKeyPress
.keysym
)
933 key_code
= s_lastKeyPress
.keycode
;
938 if ( gdk_event
->type
== GDK_KEY_PRESS
)
940 // remember it to be reused for KEY_UP event later
941 s_lastKeyPress
.keysym
= keysym
;
942 s_lastKeyPress
.keycode
= key_code
;
946 wxLogTrace(TRACE_KEYS
, _T("\t-> wxKeyCode %ld"), key_code
);
948 // sending unknown key events doesn't really make sense
952 // now fill all the other fields
953 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
955 event
.m_keyCode
= key_code
;
957 if ( gdk_event
->type
== GDK_KEY_PRESS
|| gdk_event
->type
== GDK_KEY_RELEASE
)
959 event
.m_uniChar
= key_code
;
969 GtkIMContext
*context
;
970 GdkEventKey
*lastKeyEvent
;
974 context
= gtk_im_multicontext_new();
979 g_object_unref (context
);
985 gtk_window_key_press_callback( GtkWidget
*widget
,
986 GdkEventKey
*gdk_event
,
991 // don't need to install idle handler, its done from "event" signal
995 if (g_blockEventsOnDrag
)
999 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1001 bool return_after_IM
= false;
1003 if( wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1005 // Emit KEY_DOWN event
1006 ret
= win
->GetEventHandler()->ProcessEvent( event
);
1010 // Return after IM processing as we cannot do
1011 // anything with it anyhow.
1012 return_after_IM
= true;
1015 // 2005.01.26 modified by Hong Jen Yee (hzysoft@sina.com.tw):
1016 // When we get a key_press event here, it could be originate
1017 // from the current widget or its child widgets. However, only the widget
1018 // with the INPUT FOCUS can generate the INITIAL key_press event. That is,
1019 // if the CURRENT widget doesn't have the FOCUS at all, this event definitely
1020 // originated from its child widgets and shouldn't be passed to IM context.
1021 // In fact, what a GTK+ IM should do is filtering keyEvents and convert them
1022 // into text input ONLY WHEN THE WIDGET HAS INPUT FOCUS. Besides, when current
1023 // widgets has both IM context and input focus, the event should be filtered
1024 // by gtk_im_context_filter_keypress().
1025 // Then, we should, according to GTK+ 2.0 API doc, return whatever it returns.
1026 if ((!ret
) && (win
->m_imData
!= NULL
) && ( wxWindow::FindFocus() == win
))
1028 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
1029 // docs, if IM filter returns true, no further processing should be done.
1030 // we should send the key_down event anyway.
1031 bool intercepted_by_IM
= gtk_im_context_filter_keypress(win
->m_imData
->context
, gdk_event
);
1032 win
->m_imData
->lastKeyEvent
= NULL
;
1033 if (intercepted_by_IM
)
1035 wxLogTrace(TRACE_KEYS
, _T("Key event intercepted by IM"));
1040 if (return_after_IM
)
1046 wxWindowGTK
*ancestor
= win
;
1049 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
1052 wxCommandEvent
command_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
1053 ret
= ancestor
->GetEventHandler()->ProcessEvent( command_event
);
1056 if (ancestor
->IsTopLevel())
1058 ancestor
= ancestor
->GetParent();
1061 #endif // wxUSE_ACCEL
1063 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1064 // will only be sent if it is not in an accelerator table.
1068 KeySym keysym
= gdk_event
->keyval
;
1069 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1070 key_code
= wxTranslateKeySymToWXKey(keysym
, true /* isChar */);
1073 if ( wxIsAsciiKeysym(keysym
) )
1076 key_code
= (unsigned char)keysym
;
1078 // gdk_event->string is actually deprecated
1079 else if ( gdk_event
->length
== 1 )
1081 key_code
= (unsigned char)gdk_event
->string
[0];
1087 wxLogTrace(TRACE_KEYS
, _T("Char event: %ld"), key_code
);
1089 event
.m_keyCode
= key_code
;
1091 // To conform to the docs we need to translate Ctrl-alpha
1092 // characters to values in the range 1-26.
1093 if ( event
.ControlDown() &&
1094 ( wxIsLowerChar(key_code
) || wxIsUpperChar(key_code
) ))
1096 if ( wxIsLowerChar(key_code
) )
1097 event
.m_keyCode
= key_code
- 'a' + 1;
1098 if ( wxIsUpperChar(key_code
) )
1099 event
.m_keyCode
= key_code
- 'A' + 1;
1101 event
.m_uniChar
= event
.m_keyCode
;
1105 // Implement OnCharHook by checking ancestor top level windows
1106 wxWindow
*parent
= win
;
1107 while (parent
&& !parent
->IsTopLevel())
1108 parent
= parent
->GetParent();
1111 event
.SetEventType( wxEVT_CHAR_HOOK
);
1112 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1117 event
.SetEventType(wxEVT_CHAR
);
1118 ret
= win
->GetEventHandler()->ProcessEvent( event
);
1123 // win is a control: tab can be propagated up
1125 ((gdk_event
->keyval
== GDK_Tab
) || (gdk_event
->keyval
== GDK_ISO_Left_Tab
)) &&
1126 // VZ: testing for wxTE_PROCESS_TAB shouldn't be done here - the control may
1127 // have this style, yet choose not to process this particular TAB in which
1128 // case TAB must still work as a navigational character
1129 // JS: enabling again to make consistent with other platforms
1130 // (with wxTE_PROCESS_TAB you have to call Navigate to get default
1131 // navigation behaviour)
1133 (! (win
->HasFlag(wxTE_PROCESS_TAB
) && win
->IsKindOf(CLASSINFO(wxTextCtrl
)) )) &&
1135 win
->GetParent() && (win
->GetParent()->HasFlag( wxTAB_TRAVERSAL
)) )
1137 wxNavigationKeyEvent new_event
;
1138 new_event
.SetEventObject( win
->GetParent() );
1139 // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
1140 new_event
.SetDirection( (gdk_event
->keyval
== GDK_Tab
) );
1141 // CTRL-TAB changes the (parent) window, i.e. switch notebook page
1142 new_event
.SetWindowChange( (gdk_event
->state
& GDK_CONTROL_MASK
) );
1143 new_event
.SetCurrentFocus( win
);
1144 ret
= win
->GetParent()->GetEventHandler()->ProcessEvent( new_event
);
1153 gtk_wxwindow_commit_cb (GtkIMContext
*context
,
1157 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1159 // take modifiers, cursor position, timestamp etc. from the last
1160 // key_press_event that was fed into Input Method:
1161 if (window
->m_imData
->lastKeyEvent
)
1163 wxFillOtherKeyEventFields(event
,
1164 window
, window
->m_imData
->lastKeyEvent
);
1167 const wxWxCharBuffer
data(wxGTK_CONV_BACK(str
));
1173 // Implement OnCharHook by checking ancestor top level windows
1174 wxWindow
*parent
= window
;
1175 while (parent
&& !parent
->IsTopLevel())
1176 parent
= parent
->GetParent();
1178 for( const wxChar
* pstr
= data
; *pstr
; pstr
++ )
1181 event
.m_uniChar
= *pstr
;
1182 // Backward compatible for ISO-8859-1
1183 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
1184 wxLogTrace(TRACE_KEYS
, _T("IM sent character '%c'"), event
.m_uniChar
);
1186 event
.m_keyCode
= *pstr
;
1187 #endif // wxUSE_UNICODE
1189 // To conform to the docs we need to translate Ctrl-alpha
1190 // characters to values in the range 1-26.
1191 if ( event
.ControlDown() &&
1192 ( wxIsLowerChar(*pstr
) || wxIsUpperChar(*pstr
) ))
1194 if ( wxIsLowerChar(*pstr
) )
1195 event
.m_keyCode
= *pstr
- 'a' + 1;
1196 if ( wxIsUpperChar(*pstr
) )
1197 event
.m_keyCode
= *pstr
- 'A' + 1;
1199 event
.m_keyCode
= *pstr
- 'a' + 1;
1201 event
.m_uniChar
= event
.m_keyCode
;
1207 event
.SetEventType( wxEVT_CHAR_HOOK
);
1208 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1213 event
.SetEventType(wxEVT_CHAR
);
1214 ret
= window
->GetEventHandler()->ProcessEvent( event
);
1221 //-----------------------------------------------------------------------------
1222 // "key_release_event" from any window
1223 //-----------------------------------------------------------------------------
1227 gtk_window_key_release_callback( GtkWidget
*widget
,
1228 GdkEventKey
*gdk_event
,
1233 // don't need to install idle handler, its done from "event" signal
1238 if (g_blockEventsOnDrag
)
1241 wxKeyEvent
event( wxEVT_KEY_UP
);
1242 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1244 // unknown key pressed, ignore (the event would be useless anyhow)
1248 return win
->GTKProcessEvent(event
);
1252 // ============================================================================
1254 // ============================================================================
1256 // ----------------------------------------------------------------------------
1257 // mouse event processing helpers
1258 // ----------------------------------------------------------------------------
1260 // init wxMouseEvent with the info from GdkEventXXX struct
1261 template<typename T
> void InitMouseEvent(wxWindowGTK
*win
,
1262 wxMouseEvent
& event
,
1265 event
.SetTimestamp( gdk_event
->time
);
1266 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1267 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1268 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1269 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1270 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1271 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1272 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1273 if (event
.GetEventType() == wxEVT_MOUSEWHEEL
)
1275 event
.m_linesPerAction
= 3;
1276 event
.m_wheelDelta
= 120;
1277 if (((GdkEventButton
*)gdk_event
)->button
== 4)
1278 event
.m_wheelRotation
= 120;
1279 else if (((GdkEventButton
*)gdk_event
)->button
== 5)
1280 event
.m_wheelRotation
= -120;
1283 wxPoint pt
= win
->GetClientAreaOrigin();
1284 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1285 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1287 if ((win
->m_wxwindow
) && (win
->GetLayoutDirection() == wxLayout_RightToLeft
))
1289 // origin in the upper right corner
1290 int window_width
= gtk_pizza_get_rtl_offset( GTK_PIZZA(win
->m_wxwindow
) );
1291 event
.m_x
= window_width
- event
.m_x
;
1294 event
.SetEventObject( win
);
1295 event
.SetId( win
->GetId() );
1296 event
.SetTimestamp( gdk_event
->time
);
1299 static void AdjustEventButtonState(wxMouseEvent
& event
)
1301 // GDK reports the old state of the button for a button press event, but
1302 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1303 // for a LEFT_DOWN event, not FALSE, so we will invert
1304 // left/right/middleDown for the corresponding click events
1306 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1307 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1308 (event
.GetEventType() == wxEVT_LEFT_UP
))
1310 event
.m_leftDown
= !event
.m_leftDown
;
1314 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1315 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1316 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1318 event
.m_middleDown
= !event
.m_middleDown
;
1322 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1323 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1324 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1326 event
.m_rightDown
= !event
.m_rightDown
;
1331 // find the window to send the mouse event too
1333 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1338 if (win
->m_wxwindow
)
1340 GtkPizza
*pizza
= GTK_PIZZA(win
->m_wxwindow
);
1341 xx
+= gtk_pizza_get_xoffset( pizza
);
1342 yy
+= gtk_pizza_get_yoffset( pizza
);
1345 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
1348 wxWindowGTK
*child
= node
->GetData();
1350 node
= node
->GetNext();
1351 if (!child
->IsShown())
1354 if (child
->IsTransparentForMouse())
1356 // wxStaticBox is transparent in the box itself
1357 int xx1
= child
->m_x
;
1358 int yy1
= child
->m_y
;
1359 int xx2
= child
->m_x
+ child
->m_width
;
1360 int yy2
= child
->m_y
+ child
->m_height
;
1363 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1365 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1367 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1369 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1380 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1381 (child
->m_x
<= xx
) &&
1382 (child
->m_y
<= yy
) &&
1383 (child
->m_x
+child
->m_width
>= xx
) &&
1384 (child
->m_y
+child
->m_height
>= yy
))
1397 // ----------------------------------------------------------------------------
1398 // common event handlers helpers
1399 // ----------------------------------------------------------------------------
1401 bool wxWindowGTK::GTKProcessEvent(wxEvent
& event
) const
1403 // nothing special at this level
1404 return GetEventHandler()->ProcessEvent(event
);
1407 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny
*event
) const
1411 // don't need to install idle handler, its done from "event" signal
1415 if (g_blockEventsOnDrag
)
1417 if (g_blockEventsOnScroll
)
1420 if (!GTKIsOwnWindow(event
->window
))
1426 // overloads for all GDK event types we use here: we need to have this as
1427 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1428 // derives from it in the sense that the structs have the same layout
1429 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1430 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1432 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1435 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton
)
1436 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion
)
1437 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing
)
1439 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1441 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1442 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1446 // send the wxChildFocusEvent and wxFocusEvent, common code of
1447 // gtk_window_focus_in_callback() and SetFocus()
1448 static bool DoSendFocusEvents(wxWindow
*win
)
1450 // Notify the parent keeping track of focus for the kbd navigation
1451 // purposes that we got it.
1452 wxChildFocusEvent
eventChildFocus(win
);
1453 (void)win
->GetEventHandler()->ProcessEvent(eventChildFocus
);
1455 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, win
->GetId());
1456 eventFocus
.SetEventObject(win
);
1458 return win
->GetEventHandler()->ProcessEvent(eventFocus
);
1461 // all event handlers must have C linkage as they're called from GTK+ C code
1465 //-----------------------------------------------------------------------------
1466 // "button_press_event"
1467 //-----------------------------------------------------------------------------
1470 gtk_window_button_press_callback( GtkWidget
*widget
,
1471 GdkEventButton
*gdk_event
,
1474 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1476 if (win
->m_wxwindow
&& (g_focusWindow
!= win
) && win
->AcceptsFocus())
1478 gtk_widget_grab_focus( win
->m_wxwindow
);
1481 // GDK sends surplus button down events
1482 // before a double click event. We
1483 // need to filter these out.
1484 if (gdk_event
->type
== GDK_BUTTON_PRESS
)
1486 GdkEvent
*peek_event
= gdk_event_peek();
1489 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1490 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1492 gdk_event_free( peek_event
);
1497 gdk_event_free( peek_event
);
1502 wxEventType event_type
= wxEVT_NULL
;
1504 // GdkDisplay is a GTK+ 2.2.0 thing
1505 #if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0)
1506 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1507 !gtk_check_version(2,2,0) &&
1508 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1510 // Reset GDK internal timestamp variables in order to disable GDK
1511 // triple click events. GDK will then next time believe no button has
1512 // been clicked just before, and send a normal button click event.
1513 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1514 display
->button_click_time
[1] = 0;
1515 display
->button_click_time
[0] = 0;
1519 if (gdk_event
->button
== 1)
1521 // note that GDK generates triple click events which are not supported
1522 // by wxWidgets but still have to be passed to the app as otherwise
1523 // clicks would simply go missing
1524 switch (gdk_event
->type
)
1526 // we shouldn't get triple clicks at all for GTK2 because we
1527 // suppress them artificially using the code above but we still
1528 // should map them to something for GTK1 and not just ignore them
1529 // as this would lose clicks
1530 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1531 case GDK_BUTTON_PRESS
:
1532 event_type
= wxEVT_LEFT_DOWN
;
1535 case GDK_2BUTTON_PRESS
:
1536 event_type
= wxEVT_LEFT_DCLICK
;
1540 // just to silence gcc warnings
1544 else if (gdk_event
->button
== 2)
1546 switch (gdk_event
->type
)
1548 case GDK_3BUTTON_PRESS
:
1549 case GDK_BUTTON_PRESS
:
1550 event_type
= wxEVT_MIDDLE_DOWN
;
1553 case GDK_2BUTTON_PRESS
:
1554 event_type
= wxEVT_MIDDLE_DCLICK
;
1561 else if (gdk_event
->button
== 3)
1563 switch (gdk_event
->type
)
1565 case GDK_3BUTTON_PRESS
:
1566 case GDK_BUTTON_PRESS
:
1567 event_type
= wxEVT_RIGHT_DOWN
;
1570 case GDK_2BUTTON_PRESS
:
1571 event_type
= wxEVT_RIGHT_DCLICK
;
1578 else if (gdk_event
->button
== 4 || gdk_event
->button
== 5)
1580 if (gdk_event
->type
== GDK_BUTTON_PRESS
)
1582 event_type
= wxEVT_MOUSEWHEEL
;
1586 if ( event_type
== wxEVT_NULL
)
1588 // unknown mouse button or click type
1592 wxMouseEvent
event( event_type
);
1593 InitMouseEvent( win
, event
, gdk_event
);
1595 AdjustEventButtonState(event
);
1597 // wxListBox actually gets mouse events from the item, so we need to give it
1598 // a chance to correct this
1599 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1601 // find the correct window to send the event to: it may be a different one
1602 // from the one which got it at GTK+ level because some controls don't have
1603 // their own X window and thus cannot get any events.
1604 if ( !g_captureWindow
)
1605 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1607 // reset the event object and id in case win changed.
1608 event
.SetEventObject( win
);
1609 event
.SetId( win
->GetId() );
1611 if (win
->GTKProcessEvent( event
))
1616 if (event_type
== wxEVT_RIGHT_DOWN
)
1618 // generate a "context menu" event: this is similar to right mouse
1619 // click under many GUIs except that it is generated differently
1620 // (right up under MSW, ctrl-click under Mac, right down here) and
1622 // (a) it's a command event and so is propagated to the parent
1623 // (b) under some ports it can be generated from kbd too
1624 // (c) it uses screen coords (because of (a))
1625 wxContextMenuEvent
evtCtx(
1628 win
->ClientToScreen(event
.GetPosition()));
1629 evtCtx
.SetEventObject(win
);
1630 return win
->GTKProcessEvent(evtCtx
);
1636 //-----------------------------------------------------------------------------
1637 // "button_release_event"
1638 //-----------------------------------------------------------------------------
1641 gtk_window_button_release_callback( GtkWidget
*widget
,
1642 GdkEventButton
*gdk_event
,
1645 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1647 wxEventType event_type
= wxEVT_NULL
;
1649 switch (gdk_event
->button
)
1652 event_type
= wxEVT_LEFT_UP
;
1656 event_type
= wxEVT_MIDDLE_UP
;
1660 event_type
= wxEVT_RIGHT_UP
;
1664 // unknown button, don't process
1668 wxMouseEvent
event( event_type
);
1669 InitMouseEvent( win
, event
, gdk_event
);
1671 AdjustEventButtonState(event
);
1673 // same wxListBox hack as above
1674 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1676 if ( !g_captureWindow
)
1677 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1679 // reset the event object and id in case win changed.
1680 event
.SetEventObject( win
);
1681 event
.SetId( win
->GetId() );
1683 return win
->GTKProcessEvent(event
);
1686 //-----------------------------------------------------------------------------
1687 // "motion_notify_event"
1688 //-----------------------------------------------------------------------------
1691 gtk_window_motion_notify_callback( GtkWidget
*widget
,
1692 GdkEventMotion
*gdk_event
,
1695 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1697 if (gdk_event
->is_hint
)
1701 GdkModifierType state
;
1702 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1707 wxMouseEvent
event( wxEVT_MOTION
);
1708 InitMouseEvent(win
, event
, gdk_event
);
1710 if ( g_captureWindow
)
1712 // synthesise a mouse enter or leave event if needed
1713 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1714 // This seems to be necessary and actually been added to
1715 // GDK itself in version 2.0.X
1718 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1719 if ( hasMouse
!= g_captureWindowHasMouse
)
1721 // the mouse changed window
1722 g_captureWindowHasMouse
= hasMouse
;
1724 wxMouseEvent
eventM(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1725 : wxEVT_LEAVE_WINDOW
);
1726 InitMouseEvent(win
, eventM
, gdk_event
);
1727 eventM
.SetEventObject(win
);
1728 win
->GTKProcessEvent(eventM
);
1733 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1735 // reset the event object and id in case win changed.
1736 event
.SetEventObject( win
);
1737 event
.SetId( win
->GetId() );
1740 if ( !g_captureWindow
)
1742 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1743 if (win
->GTKProcessEvent( cevent
))
1745 win
->SetCursor( cevent
.GetCursor() );
1749 return win
->GTKProcessEvent(event
);
1752 //-----------------------------------------------------------------------------
1753 // "scroll_event", (mouse wheel event)
1754 //-----------------------------------------------------------------------------
1757 window_scroll_event(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1761 // don't need to install idle handler, its done from "event" signal
1763 if (gdk_event
->direction
!= GDK_SCROLL_UP
&&
1764 gdk_event
->direction
!= GDK_SCROLL_DOWN
)
1769 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1770 // Can't use InitMouse macro because scroll events don't have button
1771 event
.SetTimestamp( gdk_event
->time
);
1772 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1773 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1774 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1775 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1776 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1777 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1778 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1779 event
.m_linesPerAction
= 3;
1780 event
.m_wheelDelta
= 120;
1781 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1782 event
.m_wheelRotation
= 120;
1784 event
.m_wheelRotation
= -120;
1786 wxPoint pt
= win
->GetClientAreaOrigin();
1787 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1788 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1790 event
.SetEventObject( win
);
1791 event
.SetId( win
->GetId() );
1792 event
.SetTimestamp( gdk_event
->time
);
1794 return win
->GTKProcessEvent(event
);
1797 //-----------------------------------------------------------------------------
1799 //-----------------------------------------------------------------------------
1801 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
1803 wxContextMenuEvent
event(wxEVT_CONTEXT_MENU
, win
->GetId(), wxPoint(-1, -1));
1804 event
.SetEventObject(win
);
1805 return win
->GTKProcessEvent(event
);
1808 //-----------------------------------------------------------------------------
1810 //-----------------------------------------------------------------------------
1813 gtk_window_focus_in_callback( GtkWidget
*widget
,
1814 GdkEventFocus
*WXUNUSED(event
),
1819 // don't need to install idle handler, its done from "event" signal
1822 gtk_im_context_focus_in(win
->m_imData
->context
);
1825 g_focusWindow
= win
;
1827 wxLogTrace(TRACE_FOCUS
,
1828 _T("%s: focus in"), win
->GetName().c_str());
1832 gdk_im_begin(win
->m_ic
, win
->m_wxwindow
->window
);
1836 // caret needs to be informed about focus change
1837 wxCaret
*caret
= win
->GetCaret();
1840 caret
->OnSetFocus();
1842 #endif // wxUSE_CARET
1844 gboolean ret
= FALSE
;
1846 // does the window itself think that it has the focus?
1847 if ( !win
->m_hasFocus
)
1849 // not yet, notify it
1850 win
->m_hasFocus
= true;
1852 (void)DoSendFocusEvents(win
);
1857 // Disable default focus handling for custom windows
1858 // since the default GTK+ handler issues a repaint
1859 if (win
->m_wxwindow
)
1865 //-----------------------------------------------------------------------------
1866 // "focus_out_event"
1867 //-----------------------------------------------------------------------------
1870 gtk_window_focus_out_callback( GtkWidget
*widget
,
1871 GdkEventFocus
*gdk_event
,
1876 // don't need to install idle handler, its done from "event" signal
1879 gtk_im_context_focus_out(win
->m_imData
->context
);
1881 wxLogTrace( TRACE_FOCUS
,
1882 _T("%s: focus out"), win
->GetName().c_str() );
1885 wxWindowGTK
*winFocus
= wxFindFocusedChild(win
);
1889 g_focusWindow
= (wxWindowGTK
*)NULL
;
1897 // caret needs to be informed about focus change
1898 wxCaret
*caret
= win
->GetCaret();
1901 caret
->OnKillFocus();
1903 #endif // wxUSE_CARET
1905 gboolean ret
= FALSE
;
1907 // don't send the window a kill focus event if it thinks that it doesn't
1908 // have focus already
1909 if ( win
->m_hasFocus
)
1911 win
->m_hasFocus
= false;
1913 wxFocusEvent
event( wxEVT_KILL_FOCUS
, win
->GetId() );
1914 event
.SetEventObject( win
);
1916 (void)win
->GTKProcessEvent( event
);
1921 // Disable default focus handling for custom windows
1922 // since the default GTK+ handler issues a repaint
1923 if (win
->m_wxwindow
)
1929 //-----------------------------------------------------------------------------
1930 // "enter_notify_event"
1931 //-----------------------------------------------------------------------------
1934 gtk_window_enter_callback( GtkWidget
*widget
,
1935 GdkEventCrossing
*gdk_event
,
1938 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1940 // Event was emitted after a grab
1941 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1945 GdkModifierType state
= (GdkModifierType
)0;
1947 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1949 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1950 InitMouseEvent(win
, event
, gdk_event
);
1951 wxPoint pt
= win
->GetClientAreaOrigin();
1952 event
.m_x
= x
+ pt
.x
;
1953 event
.m_y
= y
+ pt
.y
;
1955 if ( !g_captureWindow
)
1957 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1958 if (win
->GTKProcessEvent( cevent
))
1960 win
->SetCursor( cevent
.GetCursor() );
1964 return win
->GTKProcessEvent(event
);
1967 //-----------------------------------------------------------------------------
1968 // "leave_notify_event"
1969 //-----------------------------------------------------------------------------
1972 gtk_window_leave_callback( GtkWidget
*widget
,
1973 GdkEventCrossing
*gdk_event
,
1976 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1978 // Event was emitted after an ungrab
1979 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1981 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1982 event
.SetTimestamp( gdk_event
->time
);
1983 event
.SetEventObject( win
);
1987 GdkModifierType state
= (GdkModifierType
)0;
1989 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1991 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
) != 0;
1992 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
) != 0;
1993 event
.m_altDown
= (state
& GDK_MOD1_MASK
) != 0;
1994 event
.m_metaDown
= (state
& GDK_MOD2_MASK
) != 0;
1995 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
) != 0;
1996 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
) != 0;
1997 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
) != 0;
1999 wxPoint pt
= win
->GetClientAreaOrigin();
2000 event
.m_x
= x
+ pt
.x
;
2001 event
.m_y
= y
+ pt
.y
;
2003 return win
->GTKProcessEvent(event
);
2006 //-----------------------------------------------------------------------------
2007 // "value_changed" from scrollbar
2008 //-----------------------------------------------------------------------------
2011 gtk_scrollbar_value_changed(GtkRange
* range
, wxWindow
* win
)
2013 wxEventType eventType
= win
->GetScrollEventType(range
);
2014 if (eventType
!= wxEVT_NULL
)
2016 // Convert scroll event type to scrollwin event type
2017 eventType
+= wxEVT_SCROLLWIN_TOP
- wxEVT_SCROLL_TOP
;
2019 // find the scrollbar which generated the event
2020 wxWindowGTK::ScrollDir dir
= win
->ScrollDirFromRange(range
);
2022 // generate the corresponding wx event
2023 const int orient
= win
->OrientFromScrollDir(dir
);
2024 wxScrollWinEvent
event(eventType
, win
->GetScrollPos(orient
), orient
);
2025 event
.SetEventObject(win
);
2027 win
->m_blockValueChanged
[dir
] = true;
2028 win
->GTKProcessEvent(event
);
2029 win
->m_blockValueChanged
[dir
] = false;
2033 //-----------------------------------------------------------------------------
2034 // "button_press_event" from scrollbar
2035 //-----------------------------------------------------------------------------
2038 gtk_scrollbar_button_press_event(GtkRange
*, GdkEventButton
*, wxWindow
* win
)
2042 // don't need to install idle handler, its done from "event" signal
2044 g_blockEventsOnScroll
= true;
2045 win
->m_mouseButtonDown
= true;
2050 //-----------------------------------------------------------------------------
2051 // "event_after" from scrollbar
2052 //-----------------------------------------------------------------------------
2055 gtk_scrollbar_event_after(GtkRange
* range
, GdkEvent
* event
, wxWindow
* win
)
2057 if (event
->type
== GDK_BUTTON_RELEASE
)
2059 g_signal_handlers_block_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
2061 const int orient
= win
->OrientFromScrollDir(
2062 win
->ScrollDirFromRange(range
));
2063 wxScrollWinEvent
event(wxEVT_SCROLLWIN_THUMBRELEASE
, win
->GetScrollPos(orient
), orient
);
2064 event
.SetEventObject(win
);
2065 win
->GTKProcessEvent(event
);
2069 //-----------------------------------------------------------------------------
2070 // "button_release_event" from scrollbar
2071 //-----------------------------------------------------------------------------
2074 gtk_scrollbar_button_release_event(GtkRange
* range
, GdkEventButton
*, wxWindow
* win
)
2078 g_blockEventsOnScroll
= false;
2079 win
->m_mouseButtonDown
= false;
2080 // If thumb tracking
2081 if (win
->m_isScrolling
)
2083 win
->m_isScrolling
= false;
2084 // Hook up handler to send thumb release event after this emission is finished.
2085 // To allow setting scroll position from event handler, sending event must
2086 // be deferred until after the GtkRange handler for this signal has run
2087 g_signal_handlers_unblock_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
2093 //-----------------------------------------------------------------------------
2094 // "realize" from m_widget
2095 //-----------------------------------------------------------------------------
2097 /* We cannot set colours and fonts before the widget has
2098 been realized, so we do this directly after realization. */
2101 gtk_window_realized_callback( GtkWidget
*m_widget
, wxWindow
*win
)
2106 wxapp_install_idle_handler();
2110 GtkPizza
*pizza
= GTK_PIZZA( m_widget
);
2111 gtk_im_context_set_client_window( win
->m_imData
->context
,
2112 pizza
->bin_window
);
2115 wxWindowCreateEvent
event( win
);
2116 event
.SetEventObject( win
);
2117 win
->GTKProcessEvent( event
);
2120 //-----------------------------------------------------------------------------
2122 //-----------------------------------------------------------------------------
2125 void gtk_window_size_callback( GtkWidget
*WXUNUSED(widget
),
2126 GtkAllocation
*alloc
,
2130 wxapp_install_idle_handler();
2132 int client_width
= 0;
2133 int client_height
= 0;
2134 win
->GetClientSize( &client_width
, &client_height
);
2135 if ((client_width
== win
->m_oldClientWidth
) && (client_height
== win
->m_oldClientHeight
))
2139 wxPrintf( wxT("size_allocate ") );
2140 if (win
->GetClassInfo() && win
->GetClassInfo()->GetClassName())
2141 wxPrintf( win
->GetClassInfo()->GetClassName() );
2142 wxPrintf( wxT(" %d %d %d %d\n"),
2149 GTK_PIZZA(win
->m_wxwindow
)->m_width
= win
->GetClientSize().x
;
2151 win
->m_oldClientWidth
= client_width
;
2152 win
->m_oldClientHeight
= client_height
;
2154 if (!win
->m_nativeSizeEvent
)
2156 wxSizeEvent
event( win
->GetSize(), win
->GetId() );
2157 event
.SetEventObject( win
);
2158 win
->GTKProcessEvent( event
);
2164 #define WXUNUSED_UNLESS_XIM(param) param
2166 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2169 /* Resize XIM window */
2171 void gtk_wxwindow_size_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2172 GtkAllocation
* WXUNUSED_UNLESS_XIM(alloc
),
2173 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2176 wxapp_install_idle_handler();
2182 if (gdk_ic_get_style (win
->m_ic
) & GDK_IM_PREEDIT_POSITION
)
2186 gdk_drawable_get_size (widget
->window
, &width
, &height
);
2187 win
->m_icattr
->preedit_area
.width
= width
;
2188 win
->m_icattr
->preedit_area
.height
= height
;
2189 gdk_ic_set_attr (win
->m_ic
, win
->m_icattr
, GDK_IC_PREEDIT_AREA
);
2194 //-----------------------------------------------------------------------------
2195 // "realize" from m_wxwindow
2196 //-----------------------------------------------------------------------------
2198 /* Initialize XIM support */
2201 gtk_wxwindow_realized_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2202 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2205 wxapp_install_idle_handler();
2208 if (win
->m_ic
) return;
2209 if (!widget
) return;
2210 if (!gdk_im_ready()) return;
2212 win
->m_icattr
= gdk_ic_attr_new();
2213 if (!win
->m_icattr
) return;
2217 GdkColormap
*colormap
;
2218 GdkICAttr
*attr
= win
->m_icattr
;
2219 unsigned attrmask
= GDK_IC_ALL_REQ
;
2221 GdkIMStyle supported_style
= (GdkIMStyle
)
2222 (GDK_IM_PREEDIT_NONE
|
2223 GDK_IM_PREEDIT_NOTHING
|
2224 GDK_IM_PREEDIT_POSITION
|
2225 GDK_IM_STATUS_NONE
|
2226 GDK_IM_STATUS_NOTHING
);
2228 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2229 supported_style
= (GdkIMStyle
)(supported_style
& ~GDK_IM_PREEDIT_POSITION
);
2231 attr
->style
= style
= gdk_im_decide_style (supported_style
);
2232 attr
->client_window
= widget
->window
;
2234 if ((colormap
= gtk_widget_get_colormap (widget
)) !=
2235 gtk_widget_get_default_colormap ())
2237 attrmask
|= GDK_IC_PREEDIT_COLORMAP
;
2238 attr
->preedit_colormap
= colormap
;
2241 attrmask
|= GDK_IC_PREEDIT_FOREGROUND
;
2242 attrmask
|= GDK_IC_PREEDIT_BACKGROUND
;
2243 attr
->preedit_foreground
= widget
->style
->fg
[GTK_STATE_NORMAL
];
2244 attr
->preedit_background
= widget
->style
->base
[GTK_STATE_NORMAL
];
2246 switch (style
& GDK_IM_PREEDIT_MASK
)
2248 case GDK_IM_PREEDIT_POSITION
:
2249 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2251 g_warning ("over-the-spot style requires fontset");
2255 gdk_drawable_get_size (widget
->window
, &width
, &height
);
2257 attrmask
|= GDK_IC_PREEDIT_POSITION_REQ
;
2258 attr
->spot_location
.x
= 0;
2259 attr
->spot_location
.y
= height
;
2260 attr
->preedit_area
.x
= 0;
2261 attr
->preedit_area
.y
= 0;
2262 attr
->preedit_area
.width
= width
;
2263 attr
->preedit_area
.height
= height
;
2264 attr
->preedit_fontset
= widget
->style
->font
;
2269 win
->m_ic
= gdk_ic_new (attr
, (GdkICAttributesType
)attrmask
);
2271 if (win
->m_ic
== NULL
)
2272 g_warning ("Can't create input context.");
2275 mask
= gdk_window_get_events (widget
->window
);
2276 mask
= (GdkEventMask
)(mask
| gdk_ic_get_events (win
->m_ic
));
2277 gdk_window_set_events (widget
->window
, mask
);
2279 if (GTK_WIDGET_HAS_FOCUS(widget
))
2280 gdk_im_begin (win
->m_ic
, widget
->window
);
2287 // ----------------------------------------------------------------------------
2288 // this wxWindowBase function is implemented here (in platform-specific file)
2289 // because it is static and so couldn't be made virtual
2290 // ----------------------------------------------------------------------------
2292 wxWindow
*wxWindowBase::DoFindFocus()
2294 // the cast is necessary when we compile in wxUniversal mode
2295 return (wxWindow
*)g_focusWindow
;
2298 //-----------------------------------------------------------------------------
2299 // InsertChild for wxWindowGTK.
2300 //-----------------------------------------------------------------------------
2302 /* Callback for wxWindowGTK. This very strange beast has to be used because
2303 * C++ has no virtual methods in a constructor. We have to emulate a
2304 * virtual function here as wxNotebook requires a different way to insert
2305 * a child in it. I had opted for creating a wxNotebookPage window class
2306 * which would have made this superfluous (such in the MDI window system),
2307 * but no-one was listening to me... */
2309 static void wxInsertChildInWindow( wxWindowGTK
* parent
, wxWindowGTK
* child
)
2311 /* the window might have been scrolled already, do we
2312 have to adapt the position */
2313 GtkPizza
*pizza
= GTK_PIZZA(parent
->m_wxwindow
);
2314 child
->m_x
+= gtk_pizza_get_xoffset( pizza
);
2315 child
->m_y
+= gtk_pizza_get_yoffset( pizza
);
2317 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
2318 GTK_WIDGET(child
->m_widget
),
2325 //-----------------------------------------------------------------------------
2327 //-----------------------------------------------------------------------------
2329 wxWindow
*wxGetActiveWindow()
2331 return wxWindow::FindFocus();
2335 wxMouseState
wxGetMouseState()
2341 GdkModifierType mask
;
2343 gdk_window_get_pointer(NULL
, &x
, &y
, &mask
);
2347 ms
.SetLeftDown(mask
& GDK_BUTTON1_MASK
);
2348 ms
.SetMiddleDown(mask
& GDK_BUTTON2_MASK
);
2349 ms
.SetRightDown(mask
& GDK_BUTTON3_MASK
);
2351 ms
.SetControlDown(mask
& GDK_CONTROL_MASK
);
2352 ms
.SetShiftDown(mask
& GDK_SHIFT_MASK
);
2353 ms
.SetAltDown(mask
& GDK_MOD1_MASK
);
2354 ms
.SetMetaDown(mask
& GDK_MOD2_MASK
);
2359 //-----------------------------------------------------------------------------
2361 //-----------------------------------------------------------------------------
2363 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2365 #ifdef __WXUNIVERSAL__
2366 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2368 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
2369 #endif // __WXUNIVERSAL__/__WXGTK__
2371 void wxWindowGTK::Init()
2374 m_widget
= (GtkWidget
*) NULL
;
2375 m_wxwindow
= (GtkWidget
*) NULL
;
2376 m_focusWidget
= (GtkWidget
*) NULL
;
2386 m_needParent
= true;
2387 m_isBeingDeleted
= false;
2389 m_showOnIdle
= false;
2392 m_nativeSizeEvent
= false;
2394 m_hasScrolling
= false;
2395 m_isScrolling
= false;
2396 m_mouseButtonDown
= false;
2397 m_blockScrollEvent
= false;
2399 // initialize scrolling stuff
2400 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2402 m_scrollBar
[dir
] = NULL
;
2403 m_scrollPos
[dir
] = 0;
2404 m_blockValueChanged
[dir
] = false;
2408 m_oldClientHeight
= 0;
2412 m_insertCallback
= (wxInsertChildFunction
) NULL
;
2414 m_acceptsFocus
= false;
2417 m_clipPaintRegion
= false;
2419 m_needsStyleChange
= false;
2421 m_cursor
= *wxSTANDARD_CURSOR
;
2424 m_dirtyTabOrder
= false;
2427 wxWindowGTK::wxWindowGTK()
2432 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2437 const wxString
&name
)
2441 Create( parent
, id
, pos
, size
, style
, name
);
2444 bool wxWindowGTK::Create( wxWindow
*parent
,
2449 const wxString
&name
)
2451 if (!PreCreation( parent
, pos
, size
) ||
2452 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2454 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2458 m_insertCallback
= wxInsertChildInWindow
;
2460 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
2461 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
2463 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2465 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2466 scroll_class
->scrollbar_spacing
= 0;
2468 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2470 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(scrolledWindow
->hscrollbar
);
2471 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(scrolledWindow
->vscrollbar
);
2472 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2473 gtk_range_set_inverted( m_scrollBar
[ScrollDir_Horz
], TRUE
);
2475 m_wxwindow
= gtk_pizza_new();
2477 #ifndef __WXUNIVERSAL__
2478 GtkPizza
*pizza
= GTK_PIZZA(m_wxwindow
);
2480 if (HasFlag(wxRAISED_BORDER
))
2482 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_OUT
);
2484 else if (HasFlag(wxSUNKEN_BORDER
))
2486 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_IN
);
2488 else if (HasFlag(wxSIMPLE_BORDER
))
2490 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_THIN
);
2494 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_NONE
);
2496 #endif // __WXUNIVERSAL__
2498 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2500 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
2501 m_acceptsFocus
= true;
2503 // connect various scroll-related events
2504 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2506 // these handlers block mouse events to any window during scrolling
2507 // such as motion events and prevent GTK and wxWidgets from fighting
2508 // over where the slider should be
2509 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2510 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2511 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2512 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2514 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2515 G_CALLBACK(gtk_scrollbar_event_after
), this);
2516 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2518 // these handlers get notified when scrollbar slider moves
2519 g_signal_connect(m_scrollBar
[dir
], "value_changed",
2520 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2523 gtk_widget_show( m_wxwindow
);
2526 m_parent
->DoAddChild( this );
2528 m_focusWidget
= m_wxwindow
;
2535 wxWindowGTK::~wxWindowGTK()
2539 if (g_focusWindow
== this)
2540 g_focusWindow
= NULL
;
2542 if ( g_delayedFocus
== this )
2543 g_delayedFocus
= NULL
;
2545 m_isBeingDeleted
= true;
2548 // destroy children before destroying this window itself
2551 // unhook focus handlers to prevent stray events being
2552 // propagated to this (soon to be) dead object
2553 if (m_focusWidget
!= NULL
)
2555 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2556 (gpointer
) gtk_window_focus_in_callback
,
2558 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2559 (gpointer
) gtk_window_focus_out_callback
,
2568 gdk_ic_destroy (m_ic
);
2570 gdk_ic_attr_destroy (m_icattr
);
2573 // delete before the widgets to avoid a crash on solaris
2578 gtk_widget_destroy( m_wxwindow
);
2579 m_wxwindow
= (GtkWidget
*) NULL
;
2584 gtk_widget_destroy( m_widget
);
2585 m_widget
= (GtkWidget
*) NULL
;
2589 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2591 wxCHECK_MSG( !m_needParent
|| parent
, false, wxT("Need complete parent.") );
2593 // Use either the given size, or the default if -1 is given.
2594 // See wxWindowBase for these functions.
2595 m_width
= WidthDefault(size
.x
) ;
2596 m_height
= HeightDefault(size
.y
);
2604 void wxWindowGTK::PostCreation()
2606 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2612 // these get reported to wxWidgets -> wxPaintEvent
2614 g_signal_connect (m_wxwindow
, "expose_event",
2615 G_CALLBACK (gtk_window_expose_callback
), this);
2617 if (GetLayoutDirection() == wxLayout_LeftToRight
)
2618 gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow
), HasFlag( wxFULL_REPAINT_ON_RESIZE
) );
2621 // Create input method handler
2622 m_imData
= new wxGtkIMData
;
2624 // Cannot handle drawing preedited text yet
2625 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2627 g_signal_connect (m_imData
->context
, "commit",
2628 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2630 // these are called when the "sunken" or "raised" borders are drawn
2631 g_signal_connect (m_widget
, "expose_event",
2632 G_CALLBACK (gtk_window_own_expose_callback
), this);
2637 if (!GTK_IS_WINDOW(m_widget
))
2639 if (m_focusWidget
== NULL
)
2640 m_focusWidget
= m_widget
;
2644 g_signal_connect (m_focusWidget
, "focus_in_event",
2645 G_CALLBACK (gtk_window_focus_in_callback
), this);
2646 g_signal_connect (m_focusWidget
, "focus_out_event",
2647 G_CALLBACK (gtk_window_focus_out_callback
), this);
2651 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2652 G_CALLBACK (gtk_window_focus_in_callback
), this);
2653 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2654 G_CALLBACK (gtk_window_focus_out_callback
), this);
2658 // connect to the various key and mouse handlers
2660 GtkWidget
*connect_widget
= GetConnectWidget();
2662 ConnectWidget( connect_widget
);
2664 /* We cannot set colours, fonts and cursors before the widget has
2665 been realized, so we do this directly after realization */
2666 g_signal_connect (connect_widget
, "realize",
2667 G_CALLBACK (gtk_window_realized_callback
), this);
2671 // Catch native resize events
2672 g_signal_connect (m_wxwindow
, "size_allocate",
2673 G_CALLBACK (gtk_window_size_callback
), this);
2675 // Initialize XIM support
2676 g_signal_connect (m_wxwindow
, "realize",
2677 G_CALLBACK (gtk_wxwindow_realized_callback
), this);
2679 // And resize XIM window
2680 g_signal_connect (m_wxwindow
, "size_allocate",
2681 G_CALLBACK (gtk_wxwindow_size_callback
), this);
2684 if (GTK_IS_COMBO(m_widget
))
2686 GtkCombo
*gcombo
= GTK_COMBO(m_widget
);
2688 g_signal_connect (gcombo
->entry
, "size_request",
2689 G_CALLBACK (wxgtk_combo_size_request_callback
),
2692 #ifdef GTK_IS_FILE_CHOOSER_BUTTON
2693 else if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget
))
2695 // If we connect to the "size_request" signal of a GtkFileChooserButton
2696 // then that control won't be sized properly when placed inside sizers
2697 // (this can be tested removing this elseif and running XRC or WIDGETS samples)
2698 // FIXME: what should be done here ?
2703 // This is needed if we want to add our windows into native
2704 // GTK controls, such as the toolbar. With this callback, the
2705 // toolbar gets to know the correct size (the one set by the
2706 // programmer). Sadly, it misbehaves for wxComboBox.
2707 g_signal_connect (m_widget
, "size_request",
2708 G_CALLBACK (wxgtk_window_size_request_callback
),
2712 InheritAttributes();
2716 SetLayoutDirection(wxLayout_Default
);
2718 // unless the window was created initially hidden (i.e. Hide() had been
2719 // called before Create()), we should show it at GTK+ level as well
2721 gtk_widget_show( m_widget
);
2724 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2726 g_signal_connect (widget
, "key_press_event",
2727 G_CALLBACK (gtk_window_key_press_callback
), this);
2728 g_signal_connect (widget
, "key_release_event",
2729 G_CALLBACK (gtk_window_key_release_callback
), this);
2730 g_signal_connect (widget
, "button_press_event",
2731 G_CALLBACK (gtk_window_button_press_callback
), this);
2732 g_signal_connect (widget
, "button_release_event",
2733 G_CALLBACK (gtk_window_button_release_callback
), this);
2734 g_signal_connect (widget
, "motion_notify_event",
2735 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2736 g_signal_connect (widget
, "scroll_event",
2737 G_CALLBACK (window_scroll_event
), this);
2738 g_signal_connect (widget
, "popup_menu",
2739 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2740 g_signal_connect (widget
, "enter_notify_event",
2741 G_CALLBACK (gtk_window_enter_callback
), this);
2742 g_signal_connect (widget
, "leave_notify_event",
2743 G_CALLBACK (gtk_window_leave_callback
), this);
2746 bool wxWindowGTK::Destroy()
2748 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2752 return wxWindowBase::Destroy();
2755 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2757 // inform the parent to perform the move
2758 gtk_pizza_set_size( GTK_PIZZA(m_parent
->m_wxwindow
), m_widget
, x
, y
, width
, height
);
2762 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2764 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2765 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2767 if (m_resizing
) return; /* I don't like recursions */
2770 int currentX
, currentY
;
2771 GetPosition(¤tX
, ¤tY
);
2772 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2774 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2776 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2778 // calculate the best size if we should auto size the window
2779 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2780 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2782 const wxSize sizeBest
= GetBestSize();
2783 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2785 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2786 height
= sizeBest
.y
;
2794 int minWidth
= GetMinWidth(),
2795 minHeight
= GetMinHeight(),
2796 maxWidth
= GetMaxWidth(),
2797 maxHeight
= GetMaxHeight();
2799 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
2800 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
2801 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
2802 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
2804 #if wxUSE_TOOLBAR_NATIVE
2805 if (wxDynamicCast(GetParent(), wxToolBar
))
2807 // don't take the x,y values, they're wrong because toolbar sets them
2808 GtkWidget
*widget
= GTK_WIDGET(m_widget
);
2809 gtk_widget_set_size_request (widget
, m_width
, m_height
);
2813 if (m_parent
->m_wxwindow
== NULL
) // i.e. wxNotebook
2815 // don't set the size for children of wxNotebook, just take the values.
2823 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
2824 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
2826 if (x
!= -1) m_x
= x
+ gtk_pizza_get_xoffset( pizza
);
2827 if (y
!= -1) m_y
= y
+ gtk_pizza_get_yoffset( pizza
);
2831 m_x
= x
+ gtk_pizza_get_xoffset( pizza
);
2832 m_y
= y
+ gtk_pizza_get_yoffset( pizza
);
2835 int left_border
= 0;
2836 int right_border
= 0;
2838 int bottom_border
= 0;
2840 /* the default button has a border around it */
2841 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
2843 GtkBorder
*default_border
= NULL
;
2844 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2847 left_border
+= default_border
->left
;
2848 right_border
+= default_border
->right
;
2849 top_border
+= default_border
->top
;
2850 bottom_border
+= default_border
->bottom
;
2851 g_free( default_border
);
2855 DoMoveWindow( m_x
-top_border
,
2857 m_width
+left_border
+right_border
,
2858 m_height
+top_border
+bottom_border
);
2863 /* Sometimes the client area changes size without the
2864 whole windows's size changing, but if the whole
2865 windows's size doesn't change, no wxSizeEvent will
2866 normally be sent. Here we add an extra test if
2867 the client test has been changed and this will
2869 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2873 wxPrintf( "OnSize sent from " );
2874 if (GetClassInfo() && GetClassInfo()->GetClassName())
2875 wxPrintf( GetClassInfo()->GetClassName() );
2876 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2879 if (!m_nativeSizeEvent
)
2881 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2882 event
.SetEventObject( this );
2883 GetEventHandler()->ProcessEvent( event
);
2889 bool wxWindowGTK::GtkShowFromOnIdle()
2891 if (IsShown() && m_showOnIdle
&& !GTK_WIDGET_VISIBLE (m_widget
))
2893 GtkAllocation alloc
;
2896 alloc
.width
= m_width
;
2897 alloc
.height
= m_height
;
2898 gtk_widget_size_allocate( m_widget
, &alloc
);
2899 gtk_widget_show( m_widget
);
2900 wxShowEvent
eventShow(GetId(), true);
2901 eventShow
.SetEventObject(this);
2902 GetEventHandler()->ProcessEvent(eventShow
);
2903 m_showOnIdle
= false;
2910 void wxWindowGTK::OnInternalIdle()
2912 // Check if we have to show window now
2913 if (GtkShowFromOnIdle()) return;
2915 if ( m_dirtyTabOrder
)
2917 m_dirtyTabOrder
= false;
2921 // Update style if the window was not yet realized
2922 // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
2923 if (m_needsStyleChange
)
2925 SetBackgroundStyle(GetBackgroundStyle());
2926 m_needsStyleChange
= false;
2929 wxCursor cursor
= m_cursor
;
2930 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
2934 /* I now set the cursor anew in every OnInternalIdle call
2935 as setting the cursor in a parent window also effects the
2936 windows above so that checking for the current cursor is
2941 GdkWindow
*window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2943 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2945 if (!g_globalCursor
.Ok())
2946 cursor
= *wxSTANDARD_CURSOR
;
2948 window
= m_widget
->window
;
2949 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
2950 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2953 else if ( m_widget
)
2955 GdkWindow
*window
= m_widget
->window
;
2956 if ( window
&& !GTK_WIDGET_NO_WINDOW(m_widget
) )
2957 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2961 if (wxUpdateUIEvent::CanUpdate(this))
2962 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
2965 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
2967 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2969 if (width
) (*width
) = m_width
;
2970 if (height
) (*height
) = m_height
;
2973 void wxWindowGTK::DoSetClientSize( int width
, int height
)
2975 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2984 GetScrollbarWidth(m_widget
, dw
, dh
);
2987 #ifndef __WXUNIVERSAL__
2988 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
2990 // shadow border size is 2
2994 if (HasFlag(wxSIMPLE_BORDER
))
2996 // simple border size is 1
3000 #endif // __WXUNIVERSAL__
3006 SetSize(width
, height
);
3009 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
3011 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3023 GetScrollbarWidth(m_widget
, dw
, dh
);
3026 #ifndef __WXUNIVERSAL__
3027 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
3029 // shadow border size is 2
3033 if (HasFlag(wxSIMPLE_BORDER
))
3035 // simple border size is 1
3039 #endif // __WXUNIVERSAL__
3049 if (width
) *width
= w
;
3050 if (height
) *height
= h
;
3053 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
3055 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3059 if (m_parent
&& m_parent
->m_wxwindow
)
3061 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
3062 dx
= gtk_pizza_get_xoffset( pizza
);
3063 dy
= gtk_pizza_get_yoffset( pizza
);
3066 if (m_x
== -1 && m_y
== -1)
3068 GdkWindow
*source
= (GdkWindow
*) NULL
;
3070 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3072 source
= m_widget
->window
;
3078 gdk_window_get_origin( source
, &org_x
, &org_y
);
3081 GetParent()->ScreenToClient(&org_x
, &org_y
);
3083 ((wxWindowGTK
*) this)->m_x
= org_x
;
3084 ((wxWindowGTK
*) this)->m_y
= org_y
;
3088 if (x
) (*x
) = m_x
- dx
;
3089 if (y
) (*y
) = m_y
- dy
;
3092 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
3094 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3096 if (!m_widget
->window
) return;
3098 GdkWindow
*source
= (GdkWindow
*) NULL
;
3100 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3102 source
= m_widget
->window
;
3106 gdk_window_get_origin( source
, &org_x
, &org_y
);
3110 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3112 org_x
+= m_widget
->allocation
.x
;
3113 org_y
+= m_widget
->allocation
.y
;
3120 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3121 *x
= (GetClientSize().x
- *x
) + org_x
;
3129 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
3131 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3133 if (!m_widget
->window
) return;
3135 GdkWindow
*source
= (GdkWindow
*) NULL
;
3137 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3139 source
= m_widget
->window
;
3143 gdk_window_get_origin( source
, &org_x
, &org_y
);
3147 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3149 org_x
+= m_widget
->allocation
.x
;
3150 org_y
+= m_widget
->allocation
.y
;
3156 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3157 *x
= (GetClientSize().x
- *x
) - org_x
;
3164 bool wxWindowGTK::Show( bool show
)
3166 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3168 if (!wxWindowBase::Show(show
))
3178 gtk_widget_show( m_widget
);
3179 wxShowEvent
eventShow(GetId(), show
);
3180 eventShow
.SetEventObject(this);
3181 GetEventHandler()->ProcessEvent(eventShow
);
3186 gtk_widget_hide( m_widget
);
3187 wxShowEvent
eventShow(GetId(), show
);
3188 eventShow
.SetEventObject(this);
3189 GetEventHandler()->ProcessEvent(eventShow
);
3195 static void wxWindowNotifyEnable(wxWindowGTK
* win
, bool enable
)
3197 win
->OnParentEnable(enable
);
3199 // Recurse, so that children have the opportunity to Do The Right Thing
3200 // and reset colours that have been messed up by a parent's (really ancestor's)
3202 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
3204 node
= node
->GetNext() )
3206 wxWindow
*child
= node
->GetData();
3207 if (!child
->IsKindOf(CLASSINFO(wxDialog
)) && !child
->IsKindOf(CLASSINFO(wxFrame
)))
3208 wxWindowNotifyEnable(child
, enable
);
3212 bool wxWindowGTK::Enable( bool enable
)
3214 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3216 if (!wxWindowBase::Enable(enable
))
3222 gtk_widget_set_sensitive( m_widget
, enable
);
3224 gtk_widget_set_sensitive( m_wxwindow
, enable
);
3226 wxWindowNotifyEnable(this, enable
);
3231 int wxWindowGTK::GetCharHeight() const
3233 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
3235 wxFont font
= GetFont();
3236 wxCHECK_MSG( font
.Ok(), 12, wxT("invalid font") );
3238 PangoContext
*context
= NULL
;
3240 context
= gtk_widget_get_pango_context( m_widget
);
3245 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3246 PangoLayout
*layout
= pango_layout_new(context
);
3247 pango_layout_set_font_description(layout
, desc
);
3248 pango_layout_set_text(layout
, "H", 1);
3249 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3251 PangoRectangle rect
;
3252 pango_layout_line_get_extents(line
, NULL
, &rect
);
3254 g_object_unref (layout
);
3256 return (int) PANGO_PIXELS(rect
.height
);
3259 int wxWindowGTK::GetCharWidth() const
3261 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
3263 wxFont font
= GetFont();
3264 wxCHECK_MSG( font
.Ok(), 8, wxT("invalid font") );
3266 PangoContext
*context
= NULL
;
3268 context
= gtk_widget_get_pango_context( m_widget
);
3273 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3274 PangoLayout
*layout
= pango_layout_new(context
);
3275 pango_layout_set_font_description(layout
, desc
);
3276 pango_layout_set_text(layout
, "g", 1);
3277 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3279 PangoRectangle rect
;
3280 pango_layout_line_get_extents(line
, NULL
, &rect
);
3282 g_object_unref (layout
);
3284 return (int) PANGO_PIXELS(rect
.width
);
3287 void wxWindowGTK::GetTextExtent( const wxString
& string
,
3291 int *externalLeading
,
3292 const wxFont
*theFont
) const
3294 wxFont fontToUse
= theFont
? *theFont
: GetFont();
3296 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
3305 PangoContext
*context
= NULL
;
3307 context
= gtk_widget_get_pango_context( m_widget
);
3316 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3317 PangoLayout
*layout
= pango_layout_new(context
);
3318 pango_layout_set_font_description(layout
, desc
);
3320 const wxCharBuffer data
= wxGTK_CONV( string
);
3322 pango_layout_set_text(layout
, data
, strlen(data
));
3325 PangoRectangle rect
;
3326 pango_layout_get_extents(layout
, NULL
, &rect
);
3328 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
3329 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
3332 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
3333 int baseline
= pango_layout_iter_get_baseline(iter
);
3334 pango_layout_iter_free(iter
);
3335 *descent
= *y
- PANGO_PIXELS(baseline
);
3337 if (externalLeading
) (*externalLeading
) = 0; // ??
3339 g_object_unref (layout
);
3342 bool wxWindowGTK::GTKSetDelayedFocusIfNeeded()
3344 if ( g_delayedFocus
== this )
3346 if ( GTK_WIDGET_REALIZED(m_widget
) )
3348 gtk_widget_grab_focus(m_widget
);
3349 g_delayedFocus
= NULL
;
3358 void wxWindowGTK::SetFocus()
3360 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3363 // don't do anything if we already have focus
3369 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow
))
3371 gtk_widget_grab_focus (m_wxwindow
);
3376 if (GTK_IS_CONTAINER(m_widget
))
3378 gtk_widget_child_focus( m_widget
, GTK_DIR_TAB_FORWARD
);
3381 if (GTK_WIDGET_CAN_FOCUS(m_widget
) && !GTK_WIDGET_HAS_FOCUS (m_widget
) )
3384 if (!GTK_WIDGET_REALIZED(m_widget
))
3386 // we can't set the focus to the widget now so we remember that
3387 // it should be focused and will do it later, during the idle
3388 // time, as soon as we can
3389 wxLogTrace(TRACE_FOCUS
,
3390 _T("Delaying setting focus to %s(%s)"),
3391 GetClassInfo()->GetClassName(), GetLabel().c_str());
3393 g_delayedFocus
= this;
3397 wxLogTrace(TRACE_FOCUS
,
3398 _T("Setting focus to %s(%s)"),
3399 GetClassInfo()->GetClassName(), GetLabel().c_str());
3401 gtk_widget_grab_focus (m_widget
);
3406 wxLogTrace(TRACE_FOCUS
,
3407 _T("Can't set focus to %s(%s)"),
3408 GetClassInfo()->GetClassName(), GetLabel().c_str());
3413 bool wxWindowGTK::AcceptsFocus() const
3415 return m_acceptsFocus
&& wxWindowBase::AcceptsFocus();
3418 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3420 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3422 wxWindowGTK
*oldParent
= m_parent
,
3423 *newParent
= (wxWindowGTK
*)newParentBase
;
3425 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3427 if ( !wxWindowBase::Reparent(newParent
) )
3430 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3432 /* prevent GTK from deleting the widget arbitrarily */
3433 gtk_widget_ref( m_widget
);
3437 gtk_container_remove( GTK_CONTAINER(m_widget
->parent
), m_widget
);
3440 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3444 if (GTK_WIDGET_VISIBLE (newParent
->m_widget
))
3446 m_showOnIdle
= true;
3447 gtk_widget_hide( m_widget
);
3450 /* insert GTK representation */
3451 (*(newParent
->m_insertCallback
))(newParent
, this);
3454 /* reverse: prevent GTK from deleting the widget arbitrarily */
3455 gtk_widget_unref( m_widget
);
3457 SetLayoutDirection(wxLayout_Default
);
3462 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3464 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3466 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3468 wxASSERT_MSG( (m_insertCallback
!= NULL
), wxT("invalid child insertion function") );
3473 /* insert GTK representation */
3474 (*m_insertCallback
)(this, child
);
3477 void wxWindowGTK::AddChild(wxWindowBase
*child
)
3479 wxWindowBase::AddChild(child
);
3480 m_dirtyTabOrder
= true;
3482 wxapp_install_idle_handler();
3485 void wxWindowGTK::RemoveChild(wxWindowBase
*child
)
3487 wxWindowBase::RemoveChild(child
);
3488 m_dirtyTabOrder
= true;
3490 wxapp_install_idle_handler();
3494 wxLayoutDirection
wxWindowGTK::GTKGetLayout(GtkWidget
*widget
)
3496 return gtk_widget_get_direction(GTK_WIDGET(widget
)) == GTK_TEXT_DIR_RTL
3497 ? wxLayout_RightToLeft
3498 : wxLayout_LeftToRight
;
3502 void wxWindowGTK::GTKSetLayout(GtkWidget
*widget
, wxLayoutDirection dir
)
3504 wxASSERT_MSG( dir
!= wxLayout_Default
, _T("invalid layout direction") );
3506 gtk_widget_set_direction(GTK_WIDGET(widget
),
3507 dir
== wxLayout_RightToLeft
? GTK_TEXT_DIR_RTL
3508 : GTK_TEXT_DIR_LTR
);
3511 wxLayoutDirection
wxWindowGTK::GetLayoutDirection() const
3513 return GTKGetLayout(m_widget
);
3516 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir
)
3518 if ( dir
== wxLayout_Default
)
3520 const wxWindow
*const parent
= GetParent();
3523 // inherit layout from parent.
3524 dir
= parent
->GetLayoutDirection();
3526 else // no parent, use global default layout
3528 dir
= wxTheApp
->GetLayoutDirection();
3532 if ( dir
== wxLayout_Default
)
3535 GTKSetLayout(m_widget
, dir
);
3538 GTKSetLayout(m_wxwindow
, dir
);
3542 wxWindowGTK::AdjustForLayoutDirection(wxCoord x
,
3543 wxCoord
WXUNUSED(width
),
3544 wxCoord
WXUNUSED(widthTotal
)) const
3546 // We now mirrors the coordinates of RTL windows in GtkPizza
3550 void wxWindowGTK::DoMoveInTabOrder(wxWindow
*win
, MoveKind move
)
3552 wxWindowBase::DoMoveInTabOrder(win
, move
);
3553 m_dirtyTabOrder
= true;
3555 wxapp_install_idle_handler();
3558 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3560 // none needed by default
3564 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3566 // nothing to do by default since none is needed
3569 void wxWindowGTK::RealizeTabOrder()
3573 if ( !m_children
.empty() )
3575 // we don't only construct the correct focus chain but also use
3576 // this opportunity to update the mnemonic widgets for the widgets
3579 GList
*chain
= NULL
;
3580 wxWindowGTK
* mnemonicWindow
= NULL
;
3582 for ( wxWindowList::const_iterator i
= m_children
.begin();
3583 i
!= m_children
.end();
3586 wxWindowGTK
*win
= *i
;
3588 if ( mnemonicWindow
)
3590 if ( win
->AcceptsFocusFromKeyboard() )
3592 // wxComboBox et al. needs to focus on on a different
3593 // widget than m_widget, so if the main widget isn't
3594 // focusable try the connect widget
3595 GtkWidget
* w
= win
->m_widget
;
3596 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3598 w
= win
->GetConnectWidget();
3599 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3605 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3606 mnemonicWindow
= NULL
;
3610 else if ( win
->GTKWidgetNeedsMnemonic() )
3612 mnemonicWindow
= win
;
3615 chain
= g_list_prepend(chain
, win
->m_widget
);
3618 chain
= g_list_reverse(chain
);
3620 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3625 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3630 void wxWindowGTK::Raise()
3632 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3634 if (m_wxwindow
&& m_wxwindow
->window
)
3636 gdk_window_raise( m_wxwindow
->window
);
3638 else if (m_widget
->window
)
3640 gdk_window_raise( m_widget
->window
);
3644 void wxWindowGTK::Lower()
3646 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3648 if (m_wxwindow
&& m_wxwindow
->window
)
3650 gdk_window_lower( m_wxwindow
->window
);
3652 else if (m_widget
->window
)
3654 gdk_window_lower( m_widget
->window
);
3658 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3660 if ( !wxWindowBase::SetCursor(cursor
.Ok() ? cursor
: *wxSTANDARD_CURSOR
) )
3668 void wxWindowGTK::GTKUpdateCursor()
3670 wxCursor
cursor(g_globalCursor
.Ok() ? g_globalCursor
: GetCursor());
3673 wxArrayGdkWindows windowsThis
;
3674 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
3677 gdk_window_set_cursor(winThis
, cursor
.GetCursor());
3681 const size_t count
= windowsThis
.size();
3682 for ( size_t n
= 0; n
< count
; n
++ )
3684 GdkWindow
*win
= windowsThis
[n
];
3687 wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?"));
3691 gdk_window_set_cursor(win
, cursor
.GetCursor());
3697 void wxWindowGTK::WarpPointer( int x
, int y
)
3699 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3701 // We provide this function ourselves as it is
3702 // missing in GDK (top of this file).
3704 GdkWindow
*window
= (GdkWindow
*) NULL
;
3706 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3708 window
= GetConnectWidget()->window
;
3711 gdk_window_warp_pointer( window
, x
, y
);
3714 wxWindowGTK::ScrollDir
wxWindowGTK::ScrollDirFromRange(GtkRange
*range
) const
3716 // find the scrollbar which generated the event
3717 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3719 if ( range
== m_scrollBar
[dir
] )
3720 return (ScrollDir
)dir
;
3723 wxFAIL_MSG( _T("event from unknown scrollbar received") );
3725 return ScrollDir_Max
;
3728 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3730 bool changed
= false;
3731 GtkRange
* range
= m_scrollBar
[dir
];
3732 if ( range
&& units
)
3734 GtkAdjustment
* adj
= range
->adjustment
;
3735 gdouble inc
= unit
== ScrollUnit_Line
? adj
->step_increment
3736 : adj
->page_increment
;
3738 const int posOld
= int(adj
->value
+ 0.5);
3739 gtk_range_set_value(range
, posOld
+ units
*inc
);
3741 changed
= int(adj
->value
+ 0.5) != posOld
;
3747 bool wxWindowGTK::ScrollLines(int lines
)
3749 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3752 bool wxWindowGTK::ScrollPages(int pages
)
3754 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3757 void wxWindowGTK::Refresh( bool eraseBackground
, const wxRect
*rect
)
3761 if (!m_widget
->window
)
3766 if (!GTK_PIZZA(m_wxwindow
)->bin_window
) return;
3768 GdkRectangle gdk_rect
,
3772 gdk_rect
.x
= rect
->x
;
3773 gdk_rect
.y
= rect
->y
;
3774 gdk_rect
.width
= rect
->width
;
3775 gdk_rect
.height
= rect
->height
;
3776 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3777 gdk_rect
.x
= GetClientSize().x
- gdk_rect
.x
- gdk_rect
.width
;
3781 else // invalidate everything
3786 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, p
, TRUE
);
3790 void wxWindowGTK::Update()
3794 // when we call Update() we really want to update the window immediately on
3795 // screen, even if it means flushing the entire queue and hence slowing down
3796 // everything -- but it should still be done, it's just that Update() should
3797 // be called very rarely
3801 void wxWindowGTK::GtkUpdate()
3803 if (m_wxwindow
&& GTK_PIZZA(m_wxwindow
)->bin_window
)
3804 gdk_window_process_updates( GTK_PIZZA(m_wxwindow
)->bin_window
, FALSE
);
3805 if (m_widget
&& m_widget
->window
)
3806 gdk_window_process_updates( m_widget
->window
, FALSE
);
3808 // for consistency with other platforms (and also because it's convenient
3809 // to be able to update an entire TLW by calling Update() only once), we
3810 // should also update all our children here
3811 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3813 node
= node
->GetNext() )
3815 node
->GetData()->GtkUpdate();
3819 bool wxWindowGTK::DoIsExposed( int x
, int y
) const
3821 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
3825 bool wxWindowGTK::DoIsExposed( int x
, int y
, int w
, int h
) const
3827 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3828 return m_updateRegion
.Contains(x
-w
, y
, w
, h
) != wxOutRegion
;
3830 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
3833 void wxWindowGTK::GtkSendPaintEvents()
3837 m_updateRegion
.Clear();
3841 // Clip to paint region in wxClientDC
3842 m_clipPaintRegion
= true;
3845 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3847 maybe_rtl_region
.Clear();
3850 gdk_window_get_geometry( GTK_PIZZA(m_wxwindow
)->bin_window
,
3851 NULL
, NULL
, &width
, NULL
, NULL
);
3853 wxRegionIterator
upd( m_updateRegion
);
3857 rect
.x
= upd
.GetX();
3858 rect
.y
= upd
.GetY();
3859 rect
.width
= upd
.GetWidth();
3860 rect
.height
= upd
.GetHeight();
3862 rect
.x
= width
- rect
.x
- rect
.width
;
3863 maybe_rtl_region
.Union( rect
);
3870 // widget to draw on
3871 GtkPizza
*pizza
= GTK_PIZZA (m_wxwindow
);
3873 if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM
))
3875 // find ancestor from which to steal background
3876 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3878 parent
= (wxWindow
*)this;
3880 if (GTK_WIDGET_MAPPED(parent
->m_widget
))
3882 wxRegionIterator
upd( m_updateRegion
);
3886 rect
.x
= upd
.GetX();
3887 rect
.y
= upd
.GetY();
3888 rect
.width
= upd
.GetWidth();
3889 rect
.height
= upd
.GetHeight();
3891 gtk_paint_flat_box( parent
->m_widget
->style
,
3893 (GtkStateType
)GTK_WIDGET_STATE(m_wxwindow
),
3906 wxWindowDC
dc( (wxWindow
*)this );
3907 dc
.SetClippingRegion( m_updateRegion
);
3909 wxEraseEvent
erase_event( GetId(), &dc
);
3910 erase_event
.SetEventObject( this );
3912 GetEventHandler()->ProcessEvent(erase_event
);
3915 wxNcPaintEvent
nc_paint_event( GetId() );
3916 nc_paint_event
.SetEventObject( this );
3917 GetEventHandler()->ProcessEvent( nc_paint_event
);
3919 wxPaintEvent
paint_event( GetId() );
3920 paint_event
.SetEventObject( this );
3921 GetEventHandler()->ProcessEvent( paint_event
);
3923 m_clipPaintRegion
= false;
3925 m_updateRegion
.Clear();
3928 void wxWindowGTK::SetDoubleBuffered( bool on
)
3930 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3933 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3936 void wxWindowGTK::ClearBackground()
3938 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3942 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3944 wxWindowBase::DoSetToolTip(tip
);
3947 m_tooltip
->Apply( (wxWindow
*)this );
3950 void wxWindowGTK::ApplyToolTip( GtkTooltips
*tips
, const wxChar
*tip
)
3952 wxString
tmp( tip
);
3953 gtk_tooltips_set_tip( tips
, GetConnectWidget(), wxGTK_CONV(tmp
), (gchar
*) NULL
);
3955 #endif // wxUSE_TOOLTIPS
3957 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
3959 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3961 if (!wxWindowBase::SetBackgroundColour(colour
))
3966 // We need the pixel value e.g. for background clearing.
3967 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3970 // apply style change (forceStyle=true so that new style is applied
3971 // even if the bg colour changed from valid to wxNullColour)
3972 if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM
)
3973 ApplyWidgetStyle(true);
3978 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
3980 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3982 if (!wxWindowBase::SetForegroundColour(colour
))
3989 // We need the pixel value e.g. for background clearing.
3990 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3993 // apply style change (forceStyle=true so that new style is applied
3994 // even if the bg colour changed from valid to wxNullColour):
3995 ApplyWidgetStyle(true);
4000 PangoContext
*wxWindowGTK::GtkGetPangoDefaultContext()
4002 return gtk_widget_get_pango_context( m_widget
);
4005 GtkRcStyle
*wxWindowGTK::CreateWidgetStyle(bool forceStyle
)
4007 // do we need to apply any changes at all?
4010 !m_foregroundColour
.Ok() && !m_backgroundColour
.Ok() )
4015 GtkRcStyle
*style
= gtk_rc_style_new();
4020 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
4023 if ( m_foregroundColour
.Ok() )
4025 const GdkColor
*fg
= m_foregroundColour
.GetColor();
4027 style
->fg
[GTK_STATE_NORMAL
] = *fg
;
4028 style
->color_flags
[GTK_STATE_NORMAL
] = GTK_RC_FG
;
4030 style
->fg
[GTK_STATE_PRELIGHT
] = *fg
;
4031 style
->color_flags
[GTK_STATE_PRELIGHT
] = GTK_RC_FG
;
4033 style
->fg
[GTK_STATE_ACTIVE
] = *fg
;
4034 style
->color_flags
[GTK_STATE_ACTIVE
] = GTK_RC_FG
;
4037 if ( m_backgroundColour
.Ok() )
4039 const GdkColor
*bg
= m_backgroundColour
.GetColor();
4041 style
->bg
[GTK_STATE_NORMAL
] = *bg
;
4042 style
->base
[GTK_STATE_NORMAL
] = *bg
;
4043 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)
4044 (style
->color_flags
[GTK_STATE_NORMAL
] | GTK_RC_BG
| GTK_RC_BASE
);
4046 style
->bg
[GTK_STATE_PRELIGHT
] = *bg
;
4047 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
4048 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)
4049 (style
->color_flags
[GTK_STATE_PRELIGHT
] | GTK_RC_BG
| GTK_RC_BASE
);
4051 style
->bg
[GTK_STATE_ACTIVE
] = *bg
;
4052 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
4053 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)
4054 (style
->color_flags
[GTK_STATE_ACTIVE
] | GTK_RC_BG
| GTK_RC_BASE
);
4056 style
->bg
[GTK_STATE_INSENSITIVE
] = *bg
;
4057 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
4058 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)
4059 (style
->color_flags
[GTK_STATE_INSENSITIVE
] | GTK_RC_BG
| GTK_RC_BASE
);
4065 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle
)
4067 GtkRcStyle
*style
= CreateWidgetStyle(forceStyle
);
4070 DoApplyWidgetStyle(style
);
4071 gtk_rc_style_unref(style
);
4074 // Style change may affect GTK+'s size calculation:
4075 InvalidateBestSize();
4078 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
4081 gtk_widget_modify_style(m_wxwindow
, style
);
4083 gtk_widget_modify_style(m_widget
, style
);
4086 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style
)
4088 wxWindowBase::SetBackgroundStyle(style
);
4090 if (style
== wxBG_STYLE_CUSTOM
)
4092 GdkWindow
*window
= (GdkWindow
*) NULL
;
4094 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4096 window
= GetConnectWidget()->window
;
4100 // Make sure GDK/X11 doesn't refresh the window
4102 gdk_window_set_back_pixmap( window
, None
, False
);
4104 Display
* display
= GDK_WINDOW_DISPLAY(window
);
4107 m_needsStyleChange
= false;
4110 // Do in OnIdle, because the window is not yet available
4111 m_needsStyleChange
= true;
4113 // Don't apply widget style, or we get a grey background
4117 // apply style change (forceStyle=true so that new style is applied
4118 // even if the bg colour changed from valid to wxNullColour):
4119 ApplyWidgetStyle(true);
4124 #if wxUSE_DRAG_AND_DROP
4126 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4128 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4130 GtkWidget
*dnd_widget
= GetConnectWidget();
4132 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
4134 if (m_dropTarget
) delete m_dropTarget
;
4135 m_dropTarget
= dropTarget
;
4137 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
4140 #endif // wxUSE_DRAG_AND_DROP
4142 GtkWidget
* wxWindowGTK::GetConnectWidget()
4144 GtkWidget
*connect_widget
= m_widget
;
4145 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4147 return connect_widget
;
4150 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow
*window
) const
4152 wxArrayGdkWindows windowsThis
;
4153 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
4155 return winThis
? window
== winThis
4156 : windowsThis
.Index(window
) != wxNOT_FOUND
;
4159 GdkWindow
*wxWindowGTK::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
4161 return m_wxwindow
? GTK_PIZZA(m_wxwindow
)->bin_window
: m_widget
->window
;
4164 bool wxWindowGTK::SetFont( const wxFont
&font
)
4166 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4168 if (!wxWindowBase::SetFont(font
))
4171 // apply style change (forceStyle=true so that new style is applied
4172 // even if the font changed from valid to wxNullFont):
4173 ApplyWidgetStyle(true);
4178 void wxWindowGTK::DoCaptureMouse()
4180 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4182 GdkWindow
*window
= (GdkWindow
*) NULL
;
4184 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4186 window
= GetConnectWidget()->window
;
4188 wxCHECK_RET( window
, _T("CaptureMouse() failed") );
4190 const wxCursor
* cursor
= &m_cursor
;
4192 cursor
= wxSTANDARD_CURSOR
;
4194 gdk_pointer_grab( window
, FALSE
,
4196 (GDK_BUTTON_PRESS_MASK
|
4197 GDK_BUTTON_RELEASE_MASK
|
4198 GDK_POINTER_MOTION_HINT_MASK
|
4199 GDK_POINTER_MOTION_MASK
),
4201 cursor
->GetCursor(),
4202 (guint32
)GDK_CURRENT_TIME
);
4203 g_captureWindow
= this;
4204 g_captureWindowHasMouse
= true;
4207 void wxWindowGTK::DoReleaseMouse()
4209 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4211 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4213 g_captureWindow
= (wxWindowGTK
*) NULL
;
4215 GdkWindow
*window
= (GdkWindow
*) NULL
;
4217 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4219 window
= GetConnectWidget()->window
;
4224 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4228 wxWindow
*wxWindowBase::GetCapture()
4230 return (wxWindow
*)g_captureWindow
;
4233 bool wxWindowGTK::IsRetained() const
4238 void wxWindowGTK::BlockScrollEvent()
4240 wxASSERT(!m_blockScrollEvent
);
4241 m_blockScrollEvent
= true;
4244 void wxWindowGTK::UnblockScrollEvent()
4246 wxASSERT(m_blockScrollEvent
);
4247 m_blockScrollEvent
= false;
4250 void wxWindowGTK::SetScrollbar(int orient
,
4254 bool WXUNUSED(update
))
4256 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4257 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4261 m_hasScrolling
= true;
4265 // GtkRange requires upper > lower
4270 if (pos
> range
- thumbVisible
)
4271 pos
= range
- thumbVisible
;
4274 GtkAdjustment
* adj
= m_scrollBar
[ScrollDirFromOrient(orient
)]->adjustment
;
4275 adj
->step_increment
= 1;
4276 adj
->page_increment
=
4277 adj
->page_size
= thumbVisible
;
4279 SetScrollPos(orient
, pos
);
4280 gtk_adjustment_changed(adj
);
4283 void wxWindowGTK::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4285 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4286 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4288 // This check is more than an optimization. Without it, the slider
4289 // will not move smoothly while tracking when using wxScrollHelper.
4290 if (GetScrollPos(orient
) != pos
)
4292 const int dir
= ScrollDirFromOrient(orient
);
4293 GtkAdjustment
* adj
= m_scrollBar
[dir
]->adjustment
;
4294 const int max
= int(adj
->upper
- adj
->page_size
);
4299 m_scrollPos
[dir
] = adj
->value
= pos
;
4301 // If a "value_changed" signal emission is not already in progress
4302 if (!m_blockValueChanged
[dir
])
4304 gtk_adjustment_value_changed(adj
);
4309 int wxWindowGTK::GetScrollThumb(int orient
) const
4311 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4312 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4314 return int(m_scrollBar
[ScrollDirFromOrient(orient
)]->adjustment
->page_size
);
4317 int wxWindowGTK::GetScrollPos( int orient
) const
4319 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4320 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4322 return int(m_scrollBar
[ScrollDirFromOrient(orient
)]->adjustment
->value
+ 0.5);
4325 int wxWindowGTK::GetScrollRange( int orient
) const
4327 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4328 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4330 return int(m_scrollBar
[ScrollDirFromOrient(orient
)]->adjustment
->upper
);
4333 // Determine if increment is the same as +/-x, allowing for some small
4334 // difference due to possible inexactness in floating point arithmetic
4335 static inline bool IsScrollIncrement(double increment
, double x
)
4337 wxASSERT(increment
> 0);
4338 const double tolerance
= 1.0 / 1024;
4339 return fabs(increment
- fabs(x
)) < tolerance
;
4342 wxEventType
wxWindowGTK::GetScrollEventType(GtkRange
* range
)
4347 wxapp_install_idle_handler();
4349 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4351 const int barIndex
= range
== m_scrollBar
[1];
4352 GtkAdjustment
* adj
= range
->adjustment
;
4354 const int value
= int(adj
->value
+ 0.5);
4356 // save previous position
4357 const double oldPos
= m_scrollPos
[barIndex
];
4358 // update current position
4359 m_scrollPos
[barIndex
] = adj
->value
;
4360 // If event should be ignored, or integral position has not changed
4361 if (!m_hasVMT
|| g_blockEventsOnDrag
|| value
== int(oldPos
+ 0.5))
4366 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4369 // Difference from last change event
4370 const double diff
= adj
->value
- oldPos
;
4371 const bool isDown
= diff
> 0;
4373 if (IsScrollIncrement(adj
->step_increment
, diff
))
4375 eventType
= isDown
? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4377 else if (IsScrollIncrement(adj
->page_increment
, diff
))
4379 eventType
= isDown
? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4381 else if (m_mouseButtonDown
)
4383 // Assume track event
4384 m_isScrolling
= true;
4390 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4392 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4394 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4396 // No scrolling requested.
4397 if ((dx
== 0) && (dy
== 0)) return;
4399 m_clipPaintRegion
= true;
4401 if (GetLayoutDirection() == wxLayout_RightToLeft
)
4402 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), dx
, -dy
);
4404 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), -dx
, -dy
);
4406 m_clipPaintRegion
= false;
4409 void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4411 //RN: Note that static controls usually have no border on gtk, so maybe
4412 //it makes sense to treat that as simply no border at the wx level
4414 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4416 GtkShadowType gtkstyle
;
4418 if(wxstyle
& wxBORDER_RAISED
)
4419 gtkstyle
= GTK_SHADOW_OUT
;
4420 else if (wxstyle
& wxBORDER_SUNKEN
)
4421 gtkstyle
= GTK_SHADOW_IN
;
4422 else if (wxstyle
& wxBORDER_DOUBLE
)
4423 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4425 gtkstyle
= GTK_SHADOW_IN
;
4427 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4432 void wxWindowGTK::SetWindowStyleFlag( long style
)
4434 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4435 wxWindowBase::SetWindowStyleFlag(style
);
4438 // Find the wxWindow at the current mouse position, also returning the mouse
4440 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4442 pt
= wxGetMousePosition();
4443 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4447 // Get the current mouse position.
4448 wxPoint
wxGetMousePosition()
4450 /* This crashes when used within wxHelpContext,
4451 so we have to use the X-specific implementation below.
4453 GdkModifierType *mask;
4454 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4456 return wxPoint(x, y);
4460 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4462 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4463 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4464 Window rootReturn
, childReturn
;
4465 int rootX
, rootY
, winX
, winY
;
4466 unsigned int maskReturn
;
4468 XQueryPointer (display
,
4472 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4473 return wxPoint(rootX
, rootY
);
4477 // Needed for implementing e.g. combobox on wxGTK within a modal dialog.
4478 void wxAddGrab(wxWindow
* window
)
4480 gtk_grab_add( (GtkWidget
*) window
->GetHandle() );
4483 void wxRemoveGrab(wxWindow
* window
)
4485 gtk_grab_remove( (GtkWidget
*) window
->GetHandle() );