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 extern GtkContainerClass
*pizza_parent_class
;
83 //-----------------------------------------------------------------------------
84 // documentation on internals
85 //-----------------------------------------------------------------------------
88 I have been asked several times about writing some documentation about
89 the GTK port of wxWidgets, especially its internal structures. Obviously,
90 you cannot understand wxGTK without knowing a little about the GTK, but
91 some more information about what the wxWindow, which is the base class
92 for all other window classes, does seems required as well.
96 What does wxWindow do? It contains the common interface for the following
97 jobs of its descendants:
99 1) Define the rudimentary behaviour common to all window classes, such as
100 resizing, intercepting user input (so as to make it possible to use these
101 events for special purposes in a derived class), window names etc.
103 2) Provide the possibility to contain and manage children, if the derived
104 class is allowed to contain children, which holds true for those window
105 classes which do not display a native GTK widget. To name them, these
106 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
107 work classes are a special case and are handled a bit differently from
108 the rest. The same holds true for the wxNotebook class.
110 3) Provide the possibility to draw into a client area of a window. This,
111 too, only holds true for classes that do not display a native GTK widget
114 4) Provide the entire mechanism for scrolling widgets. This actual inter-
115 face for this is usually in wxScrolledWindow, but the GTK implementation
118 5) A multitude of helper or extra methods for special purposes, such as
119 Drag'n'Drop, managing validators etc.
121 6) Display a border (sunken, raised, simple or none).
123 Normally one might expect, that one wxWidgets window would always correspond
124 to one GTK widget. Under GTK, there is no such all-round widget that has all
125 the functionality. Moreover, the GTK defines a client area as a different
126 widget from the actual widget you are handling. Last but not least some
127 special classes (e.g. wxFrame) handle different categories of widgets and
128 still have the possibility to draw something in the client area.
129 It was therefore required to write a special purpose GTK widget, that would
130 represent a client area in the sense of wxWidgets capable to do the jobs
131 2), 3) and 4). I have written this class and it resides in win_gtk.c of
134 All windows must have a widget, with which they interact with other under-
135 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
136 the wxWindow class has a member variable called m_widget which holds a
137 pointer to this widget. When the window class represents a GTK native widget,
138 this is (in most cases) the only GTK widget the class manages. E.g. the
139 wxStaticText class handles only a GtkLabel widget a pointer to which you
140 can find in m_widget (defined in wxWindow)
142 When the class has a client area for drawing into and for containing children
143 it has to handle the client area widget (of the type GtkPizza, defined in
144 win_gtk.c), but there could be any number of widgets, handled by a class
145 The common rule for all windows is only, that the widget that interacts with
146 the rest of GTK must be referenced in m_widget and all other widgets must be
147 children of this widget on the GTK level. The top-most widget, which also
148 represents the client area, must be in the m_wxwindow field and must be of
151 As I said, the window classes that display a GTK native widget only have
152 one widget, so in the case of e.g. the wxButton class m_widget holds a
153 pointer to a GtkButton widget. But windows with client areas (for drawing
154 and children) have a m_widget field that is a pointer to a GtkScrolled-
155 Window and a m_wxwindow field that is pointer to a GtkPizza and this
156 one is (in the GTK sense) a child of the GtkScrolledWindow.
158 If the m_wxwindow field is set, then all input to this widget is inter-
159 cepted and sent to the wxWidgets class. If not, all input to the widget
160 that gets pointed to by m_widget gets intercepted and sent to the class.
164 The design of scrolling in wxWidgets is markedly different from that offered
165 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
166 clicking on a scrollbar belonging to scrolled window will inevitably move
167 the window. In wxWidgets, the scrollbar will only emit an event, send this
168 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
169 which actually moves the window and its sub-windows. Note that GtkPizza
170 memorizes how much it has been scrolled but that wxWidgets forgets this
171 so that the two coordinates systems have to be kept in synch. This is done
172 in various places using the pizza->xoffset and pizza->yoffset values.
176 Singularly the most broken code in GTK is the code that is supposed to
177 inform subwindows (child windows) about new positions. Very often, duplicate
178 events are sent without changes in size or position, equally often no
179 events are sent at all (All this is due to a bug in the GtkContainer code
180 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
181 GTK's own system and it simply waits for size events for toplevel windows
182 and then iterates down the respective size events to all window. This has
183 the disadvantage that windows might get size events before the GTK widget
184 actually has the reported size. This doesn't normally pose any problem, but
185 the OpenGL drawing routines rely on correct behaviour. Therefore, I have
186 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
187 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
188 window that is used for OpenGL output really has that size (as reported by
193 If someone at some point of time feels the immense desire to have a look at,
194 change or attempt to optimise the Refresh() logic, this person will need an
195 intimate understanding of what "draw" and "expose" events are and what
196 they are used for, in particular when used in connection with GTK's
197 own windowless widgets. Beware.
201 Cursors, too, have been a constant source of pleasure. The main difficulty
202 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
203 for the parent. To prevent this from doing too much harm, I use idle time
204 to set the cursor over and over again, starting from the toplevel windows
205 and ending with the youngest generation (speaking of parent and child windows).
206 Also don't forget that cursors (like much else) are connected to GdkWindows,
207 not GtkWidgets and that the "window" field of a GtkWidget might very well
208 point to the GdkWindow of the parent widget (-> "window-less widget") and
209 that the two obviously have very different meanings.
213 //-----------------------------------------------------------------------------
215 //-----------------------------------------------------------------------------
217 extern bool g_blockEventsOnDrag
;
218 extern bool g_blockEventsOnScroll
;
219 extern wxCursor g_globalCursor
;
221 // mouse capture state: the window which has it and if the mouse is currently
223 static wxWindowGTK
*g_captureWindow
= (wxWindowGTK
*) NULL
;
224 static bool g_captureWindowHasMouse
= false;
226 wxWindowGTK
*g_focusWindow
= (wxWindowGTK
*) NULL
;
228 // the last window which had the focus - this is normally never NULL (except
229 // if we never had focus at all) as even when g_focusWindow is NULL it still
230 // keeps its previous value
231 wxWindowGTK
*g_focusWindowLast
= (wxWindowGTK
*) NULL
;
233 // If a window get the focus set but has not been realized
234 // yet, defer setting the focus to idle time.
235 wxWindowGTK
*g_delayedFocus
= (wxWindowGTK
*) NULL
;
237 extern bool g_mainThreadLocked
;
239 //-----------------------------------------------------------------------------
241 //-----------------------------------------------------------------------------
246 # define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
248 # define DEBUG_MAIN_THREAD
251 #define DEBUG_MAIN_THREAD
254 // the trace mask used for the focus debugging messages
255 #define TRACE_FOCUS _T("focus")
257 //-----------------------------------------------------------------------------
258 // missing gdk functions
259 //-----------------------------------------------------------------------------
262 gdk_window_warp_pointer (GdkWindow
*window
,
267 window
= gdk_get_default_root_window();
269 if (!GDK_WINDOW_DESTROYED(window
))
271 XWarpPointer (GDK_WINDOW_XDISPLAY(window
),
272 None
, /* not source window -> move from anywhere */
273 GDK_WINDOW_XID(window
), /* dest window */
274 0, 0, 0, 0, /* not source window -> move from anywhere */
279 //-----------------------------------------------------------------------------
280 // local code (see below)
281 //-----------------------------------------------------------------------------
283 // returns the child of win which currently has focus or NULL if not found
285 // Note: can't be static, needed by textctrl.cpp.
286 wxWindow
*wxFindFocusedChild(wxWindowGTK
*win
)
288 wxWindow
*winFocus
= wxWindowGTK::FindFocus();
290 return (wxWindow
*)NULL
;
292 if ( winFocus
== win
)
293 return (wxWindow
*)win
;
295 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
297 node
= node
->GetNext() )
299 wxWindow
*child
= wxFindFocusedChild(node
->GetData());
304 return (wxWindow
*)NULL
;
307 static void GetScrollbarWidth(GtkWidget
* widget
, int& w
, int& h
)
309 GtkScrolledWindow
* scroll_window
= GTK_SCROLLED_WINDOW(widget
);
310 GtkScrolledWindowClass
* scroll_class
= GTK_SCROLLED_WINDOW_CLASS(GTK_OBJECT_GET_CLASS(scroll_window
));
311 GtkRequisition scroll_req
;
314 if (scroll_window
->vscrollbar_visible
)
316 scroll_req
.width
= 2;
317 scroll_req
.height
= 2;
318 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
319 (scroll_window
->vscrollbar
, &scroll_req
);
320 w
= scroll_req
.width
+
321 scroll_class
->scrollbar_spacing
;
325 if (scroll_window
->hscrollbar_visible
)
327 scroll_req
.width
= 2;
328 scroll_req
.height
= 2;
329 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
330 (scroll_window
->hscrollbar
, &scroll_req
);
331 h
= scroll_req
.height
+
332 scroll_class
->scrollbar_spacing
;
336 static void draw_frame( GtkWidget
*widget
, wxWindowGTK
*win
)
338 // wxUniversal widgets draw the borders and scrollbars themselves
339 #ifndef __WXUNIVERSAL__
346 if (win
->m_hasScrolling
)
348 GetScrollbarWidth(widget
, dw
, dh
);
353 if (GTK_WIDGET_NO_WINDOW (widget
))
355 dx
+= widget
->allocation
.x
;
356 dy
+= widget
->allocation
.y
;
359 if (win
->HasFlag(wxRAISED_BORDER
))
361 gtk_paint_shadow (widget
->style
,
365 NULL
, NULL
, NULL
, // FIXME: No clipping?
367 widget
->allocation
.width
-dw
, widget
->allocation
.height
-dh
);
371 if (win
->HasFlag(wxSUNKEN_BORDER
))
373 gtk_paint_shadow (widget
->style
,
377 NULL
, NULL
, NULL
, // FIXME: No clipping?
379 widget
->allocation
.width
-dw
, widget
->allocation
.height
-dh
);
383 if (win
->HasFlag(wxSIMPLE_BORDER
))
386 gc
= gdk_gc_new( widget
->window
);
387 gdk_gc_set_foreground( gc
, &widget
->style
->black
);
388 gdk_draw_rectangle( widget
->window
, gc
, FALSE
,
390 widget
->allocation
.width
-dw
-1, widget
->allocation
.height
-dh
-1 );
394 #endif // __WXUNIVERSAL__
397 //-----------------------------------------------------------------------------
398 // "expose_event" of m_widget
399 //-----------------------------------------------------------------------------
403 gtk_window_own_expose_callback( GtkWidget
*widget
,
404 GdkEventExpose
*gdk_event
,
407 if (gdk_event
->count
> 0) return FALSE
;
409 draw_frame( widget
, win
);
411 (* GTK_WIDGET_CLASS (pizza_parent_class
)->expose_event
) (widget
, gdk_event
);
417 //-----------------------------------------------------------------------------
418 // "size_request" of m_widget
419 //-----------------------------------------------------------------------------
421 // make it extern because wxStaticText needs to disconnect this one
423 void wxgtk_window_size_request_callback(GtkWidget
*widget
,
424 GtkRequisition
*requisition
,
428 win
->GetSize( &w
, &h
);
434 requisition
->height
= h
;
435 requisition
->width
= w
;
441 void wxgtk_combo_size_request_callback(GtkWidget
*widget
,
442 GtkRequisition
*requisition
,
445 // This callback is actually hooked into the text entry
446 // of the combo box, not the GtkHBox.
449 win
->GetSize( &w
, &h
);
455 GtkCombo
*gcombo
= GTK_COMBO(win
->m_widget
);
457 GtkRequisition entry_req
;
459 entry_req
.height
= 2;
460 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo
->button
) )->size_request
)
461 (gcombo
->button
, &entry_req
);
463 requisition
->width
= w
- entry_req
.width
;
464 requisition
->height
= entry_req
.height
;
468 //-----------------------------------------------------------------------------
469 // "expose_event" of m_wxwindow
470 //-----------------------------------------------------------------------------
474 gtk_window_expose_callback( GtkWidget
*widget
,
475 GdkEventExpose
*gdk_event
,
480 // don't need to install idle handler, its done from "event" signal
482 // This callback gets called in drawing-idle time under
483 // GTK 2.0, so we don't need to defer anything to idle
486 GtkPizza
*pizza
= GTK_PIZZA( widget
);
487 if (gdk_event
->window
!= pizza
->bin_window
) return FALSE
;
492 wxPrintf( wxT("OnExpose from ") );
493 if (win
->GetClassInfo() && win
->GetClassInfo()->GetClassName())
494 wxPrintf( win
->GetClassInfo()->GetClassName() );
495 wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event
->area
.x
,
496 (int)gdk_event
->area
.y
,
497 (int)gdk_event
->area
.width
,
498 (int)gdk_event
->area
.height
);
503 win
->m_wxwindow
->style
,
507 (GdkRectangle
*) NULL
,
509 (char *)"button", // const_cast
514 win
->GetUpdateRegion() = wxRegion( gdk_event
->region
);
516 win
->GtkSendPaintEvents();
519 // Let parent window draw window-less widgets
520 (* GTK_WIDGET_CLASS (pizza_parent_class
)->expose_event
) (widget
, gdk_event
);
526 //-----------------------------------------------------------------------------
527 // "key_press_event" from any window
528 //-----------------------------------------------------------------------------
530 // These are used when transforming Ctrl-alpha to ascii values 1-26
531 inline bool wxIsLowerChar(int code
)
533 return (code
>= 'a' && code
<= 'z' );
536 inline bool wxIsUpperChar(int code
)
538 return (code
>= 'A' && code
<= 'Z' );
542 // set WXTRACE to this to see the key event codes on the console
543 #define TRACE_KEYS _T("keyevent")
545 // translates an X key symbol to WXK_XXX value
547 // if isChar is true it means that the value returned will be used for EVT_CHAR
548 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
549 // for example, while if it is false it means that the value is going to be
550 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
552 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
558 // Shift, Control and Alt don't generate the CHAR events at all
561 key_code
= isChar
? 0 : WXK_SHIFT
;
565 key_code
= isChar
? 0 : WXK_CONTROL
;
573 key_code
= isChar
? 0 : WXK_ALT
;
576 // neither do the toggle modifies
577 case GDK_Scroll_Lock
:
578 key_code
= isChar
? 0 : WXK_SCROLL
;
582 key_code
= isChar
? 0 : WXK_CAPITAL
;
586 key_code
= isChar
? 0 : WXK_NUMLOCK
;
590 // various other special keys
603 case GDK_ISO_Left_Tab
:
610 key_code
= WXK_RETURN
;
614 key_code
= WXK_CLEAR
;
618 key_code
= WXK_PAUSE
;
622 key_code
= WXK_SELECT
;
626 key_code
= WXK_PRINT
;
630 key_code
= WXK_EXECUTE
;
634 key_code
= WXK_ESCAPE
;
637 // cursor and other extended keyboard keys
639 key_code
= WXK_DELETE
;
655 key_code
= WXK_RIGHT
;
662 case GDK_Prior
: // == GDK_Page_Up
663 key_code
= WXK_PAGEUP
;
666 case GDK_Next
: // == GDK_Page_Down
667 key_code
= WXK_PAGEDOWN
;
679 key_code
= WXK_INSERT
;
694 key_code
= (isChar
? '0' : WXK_NUMPAD0
) + keysym
- GDK_KP_0
;
698 key_code
= isChar
? ' ' : WXK_NUMPAD_SPACE
;
702 key_code
= isChar
? WXK_TAB
: WXK_NUMPAD_TAB
;
706 key_code
= isChar
? WXK_RETURN
: WXK_NUMPAD_ENTER
;
710 key_code
= isChar
? WXK_F1
: WXK_NUMPAD_F1
;
714 key_code
= isChar
? WXK_F2
: WXK_NUMPAD_F2
;
718 key_code
= isChar
? WXK_F3
: WXK_NUMPAD_F3
;
722 key_code
= isChar
? WXK_F4
: WXK_NUMPAD_F4
;
726 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_HOME
;
730 key_code
= isChar
? WXK_LEFT
: WXK_NUMPAD_LEFT
;
734 key_code
= isChar
? WXK_UP
: WXK_NUMPAD_UP
;
738 key_code
= isChar
? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
742 key_code
= isChar
? WXK_DOWN
: WXK_NUMPAD_DOWN
;
745 case GDK_KP_Prior
: // == GDK_KP_Page_Up
746 key_code
= isChar
? WXK_PAGEUP
: WXK_NUMPAD_PAGEUP
;
749 case GDK_KP_Next
: // == GDK_KP_Page_Down
750 key_code
= isChar
? WXK_PAGEDOWN
: WXK_NUMPAD_PAGEDOWN
;
754 key_code
= isChar
? WXK_END
: WXK_NUMPAD_END
;
758 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_BEGIN
;
762 key_code
= isChar
? WXK_INSERT
: WXK_NUMPAD_INSERT
;
766 key_code
= isChar
? WXK_DELETE
: WXK_NUMPAD_DELETE
;
770 key_code
= isChar
? '=' : WXK_NUMPAD_EQUAL
;
773 case GDK_KP_Multiply
:
774 key_code
= isChar
? '*' : WXK_NUMPAD_MULTIPLY
;
778 key_code
= isChar
? '+' : WXK_NUMPAD_ADD
;
781 case GDK_KP_Separator
:
782 // FIXME: what is this?
783 key_code
= isChar
? '.' : WXK_NUMPAD_SEPARATOR
;
786 case GDK_KP_Subtract
:
787 key_code
= isChar
? '-' : WXK_NUMPAD_SUBTRACT
;
791 key_code
= isChar
? '.' : WXK_NUMPAD_DECIMAL
;
795 key_code
= isChar
? '/' : WXK_NUMPAD_DIVIDE
;
812 key_code
= WXK_F1
+ keysym
- GDK_F1
;
822 static inline bool wxIsAsciiKeysym(KeySym ks
)
827 static void wxFillOtherKeyEventFields(wxKeyEvent
& event
,
829 GdkEventKey
*gdk_event
)
833 GdkModifierType state
;
834 if (gdk_event
->window
)
835 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
837 event
.SetTimestamp( gdk_event
->time
);
838 event
.SetId(win
->GetId());
839 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
840 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
841 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
842 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
) != 0;
843 event
.m_scanCode
= gdk_event
->keyval
;
844 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
845 event
.m_rawFlags
= 0;
847 event
.m_uniChar
= gdk_keyval_to_unicode(gdk_event
->keyval
);
849 wxGetMousePosition( &x
, &y
);
850 win
->ScreenToClient( &x
, &y
);
853 event
.SetEventObject( win
);
858 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
860 GdkEventKey
*gdk_event
)
862 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
863 // but only event->keyval which is quite useless to us, so remember
864 // the last character from GDK_KEY_PRESS and reuse it as last resort
866 // NB: should be MT-safe as we're always called from the main thread only
871 } s_lastKeyPress
= { 0, 0 };
873 KeySym keysym
= gdk_event
->keyval
;
875 wxLogTrace(TRACE_KEYS
, _T("Key %s event: keysym = %ld"),
876 event
.GetEventType() == wxEVT_KEY_UP
? _T("release")
880 long key_code
= wxTranslateKeySymToWXKey(keysym
, false /* !isChar */);
884 // do we have the translation or is it a plain ASCII character?
885 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
887 // we should use keysym if it is ASCII as X does some translations
888 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
889 // which we don't want here (but which we do use for OnChar())
890 if ( !wxIsAsciiKeysym(keysym
) )
892 keysym
= (KeySym
)gdk_event
->string
[0];
895 // we want to always get the same key code when the same key is
896 // pressed regardless of the state of the modifiers, i.e. on a
897 // standard US keyboard pressing '5' or '%' ('5' key with
898 // Shift) should result in the same key code in OnKeyDown():
899 // '5' (although OnChar() will get either '5' or '%').
901 // to do it we first translate keysym to keycode (== scan code)
902 // and then back but always using the lower register
903 Display
*dpy
= (Display
*)wxGetDisplay();
904 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
906 wxLogTrace(TRACE_KEYS
, _T("\t-> keycode %d"), keycode
);
908 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
910 // use the normalized, i.e. lower register, keysym if we've
912 key_code
= keysymNormalized
? keysymNormalized
: keysym
;
914 // as explained above, we want to have lower register key codes
915 // normally but for the letter keys we want to have the upper ones
917 // NB: don't use XConvertCase() here, we want to do it for letters
919 key_code
= toupper(key_code
);
921 else // non ASCII key, what to do?
923 // by default, ignore it
926 // but if we have cached information from the last KEY_PRESS
927 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
930 if ( keysym
== s_lastKeyPress
.keysym
)
932 key_code
= s_lastKeyPress
.keycode
;
937 if ( gdk_event
->type
== GDK_KEY_PRESS
)
939 // remember it to be reused for KEY_UP event later
940 s_lastKeyPress
.keysym
= keysym
;
941 s_lastKeyPress
.keycode
= key_code
;
945 wxLogTrace(TRACE_KEYS
, _T("\t-> wxKeyCode %ld"), key_code
);
947 // sending unknown key events doesn't really make sense
951 // now fill all the other fields
952 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
954 event
.m_keyCode
= key_code
;
956 if ( gdk_event
->type
== GDK_KEY_PRESS
|| gdk_event
->type
== GDK_KEY_RELEASE
)
958 event
.m_uniChar
= key_code
;
968 GtkIMContext
*context
;
969 GdkEventKey
*lastKeyEvent
;
973 context
= gtk_im_multicontext_new();
978 g_object_unref (context
);
984 gtk_window_key_press_callback( GtkWidget
*widget
,
985 GdkEventKey
*gdk_event
,
990 // don't need to install idle handler, its done from "event" signal
994 if (g_blockEventsOnDrag
)
998 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1000 bool return_after_IM
= false;
1002 if( wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1004 // Emit KEY_DOWN event
1005 ret
= win
->GetEventHandler()->ProcessEvent( event
);
1009 // Return after IM processing as we cannot do
1010 // anything with it anyhow.
1011 return_after_IM
= true;
1014 // 2005.01.26 modified by Hong Jen Yee (hzysoft@sina.com.tw):
1015 // When we get a key_press event here, it could be originate
1016 // from the current widget or its child widgets. However, only the widget
1017 // with the INPUT FOCUS can generate the INITIAL key_press event. That is,
1018 // if the CURRENT widget doesn't have the FOCUS at all, this event definitely
1019 // originated from its child widgets and shouldn't be passed to IM context.
1020 // In fact, what a GTK+ IM should do is filtering keyEvents and convert them
1021 // into text input ONLY WHEN THE WIDGET HAS INPUT FOCUS. Besides, when current
1022 // widgets has both IM context and input focus, the event should be filtered
1023 // by gtk_im_context_filter_keypress().
1024 // Then, we should, according to GTK+ 2.0 API doc, return whatever it returns.
1025 if ((!ret
) && (win
->m_imData
!= NULL
) && ( wxWindow::FindFocus() == win
))
1027 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
1028 // docs, if IM filter returns true, no further processing should be done.
1029 // we should send the key_down event anyway.
1030 bool intercepted_by_IM
= gtk_im_context_filter_keypress(win
->m_imData
->context
, gdk_event
);
1031 win
->m_imData
->lastKeyEvent
= NULL
;
1032 if (intercepted_by_IM
)
1034 wxLogTrace(TRACE_KEYS
, _T("Key event intercepted by IM"));
1039 if (return_after_IM
)
1045 wxWindowGTK
*ancestor
= win
;
1048 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
1051 wxCommandEvent
command_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
1052 ret
= ancestor
->GetEventHandler()->ProcessEvent( command_event
);
1055 if (ancestor
->IsTopLevel())
1057 ancestor
= ancestor
->GetParent();
1060 #endif // wxUSE_ACCEL
1062 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1063 // will only be sent if it is not in an accelerator table.
1067 KeySym keysym
= gdk_event
->keyval
;
1068 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1069 key_code
= wxTranslateKeySymToWXKey(keysym
, true /* isChar */);
1072 if ( wxIsAsciiKeysym(keysym
) )
1075 key_code
= (unsigned char)keysym
;
1077 // gdk_event->string is actually deprecated
1078 else if ( gdk_event
->length
== 1 )
1080 key_code
= (unsigned char)gdk_event
->string
[0];
1086 wxLogTrace(TRACE_KEYS
, _T("Char event: %ld"), key_code
);
1088 event
.m_keyCode
= key_code
;
1090 // To conform to the docs we need to translate Ctrl-alpha
1091 // characters to values in the range 1-26.
1092 if ( event
.ControlDown() &&
1093 ( wxIsLowerChar(key_code
) || wxIsUpperChar(key_code
) ))
1095 if ( wxIsLowerChar(key_code
) )
1096 event
.m_keyCode
= key_code
- 'a' + 1;
1097 if ( wxIsUpperChar(key_code
) )
1098 event
.m_keyCode
= key_code
- 'A' + 1;
1100 event
.m_uniChar
= event
.m_keyCode
;
1104 // Implement OnCharHook by checking ancestor top level windows
1105 wxWindow
*parent
= win
;
1106 while (parent
&& !parent
->IsTopLevel())
1107 parent
= parent
->GetParent();
1110 event
.SetEventType( wxEVT_CHAR_HOOK
);
1111 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1116 event
.SetEventType(wxEVT_CHAR
);
1117 ret
= win
->GetEventHandler()->ProcessEvent( event
);
1122 // win is a control: tab can be propagated up
1124 ((gdk_event
->keyval
== GDK_Tab
) || (gdk_event
->keyval
== GDK_ISO_Left_Tab
)) &&
1125 // VZ: testing for wxTE_PROCESS_TAB shouldn't be done here - the control may
1126 // have this style, yet choose not to process this particular TAB in which
1127 // case TAB must still work as a navigational character
1128 // JS: enabling again to make consistent with other platforms
1129 // (with wxTE_PROCESS_TAB you have to call Navigate to get default
1130 // navigation behaviour)
1132 (! (win
->HasFlag(wxTE_PROCESS_TAB
) && win
->IsKindOf(CLASSINFO(wxTextCtrl
)) )) &&
1134 win
->GetParent() && (win
->GetParent()->HasFlag( wxTAB_TRAVERSAL
)) )
1136 wxNavigationKeyEvent new_event
;
1137 new_event
.SetEventObject( win
->GetParent() );
1138 // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
1139 new_event
.SetDirection( (gdk_event
->keyval
== GDK_Tab
) );
1140 // CTRL-TAB changes the (parent) window, i.e. switch notebook page
1141 new_event
.SetWindowChange( (gdk_event
->state
& GDK_CONTROL_MASK
) );
1142 new_event
.SetCurrentFocus( win
);
1143 ret
= win
->GetParent()->GetEventHandler()->ProcessEvent( new_event
);
1152 gtk_wxwindow_commit_cb (GtkIMContext
*context
,
1156 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1158 // take modifiers, cursor position, timestamp etc. from the last
1159 // key_press_event that was fed into Input Method:
1160 if (window
->m_imData
->lastKeyEvent
)
1162 wxFillOtherKeyEventFields(event
,
1163 window
, window
->m_imData
->lastKeyEvent
);
1166 const wxWxCharBuffer
data(wxGTK_CONV_BACK(str
));
1172 // Implement OnCharHook by checking ancestor top level windows
1173 wxWindow
*parent
= window
;
1174 while (parent
&& !parent
->IsTopLevel())
1175 parent
= parent
->GetParent();
1177 for( const wxChar
* pstr
= data
; *pstr
; pstr
++ )
1180 event
.m_uniChar
= *pstr
;
1181 // Backward compatible for ISO-8859-1
1182 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
1183 wxLogTrace(TRACE_KEYS
, _T("IM sent character '%c'"), event
.m_uniChar
);
1185 event
.m_keyCode
= *pstr
;
1186 #endif // wxUSE_UNICODE
1188 // To conform to the docs we need to translate Ctrl-alpha
1189 // characters to values in the range 1-26.
1190 if ( event
.ControlDown() &&
1191 ( wxIsLowerChar(*pstr
) || wxIsUpperChar(*pstr
) ))
1193 if ( wxIsLowerChar(*pstr
) )
1194 event
.m_keyCode
= *pstr
- 'a' + 1;
1195 if ( wxIsUpperChar(*pstr
) )
1196 event
.m_keyCode
= *pstr
- 'A' + 1;
1198 event
.m_keyCode
= *pstr
- 'a' + 1;
1200 event
.m_uniChar
= event
.m_keyCode
;
1206 event
.SetEventType( wxEVT_CHAR_HOOK
);
1207 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1212 event
.SetEventType(wxEVT_CHAR
);
1213 ret
= window
->GetEventHandler()->ProcessEvent( event
);
1220 //-----------------------------------------------------------------------------
1221 // "key_release_event" from any window
1222 //-----------------------------------------------------------------------------
1226 gtk_window_key_release_callback( GtkWidget
*widget
,
1227 GdkEventKey
*gdk_event
,
1232 // don't need to install idle handler, its done from "event" signal
1237 if (g_blockEventsOnDrag
)
1240 wxKeyEvent
event( wxEVT_KEY_UP
);
1241 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1243 // unknown key pressed, ignore (the event would be useless anyhow)
1247 return win
->GetEventHandler()->ProcessEvent(event
);
1251 // ============================================================================
1253 // ============================================================================
1255 // ----------------------------------------------------------------------------
1256 // mouse event processing helpers
1257 // ----------------------------------------------------------------------------
1259 // init wxMouseEvent with the info from GdkEventXXX struct
1260 template<typename T
> void InitMouseEvent(wxWindowGTK
*win
,
1261 wxMouseEvent
& event
,
1264 event
.SetTimestamp( gdk_event
->time
);
1265 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1266 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1267 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1268 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1269 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1270 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1271 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1272 if (event
.GetEventType() == wxEVT_MOUSEWHEEL
)
1274 event
.m_linesPerAction
= 3;
1275 event
.m_wheelDelta
= 120;
1276 if (((GdkEventButton
*)gdk_event
)->button
== 4)
1277 event
.m_wheelRotation
= 120;
1278 else if (((GdkEventButton
*)gdk_event
)->button
== 5)
1279 event
.m_wheelRotation
= -120;
1282 wxPoint pt
= win
->GetClientAreaOrigin();
1283 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1284 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1286 event
.SetEventObject( win
);
1287 event
.SetId( win
->GetId() );
1288 event
.SetTimestamp( gdk_event
->time
);
1291 static void AdjustEventButtonState(wxMouseEvent
& event
)
1293 // GDK reports the old state of the button for a button press event, but
1294 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1295 // for a LEFT_DOWN event, not FALSE, so we will invert
1296 // left/right/middleDown for the corresponding click events
1298 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1299 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1300 (event
.GetEventType() == wxEVT_LEFT_UP
))
1302 event
.m_leftDown
= !event
.m_leftDown
;
1306 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1307 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1308 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1310 event
.m_middleDown
= !event
.m_middleDown
;
1314 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1315 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1316 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1318 event
.m_rightDown
= !event
.m_rightDown
;
1323 // find the window to send the mouse event too
1325 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1330 if (win
->m_wxwindow
)
1332 GtkPizza
*pizza
= GTK_PIZZA(win
->m_wxwindow
);
1333 xx
+= pizza
->xoffset
;
1334 yy
+= pizza
->yoffset
;
1337 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
1340 wxWindowGTK
*child
= node
->GetData();
1342 node
= node
->GetNext();
1343 if (!child
->IsShown())
1346 if (child
->IsTransparentForMouse())
1348 // wxStaticBox is transparent in the box itself
1349 int xx1
= child
->m_x
;
1350 int yy1
= child
->m_y
;
1351 int xx2
= child
->m_x
+ child
->m_width
;
1352 int yy2
= child
->m_y
+ child
->m_height
;
1355 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1357 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1359 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1361 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1372 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1373 (child
->m_x
<= xx
) &&
1374 (child
->m_y
<= yy
) &&
1375 (child
->m_x
+child
->m_width
>= xx
) &&
1376 (child
->m_y
+child
->m_height
>= yy
))
1389 // ----------------------------------------------------------------------------
1390 // common event handlers helpers
1391 // ----------------------------------------------------------------------------
1393 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny
*event
) const
1397 // don't need to install idle handler, its done from "event" signal
1401 if (g_blockEventsOnDrag
)
1403 if (g_blockEventsOnScroll
)
1406 if (!GTKIsOwnWindow(event
->window
))
1412 // overloads for all GDK event types we use here: we need to have this as
1413 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1414 // derives from it in the sense that the structs have the same layout
1415 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1416 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1418 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1421 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton
)
1422 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion
)
1423 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing
)
1425 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1427 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1428 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1432 // send the wxChildFocusEvent and wxFocusEvent, common code of
1433 // gtk_window_focus_in_callback() and SetFocus()
1434 static bool DoSendFocusEvents(wxWindow
*win
)
1436 // Notify the parent keeping track of focus for the kbd navigation
1437 // purposes that we got it.
1438 wxChildFocusEvent
eventChildFocus(win
);
1439 (void)win
->GetEventHandler()->ProcessEvent(eventChildFocus
);
1441 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, win
->GetId());
1442 eventFocus
.SetEventObject(win
);
1444 return win
->GetEventHandler()->ProcessEvent(eventFocus
);
1447 // all event handlers must have C linkage as they're called from GTK+ C code
1451 //-----------------------------------------------------------------------------
1452 // "button_press_event"
1453 //-----------------------------------------------------------------------------
1456 gtk_window_button_press_callback( GtkWidget
*widget
,
1457 GdkEventButton
*gdk_event
,
1460 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1462 if (win
->m_wxwindow
&& (g_focusWindow
!= win
) && win
->AcceptsFocus())
1464 gtk_widget_grab_focus( win
->m_wxwindow
);
1467 // GDK sends surplus button down events
1468 // before a double click event. We
1469 // need to filter these out.
1470 if (gdk_event
->type
== GDK_BUTTON_PRESS
)
1472 GdkEvent
*peek_event
= gdk_event_peek();
1475 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1476 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1478 gdk_event_free( peek_event
);
1483 gdk_event_free( peek_event
);
1488 wxEventType event_type
= wxEVT_NULL
;
1490 // GdkDisplay is a GTK+ 2.2.0 thing
1491 #if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0)
1492 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1493 !gtk_check_version(2,2,0) &&
1494 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1496 // Reset GDK internal timestamp variables in order to disable GDK
1497 // triple click events. GDK will then next time believe no button has
1498 // been clicked just before, and send a normal button click event.
1499 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1500 display
->button_click_time
[1] = 0;
1501 display
->button_click_time
[0] = 0;
1505 if (gdk_event
->button
== 1)
1507 // note that GDK generates triple click events which are not supported
1508 // by wxWidgets but still have to be passed to the app as otherwise
1509 // clicks would simply go missing
1510 switch (gdk_event
->type
)
1512 // we shouldn't get triple clicks at all for GTK2 because we
1513 // suppress them artificially using the code above but we still
1514 // should map them to something for GTK1 and not just ignore them
1515 // as this would lose clicks
1516 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1517 case GDK_BUTTON_PRESS
:
1518 event_type
= wxEVT_LEFT_DOWN
;
1521 case GDK_2BUTTON_PRESS
:
1522 event_type
= wxEVT_LEFT_DCLICK
;
1526 // just to silence gcc warnings
1530 else if (gdk_event
->button
== 2)
1532 switch (gdk_event
->type
)
1534 case GDK_3BUTTON_PRESS
:
1535 case GDK_BUTTON_PRESS
:
1536 event_type
= wxEVT_MIDDLE_DOWN
;
1539 case GDK_2BUTTON_PRESS
:
1540 event_type
= wxEVT_MIDDLE_DCLICK
;
1547 else if (gdk_event
->button
== 3)
1549 switch (gdk_event
->type
)
1551 case GDK_3BUTTON_PRESS
:
1552 case GDK_BUTTON_PRESS
:
1553 event_type
= wxEVT_RIGHT_DOWN
;
1556 case GDK_2BUTTON_PRESS
:
1557 event_type
= wxEVT_RIGHT_DCLICK
;
1564 else if (gdk_event
->button
== 4 || gdk_event
->button
== 5)
1566 if (gdk_event
->type
== GDK_BUTTON_PRESS
)
1568 event_type
= wxEVT_MOUSEWHEEL
;
1572 if ( event_type
== wxEVT_NULL
)
1574 // unknown mouse button or click type
1578 wxMouseEvent
event( event_type
);
1579 InitMouseEvent( win
, event
, gdk_event
);
1581 AdjustEventButtonState(event
);
1583 // wxListBox actually gets mouse events from the item, so we need to give it
1584 // a chance to correct this
1585 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1587 // find the correct window to send the event to: it may be a different one
1588 // from the one which got it at GTK+ level because some controls don't have
1589 // their own X window and thus cannot get any events.
1590 if ( !g_captureWindow
)
1591 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1593 // reset the event object and id in case win changed.
1594 event
.SetEventObject( win
);
1595 event
.SetId( win
->GetId() );
1597 if (win
->GetEventHandler()->ProcessEvent( event
))
1602 if (event_type
== wxEVT_RIGHT_DOWN
)
1604 // generate a "context menu" event: this is similar to right mouse
1605 // click under many GUIs except that it is generated differently
1606 // (right up under MSW, ctrl-click under Mac, right down here) and
1608 // (a) it's a command event and so is propagated to the parent
1609 // (b) under some ports it can be generated from kbd too
1610 // (c) it uses screen coords (because of (a))
1611 wxContextMenuEvent
evtCtx(
1614 win
->ClientToScreen(event
.GetPosition()));
1615 evtCtx
.SetEventObject(win
);
1616 return win
->GetEventHandler()->ProcessEvent(evtCtx
);
1622 //-----------------------------------------------------------------------------
1623 // "button_release_event"
1624 //-----------------------------------------------------------------------------
1627 gtk_window_button_release_callback( GtkWidget
*widget
,
1628 GdkEventButton
*gdk_event
,
1631 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1633 wxEventType event_type
= wxEVT_NULL
;
1635 switch (gdk_event
->button
)
1638 event_type
= wxEVT_LEFT_UP
;
1642 event_type
= wxEVT_MIDDLE_UP
;
1646 event_type
= wxEVT_RIGHT_UP
;
1650 // unknown button, don't process
1654 wxMouseEvent
event( event_type
);
1655 InitMouseEvent( win
, event
, gdk_event
);
1657 AdjustEventButtonState(event
);
1659 // same wxListBox hack as above
1660 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1662 if ( !g_captureWindow
)
1663 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1665 // reset the event object and id in case win changed.
1666 event
.SetEventObject( win
);
1667 event
.SetId( win
->GetId() );
1669 return win
->GetEventHandler()->ProcessEvent(event
);
1672 //-----------------------------------------------------------------------------
1673 // "motion_notify_event"
1674 //-----------------------------------------------------------------------------
1677 gtk_window_motion_notify_callback( GtkWidget
*widget
,
1678 GdkEventMotion
*gdk_event
,
1681 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1683 if (gdk_event
->is_hint
)
1687 GdkModifierType state
;
1688 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1693 wxMouseEvent
event( wxEVT_MOTION
);
1694 InitMouseEvent(win
, event
, gdk_event
);
1696 if ( g_captureWindow
)
1698 // synthesise a mouse enter or leave event if needed
1699 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1700 // This seems to be necessary and actually been added to
1701 // GDK itself in version 2.0.X
1704 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1705 if ( hasMouse
!= g_captureWindowHasMouse
)
1707 // the mouse changed window
1708 g_captureWindowHasMouse
= hasMouse
;
1710 wxMouseEvent
eventM(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1711 : wxEVT_LEAVE_WINDOW
);
1712 InitMouseEvent(win
, eventM
, gdk_event
);
1713 eventM
.SetEventObject(win
);
1714 win
->GetEventHandler()->ProcessEvent(eventM
);
1719 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1721 // reset the event object and id in case win changed.
1722 event
.SetEventObject( win
);
1723 event
.SetId( win
->GetId() );
1726 if ( !g_captureWindow
)
1728 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1729 if (win
->GetEventHandler()->ProcessEvent( cevent
))
1731 // Rewrite cursor handling here (away from idle).
1732 win
->SetCursor( cevent
.GetCursor() );
1736 return win
->GetEventHandler()->ProcessEvent(event
);
1739 //-----------------------------------------------------------------------------
1740 // "scroll_event", (mouse wheel event)
1741 //-----------------------------------------------------------------------------
1744 window_scroll_event(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1748 // don't need to install idle handler, its done from "event" signal
1750 if (gdk_event
->direction
!= GDK_SCROLL_UP
&&
1751 gdk_event
->direction
!= GDK_SCROLL_DOWN
)
1756 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1757 // Can't use InitMouse macro because scroll events don't have button
1758 event
.SetTimestamp( gdk_event
->time
);
1759 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1760 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1761 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1762 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1763 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1764 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1765 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1766 event
.m_linesPerAction
= 3;
1767 event
.m_wheelDelta
= 120;
1768 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1769 event
.m_wheelRotation
= 120;
1771 event
.m_wheelRotation
= -120;
1773 wxPoint pt
= win
->GetClientAreaOrigin();
1774 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1775 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1777 event
.SetEventObject( win
);
1778 event
.SetId( win
->GetId() );
1779 event
.SetTimestamp( gdk_event
->time
);
1781 return win
->GetEventHandler()->ProcessEvent(event
);
1784 //-----------------------------------------------------------------------------
1786 //-----------------------------------------------------------------------------
1788 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
1790 wxContextMenuEvent
event(wxEVT_CONTEXT_MENU
, win
->GetId(), wxPoint(-1, -1));
1791 event
.SetEventObject(win
);
1792 return win
->GetEventHandler()->ProcessEvent(event
);
1795 //-----------------------------------------------------------------------------
1797 //-----------------------------------------------------------------------------
1800 gtk_window_focus_in_callback( GtkWidget
*widget
,
1801 GdkEventFocus
*WXUNUSED(event
),
1806 // don't need to install idle handler, its done from "event" signal
1809 gtk_im_context_focus_in(win
->m_imData
->context
);
1812 g_focusWindow
= win
;
1814 wxLogTrace(TRACE_FOCUS
,
1815 _T("%s: focus in"), win
->GetName().c_str());
1819 gdk_im_begin(win
->m_ic
, win
->m_wxwindow
->window
);
1823 // caret needs to be informed about focus change
1824 wxCaret
*caret
= win
->GetCaret();
1827 caret
->OnSetFocus();
1829 #endif // wxUSE_CARET
1831 gboolean ret
= FALSE
;
1833 // does the window itself think that it has the focus?
1834 if ( !win
->m_hasFocus
)
1836 // not yet, notify it
1837 win
->m_hasFocus
= true;
1839 (void)DoSendFocusEvents(win
);
1844 // Disable default focus handling for custom windows
1845 // since the default GTK+ handler issues a repaint
1846 if (win
->m_wxwindow
)
1852 //-----------------------------------------------------------------------------
1853 // "focus_out_event"
1854 //-----------------------------------------------------------------------------
1857 gtk_window_focus_out_callback( GtkWidget
*widget
,
1858 GdkEventFocus
*gdk_event
,
1863 // don't need to install idle handler, its done from "event" signal
1866 gtk_im_context_focus_out(win
->m_imData
->context
);
1868 wxLogTrace( TRACE_FOCUS
,
1869 _T("%s: focus out"), win
->GetName().c_str() );
1872 wxWindowGTK
*winFocus
= wxFindFocusedChild(win
);
1876 g_focusWindow
= (wxWindowGTK
*)NULL
;
1884 // caret needs to be informed about focus change
1885 wxCaret
*caret
= win
->GetCaret();
1888 caret
->OnKillFocus();
1890 #endif // wxUSE_CARET
1892 gboolean ret
= FALSE
;
1894 // don't send the window a kill focus event if it thinks that it doesn't
1895 // have focus already
1896 if ( win
->m_hasFocus
)
1898 win
->m_hasFocus
= false;
1900 wxFocusEvent
event( wxEVT_KILL_FOCUS
, win
->GetId() );
1901 event
.SetEventObject( win
);
1903 (void)win
->GetEventHandler()->ProcessEvent( event
);
1908 // Disable default focus handling for custom windows
1909 // since the default GTK+ handler issues a repaint
1910 if (win
->m_wxwindow
)
1916 //-----------------------------------------------------------------------------
1917 // "enter_notify_event"
1918 //-----------------------------------------------------------------------------
1921 gtk_window_enter_callback( GtkWidget
*widget
,
1922 GdkEventCrossing
*gdk_event
,
1925 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1927 // Event was emitted after a grab
1928 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1932 GdkModifierType state
= (GdkModifierType
)0;
1934 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1936 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1937 InitMouseEvent(win
, event
, gdk_event
);
1938 wxPoint pt
= win
->GetClientAreaOrigin();
1939 event
.m_x
= x
+ pt
.x
;
1940 event
.m_y
= y
+ pt
.y
;
1942 if ( !g_captureWindow
)
1944 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1945 if (win
->GetEventHandler()->ProcessEvent( cevent
))
1947 // Rewrite cursor handling here (away from idle).
1948 win
->SetCursor( cevent
.GetCursor() );
1952 return win
->GetEventHandler()->ProcessEvent(event
);
1955 //-----------------------------------------------------------------------------
1956 // "leave_notify_event"
1957 //-----------------------------------------------------------------------------
1960 gtk_window_leave_callback( GtkWidget
*widget
,
1961 GdkEventCrossing
*gdk_event
,
1964 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1966 // Event was emitted after an ungrab
1967 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1969 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1970 event
.SetTimestamp( gdk_event
->time
);
1971 event
.SetEventObject( win
);
1975 GdkModifierType state
= (GdkModifierType
)0;
1977 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1979 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
) != 0;
1980 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
) != 0;
1981 event
.m_altDown
= (state
& GDK_MOD1_MASK
) != 0;
1982 event
.m_metaDown
= (state
& GDK_MOD2_MASK
) != 0;
1983 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
) != 0;
1984 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
) != 0;
1985 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
) != 0;
1987 wxPoint pt
= win
->GetClientAreaOrigin();
1988 event
.m_x
= x
+ pt
.x
;
1989 event
.m_y
= y
+ pt
.y
;
1991 return win
->GetEventHandler()->ProcessEvent(event
);
1994 //-----------------------------------------------------------------------------
1995 // "value_changed" from scrollbar
1996 //-----------------------------------------------------------------------------
1999 gtk_scrollbar_value_changed(GtkRange
* range
, wxWindow
* win
)
2001 wxEventType eventType
= win
->GetScrollEventType(range
);
2002 if (eventType
!= wxEVT_NULL
)
2004 // Convert scroll event type to scrollwin event type
2005 eventType
+= wxEVT_SCROLLWIN_TOP
- wxEVT_SCROLL_TOP
;
2007 // find the scrollbar which generated the event
2008 wxWindowGTK::ScrollDir dir
= win
->ScrollDirFromRange(range
);
2010 // generate the corresponding wx event
2011 const int orient
= win
->OrientFromScrollDir(dir
);
2012 wxScrollWinEvent
event(eventType
, win
->GetScrollPos(orient
), orient
);
2013 event
.SetEventObject(win
);
2015 win
->m_blockValueChanged
[dir
] = true;
2016 win
->GetEventHandler()->ProcessEvent(event
);
2017 win
->m_blockValueChanged
[dir
] = false;
2021 //-----------------------------------------------------------------------------
2022 // "button_press_event" from scrollbar
2023 //-----------------------------------------------------------------------------
2026 gtk_scrollbar_button_press_event(GtkRange
*, GdkEventButton
*, wxWindow
* win
)
2030 // don't need to install idle handler, its done from "event" signal
2032 g_blockEventsOnScroll
= true;
2033 win
->m_mouseButtonDown
= true;
2038 //-----------------------------------------------------------------------------
2039 // "event_after" from scrollbar
2040 //-----------------------------------------------------------------------------
2043 gtk_scrollbar_event_after(GtkRange
* range
, GdkEvent
* event
, wxWindow
* win
)
2045 if (event
->type
== GDK_BUTTON_RELEASE
)
2047 g_signal_handlers_block_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
2049 const int orient
= win
->OrientFromScrollDir(
2050 win
->ScrollDirFromRange(range
));
2051 wxScrollWinEvent
event(wxEVT_SCROLLWIN_THUMBRELEASE
, win
->GetScrollPos(orient
), orient
);
2052 event
.SetEventObject(win
);
2053 win
->GetEventHandler()->ProcessEvent(event
);
2057 //-----------------------------------------------------------------------------
2058 // "button_release_event" from scrollbar
2059 //-----------------------------------------------------------------------------
2062 gtk_scrollbar_button_release_event(GtkRange
* range
, GdkEventButton
*, wxWindow
* win
)
2066 g_blockEventsOnScroll
= false;
2067 win
->m_mouseButtonDown
= false;
2068 // If thumb tracking
2069 if (win
->m_isScrolling
)
2071 win
->m_isScrolling
= false;
2072 // Hook up handler to send thumb release event after this emission is finished.
2073 // To allow setting scroll position from event handler, sending event must
2074 // be deferred until after the GtkRange handler for this signal has run
2075 g_signal_handlers_unblock_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
2081 //-----------------------------------------------------------------------------
2082 // "realize" from m_widget
2083 //-----------------------------------------------------------------------------
2085 /* We cannot set colours and fonts before the widget has
2086 been realized, so we do this directly after realization. */
2089 gtk_window_realized_callback( GtkWidget
*m_widget
, wxWindow
*win
)
2094 wxapp_install_idle_handler();
2098 GtkPizza
*pizza
= GTK_PIZZA( m_widget
);
2099 gtk_im_context_set_client_window( win
->m_imData
->context
,
2100 pizza
->bin_window
);
2103 wxWindowCreateEvent
event( win
);
2104 event
.SetEventObject( win
);
2105 win
->GetEventHandler()->ProcessEvent( event
);
2108 //-----------------------------------------------------------------------------
2110 //-----------------------------------------------------------------------------
2113 void gtk_window_size_callback( GtkWidget
*WXUNUSED(widget
),
2114 GtkAllocation
*WXUNUSED(alloc
),
2118 wxapp_install_idle_handler();
2120 int client_width
= 0;
2121 int client_height
= 0;
2122 win
->GetClientSize( &client_width
, &client_height
);
2123 if ((client_width
== win
->m_oldClientWidth
) && (client_height
== win
->m_oldClientHeight
))
2126 win
->m_oldClientWidth
= client_width
;
2127 win
->m_oldClientHeight
= client_height
;
2129 if (!win
->m_nativeSizeEvent
)
2131 wxSizeEvent
event( win
->GetSize(), win
->GetId() );
2132 event
.SetEventObject( win
);
2133 win
->GetEventHandler()->ProcessEvent( event
);
2139 #define WXUNUSED_UNLESS_XIM(param) param
2141 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2144 /* Resize XIM window */
2146 void gtk_wxwindow_size_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2147 GtkAllocation
* WXUNUSED_UNLESS_XIM(alloc
),
2148 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2151 wxapp_install_idle_handler();
2157 if (gdk_ic_get_style (win
->m_ic
) & GDK_IM_PREEDIT_POSITION
)
2161 gdk_drawable_get_size (widget
->window
, &width
, &height
);
2162 win
->m_icattr
->preedit_area
.width
= width
;
2163 win
->m_icattr
->preedit_area
.height
= height
;
2164 gdk_ic_set_attr (win
->m_ic
, win
->m_icattr
, GDK_IC_PREEDIT_AREA
);
2169 //-----------------------------------------------------------------------------
2170 // "realize" from m_wxwindow
2171 //-----------------------------------------------------------------------------
2173 /* Initialize XIM support */
2176 gtk_wxwindow_realized_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2177 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2180 wxapp_install_idle_handler();
2183 if (win
->m_ic
) return;
2184 if (!widget
) return;
2185 if (!gdk_im_ready()) return;
2187 win
->m_icattr
= gdk_ic_attr_new();
2188 if (!win
->m_icattr
) return;
2192 GdkColormap
*colormap
;
2193 GdkICAttr
*attr
= win
->m_icattr
;
2194 unsigned attrmask
= GDK_IC_ALL_REQ
;
2196 GdkIMStyle supported_style
= (GdkIMStyle
)
2197 (GDK_IM_PREEDIT_NONE
|
2198 GDK_IM_PREEDIT_NOTHING
|
2199 GDK_IM_PREEDIT_POSITION
|
2200 GDK_IM_STATUS_NONE
|
2201 GDK_IM_STATUS_NOTHING
);
2203 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2204 supported_style
= (GdkIMStyle
)(supported_style
& ~GDK_IM_PREEDIT_POSITION
);
2206 attr
->style
= style
= gdk_im_decide_style (supported_style
);
2207 attr
->client_window
= widget
->window
;
2209 if ((colormap
= gtk_widget_get_colormap (widget
)) !=
2210 gtk_widget_get_default_colormap ())
2212 attrmask
|= GDK_IC_PREEDIT_COLORMAP
;
2213 attr
->preedit_colormap
= colormap
;
2216 attrmask
|= GDK_IC_PREEDIT_FOREGROUND
;
2217 attrmask
|= GDK_IC_PREEDIT_BACKGROUND
;
2218 attr
->preedit_foreground
= widget
->style
->fg
[GTK_STATE_NORMAL
];
2219 attr
->preedit_background
= widget
->style
->base
[GTK_STATE_NORMAL
];
2221 switch (style
& GDK_IM_PREEDIT_MASK
)
2223 case GDK_IM_PREEDIT_POSITION
:
2224 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2226 g_warning ("over-the-spot style requires fontset");
2230 gdk_drawable_get_size (widget
->window
, &width
, &height
);
2232 attrmask
|= GDK_IC_PREEDIT_POSITION_REQ
;
2233 attr
->spot_location
.x
= 0;
2234 attr
->spot_location
.y
= height
;
2235 attr
->preedit_area
.x
= 0;
2236 attr
->preedit_area
.y
= 0;
2237 attr
->preedit_area
.width
= width
;
2238 attr
->preedit_area
.height
= height
;
2239 attr
->preedit_fontset
= widget
->style
->font
;
2244 win
->m_ic
= gdk_ic_new (attr
, (GdkICAttributesType
)attrmask
);
2246 if (win
->m_ic
== NULL
)
2247 g_warning ("Can't create input context.");
2250 mask
= gdk_window_get_events (widget
->window
);
2251 mask
= (GdkEventMask
)(mask
| gdk_ic_get_events (win
->m_ic
));
2252 gdk_window_set_events (widget
->window
, mask
);
2254 if (GTK_WIDGET_HAS_FOCUS(widget
))
2255 gdk_im_begin (win
->m_ic
, widget
->window
);
2262 // ----------------------------------------------------------------------------
2263 // this wxWindowBase function is implemented here (in platform-specific file)
2264 // because it is static and so couldn't be made virtual
2265 // ----------------------------------------------------------------------------
2267 wxWindow
*wxWindowBase::DoFindFocus()
2269 // the cast is necessary when we compile in wxUniversal mode
2270 return (wxWindow
*)g_focusWindow
;
2273 //-----------------------------------------------------------------------------
2274 // InsertChild for wxWindowGTK.
2275 //-----------------------------------------------------------------------------
2277 /* Callback for wxWindowGTK. This very strange beast has to be used because
2278 * C++ has no virtual methods in a constructor. We have to emulate a
2279 * virtual function here as wxNotebook requires a different way to insert
2280 * a child in it. I had opted for creating a wxNotebookPage window class
2281 * which would have made this superfluous (such in the MDI window system),
2282 * but no-one was listening to me... */
2284 static void wxInsertChildInWindow( wxWindowGTK
* parent
, wxWindowGTK
* child
)
2286 /* the window might have been scrolled already, do we
2287 have to adapt the position */
2288 GtkPizza
*pizza
= GTK_PIZZA(parent
->m_wxwindow
);
2289 child
->m_x
+= pizza
->xoffset
;
2290 child
->m_y
+= pizza
->yoffset
;
2292 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
2293 GTK_WIDGET(child
->m_widget
),
2300 //-----------------------------------------------------------------------------
2302 //-----------------------------------------------------------------------------
2304 wxWindow
*wxGetActiveWindow()
2306 return wxWindow::FindFocus();
2310 wxMouseState
wxGetMouseState()
2316 GdkModifierType mask
;
2318 gdk_window_get_pointer(NULL
, &x
, &y
, &mask
);
2322 ms
.SetLeftDown(mask
& GDK_BUTTON1_MASK
);
2323 ms
.SetMiddleDown(mask
& GDK_BUTTON2_MASK
);
2324 ms
.SetRightDown(mask
& GDK_BUTTON3_MASK
);
2326 ms
.SetControlDown(mask
& GDK_CONTROL_MASK
);
2327 ms
.SetShiftDown(mask
& GDK_SHIFT_MASK
);
2328 ms
.SetAltDown(mask
& GDK_MOD1_MASK
);
2329 ms
.SetMetaDown(mask
& GDK_MOD2_MASK
);
2334 //-----------------------------------------------------------------------------
2336 //-----------------------------------------------------------------------------
2338 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2340 #ifdef __WXUNIVERSAL__
2341 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2343 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
2344 #endif // __WXUNIVERSAL__/__WXGTK__
2346 void wxWindowGTK::Init()
2349 m_widget
= (GtkWidget
*) NULL
;
2350 m_wxwindow
= (GtkWidget
*) NULL
;
2351 m_focusWidget
= (GtkWidget
*) NULL
;
2361 m_needParent
= true;
2362 m_isBeingDeleted
= false;
2364 m_showOnIdle
= false;
2367 m_nativeSizeEvent
= false;
2369 m_hasScrolling
= false;
2370 m_isScrolling
= false;
2371 m_mouseButtonDown
= false;
2372 m_blockScrollEvent
= false;
2374 // initialize scrolling stuff
2375 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2377 m_scrollBar
[dir
] = NULL
;
2378 m_scrollPos
[dir
] = 0;
2379 m_blockValueChanged
[dir
] = false;
2383 m_oldClientHeight
= 0;
2387 m_insertCallback
= (wxInsertChildFunction
) NULL
;
2389 m_acceptsFocus
= false;
2392 m_clipPaintRegion
= false;
2394 m_needsStyleChange
= false;
2396 m_cursor
= *wxSTANDARD_CURSOR
;
2399 m_dirtyTabOrder
= false;
2402 wxWindowGTK::wxWindowGTK()
2407 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2412 const wxString
&name
)
2416 Create( parent
, id
, pos
, size
, style
, name
);
2419 bool wxWindowGTK::Create( wxWindow
*parent
,
2424 const wxString
&name
)
2426 if (!PreCreation( parent
, pos
, size
) ||
2427 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2429 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2433 m_insertCallback
= wxInsertChildInWindow
;
2435 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
2436 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
2438 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2440 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2441 scroll_class
->scrollbar_spacing
= 0;
2443 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2445 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(scrolledWindow
->hscrollbar
);
2446 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(scrolledWindow
->vscrollbar
);
2448 m_wxwindow
= gtk_pizza_new();
2450 #ifndef __WXUNIVERSAL__
2451 GtkPizza
*pizza
= GTK_PIZZA(m_wxwindow
);
2453 if (HasFlag(wxRAISED_BORDER
))
2455 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_OUT
);
2457 else if (HasFlag(wxSUNKEN_BORDER
))
2459 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_IN
);
2461 else if (HasFlag(wxSIMPLE_BORDER
))
2463 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_THIN
);
2467 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_NONE
);
2469 #endif // __WXUNIVERSAL__
2471 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2473 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
2474 m_acceptsFocus
= true;
2476 // connect various scroll-related events
2477 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2479 // these handlers block mouse events to any window during scrolling
2480 // such as motion events and prevent GTK and wxWidgets from fighting
2481 // over where the slider should be
2482 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2483 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2484 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2485 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2487 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2488 G_CALLBACK(gtk_scrollbar_event_after
), this);
2489 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2491 // these handlers get notified when scrollbar slider moves
2492 g_signal_connect(m_scrollBar
[dir
], "value_changed",
2493 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2496 gtk_widget_show( m_wxwindow
);
2499 m_parent
->DoAddChild( this );
2501 m_focusWidget
= m_wxwindow
;
2508 wxWindowGTK::~wxWindowGTK()
2512 if (g_focusWindow
== this)
2513 g_focusWindow
= NULL
;
2515 if ( g_delayedFocus
== this )
2516 g_delayedFocus
= NULL
;
2518 m_isBeingDeleted
= true;
2521 // destroy children before destroying this window itself
2524 // unhook focus handlers to prevent stray events being
2525 // propagated to this (soon to be) dead object
2526 if (m_focusWidget
!= NULL
)
2528 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2529 (gpointer
) gtk_window_focus_in_callback
,
2531 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2532 (gpointer
) gtk_window_focus_out_callback
,
2541 gdk_ic_destroy (m_ic
);
2543 gdk_ic_attr_destroy (m_icattr
);
2546 // delete before the widgets to avoid a crash on solaris
2551 gtk_widget_destroy( m_wxwindow
);
2552 m_wxwindow
= (GtkWidget
*) NULL
;
2557 gtk_widget_destroy( m_widget
);
2558 m_widget
= (GtkWidget
*) NULL
;
2562 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2564 wxCHECK_MSG( !m_needParent
|| parent
, false, wxT("Need complete parent.") );
2566 // Use either the given size, or the default if -1 is given.
2567 // See wxWindowBase for these functions.
2568 m_width
= WidthDefault(size
.x
) ;
2569 m_height
= HeightDefault(size
.y
);
2577 void wxWindowGTK::PostCreation()
2579 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2585 // these get reported to wxWidgets -> wxPaintEvent
2587 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow
), TRUE
);
2589 g_signal_connect (m_wxwindow
, "expose_event",
2590 G_CALLBACK (gtk_window_expose_callback
), this);
2592 gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow
), HasFlag( wxFULL_REPAINT_ON_RESIZE
) );
2595 // Create input method handler
2596 m_imData
= new wxGtkIMData
;
2598 // Cannot handle drawing preedited text yet
2599 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2601 g_signal_connect (m_imData
->context
, "commit",
2602 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2604 // these are called when the "sunken" or "raised" borders are drawn
2605 g_signal_connect (m_widget
, "expose_event",
2606 G_CALLBACK (gtk_window_own_expose_callback
), this);
2611 if (!GTK_IS_WINDOW(m_widget
))
2613 if (m_focusWidget
== NULL
)
2614 m_focusWidget
= m_widget
;
2618 g_signal_connect (m_focusWidget
, "focus_in_event",
2619 G_CALLBACK (gtk_window_focus_in_callback
), this);
2620 g_signal_connect (m_focusWidget
, "focus_out_event",
2621 G_CALLBACK (gtk_window_focus_out_callback
), this);
2625 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2626 G_CALLBACK (gtk_window_focus_in_callback
), this);
2627 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2628 G_CALLBACK (gtk_window_focus_out_callback
), this);
2632 // connect to the various key and mouse handlers
2634 GtkWidget
*connect_widget
= GetConnectWidget();
2636 ConnectWidget( connect_widget
);
2638 /* We cannot set colours, fonts and cursors before the widget has
2639 been realized, so we do this directly after realization */
2640 g_signal_connect (connect_widget
, "realize",
2641 G_CALLBACK (gtk_window_realized_callback
), this);
2645 // Catch native resize events
2646 g_signal_connect (m_wxwindow
, "size_allocate",
2647 G_CALLBACK (gtk_window_size_callback
), this);
2649 // Initialize XIM support
2650 g_signal_connect (m_wxwindow
, "realize",
2651 G_CALLBACK (gtk_wxwindow_realized_callback
), this);
2653 // And resize XIM window
2654 g_signal_connect (m_wxwindow
, "size_allocate",
2655 G_CALLBACK (gtk_wxwindow_size_callback
), this);
2658 if (GTK_IS_COMBO(m_widget
))
2660 GtkCombo
*gcombo
= GTK_COMBO(m_widget
);
2662 g_signal_connect (gcombo
->entry
, "size_request",
2663 G_CALLBACK (wxgtk_combo_size_request_callback
),
2666 #ifdef GTK_IS_FILE_CHOOSER_BUTTON
2667 else if (GTK_IS_FILE_CHOOSER_BUTTON(m_widget
))
2669 // If we connect to the "size_request" signal of a GtkFileChooserButton
2670 // then that control won't be sized properly when placed inside sizers
2671 // (this can be tested removing this elseif and running XRC or WIDGETS samples)
2672 // FIXME: what should be done here ?
2677 // This is needed if we want to add our windows into native
2678 // GTK controls, such as the toolbar. With this callback, the
2679 // toolbar gets to know the correct size (the one set by the
2680 // programmer). Sadly, it misbehaves for wxComboBox.
2681 g_signal_connect (m_widget
, "size_request",
2682 G_CALLBACK (wxgtk_window_size_request_callback
),
2686 InheritAttributes();
2690 // unless the window was created initially hidden (i.e. Hide() had been
2691 // called before Create()), we should show it at GTK+ level as well
2693 gtk_widget_show( m_widget
);
2696 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2698 g_signal_connect (widget
, "key_press_event",
2699 G_CALLBACK (gtk_window_key_press_callback
), this);
2700 g_signal_connect (widget
, "key_release_event",
2701 G_CALLBACK (gtk_window_key_release_callback
), this);
2702 g_signal_connect (widget
, "button_press_event",
2703 G_CALLBACK (gtk_window_button_press_callback
), this);
2704 g_signal_connect (widget
, "button_release_event",
2705 G_CALLBACK (gtk_window_button_release_callback
), this);
2706 g_signal_connect (widget
, "motion_notify_event",
2707 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2708 g_signal_connect (widget
, "scroll_event",
2709 G_CALLBACK (window_scroll_event
), this);
2710 g_signal_connect (widget
, "popup_menu",
2711 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2712 g_signal_connect (widget
, "enter_notify_event",
2713 G_CALLBACK (gtk_window_enter_callback
), this);
2714 g_signal_connect (widget
, "leave_notify_event",
2715 G_CALLBACK (gtk_window_leave_callback
), this);
2718 bool wxWindowGTK::Destroy()
2720 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2724 return wxWindowBase::Destroy();
2727 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2729 gtk_pizza_set_size( GTK_PIZZA(m_parent
->m_wxwindow
), m_widget
, x
, y
, width
, height
);
2732 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2734 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2735 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2738 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
2741 if (m_resizing
) return; /* I don't like recursions */
2744 int currentX
, currentY
;
2745 GetPosition(¤tX
, ¤tY
);
2746 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2748 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2750 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2752 // calculate the best size if we should auto size the window
2753 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2754 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2756 const wxSize sizeBest
= GetBestSize();
2757 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2759 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2760 height
= sizeBest
.y
;
2768 int minWidth
= GetMinWidth(),
2769 minHeight
= GetMinHeight(),
2770 maxWidth
= GetMaxWidth(),
2771 maxHeight
= GetMaxHeight();
2773 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
2774 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
2775 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
2776 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
2778 #if wxUSE_TOOLBAR_NATIVE
2779 if (wxDynamicCast(GetParent(), wxToolBar
))
2781 // don't take the x,y values, they're wrong because toolbar sets them
2782 GtkWidget
*widget
= GTK_WIDGET(m_widget
);
2783 gtk_widget_set_size_request (widget
, m_width
, m_height
);
2784 if (GTK_WIDGET_VISIBLE (widget
))
2785 gtk_widget_queue_resize (widget
);
2789 if (m_parent
->m_wxwindow
== NULL
) // i.e. wxNotebook
2791 // don't set the size for children of wxNotebook, just take the values.
2799 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
2800 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
2802 if (x
!= -1) m_x
= x
+ pizza
->xoffset
;
2803 if (y
!= -1) m_y
= y
+ pizza
->yoffset
;
2807 m_x
= x
+ pizza
->xoffset
;
2808 m_y
= y
+ pizza
->yoffset
;
2811 int left_border
= 0;
2812 int right_border
= 0;
2814 int bottom_border
= 0;
2816 /* the default button has a border around it */
2817 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
2819 GtkBorder
*default_border
= NULL
;
2820 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2823 left_border
+= default_border
->left
;
2824 right_border
+= default_border
->right
;
2825 top_border
+= default_border
->top
;
2826 bottom_border
+= default_border
->bottom
;
2827 g_free( default_border
);
2831 DoMoveWindow( m_x
-top_border
,
2833 m_width
+left_border
+right_border
,
2834 m_height
+top_border
+bottom_border
);
2839 /* Sometimes the client area changes size without the
2840 whole windows's size changing, but if the whole
2841 windows's size doesn't change, no wxSizeEvent will
2842 normally be sent. Here we add an extra test if
2843 the client test has been changed and this will
2845 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2849 wxPrintf( "OnSize sent from " );
2850 if (GetClassInfo() && GetClassInfo()->GetClassName())
2851 wxPrintf( GetClassInfo()->GetClassName() );
2852 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2855 if (!m_nativeSizeEvent
)
2857 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2858 event
.SetEventObject( this );
2859 GetEventHandler()->ProcessEvent( event
);
2865 bool wxWindowGTK::GtkShowFromOnIdle()
2867 if (IsShown() && m_showOnIdle
&& !GTK_WIDGET_VISIBLE (m_widget
))
2869 GtkAllocation alloc
;
2872 alloc
.width
= m_width
;
2873 alloc
.height
= m_height
;
2874 gtk_widget_size_allocate( m_widget
, &alloc
);
2875 gtk_widget_show( m_widget
);
2876 wxShowEvent
eventShow(GetId(), true);
2877 eventShow
.SetEventObject(this);
2878 GetEventHandler()->ProcessEvent(eventShow
);
2879 m_showOnIdle
= false;
2886 void wxWindowGTK::OnInternalIdle()
2888 // Check if we have to show window now
2889 if (GtkShowFromOnIdle()) return;
2891 if ( m_dirtyTabOrder
)
2893 m_dirtyTabOrder
= false;
2897 // Update style if the window was not yet realized
2898 // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
2899 if (m_needsStyleChange
)
2901 SetBackgroundStyle(GetBackgroundStyle());
2902 m_needsStyleChange
= false;
2905 wxCursor cursor
= m_cursor
;
2906 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
2910 /* I now set the cursor anew in every OnInternalIdle call
2911 as setting the cursor in a parent window also effects the
2912 windows above so that checking for the current cursor is
2917 GdkWindow
*window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2919 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2921 if (!g_globalCursor
.Ok())
2922 cursor
= *wxSTANDARD_CURSOR
;
2924 window
= m_widget
->window
;
2925 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
2926 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2929 else if ( m_widget
)
2931 GdkWindow
*window
= m_widget
->window
;
2932 if ( window
&& !GTK_WIDGET_NO_WINDOW(m_widget
) )
2933 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2937 if (wxUpdateUIEvent::CanUpdate(this))
2938 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
2941 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
2943 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2945 if (width
) (*width
) = m_width
;
2946 if (height
) (*height
) = m_height
;
2949 void wxWindowGTK::DoSetClientSize( int width
, int height
)
2951 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2960 GetScrollbarWidth(m_widget
, dw
, dh
);
2963 #ifndef __WXUNIVERSAL__
2964 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
2966 // shadow border size is 2
2970 if (HasFlag(wxSIMPLE_BORDER
))
2972 // simple border size is 1
2976 #endif // __WXUNIVERSAL__
2982 SetSize(width
, height
);
2985 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
2987 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2999 GetScrollbarWidth(m_widget
, dw
, dh
);
3002 #ifndef __WXUNIVERSAL__
3003 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
3005 // shadow border size is 2
3009 if (HasFlag(wxSIMPLE_BORDER
))
3011 // simple border size is 1
3015 #endif // __WXUNIVERSAL__
3021 if (width
) *width
= w
;
3022 if (height
) *height
= h
;
3025 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
3027 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3031 if (m_parent
&& m_parent
->m_wxwindow
)
3033 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
3034 dx
= pizza
->xoffset
;
3035 dy
= pizza
->yoffset
;
3038 if (x
) (*x
) = m_x
- dx
;
3039 if (y
) (*y
) = m_y
- dy
;
3042 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
3044 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3046 if (!m_widget
->window
) return;
3048 GdkWindow
*source
= (GdkWindow
*) NULL
;
3050 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3052 source
= m_widget
->window
;
3056 gdk_window_get_origin( source
, &org_x
, &org_y
);
3060 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3062 org_x
+= m_widget
->allocation
.x
;
3063 org_y
+= m_widget
->allocation
.y
;
3071 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
3073 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3075 if (!m_widget
->window
) return;
3077 GdkWindow
*source
= (GdkWindow
*) NULL
;
3079 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3081 source
= m_widget
->window
;
3085 gdk_window_get_origin( source
, &org_x
, &org_y
);
3089 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3091 org_x
+= m_widget
->allocation
.x
;
3092 org_y
+= m_widget
->allocation
.y
;
3100 bool wxWindowGTK::Show( bool show
)
3102 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3104 if (!wxWindowBase::Show(show
))
3114 gtk_widget_show( m_widget
);
3115 wxShowEvent
eventShow(GetId(), show
);
3116 eventShow
.SetEventObject(this);
3117 GetEventHandler()->ProcessEvent(eventShow
);
3122 gtk_widget_hide( m_widget
);
3123 wxShowEvent
eventShow(GetId(), show
);
3124 eventShow
.SetEventObject(this);
3125 GetEventHandler()->ProcessEvent(eventShow
);
3131 static void wxWindowNotifyEnable(wxWindowGTK
* win
, bool enable
)
3133 win
->OnParentEnable(enable
);
3135 // Recurse, so that children have the opportunity to Do The Right Thing
3136 // and reset colours that have been messed up by a parent's (really ancestor's)
3138 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
3140 node
= node
->GetNext() )
3142 wxWindow
*child
= node
->GetData();
3143 if (!child
->IsKindOf(CLASSINFO(wxDialog
)) && !child
->IsKindOf(CLASSINFO(wxFrame
)))
3144 wxWindowNotifyEnable(child
, enable
);
3148 bool wxWindowGTK::Enable( bool enable
)
3150 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3152 if (!wxWindowBase::Enable(enable
))
3158 gtk_widget_set_sensitive( m_widget
, enable
);
3160 gtk_widget_set_sensitive( m_wxwindow
, enable
);
3162 wxWindowNotifyEnable(this, enable
);
3167 int wxWindowGTK::GetCharHeight() const
3169 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
3171 wxFont font
= GetFont();
3172 wxCHECK_MSG( font
.Ok(), 12, wxT("invalid font") );
3174 PangoContext
*context
= NULL
;
3176 context
= gtk_widget_get_pango_context( m_widget
);
3181 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3182 PangoLayout
*layout
= pango_layout_new(context
);
3183 pango_layout_set_font_description(layout
, desc
);
3184 pango_layout_set_text(layout
, "H", 1);
3185 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3187 PangoRectangle rect
;
3188 pango_layout_line_get_extents(line
, NULL
, &rect
);
3190 g_object_unref (layout
);
3192 return (int) PANGO_PIXELS(rect
.height
);
3195 int wxWindowGTK::GetCharWidth() const
3197 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
3199 wxFont font
= GetFont();
3200 wxCHECK_MSG( font
.Ok(), 8, wxT("invalid font") );
3202 PangoContext
*context
= NULL
;
3204 context
= gtk_widget_get_pango_context( m_widget
);
3209 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3210 PangoLayout
*layout
= pango_layout_new(context
);
3211 pango_layout_set_font_description(layout
, desc
);
3212 pango_layout_set_text(layout
, "g", 1);
3213 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3215 PangoRectangle rect
;
3216 pango_layout_line_get_extents(line
, NULL
, &rect
);
3218 g_object_unref (layout
);
3220 return (int) PANGO_PIXELS(rect
.width
);
3223 void wxWindowGTK::GetTextExtent( const wxString
& string
,
3227 int *externalLeading
,
3228 const wxFont
*theFont
) const
3230 wxFont fontToUse
= theFont
? *theFont
: GetFont();
3232 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
3241 PangoContext
*context
= NULL
;
3243 context
= gtk_widget_get_pango_context( m_widget
);
3252 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3253 PangoLayout
*layout
= pango_layout_new(context
);
3254 pango_layout_set_font_description(layout
, desc
);
3256 const wxCharBuffer data
= wxGTK_CONV( string
);
3258 pango_layout_set_text(layout
, data
, strlen(data
));
3261 PangoRectangle rect
;
3262 pango_layout_get_extents(layout
, NULL
, &rect
);
3264 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
3265 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
3268 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
3269 int baseline
= pango_layout_iter_get_baseline(iter
);
3270 pango_layout_iter_free(iter
);
3271 *descent
= *y
- PANGO_PIXELS(baseline
);
3273 if (externalLeading
) (*externalLeading
) = 0; // ??
3275 g_object_unref (layout
);
3278 bool wxWindowGTK::GTKSetDelayedFocusIfNeeded()
3280 if ( g_delayedFocus
== this )
3282 if ( GTK_WIDGET_REALIZED(m_widget
) )
3284 gtk_widget_grab_focus(m_widget
);
3285 g_delayedFocus
= NULL
;
3294 void wxWindowGTK::SetFocus()
3296 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3299 // don't do anything if we already have focus
3305 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow
))
3307 gtk_widget_grab_focus (m_wxwindow
);
3312 if (GTK_IS_CONTAINER(m_widget
))
3314 gtk_widget_child_focus( m_widget
, GTK_DIR_TAB_FORWARD
);
3317 if (GTK_WIDGET_CAN_FOCUS(m_widget
) && !GTK_WIDGET_HAS_FOCUS (m_widget
) )
3320 if (!GTK_WIDGET_REALIZED(m_widget
))
3322 // we can't set the focus to the widget now so we remember that
3323 // it should be focused and will do it later, during the idle
3324 // time, as soon as we can
3325 wxLogTrace(TRACE_FOCUS
,
3326 _T("Delaying setting focus to %s(%s)"),
3327 GetClassInfo()->GetClassName(), GetLabel().c_str());
3329 g_delayedFocus
= this;
3333 wxLogTrace(TRACE_FOCUS
,
3334 _T("Setting focus to %s(%s)"),
3335 GetClassInfo()->GetClassName(), GetLabel().c_str());
3337 gtk_widget_grab_focus (m_widget
);
3342 wxLogTrace(TRACE_FOCUS
,
3343 _T("Can't set focus to %s(%s)"),
3344 GetClassInfo()->GetClassName(), GetLabel().c_str());
3349 bool wxWindowGTK::AcceptsFocus() const
3351 return m_acceptsFocus
&& wxWindowBase::AcceptsFocus();
3354 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3356 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3358 wxWindowGTK
*oldParent
= m_parent
,
3359 *newParent
= (wxWindowGTK
*)newParentBase
;
3361 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3363 if ( !wxWindowBase::Reparent(newParent
) )
3366 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3368 /* prevent GTK from deleting the widget arbitrarily */
3369 gtk_widget_ref( m_widget
);
3373 gtk_container_remove( GTK_CONTAINER(m_widget
->parent
), m_widget
);
3376 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3380 if (GTK_WIDGET_VISIBLE (newParent
->m_widget
))
3382 m_showOnIdle
= true;
3383 gtk_widget_hide( m_widget
);
3386 /* insert GTK representation */
3387 (*(newParent
->m_insertCallback
))(newParent
, this);
3390 /* reverse: prevent GTK from deleting the widget arbitrarily */
3391 gtk_widget_unref( m_widget
);
3396 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3398 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3400 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3402 wxASSERT_MSG( (m_insertCallback
!= NULL
), wxT("invalid child insertion function") );
3407 /* insert GTK representation */
3408 (*m_insertCallback
)(this, child
);
3411 void wxWindowGTK::AddChild(wxWindowBase
*child
)
3413 wxWindowBase::AddChild(child
);
3414 m_dirtyTabOrder
= true;
3416 wxapp_install_idle_handler();
3419 void wxWindowGTK::RemoveChild(wxWindowBase
*child
)
3421 wxWindowBase::RemoveChild(child
);
3422 m_dirtyTabOrder
= true;
3424 wxapp_install_idle_handler();
3427 void wxWindowGTK::DoMoveInTabOrder(wxWindow
*win
, MoveKind move
)
3429 wxWindowBase::DoMoveInTabOrder(win
, move
);
3430 m_dirtyTabOrder
= true;
3432 wxapp_install_idle_handler();
3435 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3437 // none needed by default
3441 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3443 // nothing to do by default since none is needed
3446 void wxWindowGTK::RealizeTabOrder()
3450 if ( !m_children
.empty() )
3452 // we don't only construct the correct focus chain but also use
3453 // this opportunity to update the mnemonic widgets for the widgets
3456 GList
*chain
= NULL
;
3457 wxWindowGTK
* mnemonicWindow
= NULL
;
3459 for ( wxWindowList::const_iterator i
= m_children
.begin();
3460 i
!= m_children
.end();
3463 wxWindowGTK
*win
= *i
;
3465 if ( mnemonicWindow
)
3467 if ( win
->AcceptsFocusFromKeyboard() )
3469 // wxComboBox et al. needs to focus on on a different
3470 // widget than m_widget, so if the main widget isn't
3471 // focusable try the connect widget
3472 GtkWidget
* w
= win
->m_widget
;
3473 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3475 w
= win
->GetConnectWidget();
3476 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3482 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3483 mnemonicWindow
= NULL
;
3487 else if ( win
->GTKWidgetNeedsMnemonic() )
3489 mnemonicWindow
= win
;
3492 chain
= g_list_prepend(chain
, win
->m_widget
);
3495 chain
= g_list_reverse(chain
);
3497 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3502 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3507 void wxWindowGTK::Raise()
3509 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3511 if (m_wxwindow
&& m_wxwindow
->window
)
3513 gdk_window_raise( m_wxwindow
->window
);
3515 else if (m_widget
->window
)
3517 gdk_window_raise( m_widget
->window
);
3521 void wxWindowGTK::Lower()
3523 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3525 if (m_wxwindow
&& m_wxwindow
->window
)
3527 gdk_window_lower( m_wxwindow
->window
);
3529 else if (m_widget
->window
)
3531 gdk_window_lower( m_widget
->window
);
3535 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3537 if ( !wxWindowBase::SetCursor( cursor
.Ok() ? cursor
: *wxSTANDARD_CURSOR
) )
3545 void wxWindowGTK::GTKUpdateCursor()
3547 wxCursor
cursor(g_globalCursor
.Ok() ? g_globalCursor
: GetCursor());
3550 wxArrayGdkWindows windowsThis
;
3551 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
3554 gdk_window_set_cursor(winThis
, cursor
.GetCursor());
3558 const size_t count
= windowsThis
.size();
3559 for ( size_t n
= 0; n
< count
; n
++ )
3561 GdkWindow
*win
= windowsThis
[n
];
3564 wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?"));
3568 gdk_window_set_cursor(win
, cursor
.GetCursor());
3574 void wxWindowGTK::WarpPointer( int x
, int y
)
3576 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3578 // We provide this function ourselves as it is
3579 // missing in GDK (top of this file).
3581 GdkWindow
*window
= (GdkWindow
*) NULL
;
3583 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3585 window
= GetConnectWidget()->window
;
3588 gdk_window_warp_pointer( window
, x
, y
);
3591 wxWindowGTK::ScrollDir
wxWindowGTK::ScrollDirFromRange(GtkRange
*range
) const
3593 // find the scrollbar which generated the event
3594 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3596 if ( range
== m_scrollBar
[dir
] )
3597 return (ScrollDir
)dir
;
3600 wxFAIL_MSG( _T("event from unknown scrollbar received") );
3602 return ScrollDir_Max
;
3605 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3607 bool changed
= false;
3608 GtkRange
* range
= m_scrollBar
[dir
];
3609 if ( range
&& units
)
3611 GtkAdjustment
* adj
= range
->adjustment
;
3612 gdouble inc
= unit
== ScrollUnit_Line
? adj
->step_increment
3613 : adj
->page_increment
;
3615 const int posOld
= int(adj
->value
+ 0.5);
3616 gtk_range_set_value(range
, posOld
+ units
*inc
);
3618 changed
= int(adj
->value
+ 0.5) != posOld
;
3624 bool wxWindowGTK::ScrollLines(int lines
)
3626 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3629 bool wxWindowGTK::ScrollPages(int pages
)
3631 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3634 void wxWindowGTK::Refresh( bool eraseBackground
, const wxRect
*rect
)
3638 if (!m_widget
->window
)
3643 if (!GTK_PIZZA(m_wxwindow
)->bin_window
) return;
3645 GdkRectangle gdk_rect
,
3649 gdk_rect
.x
= rect
->x
;
3650 gdk_rect
.y
= rect
->y
;
3651 gdk_rect
.width
= rect
->width
;
3652 gdk_rect
.height
= rect
->height
;
3655 else // invalidate everything
3660 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, p
, TRUE
);
3664 void wxWindowGTK::Update()
3668 // when we call Update() we really want to update the window immediately on
3669 // screen, even if it means flushing the entire queue and hence slowing down
3670 // everything -- but it should still be done, it's just that Update() should
3671 // be called very rarely
3675 void wxWindowGTK::GtkUpdate()
3677 if (m_wxwindow
&& GTK_PIZZA(m_wxwindow
)->bin_window
)
3678 gdk_window_process_updates( GTK_PIZZA(m_wxwindow
)->bin_window
, FALSE
);
3679 if (m_widget
&& m_widget
->window
)
3680 gdk_window_process_updates( m_widget
->window
, FALSE
);
3682 // for consistency with other platforms (and also because it's convenient
3683 // to be able to update an entire TLW by calling Update() only once), we
3684 // should also update all our children here
3685 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3687 node
= node
->GetNext() )
3689 node
->GetData()->GtkUpdate();
3693 void wxWindowGTK::GtkSendPaintEvents()
3697 m_updateRegion
.Clear();
3701 // Clip to paint region in wxClientDC
3702 m_clipPaintRegion
= true;
3704 // widget to draw on
3705 GtkPizza
*pizza
= GTK_PIZZA (m_wxwindow
);
3707 if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM
))
3709 // find ancestor from which to steal background
3710 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3712 parent
= (wxWindow
*)this;
3714 if (GTK_WIDGET_MAPPED(parent
->m_widget
))
3716 wxRegionIterator
upd( m_updateRegion
);
3720 rect
.x
= upd
.GetX();
3721 rect
.y
= upd
.GetY();
3722 rect
.width
= upd
.GetWidth();
3723 rect
.height
= upd
.GetHeight();
3725 gtk_paint_flat_box( parent
->m_widget
->style
,
3727 (GtkStateType
)GTK_WIDGET_STATE(m_wxwindow
),
3741 wxWindowDC
dc( (wxWindow
*)this );
3742 dc
.SetClippingRegion( m_updateRegion
);
3744 wxEraseEvent
erase_event( GetId(), &dc
);
3745 erase_event
.SetEventObject( this );
3747 GetEventHandler()->ProcessEvent(erase_event
);
3750 wxNcPaintEvent
nc_paint_event( GetId() );
3751 nc_paint_event
.SetEventObject( this );
3752 GetEventHandler()->ProcessEvent( nc_paint_event
);
3754 wxPaintEvent
paint_event( GetId() );
3755 paint_event
.SetEventObject( this );
3756 GetEventHandler()->ProcessEvent( paint_event
);
3758 m_clipPaintRegion
= false;
3760 m_updateRegion
.Clear();
3763 void wxWindowGTK::SetDoubleBuffered( bool on
)
3765 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3768 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3771 void wxWindowGTK::ClearBackground()
3773 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3777 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3779 wxWindowBase::DoSetToolTip(tip
);
3782 m_tooltip
->Apply( (wxWindow
*)this );
3785 void wxWindowGTK::ApplyToolTip( GtkTooltips
*tips
, const wxChar
*tip
)
3787 wxString
tmp( tip
);
3788 gtk_tooltips_set_tip( tips
, GetConnectWidget(), wxGTK_CONV(tmp
), (gchar
*) NULL
);
3790 #endif // wxUSE_TOOLTIPS
3792 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
3794 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3796 if (!wxWindowBase::SetBackgroundColour(colour
))
3801 // We need the pixel value e.g. for background clearing.
3802 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3805 // apply style change (forceStyle=true so that new style is applied
3806 // even if the bg colour changed from valid to wxNullColour)
3807 if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM
)
3808 ApplyWidgetStyle(true);
3813 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
3815 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3817 if (!wxWindowBase::SetForegroundColour(colour
))
3824 // We need the pixel value e.g. for background clearing.
3825 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3828 // apply style change (forceStyle=true so that new style is applied
3829 // even if the bg colour changed from valid to wxNullColour):
3830 ApplyWidgetStyle(true);
3835 PangoContext
*wxWindowGTK::GtkGetPangoDefaultContext()
3837 return gtk_widget_get_pango_context( m_widget
);
3840 GtkRcStyle
*wxWindowGTK::CreateWidgetStyle(bool forceStyle
)
3842 // do we need to apply any changes at all?
3845 !m_foregroundColour
.Ok() && !m_backgroundColour
.Ok() )
3850 GtkRcStyle
*style
= gtk_rc_style_new();
3855 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
3858 if ( m_foregroundColour
.Ok() )
3860 const GdkColor
*fg
= m_foregroundColour
.GetColor();
3862 style
->fg
[GTK_STATE_NORMAL
] = *fg
;
3863 style
->color_flags
[GTK_STATE_NORMAL
] = GTK_RC_FG
;
3865 style
->fg
[GTK_STATE_PRELIGHT
] = *fg
;
3866 style
->color_flags
[GTK_STATE_PRELIGHT
] = GTK_RC_FG
;
3868 style
->fg
[GTK_STATE_ACTIVE
] = *fg
;
3869 style
->color_flags
[GTK_STATE_ACTIVE
] = GTK_RC_FG
;
3872 if ( m_backgroundColour
.Ok() )
3874 const GdkColor
*bg
= m_backgroundColour
.GetColor();
3876 style
->bg
[GTK_STATE_NORMAL
] = *bg
;
3877 style
->base
[GTK_STATE_NORMAL
] = *bg
;
3878 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)
3879 (style
->color_flags
[GTK_STATE_NORMAL
] | GTK_RC_BG
| GTK_RC_BASE
);
3881 style
->bg
[GTK_STATE_PRELIGHT
] = *bg
;
3882 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
3883 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)
3884 (style
->color_flags
[GTK_STATE_PRELIGHT
] | GTK_RC_BG
| GTK_RC_BASE
);
3886 style
->bg
[GTK_STATE_ACTIVE
] = *bg
;
3887 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
3888 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)
3889 (style
->color_flags
[GTK_STATE_ACTIVE
] | GTK_RC_BG
| GTK_RC_BASE
);
3891 style
->bg
[GTK_STATE_INSENSITIVE
] = *bg
;
3892 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
3893 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)
3894 (style
->color_flags
[GTK_STATE_INSENSITIVE
] | GTK_RC_BG
| GTK_RC_BASE
);
3900 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle
)
3902 GtkRcStyle
*style
= CreateWidgetStyle(forceStyle
);
3905 DoApplyWidgetStyle(style
);
3906 gtk_rc_style_unref(style
);
3909 // Style change may affect GTK+'s size calculation:
3910 InvalidateBestSize();
3913 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
3916 gtk_widget_modify_style(m_wxwindow
, style
);
3918 gtk_widget_modify_style(m_widget
, style
);
3921 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style
)
3923 wxWindowBase::SetBackgroundStyle(style
);
3925 if (style
== wxBG_STYLE_CUSTOM
)
3927 GdkWindow
*window
= (GdkWindow
*) NULL
;
3929 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3931 window
= GetConnectWidget()->window
;
3935 // Make sure GDK/X11 doesn't refresh the window
3937 gdk_window_set_back_pixmap( window
, None
, False
);
3939 Display
* display
= GDK_WINDOW_DISPLAY(window
);
3942 m_needsStyleChange
= false;
3945 // Do in OnIdle, because the window is not yet available
3946 m_needsStyleChange
= true;
3948 // Don't apply widget style, or we get a grey background
3952 // apply style change (forceStyle=true so that new style is applied
3953 // even if the bg colour changed from valid to wxNullColour):
3954 ApplyWidgetStyle(true);
3959 #if wxUSE_DRAG_AND_DROP
3961 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
3963 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3965 GtkWidget
*dnd_widget
= GetConnectWidget();
3967 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
3969 if (m_dropTarget
) delete m_dropTarget
;
3970 m_dropTarget
= dropTarget
;
3972 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
3975 #endif // wxUSE_DRAG_AND_DROP
3977 GtkWidget
* wxWindowGTK::GetConnectWidget()
3979 GtkWidget
*connect_widget
= m_widget
;
3980 if (m_wxwindow
) connect_widget
= m_wxwindow
;
3982 return connect_widget
;
3985 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow
*window
) const
3987 wxArrayGdkWindows windowsThis
;
3988 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
3990 return winThis
? window
== winThis
3991 : windowsThis
.Index(window
) != wxNOT_FOUND
;
3994 GdkWindow
*wxWindowGTK::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
3996 return m_wxwindow
? GTK_PIZZA(m_wxwindow
)->bin_window
: m_widget
->window
;
3999 bool wxWindowGTK::SetFont( const wxFont
&font
)
4001 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4003 if (!wxWindowBase::SetFont(font
))
4006 // apply style change (forceStyle=true so that new style is applied
4007 // even if the font changed from valid to wxNullFont):
4008 ApplyWidgetStyle(true);
4013 void wxWindowGTK::DoCaptureMouse()
4015 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4017 GdkWindow
*window
= (GdkWindow
*) NULL
;
4019 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4021 window
= GetConnectWidget()->window
;
4023 wxCHECK_RET( window
, _T("CaptureMouse() failed") );
4025 const wxCursor
* cursor
= &m_cursor
;
4027 cursor
= wxSTANDARD_CURSOR
;
4029 gdk_pointer_grab( window
, FALSE
,
4031 (GDK_BUTTON_PRESS_MASK
|
4032 GDK_BUTTON_RELEASE_MASK
|
4033 GDK_POINTER_MOTION_HINT_MASK
|
4034 GDK_POINTER_MOTION_MASK
),
4036 cursor
->GetCursor(),
4037 (guint32
)GDK_CURRENT_TIME
);
4038 g_captureWindow
= this;
4039 g_captureWindowHasMouse
= true;
4042 void wxWindowGTK::DoReleaseMouse()
4044 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4046 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4048 g_captureWindow
= (wxWindowGTK
*) NULL
;
4050 GdkWindow
*window
= (GdkWindow
*) NULL
;
4052 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4054 window
= GetConnectWidget()->window
;
4059 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4063 wxWindow
*wxWindowBase::GetCapture()
4065 return (wxWindow
*)g_captureWindow
;
4068 bool wxWindowGTK::IsRetained() const
4073 void wxWindowGTK::BlockScrollEvent()
4075 wxASSERT(!m_blockScrollEvent
);
4076 m_blockScrollEvent
= true;
4079 void wxWindowGTK::UnblockScrollEvent()
4081 wxASSERT(m_blockScrollEvent
);
4082 m_blockScrollEvent
= false;
4085 void wxWindowGTK::SetScrollbar(int orient
,
4089 bool WXUNUSED(update
))
4091 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4092 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4096 m_hasScrolling
= true;
4100 // GtkRange requires upper > lower
4105 if (pos
> range
- thumbVisible
)
4106 pos
= range
- thumbVisible
;
4109 GtkAdjustment
* adj
= m_scrollBar
[ScrollDirFromOrient(orient
)]->adjustment
;
4110 adj
->step_increment
= 1;
4111 adj
->page_increment
=
4112 adj
->page_size
= thumbVisible
;
4114 SetScrollPos(orient
, pos
);
4115 gtk_adjustment_changed(adj
);
4118 void wxWindowGTK::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4120 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4121 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4123 // This check is more than an optimization. Without it, the slider
4124 // will not move smoothly while tracking when using wxScrollHelper.
4125 if (GetScrollPos(orient
) != pos
)
4127 const int dir
= ScrollDirFromOrient(orient
);
4128 GtkAdjustment
* adj
= m_scrollBar
[dir
]->adjustment
;
4129 const int max
= int(adj
->upper
- adj
->page_size
);
4136 // If a "value_changed" signal emission is not already in progress
4137 if (!m_blockValueChanged
[dir
])
4139 gtk_adjustment_value_changed(adj
);
4144 int wxWindowGTK::GetScrollThumb(int orient
) const
4146 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4147 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4149 return int(m_scrollBar
[ScrollDirFromOrient(orient
)]->adjustment
->page_size
);
4152 int wxWindowGTK::GetScrollPos( int orient
) const
4154 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4155 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4157 return int(m_scrollBar
[ScrollDirFromOrient(orient
)]->adjustment
->value
+ 0.5);
4160 int wxWindowGTK::GetScrollRange( int orient
) const
4162 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4163 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4165 return int(m_scrollBar
[ScrollDirFromOrient(orient
)]->adjustment
->upper
);
4168 // Determine if increment is the same as +/-x, allowing for some small
4169 // difference due to possible inexactness in floating point arithmetic
4170 static inline bool IsScrollIncrement(double increment
, double x
)
4172 wxASSERT(increment
> 0);
4173 const double tolerance
= 1.0 / 1024;
4174 return fabs(increment
- fabs(x
)) < tolerance
;
4177 wxEventType
wxWindowGTK::GetScrollEventType(GtkRange
* range
)
4182 wxapp_install_idle_handler();
4184 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4186 const int barIndex
= range
== m_scrollBar
[1];
4187 GtkAdjustment
* adj
= range
->adjustment
;
4188 const int value
= int(adj
->value
+ 0.5);
4189 // save previous position
4190 const double oldPos
= m_scrollPos
[barIndex
];
4191 // update current position
4192 m_scrollPos
[barIndex
] = adj
->value
;
4193 // If event should be ignored, or integral position has not changed
4194 if (!m_hasVMT
|| g_blockEventsOnDrag
|| value
== int(oldPos
+ 0.5))
4199 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4202 // Difference from last change event
4203 const double diff
= adj
->value
- oldPos
;
4204 const bool isDown
= diff
> 0;
4206 if (IsScrollIncrement(adj
->step_increment
, diff
))
4208 eventType
= isDown
? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4210 else if (IsScrollIncrement(adj
->page_increment
, diff
))
4212 eventType
= isDown
? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4214 else if (m_mouseButtonDown
)
4216 // Assume track event
4217 m_isScrolling
= true;
4223 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4225 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4227 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4229 // No scrolling requested.
4230 if ((dx
== 0) && (dy
== 0)) return;
4232 m_clipPaintRegion
= true;
4234 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), -dx
, -dy
);
4236 m_clipPaintRegion
= false;
4239 void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4241 //RN: Note that static controls usually have no border on gtk, so maybe
4242 //it makes sense to treat that as simply no border at the wx level
4244 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4246 GtkShadowType gtkstyle
;
4248 if(wxstyle
& wxBORDER_RAISED
)
4249 gtkstyle
= GTK_SHADOW_OUT
;
4250 else if (wxstyle
& wxBORDER_SUNKEN
)
4251 gtkstyle
= GTK_SHADOW_IN
;
4252 else if (wxstyle
& wxBORDER_DOUBLE
)
4253 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4255 gtkstyle
= GTK_SHADOW_IN
;
4257 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4262 void wxWindowGTK::SetWindowStyleFlag( long style
)
4264 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4265 wxWindowBase::SetWindowStyleFlag(style
);
4268 // Find the wxWindow at the current mouse position, also returning the mouse
4270 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4272 pt
= wxGetMousePosition();
4273 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4277 // Get the current mouse position.
4278 wxPoint
wxGetMousePosition()
4280 /* This crashes when used within wxHelpContext,
4281 so we have to use the X-specific implementation below.
4283 GdkModifierType *mask;
4284 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4286 return wxPoint(x, y);
4290 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4292 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4293 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4294 Window rootReturn
, childReturn
;
4295 int rootX
, rootY
, winX
, winY
;
4296 unsigned int maskReturn
;
4298 XQueryPointer (display
,
4302 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4303 return wxPoint(rootX
, rootY
);
4307 // Needed for implementing e.g. combobox on wxGTK within a modal dialog.
4308 void wxAddGrab(wxWindow
* window
)
4310 gtk_grab_add( (GtkWidget
*) window
->GetHandle() );
4313 void wxRemoveGrab(wxWindow
* window
)
4315 gtk_grab_remove( (GtkWidget
*) window
->GetHandle() );