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
->GTKProcessEvent(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
+= gtk_pizza_get_xoffset( pizza
);
1334 yy
+= gtk_pizza_get_yoffset( pizza
);
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 bool wxWindowGTK::GTKProcessEvent(wxEvent
& event
) const
1395 // nothing special at this level
1396 return GetEventHandler()->ProcessEvent(event
);
1399 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny
*event
) const
1403 // don't need to install idle handler, its done from "event" signal
1407 if (g_blockEventsOnDrag
)
1409 if (g_blockEventsOnScroll
)
1412 if (!GTKIsOwnWindow(event
->window
))
1418 // overloads for all GDK event types we use here: we need to have this as
1419 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1420 // derives from it in the sense that the structs have the same layout
1421 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1422 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1424 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1427 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton
)
1428 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion
)
1429 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing
)
1431 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1433 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1434 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1438 // send the wxChildFocusEvent and wxFocusEvent, common code of
1439 // gtk_window_focus_in_callback() and SetFocus()
1440 static bool DoSendFocusEvents(wxWindow
*win
)
1442 // Notify the parent keeping track of focus for the kbd navigation
1443 // purposes that we got it.
1444 wxChildFocusEvent
eventChildFocus(win
);
1445 (void)win
->GetEventHandler()->ProcessEvent(eventChildFocus
);
1447 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, win
->GetId());
1448 eventFocus
.SetEventObject(win
);
1450 return win
->GetEventHandler()->ProcessEvent(eventFocus
);
1453 // all event handlers must have C linkage as they're called from GTK+ C code
1457 //-----------------------------------------------------------------------------
1458 // "button_press_event"
1459 //-----------------------------------------------------------------------------
1462 gtk_window_button_press_callback( GtkWidget
*widget
,
1463 GdkEventButton
*gdk_event
,
1466 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1468 if (win
->m_wxwindow
&& (g_focusWindow
!= win
) && win
->AcceptsFocus())
1470 gtk_widget_grab_focus( win
->m_wxwindow
);
1473 // GDK sends surplus button down events
1474 // before a double click event. We
1475 // need to filter these out.
1476 if (gdk_event
->type
== GDK_BUTTON_PRESS
)
1478 GdkEvent
*peek_event
= gdk_event_peek();
1481 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1482 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1484 gdk_event_free( peek_event
);
1489 gdk_event_free( peek_event
);
1494 wxEventType event_type
= wxEVT_NULL
;
1496 // GdkDisplay is a GTK+ 2.2.0 thing
1497 #if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0)
1498 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1499 !gtk_check_version(2,2,0) &&
1500 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1502 // Reset GDK internal timestamp variables in order to disable GDK
1503 // triple click events. GDK will then next time believe no button has
1504 // been clicked just before, and send a normal button click event.
1505 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1506 display
->button_click_time
[1] = 0;
1507 display
->button_click_time
[0] = 0;
1511 if (gdk_event
->button
== 1)
1513 // note that GDK generates triple click events which are not supported
1514 // by wxWidgets but still have to be passed to the app as otherwise
1515 // clicks would simply go missing
1516 switch (gdk_event
->type
)
1518 // we shouldn't get triple clicks at all for GTK2 because we
1519 // suppress them artificially using the code above but we still
1520 // should map them to something for GTK1 and not just ignore them
1521 // as this would lose clicks
1522 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1523 case GDK_BUTTON_PRESS
:
1524 event_type
= wxEVT_LEFT_DOWN
;
1527 case GDK_2BUTTON_PRESS
:
1528 event_type
= wxEVT_LEFT_DCLICK
;
1532 // just to silence gcc warnings
1536 else if (gdk_event
->button
== 2)
1538 switch (gdk_event
->type
)
1540 case GDK_3BUTTON_PRESS
:
1541 case GDK_BUTTON_PRESS
:
1542 event_type
= wxEVT_MIDDLE_DOWN
;
1545 case GDK_2BUTTON_PRESS
:
1546 event_type
= wxEVT_MIDDLE_DCLICK
;
1553 else if (gdk_event
->button
== 3)
1555 switch (gdk_event
->type
)
1557 case GDK_3BUTTON_PRESS
:
1558 case GDK_BUTTON_PRESS
:
1559 event_type
= wxEVT_RIGHT_DOWN
;
1562 case GDK_2BUTTON_PRESS
:
1563 event_type
= wxEVT_RIGHT_DCLICK
;
1570 else if (gdk_event
->button
== 4 || gdk_event
->button
== 5)
1572 if (gdk_event
->type
== GDK_BUTTON_PRESS
)
1574 event_type
= wxEVT_MOUSEWHEEL
;
1578 if ( event_type
== wxEVT_NULL
)
1580 // unknown mouse button or click type
1584 wxMouseEvent
event( event_type
);
1585 InitMouseEvent( win
, event
, gdk_event
);
1587 AdjustEventButtonState(event
);
1589 // wxListBox actually gets mouse events from the item, so we need to give it
1590 // a chance to correct this
1591 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1593 // find the correct window to send the event to: it may be a different one
1594 // from the one which got it at GTK+ level because some controls don't have
1595 // their own X window and thus cannot get any events.
1596 if ( !g_captureWindow
)
1597 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1599 // reset the event object and id in case win changed.
1600 event
.SetEventObject( win
);
1601 event
.SetId( win
->GetId() );
1603 if (win
->GTKProcessEvent( event
))
1608 if (event_type
== wxEVT_RIGHT_DOWN
)
1610 // generate a "context menu" event: this is similar to right mouse
1611 // click under many GUIs except that it is generated differently
1612 // (right up under MSW, ctrl-click under Mac, right down here) and
1614 // (a) it's a command event and so is propagated to the parent
1615 // (b) under some ports it can be generated from kbd too
1616 // (c) it uses screen coords (because of (a))
1617 wxContextMenuEvent
evtCtx(
1620 win
->ClientToScreen(event
.GetPosition()));
1621 evtCtx
.SetEventObject(win
);
1622 return win
->GTKProcessEvent(evtCtx
);
1628 //-----------------------------------------------------------------------------
1629 // "button_release_event"
1630 //-----------------------------------------------------------------------------
1633 gtk_window_button_release_callback( GtkWidget
*widget
,
1634 GdkEventButton
*gdk_event
,
1637 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1639 wxEventType event_type
= wxEVT_NULL
;
1641 switch (gdk_event
->button
)
1644 event_type
= wxEVT_LEFT_UP
;
1648 event_type
= wxEVT_MIDDLE_UP
;
1652 event_type
= wxEVT_RIGHT_UP
;
1656 // unknown button, don't process
1660 wxMouseEvent
event( event_type
);
1661 InitMouseEvent( win
, event
, gdk_event
);
1663 AdjustEventButtonState(event
);
1665 // same wxListBox hack as above
1666 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1668 if ( !g_captureWindow
)
1669 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1671 // reset the event object and id in case win changed.
1672 event
.SetEventObject( win
);
1673 event
.SetId( win
->GetId() );
1675 return win
->GTKProcessEvent(event
);
1678 //-----------------------------------------------------------------------------
1679 // "motion_notify_event"
1680 //-----------------------------------------------------------------------------
1683 gtk_window_motion_notify_callback( GtkWidget
*widget
,
1684 GdkEventMotion
*gdk_event
,
1687 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1689 if (gdk_event
->is_hint
)
1693 GdkModifierType state
;
1694 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1699 wxMouseEvent
event( wxEVT_MOTION
);
1700 InitMouseEvent(win
, event
, gdk_event
);
1702 if ( g_captureWindow
)
1704 // synthesise a mouse enter or leave event if needed
1705 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1706 // This seems to be necessary and actually been added to
1707 // GDK itself in version 2.0.X
1710 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1711 if ( hasMouse
!= g_captureWindowHasMouse
)
1713 // the mouse changed window
1714 g_captureWindowHasMouse
= hasMouse
;
1716 wxMouseEvent
eventM(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1717 : wxEVT_LEAVE_WINDOW
);
1718 InitMouseEvent(win
, eventM
, gdk_event
);
1719 eventM
.SetEventObject(win
);
1720 win
->GTKProcessEvent(eventM
);
1725 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1727 // reset the event object and id in case win changed.
1728 event
.SetEventObject( win
);
1729 event
.SetId( win
->GetId() );
1732 if ( !g_captureWindow
)
1734 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1735 if (win
->GTKProcessEvent( cevent
))
1737 win
->SetCursor( cevent
.GetCursor() );
1741 return win
->GTKProcessEvent(event
);
1744 //-----------------------------------------------------------------------------
1745 // "scroll_event", (mouse wheel event)
1746 //-----------------------------------------------------------------------------
1749 window_scroll_event(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1753 // don't need to install idle handler, its done from "event" signal
1755 if (gdk_event
->direction
!= GDK_SCROLL_UP
&&
1756 gdk_event
->direction
!= GDK_SCROLL_DOWN
)
1761 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1762 // Can't use InitMouse macro because scroll events don't have button
1763 event
.SetTimestamp( gdk_event
->time
);
1764 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1765 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1766 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1767 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1768 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1769 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1770 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1771 event
.m_linesPerAction
= 3;
1772 event
.m_wheelDelta
= 120;
1773 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1774 event
.m_wheelRotation
= 120;
1776 event
.m_wheelRotation
= -120;
1778 wxPoint pt
= win
->GetClientAreaOrigin();
1779 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1780 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1782 event
.SetEventObject( win
);
1783 event
.SetId( win
->GetId() );
1784 event
.SetTimestamp( gdk_event
->time
);
1786 return win
->GTKProcessEvent(event
);
1789 //-----------------------------------------------------------------------------
1791 //-----------------------------------------------------------------------------
1793 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
1795 wxContextMenuEvent
event(wxEVT_CONTEXT_MENU
, win
->GetId(), wxPoint(-1, -1));
1796 event
.SetEventObject(win
);
1797 return win
->GTKProcessEvent(event
);
1800 //-----------------------------------------------------------------------------
1802 //-----------------------------------------------------------------------------
1805 gtk_window_focus_in_callback( GtkWidget
*widget
,
1806 GdkEventFocus
*WXUNUSED(event
),
1811 // don't need to install idle handler, its done from "event" signal
1814 gtk_im_context_focus_in(win
->m_imData
->context
);
1817 g_focusWindow
= win
;
1819 wxLogTrace(TRACE_FOCUS
,
1820 _T("%s: focus in"), win
->GetName().c_str());
1824 gdk_im_begin(win
->m_ic
, win
->m_wxwindow
->window
);
1828 // caret needs to be informed about focus change
1829 wxCaret
*caret
= win
->GetCaret();
1832 caret
->OnSetFocus();
1834 #endif // wxUSE_CARET
1836 gboolean ret
= FALSE
;
1838 // does the window itself think that it has the focus?
1839 if ( !win
->m_hasFocus
)
1841 // not yet, notify it
1842 win
->m_hasFocus
= true;
1844 (void)DoSendFocusEvents(win
);
1849 // Disable default focus handling for custom windows
1850 // since the default GTK+ handler issues a repaint
1851 if (win
->m_wxwindow
)
1857 //-----------------------------------------------------------------------------
1858 // "focus_out_event"
1859 //-----------------------------------------------------------------------------
1862 gtk_window_focus_out_callback( GtkWidget
*widget
,
1863 GdkEventFocus
*gdk_event
,
1868 // don't need to install idle handler, its done from "event" signal
1871 gtk_im_context_focus_out(win
->m_imData
->context
);
1873 wxLogTrace( TRACE_FOCUS
,
1874 _T("%s: focus out"), win
->GetName().c_str() );
1877 wxWindowGTK
*winFocus
= wxFindFocusedChild(win
);
1881 g_focusWindow
= (wxWindowGTK
*)NULL
;
1889 // caret needs to be informed about focus change
1890 wxCaret
*caret
= win
->GetCaret();
1893 caret
->OnKillFocus();
1895 #endif // wxUSE_CARET
1897 gboolean ret
= FALSE
;
1899 // don't send the window a kill focus event if it thinks that it doesn't
1900 // have focus already
1901 if ( win
->m_hasFocus
)
1903 win
->m_hasFocus
= false;
1905 wxFocusEvent
event( wxEVT_KILL_FOCUS
, win
->GetId() );
1906 event
.SetEventObject( win
);
1908 (void)win
->GTKProcessEvent( event
);
1913 // Disable default focus handling for custom windows
1914 // since the default GTK+ handler issues a repaint
1915 if (win
->m_wxwindow
)
1921 //-----------------------------------------------------------------------------
1922 // "enter_notify_event"
1923 //-----------------------------------------------------------------------------
1926 gtk_window_enter_callback( GtkWidget
*widget
,
1927 GdkEventCrossing
*gdk_event
,
1930 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1932 // Event was emitted after a grab
1933 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1937 GdkModifierType state
= (GdkModifierType
)0;
1939 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1941 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1942 InitMouseEvent(win
, event
, gdk_event
);
1943 wxPoint pt
= win
->GetClientAreaOrigin();
1944 event
.m_x
= x
+ pt
.x
;
1945 event
.m_y
= y
+ pt
.y
;
1947 if ( !g_captureWindow
)
1949 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1950 if (win
->GTKProcessEvent( cevent
))
1952 win
->SetCursor( cevent
.GetCursor() );
1956 return win
->GTKProcessEvent(event
);
1959 //-----------------------------------------------------------------------------
1960 // "leave_notify_event"
1961 //-----------------------------------------------------------------------------
1964 gtk_window_leave_callback( GtkWidget
*widget
,
1965 GdkEventCrossing
*gdk_event
,
1968 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1970 // Event was emitted after an ungrab
1971 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1973 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1974 event
.SetTimestamp( gdk_event
->time
);
1975 event
.SetEventObject( win
);
1979 GdkModifierType state
= (GdkModifierType
)0;
1981 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1983 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
) != 0;
1984 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
) != 0;
1985 event
.m_altDown
= (state
& GDK_MOD1_MASK
) != 0;
1986 event
.m_metaDown
= (state
& GDK_MOD2_MASK
) != 0;
1987 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
) != 0;
1988 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
) != 0;
1989 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
) != 0;
1991 wxPoint pt
= win
->GetClientAreaOrigin();
1992 event
.m_x
= x
+ pt
.x
;
1993 event
.m_y
= y
+ pt
.y
;
1995 return win
->GTKProcessEvent(event
);
1998 //-----------------------------------------------------------------------------
1999 // "value_changed" from scrollbar
2000 //-----------------------------------------------------------------------------
2003 gtk_scrollbar_value_changed(GtkRange
* range
, wxWindow
* win
)
2005 wxEventType eventType
= win
->GetScrollEventType(range
);
2006 if (eventType
!= wxEVT_NULL
)
2008 // Convert scroll event type to scrollwin event type
2009 eventType
+= wxEVT_SCROLLWIN_TOP
- wxEVT_SCROLL_TOP
;
2011 // find the scrollbar which generated the event
2012 wxWindowGTK::ScrollDir dir
= win
->ScrollDirFromRange(range
);
2014 // generate the corresponding wx event
2015 const int orient
= win
->OrientFromScrollDir(dir
);
2016 wxScrollWinEvent
event(eventType
, win
->GetScrollPos(orient
), orient
);
2017 event
.SetEventObject(win
);
2019 win
->m_blockValueChanged
[dir
] = true;
2020 win
->GTKProcessEvent(event
);
2021 win
->m_blockValueChanged
[dir
] = false;
2025 //-----------------------------------------------------------------------------
2026 // "button_press_event" from scrollbar
2027 //-----------------------------------------------------------------------------
2030 gtk_scrollbar_button_press_event(GtkRange
*, GdkEventButton
*, wxWindow
* win
)
2034 // don't need to install idle handler, its done from "event" signal
2036 g_blockEventsOnScroll
= true;
2037 win
->m_mouseButtonDown
= true;
2042 //-----------------------------------------------------------------------------
2043 // "event_after" from scrollbar
2044 //-----------------------------------------------------------------------------
2047 gtk_scrollbar_event_after(GtkRange
* range
, GdkEvent
* event
, wxWindow
* win
)
2049 if (event
->type
== GDK_BUTTON_RELEASE
)
2051 g_signal_handlers_block_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
2053 const int orient
= win
->OrientFromScrollDir(
2054 win
->ScrollDirFromRange(range
));
2055 wxScrollWinEvent
event(wxEVT_SCROLLWIN_THUMBRELEASE
, win
->GetScrollPos(orient
), orient
);
2056 event
.SetEventObject(win
);
2057 win
->GTKProcessEvent(event
);
2061 //-----------------------------------------------------------------------------
2062 // "button_release_event" from scrollbar
2063 //-----------------------------------------------------------------------------
2066 gtk_scrollbar_button_release_event(GtkRange
* range
, GdkEventButton
*, wxWindow
* win
)
2070 g_blockEventsOnScroll
= false;
2071 win
->m_mouseButtonDown
= false;
2072 // If thumb tracking
2073 if (win
->m_isScrolling
)
2075 win
->m_isScrolling
= false;
2076 // Hook up handler to send thumb release event after this emission is finished.
2077 // To allow setting scroll position from event handler, sending event must
2078 // be deferred until after the GtkRange handler for this signal has run
2079 g_signal_handlers_unblock_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
2085 //-----------------------------------------------------------------------------
2086 // "realize" from m_widget
2087 //-----------------------------------------------------------------------------
2089 /* We cannot set colours and fonts before the widget has
2090 been realized, so we do this directly after realization. */
2093 gtk_window_realized_callback( GtkWidget
*m_widget
, wxWindow
*win
)
2098 wxapp_install_idle_handler();
2102 GtkPizza
*pizza
= GTK_PIZZA( m_widget
);
2103 gtk_im_context_set_client_window( win
->m_imData
->context
,
2104 pizza
->bin_window
);
2107 wxWindowCreateEvent
event( win
);
2108 event
.SetEventObject( win
);
2109 win
->GTKProcessEvent( event
);
2112 //-----------------------------------------------------------------------------
2114 //-----------------------------------------------------------------------------
2117 void gtk_window_size_callback( GtkWidget
*WXUNUSED(widget
),
2118 GtkAllocation
*alloc
,
2122 wxapp_install_idle_handler();
2124 int client_width
= 0;
2125 int client_height
= 0;
2126 win
->GetClientSize( &client_width
, &client_height
);
2127 if ((client_width
== win
->m_oldClientWidth
) && (client_height
== win
->m_oldClientHeight
))
2130 GTK_PIZZA(win
->m_wxwindow
)->m_width
= alloc
->width
;
2132 win
->m_oldClientWidth
= client_width
;
2133 win
->m_oldClientHeight
= client_height
;
2135 if (!win
->m_nativeSizeEvent
)
2137 wxSizeEvent
event( win
->GetSize(), win
->GetId() );
2138 event
.SetEventObject( win
);
2139 win
->GTKProcessEvent( event
);
2145 #define WXUNUSED_UNLESS_XIM(param) param
2147 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2150 /* Resize XIM window */
2152 void gtk_wxwindow_size_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2153 GtkAllocation
* WXUNUSED_UNLESS_XIM(alloc
),
2154 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2157 wxapp_install_idle_handler();
2163 if (gdk_ic_get_style (win
->m_ic
) & GDK_IM_PREEDIT_POSITION
)
2167 gdk_drawable_get_size (widget
->window
, &width
, &height
);
2168 win
->m_icattr
->preedit_area
.width
= width
;
2169 win
->m_icattr
->preedit_area
.height
= height
;
2170 gdk_ic_set_attr (win
->m_ic
, win
->m_icattr
, GDK_IC_PREEDIT_AREA
);
2175 //-----------------------------------------------------------------------------
2176 // "realize" from m_wxwindow
2177 //-----------------------------------------------------------------------------
2179 /* Initialize XIM support */
2182 gtk_wxwindow_realized_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2183 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2186 wxapp_install_idle_handler();
2189 if (win
->m_ic
) return;
2190 if (!widget
) return;
2191 if (!gdk_im_ready()) return;
2193 win
->m_icattr
= gdk_ic_attr_new();
2194 if (!win
->m_icattr
) return;
2198 GdkColormap
*colormap
;
2199 GdkICAttr
*attr
= win
->m_icattr
;
2200 unsigned attrmask
= GDK_IC_ALL_REQ
;
2202 GdkIMStyle supported_style
= (GdkIMStyle
)
2203 (GDK_IM_PREEDIT_NONE
|
2204 GDK_IM_PREEDIT_NOTHING
|
2205 GDK_IM_PREEDIT_POSITION
|
2206 GDK_IM_STATUS_NONE
|
2207 GDK_IM_STATUS_NOTHING
);
2209 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2210 supported_style
= (GdkIMStyle
)(supported_style
& ~GDK_IM_PREEDIT_POSITION
);
2212 attr
->style
= style
= gdk_im_decide_style (supported_style
);
2213 attr
->client_window
= widget
->window
;
2215 if ((colormap
= gtk_widget_get_colormap (widget
)) !=
2216 gtk_widget_get_default_colormap ())
2218 attrmask
|= GDK_IC_PREEDIT_COLORMAP
;
2219 attr
->preedit_colormap
= colormap
;
2222 attrmask
|= GDK_IC_PREEDIT_FOREGROUND
;
2223 attrmask
|= GDK_IC_PREEDIT_BACKGROUND
;
2224 attr
->preedit_foreground
= widget
->style
->fg
[GTK_STATE_NORMAL
];
2225 attr
->preedit_background
= widget
->style
->base
[GTK_STATE_NORMAL
];
2227 switch (style
& GDK_IM_PREEDIT_MASK
)
2229 case GDK_IM_PREEDIT_POSITION
:
2230 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2232 g_warning ("over-the-spot style requires fontset");
2236 gdk_drawable_get_size (widget
->window
, &width
, &height
);
2238 attrmask
|= GDK_IC_PREEDIT_POSITION_REQ
;
2239 attr
->spot_location
.x
= 0;
2240 attr
->spot_location
.y
= height
;
2241 attr
->preedit_area
.x
= 0;
2242 attr
->preedit_area
.y
= 0;
2243 attr
->preedit_area
.width
= width
;
2244 attr
->preedit_area
.height
= height
;
2245 attr
->preedit_fontset
= widget
->style
->font
;
2250 win
->m_ic
= gdk_ic_new (attr
, (GdkICAttributesType
)attrmask
);
2252 if (win
->m_ic
== NULL
)
2253 g_warning ("Can't create input context.");
2256 mask
= gdk_window_get_events (widget
->window
);
2257 mask
= (GdkEventMask
)(mask
| gdk_ic_get_events (win
->m_ic
));
2258 gdk_window_set_events (widget
->window
, mask
);
2260 if (GTK_WIDGET_HAS_FOCUS(widget
))
2261 gdk_im_begin (win
->m_ic
, widget
->window
);
2268 // ----------------------------------------------------------------------------
2269 // this wxWindowBase function is implemented here (in platform-specific file)
2270 // because it is static and so couldn't be made virtual
2271 // ----------------------------------------------------------------------------
2273 wxWindow
*wxWindowBase::DoFindFocus()
2275 // the cast is necessary when we compile in wxUniversal mode
2276 return (wxWindow
*)g_focusWindow
;
2279 //-----------------------------------------------------------------------------
2280 // InsertChild for wxWindowGTK.
2281 //-----------------------------------------------------------------------------
2283 /* Callback for wxWindowGTK. This very strange beast has to be used because
2284 * C++ has no virtual methods in a constructor. We have to emulate a
2285 * virtual function here as wxNotebook requires a different way to insert
2286 * a child in it. I had opted for creating a wxNotebookPage window class
2287 * which would have made this superfluous (such in the MDI window system),
2288 * but no-one was listening to me... */
2290 static void wxInsertChildInWindow( wxWindowGTK
* parent
, wxWindowGTK
* child
)
2292 /* the window might have been scrolled already, do we
2293 have to adapt the position */
2294 GtkPizza
*pizza
= GTK_PIZZA(parent
->m_wxwindow
);
2295 child
->m_x
+= gtk_pizza_get_xoffset( pizza
);
2296 child
->m_y
+= gtk_pizza_get_yoffset( pizza
);
2298 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
2299 GTK_WIDGET(child
->m_widget
),
2306 //-----------------------------------------------------------------------------
2308 //-----------------------------------------------------------------------------
2310 wxWindow
*wxGetActiveWindow()
2312 return wxWindow::FindFocus();
2316 wxMouseState
wxGetMouseState()
2322 GdkModifierType mask
;
2324 gdk_window_get_pointer(NULL
, &x
, &y
, &mask
);
2328 ms
.SetLeftDown(mask
& GDK_BUTTON1_MASK
);
2329 ms
.SetMiddleDown(mask
& GDK_BUTTON2_MASK
);
2330 ms
.SetRightDown(mask
& GDK_BUTTON3_MASK
);
2332 ms
.SetControlDown(mask
& GDK_CONTROL_MASK
);
2333 ms
.SetShiftDown(mask
& GDK_SHIFT_MASK
);
2334 ms
.SetAltDown(mask
& GDK_MOD1_MASK
);
2335 ms
.SetMetaDown(mask
& GDK_MOD2_MASK
);
2340 //-----------------------------------------------------------------------------
2342 //-----------------------------------------------------------------------------
2344 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2346 #ifdef __WXUNIVERSAL__
2347 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2349 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
2350 #endif // __WXUNIVERSAL__/__WXGTK__
2352 void wxWindowGTK::Init()
2355 m_widget
= (GtkWidget
*) NULL
;
2356 m_wxwindow
= (GtkWidget
*) NULL
;
2357 m_focusWidget
= (GtkWidget
*) NULL
;
2367 m_needParent
= true;
2368 m_isBeingDeleted
= false;
2370 m_showOnIdle
= false;
2373 m_nativeSizeEvent
= false;
2375 m_hasScrolling
= false;
2376 m_isScrolling
= false;
2377 m_mouseButtonDown
= false;
2378 m_blockScrollEvent
= false;
2380 // initialize scrolling stuff
2381 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2383 m_scrollBar
[dir
] = NULL
;
2384 m_scrollPos
[dir
] = 0;
2385 m_blockValueChanged
[dir
] = false;
2389 m_oldClientHeight
= 0;
2393 m_insertCallback
= (wxInsertChildFunction
) NULL
;
2395 m_acceptsFocus
= false;
2398 m_clipPaintRegion
= false;
2400 m_needsStyleChange
= false;
2402 m_cursor
= *wxSTANDARD_CURSOR
;
2405 m_dirtyTabOrder
= false;
2408 wxWindowGTK::wxWindowGTK()
2413 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2418 const wxString
&name
)
2422 Create( parent
, id
, pos
, size
, style
, name
);
2425 bool wxWindowGTK::Create( wxWindow
*parent
,
2430 const wxString
&name
)
2432 if (!PreCreation( parent
, pos
, size
) ||
2433 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2435 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2439 m_insertCallback
= wxInsertChildInWindow
;
2441 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
2442 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
2444 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2446 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2447 scroll_class
->scrollbar_spacing
= 0;
2449 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2451 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(scrolledWindow
->hscrollbar
);
2452 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(scrolledWindow
->vscrollbar
);
2454 m_wxwindow
= gtk_pizza_new();
2456 #ifndef __WXUNIVERSAL__
2457 GtkPizza
*pizza
= GTK_PIZZA(m_wxwindow
);
2459 if (HasFlag(wxRAISED_BORDER
))
2461 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_OUT
);
2463 else if (HasFlag(wxSUNKEN_BORDER
))
2465 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_IN
);
2467 else if (HasFlag(wxSIMPLE_BORDER
))
2469 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_THIN
);
2473 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_NONE
);
2475 #endif // __WXUNIVERSAL__
2477 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2479 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
2480 m_acceptsFocus
= true;
2482 // connect various scroll-related events
2483 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2485 // these handlers block mouse events to any window during scrolling
2486 // such as motion events and prevent GTK and wxWidgets from fighting
2487 // over where the slider should be
2488 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2489 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2490 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2491 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2493 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2494 G_CALLBACK(gtk_scrollbar_event_after
), this);
2495 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2497 // these handlers get notified when scrollbar slider moves
2498 g_signal_connect(m_scrollBar
[dir
], "value_changed",
2499 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2502 gtk_widget_show( m_wxwindow
);
2505 m_parent
->DoAddChild( this );
2507 m_focusWidget
= m_wxwindow
;
2514 wxWindowGTK::~wxWindowGTK()
2518 if (g_focusWindow
== this)
2519 g_focusWindow
= NULL
;
2521 if ( g_delayedFocus
== this )
2522 g_delayedFocus
= NULL
;
2524 m_isBeingDeleted
= true;
2527 // destroy children before destroying this window itself
2530 // unhook focus handlers to prevent stray events being
2531 // propagated to this (soon to be) dead object
2532 if (m_focusWidget
!= NULL
)
2534 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2535 (gpointer
) gtk_window_focus_in_callback
,
2537 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2538 (gpointer
) gtk_window_focus_out_callback
,
2547 gdk_ic_destroy (m_ic
);
2549 gdk_ic_attr_destroy (m_icattr
);
2552 // delete before the widgets to avoid a crash on solaris
2557 gtk_widget_destroy( m_wxwindow
);
2558 m_wxwindow
= (GtkWidget
*) NULL
;
2563 gtk_widget_destroy( m_widget
);
2564 m_widget
= (GtkWidget
*) NULL
;
2568 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2570 wxCHECK_MSG( !m_needParent
|| parent
, false, wxT("Need complete parent.") );
2572 // Use either the given size, or the default if -1 is given.
2573 // See wxWindowBase for these functions.
2574 m_width
= WidthDefault(size
.x
) ;
2575 m_height
= HeightDefault(size
.y
);
2583 void wxWindowGTK::PostCreation()
2585 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2591 // these get reported to wxWidgets -> wxPaintEvent
2593 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow
), TRUE
);
2595 g_signal_connect (m_wxwindow
, "expose_event",
2596 G_CALLBACK (gtk_window_expose_callback
), this);
2598 gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow
), HasFlag( wxFULL_REPAINT_ON_RESIZE
) );
2601 // Create input method handler
2602 m_imData
= new wxGtkIMData
;
2604 // Cannot handle drawing preedited text yet
2605 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2607 g_signal_connect (m_imData
->context
, "commit",
2608 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2610 // these are called when the "sunken" or "raised" borders are drawn
2611 g_signal_connect (m_widget
, "expose_event",
2612 G_CALLBACK (gtk_window_own_expose_callback
), this);
2617 if (!GTK_IS_WINDOW(m_widget
))
2619 if (m_focusWidget
== NULL
)
2620 m_focusWidget
= m_widget
;
2624 g_signal_connect (m_focusWidget
, "focus_in_event",
2625 G_CALLBACK (gtk_window_focus_in_callback
), this);
2626 g_signal_connect (m_focusWidget
, "focus_out_event",
2627 G_CALLBACK (gtk_window_focus_out_callback
), this);
2631 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2632 G_CALLBACK (gtk_window_focus_in_callback
), this);
2633 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2634 G_CALLBACK (gtk_window_focus_out_callback
), this);
2638 // connect to the various key and mouse handlers
2640 GtkWidget
*connect_widget
= GetConnectWidget();
2642 ConnectWidget( connect_widget
);
2644 /* We cannot set colours, fonts and cursors before the widget has
2645 been realized, so we do this directly after realization */
2646 g_signal_connect (connect_widget
, "realize",
2647 G_CALLBACK (gtk_window_realized_callback
), this);
2651 // Catch native resize events
2652 g_signal_connect (m_wxwindow
, "size_allocate",
2653 G_CALLBACK (gtk_window_size_callback
), this);
2655 // Initialize XIM support
2656 g_signal_connect (m_wxwindow
, "realize",
2657 G_CALLBACK (gtk_wxwindow_realized_callback
), this);
2659 // And resize XIM window
2660 g_signal_connect (m_wxwindow
, "size_allocate",
2661 G_CALLBACK (gtk_wxwindow_size_callback
), this);
2664 if (GTK_IS_COMBO(m_widget
))
2666 GtkCombo
*gcombo
= GTK_COMBO(m_widget
);
2668 g_signal_connect (gcombo
->entry
, "size_request",
2669 G_CALLBACK (wxgtk_combo_size_request_callback
),
2672 #ifdef GTK_IS_FILE_CHOOSER_BUTTON
2673 else if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget
))
2675 // If we connect to the "size_request" signal of a GtkFileChooserButton
2676 // then that control won't be sized properly when placed inside sizers
2677 // (this can be tested removing this elseif and running XRC or WIDGETS samples)
2678 // FIXME: what should be done here ?
2683 // This is needed if we want to add our windows into native
2684 // GTK controls, such as the toolbar. With this callback, the
2685 // toolbar gets to know the correct size (the one set by the
2686 // programmer). Sadly, it misbehaves for wxComboBox.
2687 g_signal_connect (m_widget
, "size_request",
2688 G_CALLBACK (wxgtk_window_size_request_callback
),
2692 InheritAttributes();
2696 SetLayoutDirection(wxLayout_Default
);
2698 // unless the window was created initially hidden (i.e. Hide() had been
2699 // called before Create()), we should show it at GTK+ level as well
2701 gtk_widget_show( m_widget
);
2704 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2706 g_signal_connect (widget
, "key_press_event",
2707 G_CALLBACK (gtk_window_key_press_callback
), this);
2708 g_signal_connect (widget
, "key_release_event",
2709 G_CALLBACK (gtk_window_key_release_callback
), this);
2710 g_signal_connect (widget
, "button_press_event",
2711 G_CALLBACK (gtk_window_button_press_callback
), this);
2712 g_signal_connect (widget
, "button_release_event",
2713 G_CALLBACK (gtk_window_button_release_callback
), this);
2714 g_signal_connect (widget
, "motion_notify_event",
2715 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2716 g_signal_connect (widget
, "scroll_event",
2717 G_CALLBACK (window_scroll_event
), this);
2718 g_signal_connect (widget
, "popup_menu",
2719 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2720 g_signal_connect (widget
, "enter_notify_event",
2721 G_CALLBACK (gtk_window_enter_callback
), this);
2722 g_signal_connect (widget
, "leave_notify_event",
2723 G_CALLBACK (gtk_window_leave_callback
), this);
2726 bool wxWindowGTK::Destroy()
2728 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2732 return wxWindowBase::Destroy();
2735 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2737 // inform the parent to perform the move
2738 gtk_pizza_set_size( GTK_PIZZA(m_parent
->m_wxwindow
), m_widget
, x
, y
, width
, height
);
2742 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2744 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2745 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2748 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
2751 if (m_resizing
) return; /* I don't like recursions */
2754 int currentX
, currentY
;
2755 GetPosition(¤tX
, ¤tY
);
2756 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2758 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2760 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2762 // calculate the best size if we should auto size the window
2763 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2764 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2766 const wxSize sizeBest
= GetBestSize();
2767 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2769 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2770 height
= sizeBest
.y
;
2778 int minWidth
= GetMinWidth(),
2779 minHeight
= GetMinHeight(),
2780 maxWidth
= GetMaxWidth(),
2781 maxHeight
= GetMaxHeight();
2783 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
2784 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
2785 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
2786 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
2788 #if wxUSE_TOOLBAR_NATIVE
2789 if (wxDynamicCast(GetParent(), wxToolBar
))
2791 // don't take the x,y values, they're wrong because toolbar sets them
2792 GtkWidget
*widget
= GTK_WIDGET(m_widget
);
2793 gtk_widget_set_size_request (widget
, m_width
, m_height
);
2797 if (m_parent
->m_wxwindow
== NULL
) // i.e. wxNotebook
2799 // don't set the size for children of wxNotebook, just take the values.
2807 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
2808 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
2810 if (x
!= -1) m_x
= x
+ gtk_pizza_get_xoffset( pizza
);
2811 if (y
!= -1) m_y
= y
+ gtk_pizza_get_yoffset( pizza
);
2815 m_x
= x
+ gtk_pizza_get_xoffset( pizza
);
2816 m_y
= y
+ gtk_pizza_get_yoffset( pizza
);
2819 int left_border
= 0;
2820 int right_border
= 0;
2822 int bottom_border
= 0;
2824 /* the default button has a border around it */
2825 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
2827 GtkBorder
*default_border
= NULL
;
2828 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2831 left_border
+= default_border
->left
;
2832 right_border
+= default_border
->right
;
2833 top_border
+= default_border
->top
;
2834 bottom_border
+= default_border
->bottom
;
2835 g_free( default_border
);
2839 DoMoveWindow( m_x
-top_border
,
2841 m_width
+left_border
+right_border
,
2842 m_height
+top_border
+bottom_border
);
2847 /* Sometimes the client area changes size without the
2848 whole windows's size changing, but if the whole
2849 windows's size doesn't change, no wxSizeEvent will
2850 normally be sent. Here we add an extra test if
2851 the client test has been changed and this will
2853 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2857 wxPrintf( "OnSize sent from " );
2858 if (GetClassInfo() && GetClassInfo()->GetClassName())
2859 wxPrintf( GetClassInfo()->GetClassName() );
2860 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2863 if (!m_nativeSizeEvent
)
2865 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2866 event
.SetEventObject( this );
2867 GetEventHandler()->ProcessEvent( event
);
2873 bool wxWindowGTK::GtkShowFromOnIdle()
2875 if (IsShown() && m_showOnIdle
&& !GTK_WIDGET_VISIBLE (m_widget
))
2877 GtkAllocation alloc
;
2880 alloc
.width
= m_width
;
2881 alloc
.height
= m_height
;
2882 gtk_widget_size_allocate( m_widget
, &alloc
);
2883 gtk_widget_show( m_widget
);
2884 wxShowEvent
eventShow(GetId(), true);
2885 eventShow
.SetEventObject(this);
2886 GetEventHandler()->ProcessEvent(eventShow
);
2887 m_showOnIdle
= false;
2894 void wxWindowGTK::OnInternalIdle()
2896 // Check if we have to show window now
2897 if (GtkShowFromOnIdle()) return;
2899 if ( m_dirtyTabOrder
)
2901 m_dirtyTabOrder
= false;
2905 // Update style if the window was not yet realized
2906 // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
2907 if (m_needsStyleChange
)
2909 SetBackgroundStyle(GetBackgroundStyle());
2910 m_needsStyleChange
= false;
2913 wxCursor cursor
= m_cursor
;
2914 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
2918 /* I now set the cursor anew in every OnInternalIdle call
2919 as setting the cursor in a parent window also effects the
2920 windows above so that checking for the current cursor is
2925 GdkWindow
*window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2927 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2929 if (!g_globalCursor
.Ok())
2930 cursor
= *wxSTANDARD_CURSOR
;
2932 window
= m_widget
->window
;
2933 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
2934 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2937 else if ( m_widget
)
2939 GdkWindow
*window
= m_widget
->window
;
2940 if ( window
&& !GTK_WIDGET_NO_WINDOW(m_widget
) )
2941 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2945 if (wxUpdateUIEvent::CanUpdate(this))
2946 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
2949 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
2951 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2953 if (width
) (*width
) = m_width
;
2954 if (height
) (*height
) = m_height
;
2957 void wxWindowGTK::DoSetClientSize( int width
, int height
)
2959 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2968 GetScrollbarWidth(m_widget
, dw
, dh
);
2971 #ifndef __WXUNIVERSAL__
2972 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
2974 // shadow border size is 2
2978 if (HasFlag(wxSIMPLE_BORDER
))
2980 // simple border size is 1
2984 #endif // __WXUNIVERSAL__
2990 SetSize(width
, height
);
2993 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
2995 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3007 GetScrollbarWidth(m_widget
, dw
, dh
);
3010 #ifndef __WXUNIVERSAL__
3011 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
3013 // shadow border size is 2
3017 if (HasFlag(wxSIMPLE_BORDER
))
3019 // simple border size is 1
3023 #endif // __WXUNIVERSAL__
3033 if (width
) *width
= w
;
3034 if (height
) *height
= h
;
3037 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
3039 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3043 if (m_parent
&& m_parent
->m_wxwindow
)
3045 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
3046 dx
= gtk_pizza_get_xoffset( pizza
);
3047 dy
= gtk_pizza_get_yoffset( pizza
);
3050 if (x
) (*x
) = m_x
- dx
;
3051 if (y
) (*y
) = m_y
- dy
;
3054 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
3056 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3058 if (!m_widget
->window
) return;
3060 GdkWindow
*source
= (GdkWindow
*) NULL
;
3062 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3064 source
= m_widget
->window
;
3068 gdk_window_get_origin( source
, &org_x
, &org_y
);
3072 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3074 org_x
+= m_widget
->allocation
.x
;
3075 org_y
+= m_widget
->allocation
.y
;
3083 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
3085 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3087 if (!m_widget
->window
) return;
3089 GdkWindow
*source
= (GdkWindow
*) NULL
;
3091 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3093 source
= m_widget
->window
;
3097 gdk_window_get_origin( source
, &org_x
, &org_y
);
3101 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3103 org_x
+= m_widget
->allocation
.x
;
3104 org_y
+= m_widget
->allocation
.y
;
3112 bool wxWindowGTK::Show( bool show
)
3114 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3116 if (!wxWindowBase::Show(show
))
3126 gtk_widget_show( m_widget
);
3127 wxShowEvent
eventShow(GetId(), show
);
3128 eventShow
.SetEventObject(this);
3129 GetEventHandler()->ProcessEvent(eventShow
);
3134 gtk_widget_hide( m_widget
);
3135 wxShowEvent
eventShow(GetId(), show
);
3136 eventShow
.SetEventObject(this);
3137 GetEventHandler()->ProcessEvent(eventShow
);
3143 static void wxWindowNotifyEnable(wxWindowGTK
* win
, bool enable
)
3145 win
->OnParentEnable(enable
);
3147 // Recurse, so that children have the opportunity to Do The Right Thing
3148 // and reset colours that have been messed up by a parent's (really ancestor's)
3150 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
3152 node
= node
->GetNext() )
3154 wxWindow
*child
= node
->GetData();
3155 if (!child
->IsKindOf(CLASSINFO(wxDialog
)) && !child
->IsKindOf(CLASSINFO(wxFrame
)))
3156 wxWindowNotifyEnable(child
, enable
);
3160 bool wxWindowGTK::Enable( bool enable
)
3162 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3164 if (!wxWindowBase::Enable(enable
))
3170 gtk_widget_set_sensitive( m_widget
, enable
);
3172 gtk_widget_set_sensitive( m_wxwindow
, enable
);
3174 wxWindowNotifyEnable(this, enable
);
3179 int wxWindowGTK::GetCharHeight() const
3181 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
3183 wxFont font
= GetFont();
3184 wxCHECK_MSG( font
.Ok(), 12, wxT("invalid font") );
3186 PangoContext
*context
= NULL
;
3188 context
= gtk_widget_get_pango_context( m_widget
);
3193 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3194 PangoLayout
*layout
= pango_layout_new(context
);
3195 pango_layout_set_font_description(layout
, desc
);
3196 pango_layout_set_text(layout
, "H", 1);
3197 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3199 PangoRectangle rect
;
3200 pango_layout_line_get_extents(line
, NULL
, &rect
);
3202 g_object_unref (layout
);
3204 return (int) PANGO_PIXELS(rect
.height
);
3207 int wxWindowGTK::GetCharWidth() const
3209 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
3211 wxFont font
= GetFont();
3212 wxCHECK_MSG( font
.Ok(), 8, wxT("invalid font") );
3214 PangoContext
*context
= NULL
;
3216 context
= gtk_widget_get_pango_context( m_widget
);
3221 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3222 PangoLayout
*layout
= pango_layout_new(context
);
3223 pango_layout_set_font_description(layout
, desc
);
3224 pango_layout_set_text(layout
, "g", 1);
3225 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3227 PangoRectangle rect
;
3228 pango_layout_line_get_extents(line
, NULL
, &rect
);
3230 g_object_unref (layout
);
3232 return (int) PANGO_PIXELS(rect
.width
);
3235 void wxWindowGTK::GetTextExtent( const wxString
& string
,
3239 int *externalLeading
,
3240 const wxFont
*theFont
) const
3242 wxFont fontToUse
= theFont
? *theFont
: GetFont();
3244 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
3253 PangoContext
*context
= NULL
;
3255 context
= gtk_widget_get_pango_context( m_widget
);
3264 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3265 PangoLayout
*layout
= pango_layout_new(context
);
3266 pango_layout_set_font_description(layout
, desc
);
3268 const wxCharBuffer data
= wxGTK_CONV( string
);
3270 pango_layout_set_text(layout
, data
, strlen(data
));
3273 PangoRectangle rect
;
3274 pango_layout_get_extents(layout
, NULL
, &rect
);
3276 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
3277 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
3280 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
3281 int baseline
= pango_layout_iter_get_baseline(iter
);
3282 pango_layout_iter_free(iter
);
3283 *descent
= *y
- PANGO_PIXELS(baseline
);
3285 if (externalLeading
) (*externalLeading
) = 0; // ??
3287 g_object_unref (layout
);
3290 bool wxWindowGTK::GTKSetDelayedFocusIfNeeded()
3292 if ( g_delayedFocus
== this )
3294 if ( GTK_WIDGET_REALIZED(m_widget
) )
3296 gtk_widget_grab_focus(m_widget
);
3297 g_delayedFocus
= NULL
;
3306 void wxWindowGTK::SetFocus()
3308 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3311 // don't do anything if we already have focus
3317 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow
))
3319 gtk_widget_grab_focus (m_wxwindow
);
3324 if (GTK_IS_CONTAINER(m_widget
))
3326 gtk_widget_child_focus( m_widget
, GTK_DIR_TAB_FORWARD
);
3329 if (GTK_WIDGET_CAN_FOCUS(m_widget
) && !GTK_WIDGET_HAS_FOCUS (m_widget
) )
3332 if (!GTK_WIDGET_REALIZED(m_widget
))
3334 // we can't set the focus to the widget now so we remember that
3335 // it should be focused and will do it later, during the idle
3336 // time, as soon as we can
3337 wxLogTrace(TRACE_FOCUS
,
3338 _T("Delaying setting focus to %s(%s)"),
3339 GetClassInfo()->GetClassName(), GetLabel().c_str());
3341 g_delayedFocus
= this;
3345 wxLogTrace(TRACE_FOCUS
,
3346 _T("Setting focus to %s(%s)"),
3347 GetClassInfo()->GetClassName(), GetLabel().c_str());
3349 gtk_widget_grab_focus (m_widget
);
3354 wxLogTrace(TRACE_FOCUS
,
3355 _T("Can't set focus to %s(%s)"),
3356 GetClassInfo()->GetClassName(), GetLabel().c_str());
3361 bool wxWindowGTK::AcceptsFocus() const
3363 return m_acceptsFocus
&& wxWindowBase::AcceptsFocus();
3366 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3368 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3370 wxWindowGTK
*oldParent
= m_parent
,
3371 *newParent
= (wxWindowGTK
*)newParentBase
;
3373 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3375 if ( !wxWindowBase::Reparent(newParent
) )
3378 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3380 /* prevent GTK from deleting the widget arbitrarily */
3381 gtk_widget_ref( m_widget
);
3385 gtk_container_remove( GTK_CONTAINER(m_widget
->parent
), m_widget
);
3388 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3392 if (GTK_WIDGET_VISIBLE (newParent
->m_widget
))
3394 m_showOnIdle
= true;
3395 gtk_widget_hide( m_widget
);
3398 /* insert GTK representation */
3399 (*(newParent
->m_insertCallback
))(newParent
, this);
3402 /* reverse: prevent GTK from deleting the widget arbitrarily */
3403 gtk_widget_unref( m_widget
);
3405 SetLayoutDirection(wxLayout_Default
);
3410 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3412 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3414 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3416 wxASSERT_MSG( (m_insertCallback
!= NULL
), wxT("invalid child insertion function") );
3421 /* insert GTK representation */
3422 (*m_insertCallback
)(this, child
);
3425 void wxWindowGTK::AddChild(wxWindowBase
*child
)
3427 wxWindowBase::AddChild(child
);
3428 m_dirtyTabOrder
= true;
3430 wxapp_install_idle_handler();
3433 void wxWindowGTK::RemoveChild(wxWindowBase
*child
)
3435 wxWindowBase::RemoveChild(child
);
3436 m_dirtyTabOrder
= true;
3438 wxapp_install_idle_handler();
3442 wxLayoutDirection
wxWindowGTK::GTKGetLayout(GtkWidget
*widget
)
3444 return gtk_widget_get_direction(GTK_WIDGET(widget
)) == GTK_TEXT_DIR_RTL
3445 ? wxLayout_RightToLeft
3446 : wxLayout_LeftToRight
;
3450 void wxWindowGTK::GTKSetLayout(GtkWidget
*widget
, wxLayoutDirection dir
)
3452 wxASSERT_MSG( dir
!= wxLayout_Default
, _T("invalid layout direction") );
3454 gtk_widget_set_direction(GTK_WIDGET(widget
),
3455 dir
== wxLayout_RightToLeft
? GTK_TEXT_DIR_RTL
3456 : GTK_TEXT_DIR_LTR
);
3459 wxLayoutDirection
wxWindowGTK::GetLayoutDirection() const
3461 return GTKGetLayout(m_widget
);
3464 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir
)
3466 if ( dir
== wxLayout_Default
)
3468 const wxWindow
*const parent
= GetParent();
3471 // inherit layout from parent.
3472 dir
= parent
->GetLayoutDirection();
3474 else // no parent, use global default layout
3476 dir
= wxTheApp
->GetLayoutDirection();
3480 if ( dir
== wxLayout_Default
)
3483 GTKSetLayout(m_widget
, dir
);
3486 GTKSetLayout(m_wxwindow
, dir
);
3490 wxWindowGTK::AdjustForLayoutDirection(wxCoord x
,
3491 wxCoord
WXUNUSED(width
),
3492 wxCoord
WXUNUSED(widthTotal
)) const
3494 // We now mirrors the coordinates of RTL windows in GtkPizza
3498 void wxWindowGTK::DoMoveInTabOrder(wxWindow
*win
, MoveKind move
)
3500 wxWindowBase::DoMoveInTabOrder(win
, move
);
3501 m_dirtyTabOrder
= true;
3503 wxapp_install_idle_handler();
3506 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3508 // none needed by default
3512 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3514 // nothing to do by default since none is needed
3517 void wxWindowGTK::RealizeTabOrder()
3521 if ( !m_children
.empty() )
3523 // we don't only construct the correct focus chain but also use
3524 // this opportunity to update the mnemonic widgets for the widgets
3527 GList
*chain
= NULL
;
3528 wxWindowGTK
* mnemonicWindow
= NULL
;
3530 for ( wxWindowList::const_iterator i
= m_children
.begin();
3531 i
!= m_children
.end();
3534 wxWindowGTK
*win
= *i
;
3536 if ( mnemonicWindow
)
3538 if ( win
->AcceptsFocusFromKeyboard() )
3540 // wxComboBox et al. needs to focus on on a different
3541 // widget than m_widget, so if the main widget isn't
3542 // focusable try the connect widget
3543 GtkWidget
* w
= win
->m_widget
;
3544 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3546 w
= win
->GetConnectWidget();
3547 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3553 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3554 mnemonicWindow
= NULL
;
3558 else if ( win
->GTKWidgetNeedsMnemonic() )
3560 mnemonicWindow
= win
;
3563 chain
= g_list_prepend(chain
, win
->m_widget
);
3566 chain
= g_list_reverse(chain
);
3568 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3573 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3578 void wxWindowGTK::Raise()
3580 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3582 if (m_wxwindow
&& m_wxwindow
->window
)
3584 gdk_window_raise( m_wxwindow
->window
);
3586 else if (m_widget
->window
)
3588 gdk_window_raise( m_widget
->window
);
3592 void wxWindowGTK::Lower()
3594 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3596 if (m_wxwindow
&& m_wxwindow
->window
)
3598 gdk_window_lower( m_wxwindow
->window
);
3600 else if (m_widget
->window
)
3602 gdk_window_lower( m_widget
->window
);
3606 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3608 if ( !wxWindowBase::SetCursor(cursor
.Ok() ? cursor
: *wxSTANDARD_CURSOR
) )
3616 void wxWindowGTK::GTKUpdateCursor()
3618 wxCursor
cursor(g_globalCursor
.Ok() ? g_globalCursor
: GetCursor());
3621 wxArrayGdkWindows windowsThis
;
3622 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
3625 gdk_window_set_cursor(winThis
, cursor
.GetCursor());
3629 const size_t count
= windowsThis
.size();
3630 for ( size_t n
= 0; n
< count
; n
++ )
3632 GdkWindow
*win
= windowsThis
[n
];
3635 wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?"));
3639 gdk_window_set_cursor(win
, cursor
.GetCursor());
3645 void wxWindowGTK::WarpPointer( int x
, int y
)
3647 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3649 // We provide this function ourselves as it is
3650 // missing in GDK (top of this file).
3652 GdkWindow
*window
= (GdkWindow
*) NULL
;
3654 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3656 window
= GetConnectWidget()->window
;
3659 gdk_window_warp_pointer( window
, x
, y
);
3662 wxWindowGTK::ScrollDir
wxWindowGTK::ScrollDirFromRange(GtkRange
*range
) const
3664 // find the scrollbar which generated the event
3665 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3667 if ( range
== m_scrollBar
[dir
] )
3668 return (ScrollDir
)dir
;
3671 wxFAIL_MSG( _T("event from unknown scrollbar received") );
3673 return ScrollDir_Max
;
3676 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3678 bool changed
= false;
3679 GtkRange
* range
= m_scrollBar
[dir
];
3680 if ( range
&& units
)
3682 GtkAdjustment
* adj
= range
->adjustment
;
3683 gdouble inc
= unit
== ScrollUnit_Line
? adj
->step_increment
3684 : adj
->page_increment
;
3686 const int posOld
= int(adj
->value
+ 0.5);
3687 gtk_range_set_value(range
, posOld
+ units
*inc
);
3689 changed
= int(adj
->value
+ 0.5) != posOld
;
3695 bool wxWindowGTK::ScrollLines(int lines
)
3697 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3700 bool wxWindowGTK::ScrollPages(int pages
)
3702 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3705 void wxWindowGTK::Refresh( bool eraseBackground
, const wxRect
*rect
)
3709 if (!m_widget
->window
)
3714 if (!GTK_PIZZA(m_wxwindow
)->bin_window
) return;
3716 GdkRectangle gdk_rect
,
3720 gdk_rect
.x
= rect
->x
;
3721 gdk_rect
.y
= rect
->y
;
3722 gdk_rect
.width
= rect
->width
;
3723 gdk_rect
.height
= rect
->height
;
3726 else // invalidate everything
3731 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, p
, TRUE
);
3735 void wxWindowGTK::Update()
3739 // when we call Update() we really want to update the window immediately on
3740 // screen, even if it means flushing the entire queue and hence slowing down
3741 // everything -- but it should still be done, it's just that Update() should
3742 // be called very rarely
3746 void wxWindowGTK::GtkUpdate()
3748 if (m_wxwindow
&& GTK_PIZZA(m_wxwindow
)->bin_window
)
3749 gdk_window_process_updates( GTK_PIZZA(m_wxwindow
)->bin_window
, FALSE
);
3750 if (m_widget
&& m_widget
->window
)
3751 gdk_window_process_updates( m_widget
->window
, FALSE
);
3753 // for consistency with other platforms (and also because it's convenient
3754 // to be able to update an entire TLW by calling Update() only once), we
3755 // should also update all our children here
3756 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3758 node
= node
->GetNext() )
3760 node
->GetData()->GtkUpdate();
3764 void wxWindowGTK::GtkSendPaintEvents()
3768 m_updateRegion
.Clear();
3772 // Clip to paint region in wxClientDC
3773 m_clipPaintRegion
= true;
3775 // widget to draw on
3776 GtkPizza
*pizza
= GTK_PIZZA (m_wxwindow
);
3778 if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM
))
3780 // find ancestor from which to steal background
3781 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3783 parent
= (wxWindow
*)this;
3785 if (GTK_WIDGET_MAPPED(parent
->m_widget
))
3787 wxRegionIterator
upd( m_updateRegion
);
3791 rect
.x
= upd
.GetX();
3792 rect
.y
= upd
.GetY();
3793 rect
.width
= upd
.GetWidth();
3794 rect
.height
= upd
.GetHeight();
3796 gtk_paint_flat_box( parent
->m_widget
->style
,
3798 (GtkStateType
)GTK_WIDGET_STATE(m_wxwindow
),
3812 wxWindowDC
dc( (wxWindow
*)this );
3813 dc
.SetClippingRegion( m_updateRegion
);
3815 wxEraseEvent
erase_event( GetId(), &dc
);
3816 erase_event
.SetEventObject( this );
3818 GetEventHandler()->ProcessEvent(erase_event
);
3821 wxNcPaintEvent
nc_paint_event( GetId() );
3822 nc_paint_event
.SetEventObject( this );
3823 GetEventHandler()->ProcessEvent( nc_paint_event
);
3825 wxPaintEvent
paint_event( GetId() );
3826 paint_event
.SetEventObject( this );
3827 GetEventHandler()->ProcessEvent( paint_event
);
3829 m_clipPaintRegion
= false;
3831 m_updateRegion
.Clear();
3834 void wxWindowGTK::SetDoubleBuffered( bool on
)
3836 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3839 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3842 void wxWindowGTK::ClearBackground()
3844 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3848 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3850 wxWindowBase::DoSetToolTip(tip
);
3853 m_tooltip
->Apply( (wxWindow
*)this );
3856 void wxWindowGTK::ApplyToolTip( GtkTooltips
*tips
, const wxChar
*tip
)
3858 wxString
tmp( tip
);
3859 gtk_tooltips_set_tip( tips
, GetConnectWidget(), wxGTK_CONV(tmp
), (gchar
*) NULL
);
3861 #endif // wxUSE_TOOLTIPS
3863 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
3865 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3867 if (!wxWindowBase::SetBackgroundColour(colour
))
3872 // We need the pixel value e.g. for background clearing.
3873 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3876 // apply style change (forceStyle=true so that new style is applied
3877 // even if the bg colour changed from valid to wxNullColour)
3878 if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM
)
3879 ApplyWidgetStyle(true);
3884 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
3886 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3888 if (!wxWindowBase::SetForegroundColour(colour
))
3895 // We need the pixel value e.g. for background clearing.
3896 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3899 // apply style change (forceStyle=true so that new style is applied
3900 // even if the bg colour changed from valid to wxNullColour):
3901 ApplyWidgetStyle(true);
3906 PangoContext
*wxWindowGTK::GtkGetPangoDefaultContext()
3908 return gtk_widget_get_pango_context( m_widget
);
3911 GtkRcStyle
*wxWindowGTK::CreateWidgetStyle(bool forceStyle
)
3913 // do we need to apply any changes at all?
3916 !m_foregroundColour
.Ok() && !m_backgroundColour
.Ok() )
3921 GtkRcStyle
*style
= gtk_rc_style_new();
3926 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
3929 if ( m_foregroundColour
.Ok() )
3931 const GdkColor
*fg
= m_foregroundColour
.GetColor();
3933 style
->fg
[GTK_STATE_NORMAL
] = *fg
;
3934 style
->color_flags
[GTK_STATE_NORMAL
] = GTK_RC_FG
;
3936 style
->fg
[GTK_STATE_PRELIGHT
] = *fg
;
3937 style
->color_flags
[GTK_STATE_PRELIGHT
] = GTK_RC_FG
;
3939 style
->fg
[GTK_STATE_ACTIVE
] = *fg
;
3940 style
->color_flags
[GTK_STATE_ACTIVE
] = GTK_RC_FG
;
3943 if ( m_backgroundColour
.Ok() )
3945 const GdkColor
*bg
= m_backgroundColour
.GetColor();
3947 style
->bg
[GTK_STATE_NORMAL
] = *bg
;
3948 style
->base
[GTK_STATE_NORMAL
] = *bg
;
3949 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)
3950 (style
->color_flags
[GTK_STATE_NORMAL
] | GTK_RC_BG
| GTK_RC_BASE
);
3952 style
->bg
[GTK_STATE_PRELIGHT
] = *bg
;
3953 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
3954 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)
3955 (style
->color_flags
[GTK_STATE_PRELIGHT
] | GTK_RC_BG
| GTK_RC_BASE
);
3957 style
->bg
[GTK_STATE_ACTIVE
] = *bg
;
3958 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
3959 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)
3960 (style
->color_flags
[GTK_STATE_ACTIVE
] | GTK_RC_BG
| GTK_RC_BASE
);
3962 style
->bg
[GTK_STATE_INSENSITIVE
] = *bg
;
3963 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
3964 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)
3965 (style
->color_flags
[GTK_STATE_INSENSITIVE
] | GTK_RC_BG
| GTK_RC_BASE
);
3971 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle
)
3973 GtkRcStyle
*style
= CreateWidgetStyle(forceStyle
);
3976 DoApplyWidgetStyle(style
);
3977 gtk_rc_style_unref(style
);
3980 // Style change may affect GTK+'s size calculation:
3981 InvalidateBestSize();
3984 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
3987 gtk_widget_modify_style(m_wxwindow
, style
);
3989 gtk_widget_modify_style(m_widget
, style
);
3992 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style
)
3994 wxWindowBase::SetBackgroundStyle(style
);
3996 if (style
== wxBG_STYLE_CUSTOM
)
3998 GdkWindow
*window
= (GdkWindow
*) NULL
;
4000 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4002 window
= GetConnectWidget()->window
;
4006 // Make sure GDK/X11 doesn't refresh the window
4008 gdk_window_set_back_pixmap( window
, None
, False
);
4010 Display
* display
= GDK_WINDOW_DISPLAY(window
);
4013 m_needsStyleChange
= false;
4016 // Do in OnIdle, because the window is not yet available
4017 m_needsStyleChange
= true;
4019 // Don't apply widget style, or we get a grey background
4023 // apply style change (forceStyle=true so that new style is applied
4024 // even if the bg colour changed from valid to wxNullColour):
4025 ApplyWidgetStyle(true);
4030 #if wxUSE_DRAG_AND_DROP
4032 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4034 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4036 GtkWidget
*dnd_widget
= GetConnectWidget();
4038 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
4040 if (m_dropTarget
) delete m_dropTarget
;
4041 m_dropTarget
= dropTarget
;
4043 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
4046 #endif // wxUSE_DRAG_AND_DROP
4048 GtkWidget
* wxWindowGTK::GetConnectWidget()
4050 GtkWidget
*connect_widget
= m_widget
;
4051 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4053 return connect_widget
;
4056 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow
*window
) const
4058 wxArrayGdkWindows windowsThis
;
4059 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
4061 return winThis
? window
== winThis
4062 : windowsThis
.Index(window
) != wxNOT_FOUND
;
4065 GdkWindow
*wxWindowGTK::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
4067 return m_wxwindow
? GTK_PIZZA(m_wxwindow
)->bin_window
: m_widget
->window
;
4070 bool wxWindowGTK::SetFont( const wxFont
&font
)
4072 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4074 if (!wxWindowBase::SetFont(font
))
4077 // apply style change (forceStyle=true so that new style is applied
4078 // even if the font changed from valid to wxNullFont):
4079 ApplyWidgetStyle(true);
4084 void wxWindowGTK::DoCaptureMouse()
4086 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4088 GdkWindow
*window
= (GdkWindow
*) NULL
;
4090 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4092 window
= GetConnectWidget()->window
;
4094 wxCHECK_RET( window
, _T("CaptureMouse() failed") );
4096 const wxCursor
* cursor
= &m_cursor
;
4098 cursor
= wxSTANDARD_CURSOR
;
4100 gdk_pointer_grab( window
, FALSE
,
4102 (GDK_BUTTON_PRESS_MASK
|
4103 GDK_BUTTON_RELEASE_MASK
|
4104 GDK_POINTER_MOTION_HINT_MASK
|
4105 GDK_POINTER_MOTION_MASK
),
4107 cursor
->GetCursor(),
4108 (guint32
)GDK_CURRENT_TIME
);
4109 g_captureWindow
= this;
4110 g_captureWindowHasMouse
= true;
4113 void wxWindowGTK::DoReleaseMouse()
4115 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4117 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4119 g_captureWindow
= (wxWindowGTK
*) NULL
;
4121 GdkWindow
*window
= (GdkWindow
*) NULL
;
4123 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4125 window
= GetConnectWidget()->window
;
4130 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4134 wxWindow
*wxWindowBase::GetCapture()
4136 return (wxWindow
*)g_captureWindow
;
4139 bool wxWindowGTK::IsRetained() const
4144 void wxWindowGTK::BlockScrollEvent()
4146 wxASSERT(!m_blockScrollEvent
);
4147 m_blockScrollEvent
= true;
4150 void wxWindowGTK::UnblockScrollEvent()
4152 wxASSERT(m_blockScrollEvent
);
4153 m_blockScrollEvent
= false;
4156 void wxWindowGTK::SetScrollbar(int orient
,
4160 bool WXUNUSED(update
))
4162 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4163 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4167 m_hasScrolling
= true;
4171 // GtkRange requires upper > lower
4176 if (pos
> range
- thumbVisible
)
4177 pos
= range
- thumbVisible
;
4180 GtkAdjustment
* adj
= m_scrollBar
[ScrollDirFromOrient(orient
)]->adjustment
;
4181 adj
->step_increment
= 1;
4182 adj
->page_increment
=
4183 adj
->page_size
= thumbVisible
;
4185 SetScrollPos(orient
, pos
);
4186 gtk_adjustment_changed(adj
);
4189 void wxWindowGTK::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4191 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4192 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4194 // This check is more than an optimization. Without it, the slider
4195 // will not move smoothly while tracking when using wxScrollHelper.
4196 if (GetScrollPos(orient
) != pos
)
4198 const int dir
= ScrollDirFromOrient(orient
);
4199 GtkAdjustment
* adj
= m_scrollBar
[dir
]->adjustment
;
4200 const int max
= int(adj
->upper
- adj
->page_size
);
4207 // If a "value_changed" signal emission is not already in progress
4208 if (!m_blockValueChanged
[dir
])
4210 gtk_adjustment_value_changed(adj
);
4215 int wxWindowGTK::GetScrollThumb(int orient
) const
4217 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4218 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4220 return int(m_scrollBar
[ScrollDirFromOrient(orient
)]->adjustment
->page_size
);
4223 int wxWindowGTK::GetScrollPos( int orient
) const
4225 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4226 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4228 return int(m_scrollBar
[ScrollDirFromOrient(orient
)]->adjustment
->value
+ 0.5);
4231 int wxWindowGTK::GetScrollRange( int orient
) const
4233 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4234 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4236 return int(m_scrollBar
[ScrollDirFromOrient(orient
)]->adjustment
->upper
);
4239 // Determine if increment is the same as +/-x, allowing for some small
4240 // difference due to possible inexactness in floating point arithmetic
4241 static inline bool IsScrollIncrement(double increment
, double x
)
4243 wxASSERT(increment
> 0);
4244 const double tolerance
= 1.0 / 1024;
4245 return fabs(increment
- fabs(x
)) < tolerance
;
4248 wxEventType
wxWindowGTK::GetScrollEventType(GtkRange
* range
)
4253 wxapp_install_idle_handler();
4255 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4257 const int barIndex
= range
== m_scrollBar
[1];
4258 GtkAdjustment
* adj
= range
->adjustment
;
4259 const int value
= int(adj
->value
+ 0.5);
4260 // save previous position
4261 const double oldPos
= m_scrollPos
[barIndex
];
4262 // update current position
4263 m_scrollPos
[barIndex
] = adj
->value
;
4264 // If event should be ignored, or integral position has not changed
4265 if (!m_hasVMT
|| g_blockEventsOnDrag
|| value
== int(oldPos
+ 0.5))
4270 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4273 // Difference from last change event
4274 const double diff
= adj
->value
- oldPos
;
4275 const bool isDown
= diff
> 0;
4277 if (IsScrollIncrement(adj
->step_increment
, diff
))
4279 eventType
= isDown
? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4281 else if (IsScrollIncrement(adj
->page_increment
, diff
))
4283 eventType
= isDown
? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4285 else if (m_mouseButtonDown
)
4287 // Assume track event
4288 m_isScrolling
= true;
4294 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4296 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4298 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4300 // No scrolling requested.
4301 if ((dx
== 0) && (dy
== 0)) return;
4303 m_clipPaintRegion
= true;
4305 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), -dx
, -dy
);
4307 m_clipPaintRegion
= false;
4310 void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4312 //RN: Note that static controls usually have no border on gtk, so maybe
4313 //it makes sense to treat that as simply no border at the wx level
4315 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4317 GtkShadowType gtkstyle
;
4319 if(wxstyle
& wxBORDER_RAISED
)
4320 gtkstyle
= GTK_SHADOW_OUT
;
4321 else if (wxstyle
& wxBORDER_SUNKEN
)
4322 gtkstyle
= GTK_SHADOW_IN
;
4323 else if (wxstyle
& wxBORDER_DOUBLE
)
4324 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4326 gtkstyle
= GTK_SHADOW_IN
;
4328 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4333 void wxWindowGTK::SetWindowStyleFlag( long style
)
4335 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4336 wxWindowBase::SetWindowStyleFlag(style
);
4339 // Find the wxWindow at the current mouse position, also returning the mouse
4341 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4343 pt
= wxGetMousePosition();
4344 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4348 // Get the current mouse position.
4349 wxPoint
wxGetMousePosition()
4351 /* This crashes when used within wxHelpContext,
4352 so we have to use the X-specific implementation below.
4354 GdkModifierType *mask;
4355 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4357 return wxPoint(x, y);
4361 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4363 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4364 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4365 Window rootReturn
, childReturn
;
4366 int rootX
, rootY
, winX
, winY
;
4367 unsigned int maskReturn
;
4369 XQueryPointer (display
,
4373 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4374 return wxPoint(rootX
, rootY
);
4378 // Needed for implementing e.g. combobox on wxGTK within a modal dialog.
4379 void wxAddGrab(wxWindow
* window
)
4381 gtk_grab_add( (GtkWidget
*) window
->GetHandle() );
4384 void wxRemoveGrab(wxWindow
* window
)
4386 gtk_grab_remove( (GtkWidget
*) window
->GetHandle() );