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
+= pizza
->xoffset
;
1334 yy
+= pizza
->yoffset
;
1337 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
1340 wxWindowGTK
*child
= node
->GetData();
1342 node
= node
->GetNext();
1343 if (!child
->IsShown())
1346 if (child
->IsTransparentForMouse())
1348 // wxStaticBox is transparent in the box itself
1349 int xx1
= child
->m_x
;
1350 int yy1
= child
->m_y
;
1351 int xx2
= child
->m_x
+ child
->m_width
;
1352 int yy2
= child
->m_y
+ child
->m_height
;
1355 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1357 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1359 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1361 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1372 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1373 (child
->m_x
<= xx
) &&
1374 (child
->m_y
<= yy
) &&
1375 (child
->m_x
+child
->m_width
>= xx
) &&
1376 (child
->m_y
+child
->m_height
>= yy
))
1389 // ----------------------------------------------------------------------------
1390 // common event handlers helpers
1391 // ----------------------------------------------------------------------------
1393 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
*WXUNUSED(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 win
->m_oldClientWidth
= client_width
;
2131 win
->m_oldClientHeight
= client_height
;
2133 if (!win
->m_nativeSizeEvent
)
2135 wxSizeEvent
event( win
->GetSize(), win
->GetId() );
2136 event
.SetEventObject( win
);
2137 win
->GTKProcessEvent( event
);
2143 #define WXUNUSED_UNLESS_XIM(param) param
2145 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2148 /* Resize XIM window */
2150 void gtk_wxwindow_size_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2151 GtkAllocation
* WXUNUSED_UNLESS_XIM(alloc
),
2152 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2155 wxapp_install_idle_handler();
2161 if (gdk_ic_get_style (win
->m_ic
) & GDK_IM_PREEDIT_POSITION
)
2165 gdk_drawable_get_size (widget
->window
, &width
, &height
);
2166 win
->m_icattr
->preedit_area
.width
= width
;
2167 win
->m_icattr
->preedit_area
.height
= height
;
2168 gdk_ic_set_attr (win
->m_ic
, win
->m_icattr
, GDK_IC_PREEDIT_AREA
);
2173 //-----------------------------------------------------------------------------
2174 // "realize" from m_wxwindow
2175 //-----------------------------------------------------------------------------
2177 /* Initialize XIM support */
2180 gtk_wxwindow_realized_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2181 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2184 wxapp_install_idle_handler();
2187 if (win
->m_ic
) return;
2188 if (!widget
) return;
2189 if (!gdk_im_ready()) return;
2191 win
->m_icattr
= gdk_ic_attr_new();
2192 if (!win
->m_icattr
) return;
2196 GdkColormap
*colormap
;
2197 GdkICAttr
*attr
= win
->m_icattr
;
2198 unsigned attrmask
= GDK_IC_ALL_REQ
;
2200 GdkIMStyle supported_style
= (GdkIMStyle
)
2201 (GDK_IM_PREEDIT_NONE
|
2202 GDK_IM_PREEDIT_NOTHING
|
2203 GDK_IM_PREEDIT_POSITION
|
2204 GDK_IM_STATUS_NONE
|
2205 GDK_IM_STATUS_NOTHING
);
2207 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2208 supported_style
= (GdkIMStyle
)(supported_style
& ~GDK_IM_PREEDIT_POSITION
);
2210 attr
->style
= style
= gdk_im_decide_style (supported_style
);
2211 attr
->client_window
= widget
->window
;
2213 if ((colormap
= gtk_widget_get_colormap (widget
)) !=
2214 gtk_widget_get_default_colormap ())
2216 attrmask
|= GDK_IC_PREEDIT_COLORMAP
;
2217 attr
->preedit_colormap
= colormap
;
2220 attrmask
|= GDK_IC_PREEDIT_FOREGROUND
;
2221 attrmask
|= GDK_IC_PREEDIT_BACKGROUND
;
2222 attr
->preedit_foreground
= widget
->style
->fg
[GTK_STATE_NORMAL
];
2223 attr
->preedit_background
= widget
->style
->base
[GTK_STATE_NORMAL
];
2225 switch (style
& GDK_IM_PREEDIT_MASK
)
2227 case GDK_IM_PREEDIT_POSITION
:
2228 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2230 g_warning ("over-the-spot style requires fontset");
2234 gdk_drawable_get_size (widget
->window
, &width
, &height
);
2236 attrmask
|= GDK_IC_PREEDIT_POSITION_REQ
;
2237 attr
->spot_location
.x
= 0;
2238 attr
->spot_location
.y
= height
;
2239 attr
->preedit_area
.x
= 0;
2240 attr
->preedit_area
.y
= 0;
2241 attr
->preedit_area
.width
= width
;
2242 attr
->preedit_area
.height
= height
;
2243 attr
->preedit_fontset
= widget
->style
->font
;
2248 win
->m_ic
= gdk_ic_new (attr
, (GdkICAttributesType
)attrmask
);
2250 if (win
->m_ic
== NULL
)
2251 g_warning ("Can't create input context.");
2254 mask
= gdk_window_get_events (widget
->window
);
2255 mask
= (GdkEventMask
)(mask
| gdk_ic_get_events (win
->m_ic
));
2256 gdk_window_set_events (widget
->window
, mask
);
2258 if (GTK_WIDGET_HAS_FOCUS(widget
))
2259 gdk_im_begin (win
->m_ic
, widget
->window
);
2266 // ----------------------------------------------------------------------------
2267 // this wxWindowBase function is implemented here (in platform-specific file)
2268 // because it is static and so couldn't be made virtual
2269 // ----------------------------------------------------------------------------
2271 wxWindow
*wxWindowBase::DoFindFocus()
2273 // the cast is necessary when we compile in wxUniversal mode
2274 return (wxWindow
*)g_focusWindow
;
2277 //-----------------------------------------------------------------------------
2278 // InsertChild for wxWindowGTK.
2279 //-----------------------------------------------------------------------------
2281 /* Callback for wxWindowGTK. This very strange beast has to be used because
2282 * C++ has no virtual methods in a constructor. We have to emulate a
2283 * virtual function here as wxNotebook requires a different way to insert
2284 * a child in it. I had opted for creating a wxNotebookPage window class
2285 * which would have made this superfluous (such in the MDI window system),
2286 * but no-one was listening to me... */
2288 static void wxInsertChildInWindow( wxWindowGTK
* parent
, wxWindowGTK
* child
)
2290 /* the window might have been scrolled already, do we
2291 have to adapt the position */
2292 GtkPizza
*pizza
= GTK_PIZZA(parent
->m_wxwindow
);
2293 child
->m_x
+= pizza
->xoffset
;
2294 child
->m_y
+= pizza
->yoffset
;
2296 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
2297 GTK_WIDGET(child
->m_widget
),
2304 //-----------------------------------------------------------------------------
2306 //-----------------------------------------------------------------------------
2308 wxWindow
*wxGetActiveWindow()
2310 return wxWindow::FindFocus();
2314 wxMouseState
wxGetMouseState()
2320 GdkModifierType mask
;
2322 gdk_window_get_pointer(NULL
, &x
, &y
, &mask
);
2326 ms
.SetLeftDown(mask
& GDK_BUTTON1_MASK
);
2327 ms
.SetMiddleDown(mask
& GDK_BUTTON2_MASK
);
2328 ms
.SetRightDown(mask
& GDK_BUTTON3_MASK
);
2330 ms
.SetControlDown(mask
& GDK_CONTROL_MASK
);
2331 ms
.SetShiftDown(mask
& GDK_SHIFT_MASK
);
2332 ms
.SetAltDown(mask
& GDK_MOD1_MASK
);
2333 ms
.SetMetaDown(mask
& GDK_MOD2_MASK
);
2338 //-----------------------------------------------------------------------------
2340 //-----------------------------------------------------------------------------
2342 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2344 #ifdef __WXUNIVERSAL__
2345 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2347 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
2348 #endif // __WXUNIVERSAL__/__WXGTK__
2350 void wxWindowGTK::Init()
2353 m_widget
= (GtkWidget
*) NULL
;
2354 m_wxwindow
= (GtkWidget
*) NULL
;
2355 m_focusWidget
= (GtkWidget
*) NULL
;
2365 m_needParent
= true;
2366 m_isBeingDeleted
= false;
2368 m_showOnIdle
= false;
2371 m_nativeSizeEvent
= false;
2373 m_hasScrolling
= false;
2374 m_isScrolling
= false;
2375 m_mouseButtonDown
= false;
2376 m_blockScrollEvent
= false;
2378 // initialize scrolling stuff
2379 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2381 m_scrollBar
[dir
] = NULL
;
2382 m_scrollPos
[dir
] = 0;
2383 m_blockValueChanged
[dir
] = false;
2387 m_oldClientHeight
= 0;
2391 m_insertCallback
= (wxInsertChildFunction
) NULL
;
2393 m_acceptsFocus
= false;
2396 m_clipPaintRegion
= false;
2398 m_needsStyleChange
= false;
2400 m_cursor
= *wxSTANDARD_CURSOR
;
2403 m_dirtyTabOrder
= false;
2406 wxWindowGTK::wxWindowGTK()
2411 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2416 const wxString
&name
)
2420 Create( parent
, id
, pos
, size
, style
, name
);
2423 bool wxWindowGTK::Create( wxWindow
*parent
,
2428 const wxString
&name
)
2430 if (!PreCreation( parent
, pos
, size
) ||
2431 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2433 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2437 m_insertCallback
= wxInsertChildInWindow
;
2439 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
2440 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
2442 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2444 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2445 scroll_class
->scrollbar_spacing
= 0;
2447 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2449 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(scrolledWindow
->hscrollbar
);
2450 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(scrolledWindow
->vscrollbar
);
2452 m_wxwindow
= gtk_pizza_new();
2454 #ifndef __WXUNIVERSAL__
2455 GtkPizza
*pizza
= GTK_PIZZA(m_wxwindow
);
2457 if (HasFlag(wxRAISED_BORDER
))
2459 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_OUT
);
2461 else if (HasFlag(wxSUNKEN_BORDER
))
2463 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_IN
);
2465 else if (HasFlag(wxSIMPLE_BORDER
))
2467 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_THIN
);
2471 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_NONE
);
2473 #endif // __WXUNIVERSAL__
2475 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2477 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
2478 m_acceptsFocus
= true;
2480 // connect various scroll-related events
2481 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2483 // these handlers block mouse events to any window during scrolling
2484 // such as motion events and prevent GTK and wxWidgets from fighting
2485 // over where the slider should be
2486 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2487 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2488 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2489 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2491 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2492 G_CALLBACK(gtk_scrollbar_event_after
), this);
2493 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2495 // these handlers get notified when scrollbar slider moves
2496 g_signal_connect(m_scrollBar
[dir
], "value_changed",
2497 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2500 gtk_widget_show( m_wxwindow
);
2503 m_parent
->DoAddChild( this );
2505 m_focusWidget
= m_wxwindow
;
2512 wxWindowGTK::~wxWindowGTK()
2516 if (g_focusWindow
== this)
2517 g_focusWindow
= NULL
;
2519 if ( g_delayedFocus
== this )
2520 g_delayedFocus
= NULL
;
2522 m_isBeingDeleted
= true;
2525 // destroy children before destroying this window itself
2528 // unhook focus handlers to prevent stray events being
2529 // propagated to this (soon to be) dead object
2530 if (m_focusWidget
!= NULL
)
2532 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2533 (gpointer
) gtk_window_focus_in_callback
,
2535 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2536 (gpointer
) gtk_window_focus_out_callback
,
2545 gdk_ic_destroy (m_ic
);
2547 gdk_ic_attr_destroy (m_icattr
);
2550 // delete before the widgets to avoid a crash on solaris
2555 gtk_widget_destroy( m_wxwindow
);
2556 m_wxwindow
= (GtkWidget
*) NULL
;
2561 gtk_widget_destroy( m_widget
);
2562 m_widget
= (GtkWidget
*) NULL
;
2566 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2568 wxCHECK_MSG( !m_needParent
|| parent
, false, wxT("Need complete parent.") );
2570 // Use either the given size, or the default if -1 is given.
2571 // See wxWindowBase for these functions.
2572 m_width
= WidthDefault(size
.x
) ;
2573 m_height
= HeightDefault(size
.y
);
2581 void wxWindowGTK::PostCreation()
2583 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2589 // these get reported to wxWidgets -> wxPaintEvent
2591 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow
), TRUE
);
2593 g_signal_connect (m_wxwindow
, "expose_event",
2594 G_CALLBACK (gtk_window_expose_callback
), this);
2596 gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow
), HasFlag( wxFULL_REPAINT_ON_RESIZE
) );
2599 // Create input method handler
2600 m_imData
= new wxGtkIMData
;
2602 // Cannot handle drawing preedited text yet
2603 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2605 g_signal_connect (m_imData
->context
, "commit",
2606 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2608 // these are called when the "sunken" or "raised" borders are drawn
2609 g_signal_connect (m_widget
, "expose_event",
2610 G_CALLBACK (gtk_window_own_expose_callback
), this);
2615 if (!GTK_IS_WINDOW(m_widget
))
2617 if (m_focusWidget
== NULL
)
2618 m_focusWidget
= m_widget
;
2622 g_signal_connect (m_focusWidget
, "focus_in_event",
2623 G_CALLBACK (gtk_window_focus_in_callback
), this);
2624 g_signal_connect (m_focusWidget
, "focus_out_event",
2625 G_CALLBACK (gtk_window_focus_out_callback
), this);
2629 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2630 G_CALLBACK (gtk_window_focus_in_callback
), this);
2631 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2632 G_CALLBACK (gtk_window_focus_out_callback
), this);
2636 // connect to the various key and mouse handlers
2638 GtkWidget
*connect_widget
= GetConnectWidget();
2640 ConnectWidget( connect_widget
);
2642 /* We cannot set colours, fonts and cursors before the widget has
2643 been realized, so we do this directly after realization */
2644 g_signal_connect (connect_widget
, "realize",
2645 G_CALLBACK (gtk_window_realized_callback
), this);
2649 // Catch native resize events
2650 g_signal_connect (m_wxwindow
, "size_allocate",
2651 G_CALLBACK (gtk_window_size_callback
), this);
2653 // Initialize XIM support
2654 g_signal_connect (m_wxwindow
, "realize",
2655 G_CALLBACK (gtk_wxwindow_realized_callback
), this);
2657 // And resize XIM window
2658 g_signal_connect (m_wxwindow
, "size_allocate",
2659 G_CALLBACK (gtk_wxwindow_size_callback
), this);
2662 if (GTK_IS_COMBO(m_widget
))
2664 GtkCombo
*gcombo
= GTK_COMBO(m_widget
);
2666 g_signal_connect (gcombo
->entry
, "size_request",
2667 G_CALLBACK (wxgtk_combo_size_request_callback
),
2670 #ifdef GTK_IS_FILE_CHOOSER_BUTTON
2671 else if (GTK_IS_FILE_CHOOSER_BUTTON(m_widget
))
2673 // If we connect to the "size_request" signal of a GtkFileChooserButton
2674 // then that control won't be sized properly when placed inside sizers
2675 // (this can be tested removing this elseif and running XRC or WIDGETS samples)
2676 // FIXME: what should be done here ?
2681 // This is needed if we want to add our windows into native
2682 // GTK controls, such as the toolbar. With this callback, the
2683 // toolbar gets to know the correct size (the one set by the
2684 // programmer). Sadly, it misbehaves for wxComboBox.
2685 g_signal_connect (m_widget
, "size_request",
2686 G_CALLBACK (wxgtk_window_size_request_callback
),
2690 InheritAttributes();
2694 SetLayoutDirection(wxLayout_Default
);
2696 // unless the window was created initially hidden (i.e. Hide() had been
2697 // called before Create()), we should show it at GTK+ level as well
2699 gtk_widget_show( m_widget
);
2702 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2704 g_signal_connect (widget
, "key_press_event",
2705 G_CALLBACK (gtk_window_key_press_callback
), this);
2706 g_signal_connect (widget
, "key_release_event",
2707 G_CALLBACK (gtk_window_key_release_callback
), this);
2708 g_signal_connect (widget
, "button_press_event",
2709 G_CALLBACK (gtk_window_button_press_callback
), this);
2710 g_signal_connect (widget
, "button_release_event",
2711 G_CALLBACK (gtk_window_button_release_callback
), this);
2712 g_signal_connect (widget
, "motion_notify_event",
2713 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2714 g_signal_connect (widget
, "scroll_event",
2715 G_CALLBACK (window_scroll_event
), this);
2716 g_signal_connect (widget
, "popup_menu",
2717 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2718 g_signal_connect (widget
, "enter_notify_event",
2719 G_CALLBACK (gtk_window_enter_callback
), this);
2720 g_signal_connect (widget
, "leave_notify_event",
2721 G_CALLBACK (gtk_window_leave_callback
), this);
2724 bool wxWindowGTK::Destroy()
2726 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2730 return wxWindowBase::Destroy();
2733 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2735 gtk_pizza_set_size( GTK_PIZZA(m_parent
->m_wxwindow
), m_widget
, x
, y
, width
, height
);
2738 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2740 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2741 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2744 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
2747 if (m_resizing
) return; /* I don't like recursions */
2750 int currentX
, currentY
;
2751 GetPosition(¤tX
, ¤tY
);
2752 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2754 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2756 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2758 // calculate the best size if we should auto size the window
2759 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2760 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2762 const wxSize sizeBest
= GetBestSize();
2763 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2765 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2766 height
= sizeBest
.y
;
2774 int minWidth
= GetMinWidth(),
2775 minHeight
= GetMinHeight(),
2776 maxWidth
= GetMaxWidth(),
2777 maxHeight
= GetMaxHeight();
2779 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
2780 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
2781 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
2782 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
2784 #if wxUSE_TOOLBAR_NATIVE
2785 if (wxDynamicCast(GetParent(), wxToolBar
))
2787 // don't take the x,y values, they're wrong because toolbar sets them
2788 GtkWidget
*widget
= GTK_WIDGET(m_widget
);
2789 gtk_widget_set_size_request (widget
, m_width
, m_height
);
2793 if (m_parent
->m_wxwindow
== NULL
) // i.e. wxNotebook
2795 // don't set the size for children of wxNotebook, just take the values.
2803 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
2804 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
2806 if (x
!= -1) m_x
= x
+ pizza
->xoffset
;
2807 if (y
!= -1) m_y
= y
+ pizza
->yoffset
;
2811 m_x
= x
+ pizza
->xoffset
;
2812 m_y
= y
+ pizza
->yoffset
;
2815 int left_border
= 0;
2816 int right_border
= 0;
2818 int bottom_border
= 0;
2820 /* the default button has a border around it */
2821 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
2823 GtkBorder
*default_border
= NULL
;
2824 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2827 left_border
+= default_border
->left
;
2828 right_border
+= default_border
->right
;
2829 top_border
+= default_border
->top
;
2830 bottom_border
+= default_border
->bottom
;
2831 g_free( default_border
);
2835 DoMoveWindow( m_x
-top_border
,
2837 m_width
+left_border
+right_border
,
2838 m_height
+top_border
+bottom_border
);
2843 /* Sometimes the client area changes size without the
2844 whole windows's size changing, but if the whole
2845 windows's size doesn't change, no wxSizeEvent will
2846 normally be sent. Here we add an extra test if
2847 the client test has been changed and this will
2849 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2853 wxPrintf( "OnSize sent from " );
2854 if (GetClassInfo() && GetClassInfo()->GetClassName())
2855 wxPrintf( GetClassInfo()->GetClassName() );
2856 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2859 if (!m_nativeSizeEvent
)
2861 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2862 event
.SetEventObject( this );
2863 GetEventHandler()->ProcessEvent( event
);
2869 bool wxWindowGTK::GtkShowFromOnIdle()
2871 if (IsShown() && m_showOnIdle
&& !GTK_WIDGET_VISIBLE (m_widget
))
2873 GtkAllocation alloc
;
2876 alloc
.width
= m_width
;
2877 alloc
.height
= m_height
;
2878 gtk_widget_size_allocate( m_widget
, &alloc
);
2879 gtk_widget_show( m_widget
);
2880 wxShowEvent
eventShow(GetId(), true);
2881 eventShow
.SetEventObject(this);
2882 GetEventHandler()->ProcessEvent(eventShow
);
2883 m_showOnIdle
= false;
2890 void wxWindowGTK::OnInternalIdle()
2892 // Check if we have to show window now
2893 if (GtkShowFromOnIdle()) return;
2895 if ( m_dirtyTabOrder
)
2897 m_dirtyTabOrder
= false;
2901 // Update style if the window was not yet realized
2902 // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
2903 if (m_needsStyleChange
)
2905 SetBackgroundStyle(GetBackgroundStyle());
2906 m_needsStyleChange
= false;
2909 wxCursor cursor
= m_cursor
;
2910 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
2914 /* I now set the cursor anew in every OnInternalIdle call
2915 as setting the cursor in a parent window also effects the
2916 windows above so that checking for the current cursor is
2921 GdkWindow
*window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2923 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2925 if (!g_globalCursor
.Ok())
2926 cursor
= *wxSTANDARD_CURSOR
;
2928 window
= m_widget
->window
;
2929 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
2930 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2933 else if ( m_widget
)
2935 GdkWindow
*window
= m_widget
->window
;
2936 if ( window
&& !GTK_WIDGET_NO_WINDOW(m_widget
) )
2937 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2941 if (wxUpdateUIEvent::CanUpdate(this))
2942 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
2945 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
2947 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2949 if (width
) (*width
) = m_width
;
2950 if (height
) (*height
) = m_height
;
2953 void wxWindowGTK::DoSetClientSize( int width
, int height
)
2955 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2964 GetScrollbarWidth(m_widget
, dw
, dh
);
2967 #ifndef __WXUNIVERSAL__
2968 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
2970 // shadow border size is 2
2974 if (HasFlag(wxSIMPLE_BORDER
))
2976 // simple border size is 1
2980 #endif // __WXUNIVERSAL__
2986 SetSize(width
, height
);
2989 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
2991 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3003 GetScrollbarWidth(m_widget
, dw
, dh
);
3006 #ifndef __WXUNIVERSAL__
3007 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
3009 // shadow border size is 2
3013 if (HasFlag(wxSIMPLE_BORDER
))
3015 // simple border size is 1
3019 #endif // __WXUNIVERSAL__
3025 if (width
) *width
= w
;
3026 if (height
) *height
= h
;
3029 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
3031 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3035 if (m_parent
&& m_parent
->m_wxwindow
)
3037 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
3038 dx
= pizza
->xoffset
;
3039 dy
= pizza
->yoffset
;
3042 if (x
) (*x
) = m_x
- dx
;
3043 if (y
) (*y
) = m_y
- dy
;
3046 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
3048 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3050 if (!m_widget
->window
) return;
3052 GdkWindow
*source
= (GdkWindow
*) NULL
;
3054 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3056 source
= m_widget
->window
;
3060 gdk_window_get_origin( source
, &org_x
, &org_y
);
3064 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3066 org_x
+= m_widget
->allocation
.x
;
3067 org_y
+= m_widget
->allocation
.y
;
3075 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
3077 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3079 if (!m_widget
->window
) return;
3081 GdkWindow
*source
= (GdkWindow
*) NULL
;
3083 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3085 source
= m_widget
->window
;
3089 gdk_window_get_origin( source
, &org_x
, &org_y
);
3093 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3095 org_x
+= m_widget
->allocation
.x
;
3096 org_y
+= m_widget
->allocation
.y
;
3104 bool wxWindowGTK::Show( bool show
)
3106 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3108 if (!wxWindowBase::Show(show
))
3118 gtk_widget_show( m_widget
);
3119 wxShowEvent
eventShow(GetId(), show
);
3120 eventShow
.SetEventObject(this);
3121 GetEventHandler()->ProcessEvent(eventShow
);
3126 gtk_widget_hide( m_widget
);
3127 wxShowEvent
eventShow(GetId(), show
);
3128 eventShow
.SetEventObject(this);
3129 GetEventHandler()->ProcessEvent(eventShow
);
3135 static void wxWindowNotifyEnable(wxWindowGTK
* win
, bool enable
)
3137 win
->OnParentEnable(enable
);
3139 // Recurse, so that children have the opportunity to Do The Right Thing
3140 // and reset colours that have been messed up by a parent's (really ancestor's)
3142 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
3144 node
= node
->GetNext() )
3146 wxWindow
*child
= node
->GetData();
3147 if (!child
->IsKindOf(CLASSINFO(wxDialog
)) && !child
->IsKindOf(CLASSINFO(wxFrame
)))
3148 wxWindowNotifyEnable(child
, enable
);
3152 bool wxWindowGTK::Enable( bool enable
)
3154 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3156 if (!wxWindowBase::Enable(enable
))
3162 gtk_widget_set_sensitive( m_widget
, enable
);
3164 gtk_widget_set_sensitive( m_wxwindow
, enable
);
3166 wxWindowNotifyEnable(this, enable
);
3171 int wxWindowGTK::GetCharHeight() const
3173 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
3175 wxFont font
= GetFont();
3176 wxCHECK_MSG( font
.Ok(), 12, wxT("invalid font") );
3178 PangoContext
*context
= NULL
;
3180 context
= gtk_widget_get_pango_context( m_widget
);
3185 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3186 PangoLayout
*layout
= pango_layout_new(context
);
3187 pango_layout_set_font_description(layout
, desc
);
3188 pango_layout_set_text(layout
, "H", 1);
3189 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3191 PangoRectangle rect
;
3192 pango_layout_line_get_extents(line
, NULL
, &rect
);
3194 g_object_unref (layout
);
3196 return (int) PANGO_PIXELS(rect
.height
);
3199 int wxWindowGTK::GetCharWidth() const
3201 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
3203 wxFont font
= GetFont();
3204 wxCHECK_MSG( font
.Ok(), 8, wxT("invalid font") );
3206 PangoContext
*context
= NULL
;
3208 context
= gtk_widget_get_pango_context( m_widget
);
3213 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3214 PangoLayout
*layout
= pango_layout_new(context
);
3215 pango_layout_set_font_description(layout
, desc
);
3216 pango_layout_set_text(layout
, "g", 1);
3217 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3219 PangoRectangle rect
;
3220 pango_layout_line_get_extents(line
, NULL
, &rect
);
3222 g_object_unref (layout
);
3224 return (int) PANGO_PIXELS(rect
.width
);
3227 void wxWindowGTK::GetTextExtent( const wxString
& string
,
3231 int *externalLeading
,
3232 const wxFont
*theFont
) const
3234 wxFont fontToUse
= theFont
? *theFont
: GetFont();
3236 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
3245 PangoContext
*context
= NULL
;
3247 context
= gtk_widget_get_pango_context( m_widget
);
3256 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3257 PangoLayout
*layout
= pango_layout_new(context
);
3258 pango_layout_set_font_description(layout
, desc
);
3260 const wxCharBuffer data
= wxGTK_CONV( string
);
3262 pango_layout_set_text(layout
, data
, strlen(data
));
3265 PangoRectangle rect
;
3266 pango_layout_get_extents(layout
, NULL
, &rect
);
3268 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
3269 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
3272 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
3273 int baseline
= pango_layout_iter_get_baseline(iter
);
3274 pango_layout_iter_free(iter
);
3275 *descent
= *y
- PANGO_PIXELS(baseline
);
3277 if (externalLeading
) (*externalLeading
) = 0; // ??
3279 g_object_unref (layout
);
3282 bool wxWindowGTK::GTKSetDelayedFocusIfNeeded()
3284 if ( g_delayedFocus
== this )
3286 if ( GTK_WIDGET_REALIZED(m_widget
) )
3288 gtk_widget_grab_focus(m_widget
);
3289 g_delayedFocus
= NULL
;
3298 void wxWindowGTK::SetFocus()
3300 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3303 // don't do anything if we already have focus
3309 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow
))
3311 gtk_widget_grab_focus (m_wxwindow
);
3316 if (GTK_IS_CONTAINER(m_widget
))
3318 gtk_widget_child_focus( m_widget
, GTK_DIR_TAB_FORWARD
);
3321 if (GTK_WIDGET_CAN_FOCUS(m_widget
) && !GTK_WIDGET_HAS_FOCUS (m_widget
) )
3324 if (!GTK_WIDGET_REALIZED(m_widget
))
3326 // we can't set the focus to the widget now so we remember that
3327 // it should be focused and will do it later, during the idle
3328 // time, as soon as we can
3329 wxLogTrace(TRACE_FOCUS
,
3330 _T("Delaying setting focus to %s(%s)"),
3331 GetClassInfo()->GetClassName(), GetLabel().c_str());
3333 g_delayedFocus
= this;
3337 wxLogTrace(TRACE_FOCUS
,
3338 _T("Setting focus to %s(%s)"),
3339 GetClassInfo()->GetClassName(), GetLabel().c_str());
3341 gtk_widget_grab_focus (m_widget
);
3346 wxLogTrace(TRACE_FOCUS
,
3347 _T("Can't set focus to %s(%s)"),
3348 GetClassInfo()->GetClassName(), GetLabel().c_str());
3353 bool wxWindowGTK::AcceptsFocus() const
3355 return m_acceptsFocus
&& wxWindowBase::AcceptsFocus();
3358 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3360 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3362 wxWindowGTK
*oldParent
= m_parent
,
3363 *newParent
= (wxWindowGTK
*)newParentBase
;
3365 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3367 if ( !wxWindowBase::Reparent(newParent
) )
3370 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3372 /* prevent GTK from deleting the widget arbitrarily */
3373 gtk_widget_ref( m_widget
);
3377 gtk_container_remove( GTK_CONTAINER(m_widget
->parent
), m_widget
);
3380 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3384 if (GTK_WIDGET_VISIBLE (newParent
->m_widget
))
3386 m_showOnIdle
= true;
3387 gtk_widget_hide( m_widget
);
3390 /* insert GTK representation */
3391 (*(newParent
->m_insertCallback
))(newParent
, this);
3394 /* reverse: prevent GTK from deleting the widget arbitrarily */
3395 gtk_widget_unref( m_widget
);
3397 SetLayoutDirection(wxLayout_Default
);
3402 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3404 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3406 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3408 wxASSERT_MSG( (m_insertCallback
!= NULL
), wxT("invalid child insertion function") );
3413 /* insert GTK representation */
3414 (*m_insertCallback
)(this, child
);
3417 void wxWindowGTK::AddChild(wxWindowBase
*child
)
3419 wxWindowBase::AddChild(child
);
3420 m_dirtyTabOrder
= true;
3422 wxapp_install_idle_handler();
3425 void wxWindowGTK::RemoveChild(wxWindowBase
*child
)
3427 wxWindowBase::RemoveChild(child
);
3428 m_dirtyTabOrder
= true;
3430 wxapp_install_idle_handler();
3434 wxLayoutDirection
wxWindowGTK::GTKGetLayout(GtkWidget
*widget
)
3436 return gtk_widget_get_direction(GTK_WIDGET(widget
)) == GTK_TEXT_DIR_RTL
3437 ? wxLayout_RightToLeft
3438 : wxLayout_LeftToRight
;
3442 void wxWindowGTK::GTKSetLayout(GtkWidget
*widget
, wxLayoutDirection dir
)
3444 wxASSERT_MSG( dir
!= wxLayout_Default
, _T("invalid layout direction") );
3446 gtk_widget_set_direction(GTK_WIDGET(widget
),
3447 dir
== wxLayout_RightToLeft
? GTK_TEXT_DIR_RTL
3448 : GTK_TEXT_DIR_LTR
);
3451 wxLayoutDirection
wxWindowGTK::GetLayoutDirection() const
3453 return GTKGetLayout(m_widget
);
3456 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir
)
3458 if ( dir
== wxLayout_Default
)
3460 const wxWindow
*const parent
= GetParent();
3463 // inherit layout from parent.
3464 dir
= parent
->GetLayoutDirection();
3466 else // no parent, use global default layout
3468 dir
= wxTheApp
->GetLayoutDirection();
3472 if ( dir
== wxLayout_Default
)
3475 GTKSetLayout(m_widget
, dir
);
3478 void wxWindowGTK::DoMoveInTabOrder(wxWindow
*win
, MoveKind move
)
3480 wxWindowBase::DoMoveInTabOrder(win
, move
);
3481 m_dirtyTabOrder
= true;
3483 wxapp_install_idle_handler();
3486 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3488 // none needed by default
3492 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3494 // nothing to do by default since none is needed
3497 void wxWindowGTK::RealizeTabOrder()
3501 if ( !m_children
.empty() )
3503 // we don't only construct the correct focus chain but also use
3504 // this opportunity to update the mnemonic widgets for the widgets
3507 GList
*chain
= NULL
;
3508 wxWindowGTK
* mnemonicWindow
= NULL
;
3510 for ( wxWindowList::const_iterator i
= m_children
.begin();
3511 i
!= m_children
.end();
3514 wxWindowGTK
*win
= *i
;
3516 if ( mnemonicWindow
)
3518 if ( win
->AcceptsFocusFromKeyboard() )
3520 // wxComboBox et al. needs to focus on on a different
3521 // widget than m_widget, so if the main widget isn't
3522 // focusable try the connect widget
3523 GtkWidget
* w
= win
->m_widget
;
3524 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3526 w
= win
->GetConnectWidget();
3527 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3533 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3534 mnemonicWindow
= NULL
;
3538 else if ( win
->GTKWidgetNeedsMnemonic() )
3540 mnemonicWindow
= win
;
3543 chain
= g_list_prepend(chain
, win
->m_widget
);
3546 chain
= g_list_reverse(chain
);
3548 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3553 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3558 void wxWindowGTK::Raise()
3560 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3562 if (m_wxwindow
&& m_wxwindow
->window
)
3564 gdk_window_raise( m_wxwindow
->window
);
3566 else if (m_widget
->window
)
3568 gdk_window_raise( m_widget
->window
);
3572 void wxWindowGTK::Lower()
3574 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3576 if (m_wxwindow
&& m_wxwindow
->window
)
3578 gdk_window_lower( m_wxwindow
->window
);
3580 else if (m_widget
->window
)
3582 gdk_window_lower( m_widget
->window
);
3586 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3588 if ( !wxWindowBase::SetCursor(cursor
.Ok() ? cursor
: *wxSTANDARD_CURSOR
) )
3596 void wxWindowGTK::GTKUpdateCursor()
3598 wxCursor
cursor(g_globalCursor
.Ok() ? g_globalCursor
: GetCursor());
3601 wxArrayGdkWindows windowsThis
;
3602 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
3605 gdk_window_set_cursor(winThis
, cursor
.GetCursor());
3609 const size_t count
= windowsThis
.size();
3610 for ( size_t n
= 0; n
< count
; n
++ )
3612 GdkWindow
*win
= windowsThis
[n
];
3615 wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?"));
3619 gdk_window_set_cursor(win
, cursor
.GetCursor());
3625 void wxWindowGTK::WarpPointer( int x
, int y
)
3627 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3629 // We provide this function ourselves as it is
3630 // missing in GDK (top of this file).
3632 GdkWindow
*window
= (GdkWindow
*) NULL
;
3634 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3636 window
= GetConnectWidget()->window
;
3639 gdk_window_warp_pointer( window
, x
, y
);
3642 wxWindowGTK::ScrollDir
wxWindowGTK::ScrollDirFromRange(GtkRange
*range
) const
3644 // find the scrollbar which generated the event
3645 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3647 if ( range
== m_scrollBar
[dir
] )
3648 return (ScrollDir
)dir
;
3651 wxFAIL_MSG( _T("event from unknown scrollbar received") );
3653 return ScrollDir_Max
;
3656 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3658 bool changed
= false;
3659 GtkRange
* range
= m_scrollBar
[dir
];
3660 if ( range
&& units
)
3662 GtkAdjustment
* adj
= range
->adjustment
;
3663 gdouble inc
= unit
== ScrollUnit_Line
? adj
->step_increment
3664 : adj
->page_increment
;
3666 const int posOld
= int(adj
->value
+ 0.5);
3667 gtk_range_set_value(range
, posOld
+ units
*inc
);
3669 changed
= int(adj
->value
+ 0.5) != posOld
;
3675 bool wxWindowGTK::ScrollLines(int lines
)
3677 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3680 bool wxWindowGTK::ScrollPages(int pages
)
3682 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3685 void wxWindowGTK::Refresh( bool eraseBackground
, const wxRect
*rect
)
3689 if (!m_widget
->window
)
3694 if (!GTK_PIZZA(m_wxwindow
)->bin_window
) return;
3696 GdkRectangle gdk_rect
,
3700 gdk_rect
.x
= rect
->x
;
3701 gdk_rect
.y
= rect
->y
;
3702 gdk_rect
.width
= rect
->width
;
3703 gdk_rect
.height
= rect
->height
;
3706 else // invalidate everything
3711 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, p
, TRUE
);
3715 void wxWindowGTK::Update()
3719 // when we call Update() we really want to update the window immediately on
3720 // screen, even if it means flushing the entire queue and hence slowing down
3721 // everything -- but it should still be done, it's just that Update() should
3722 // be called very rarely
3726 void wxWindowGTK::GtkUpdate()
3728 if (m_wxwindow
&& GTK_PIZZA(m_wxwindow
)->bin_window
)
3729 gdk_window_process_updates( GTK_PIZZA(m_wxwindow
)->bin_window
, FALSE
);
3730 if (m_widget
&& m_widget
->window
)
3731 gdk_window_process_updates( m_widget
->window
, FALSE
);
3733 // for consistency with other platforms (and also because it's convenient
3734 // to be able to update an entire TLW by calling Update() only once), we
3735 // should also update all our children here
3736 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3738 node
= node
->GetNext() )
3740 node
->GetData()->GtkUpdate();
3744 void wxWindowGTK::GtkSendPaintEvents()
3748 m_updateRegion
.Clear();
3752 // Clip to paint region in wxClientDC
3753 m_clipPaintRegion
= true;
3755 // widget to draw on
3756 GtkPizza
*pizza
= GTK_PIZZA (m_wxwindow
);
3758 if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM
))
3760 // find ancestor from which to steal background
3761 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3763 parent
= (wxWindow
*)this;
3765 if (GTK_WIDGET_MAPPED(parent
->m_widget
))
3767 wxRegionIterator
upd( m_updateRegion
);
3771 rect
.x
= upd
.GetX();
3772 rect
.y
= upd
.GetY();
3773 rect
.width
= upd
.GetWidth();
3774 rect
.height
= upd
.GetHeight();
3776 gtk_paint_flat_box( parent
->m_widget
->style
,
3778 (GtkStateType
)GTK_WIDGET_STATE(m_wxwindow
),
3792 wxWindowDC
dc( (wxWindow
*)this );
3793 dc
.SetClippingRegion( m_updateRegion
);
3795 wxEraseEvent
erase_event( GetId(), &dc
);
3796 erase_event
.SetEventObject( this );
3798 GetEventHandler()->ProcessEvent(erase_event
);
3801 wxNcPaintEvent
nc_paint_event( GetId() );
3802 nc_paint_event
.SetEventObject( this );
3803 GetEventHandler()->ProcessEvent( nc_paint_event
);
3805 wxPaintEvent
paint_event( GetId() );
3806 paint_event
.SetEventObject( this );
3807 GetEventHandler()->ProcessEvent( paint_event
);
3809 m_clipPaintRegion
= false;
3811 m_updateRegion
.Clear();
3814 void wxWindowGTK::SetDoubleBuffered( bool on
)
3816 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3819 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3822 void wxWindowGTK::ClearBackground()
3824 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3828 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3830 wxWindowBase::DoSetToolTip(tip
);
3833 m_tooltip
->Apply( (wxWindow
*)this );
3836 void wxWindowGTK::ApplyToolTip( GtkTooltips
*tips
, const wxChar
*tip
)
3838 wxString
tmp( tip
);
3839 gtk_tooltips_set_tip( tips
, GetConnectWidget(), wxGTK_CONV(tmp
), (gchar
*) NULL
);
3841 #endif // wxUSE_TOOLTIPS
3843 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
3845 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3847 if (!wxWindowBase::SetBackgroundColour(colour
))
3852 // We need the pixel value e.g. for background clearing.
3853 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3856 // apply style change (forceStyle=true so that new style is applied
3857 // even if the bg colour changed from valid to wxNullColour)
3858 if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM
)
3859 ApplyWidgetStyle(true);
3864 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
3866 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3868 if (!wxWindowBase::SetForegroundColour(colour
))
3875 // We need the pixel value e.g. for background clearing.
3876 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3879 // apply style change (forceStyle=true so that new style is applied
3880 // even if the bg colour changed from valid to wxNullColour):
3881 ApplyWidgetStyle(true);
3886 PangoContext
*wxWindowGTK::GtkGetPangoDefaultContext()
3888 return gtk_widget_get_pango_context( m_widget
);
3891 GtkRcStyle
*wxWindowGTK::CreateWidgetStyle(bool forceStyle
)
3893 // do we need to apply any changes at all?
3896 !m_foregroundColour
.Ok() && !m_backgroundColour
.Ok() )
3901 GtkRcStyle
*style
= gtk_rc_style_new();
3906 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
3909 if ( m_foregroundColour
.Ok() )
3911 const GdkColor
*fg
= m_foregroundColour
.GetColor();
3913 style
->fg
[GTK_STATE_NORMAL
] = *fg
;
3914 style
->color_flags
[GTK_STATE_NORMAL
] = GTK_RC_FG
;
3916 style
->fg
[GTK_STATE_PRELIGHT
] = *fg
;
3917 style
->color_flags
[GTK_STATE_PRELIGHT
] = GTK_RC_FG
;
3919 style
->fg
[GTK_STATE_ACTIVE
] = *fg
;
3920 style
->color_flags
[GTK_STATE_ACTIVE
] = GTK_RC_FG
;
3923 if ( m_backgroundColour
.Ok() )
3925 const GdkColor
*bg
= m_backgroundColour
.GetColor();
3927 style
->bg
[GTK_STATE_NORMAL
] = *bg
;
3928 style
->base
[GTK_STATE_NORMAL
] = *bg
;
3929 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)
3930 (style
->color_flags
[GTK_STATE_NORMAL
] | GTK_RC_BG
| GTK_RC_BASE
);
3932 style
->bg
[GTK_STATE_PRELIGHT
] = *bg
;
3933 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
3934 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)
3935 (style
->color_flags
[GTK_STATE_PRELIGHT
] | GTK_RC_BG
| GTK_RC_BASE
);
3937 style
->bg
[GTK_STATE_ACTIVE
] = *bg
;
3938 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
3939 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)
3940 (style
->color_flags
[GTK_STATE_ACTIVE
] | GTK_RC_BG
| GTK_RC_BASE
);
3942 style
->bg
[GTK_STATE_INSENSITIVE
] = *bg
;
3943 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
3944 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)
3945 (style
->color_flags
[GTK_STATE_INSENSITIVE
] | GTK_RC_BG
| GTK_RC_BASE
);
3951 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle
)
3953 GtkRcStyle
*style
= CreateWidgetStyle(forceStyle
);
3956 DoApplyWidgetStyle(style
);
3957 gtk_rc_style_unref(style
);
3960 // Style change may affect GTK+'s size calculation:
3961 InvalidateBestSize();
3964 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
3967 gtk_widget_modify_style(m_wxwindow
, style
);
3969 gtk_widget_modify_style(m_widget
, style
);
3972 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style
)
3974 wxWindowBase::SetBackgroundStyle(style
);
3976 if (style
== wxBG_STYLE_CUSTOM
)
3978 GdkWindow
*window
= (GdkWindow
*) NULL
;
3980 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3982 window
= GetConnectWidget()->window
;
3986 // Make sure GDK/X11 doesn't refresh the window
3988 gdk_window_set_back_pixmap( window
, None
, False
);
3990 Display
* display
= GDK_WINDOW_DISPLAY(window
);
3993 m_needsStyleChange
= false;
3996 // Do in OnIdle, because the window is not yet available
3997 m_needsStyleChange
= true;
3999 // Don't apply widget style, or we get a grey background
4003 // apply style change (forceStyle=true so that new style is applied
4004 // even if the bg colour changed from valid to wxNullColour):
4005 ApplyWidgetStyle(true);
4010 #if wxUSE_DRAG_AND_DROP
4012 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4014 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4016 GtkWidget
*dnd_widget
= GetConnectWidget();
4018 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
4020 if (m_dropTarget
) delete m_dropTarget
;
4021 m_dropTarget
= dropTarget
;
4023 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
4026 #endif // wxUSE_DRAG_AND_DROP
4028 GtkWidget
* wxWindowGTK::GetConnectWidget()
4030 GtkWidget
*connect_widget
= m_widget
;
4031 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4033 return connect_widget
;
4036 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow
*window
) const
4038 wxArrayGdkWindows windowsThis
;
4039 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
4041 return winThis
? window
== winThis
4042 : windowsThis
.Index(window
) != wxNOT_FOUND
;
4045 GdkWindow
*wxWindowGTK::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
4047 return m_wxwindow
? GTK_PIZZA(m_wxwindow
)->bin_window
: m_widget
->window
;
4050 bool wxWindowGTK::SetFont( const wxFont
&font
)
4052 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4054 if (!wxWindowBase::SetFont(font
))
4057 // apply style change (forceStyle=true so that new style is applied
4058 // even if the font changed from valid to wxNullFont):
4059 ApplyWidgetStyle(true);
4064 void wxWindowGTK::DoCaptureMouse()
4066 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4068 GdkWindow
*window
= (GdkWindow
*) NULL
;
4070 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4072 window
= GetConnectWidget()->window
;
4074 wxCHECK_RET( window
, _T("CaptureMouse() failed") );
4076 const wxCursor
* cursor
= &m_cursor
;
4078 cursor
= wxSTANDARD_CURSOR
;
4080 gdk_pointer_grab( window
, FALSE
,
4082 (GDK_BUTTON_PRESS_MASK
|
4083 GDK_BUTTON_RELEASE_MASK
|
4084 GDK_POINTER_MOTION_HINT_MASK
|
4085 GDK_POINTER_MOTION_MASK
),
4087 cursor
->GetCursor(),
4088 (guint32
)GDK_CURRENT_TIME
);
4089 g_captureWindow
= this;
4090 g_captureWindowHasMouse
= true;
4093 void wxWindowGTK::DoReleaseMouse()
4095 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4097 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4099 g_captureWindow
= (wxWindowGTK
*) NULL
;
4101 GdkWindow
*window
= (GdkWindow
*) NULL
;
4103 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4105 window
= GetConnectWidget()->window
;
4110 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4114 wxWindow
*wxWindowBase::GetCapture()
4116 return (wxWindow
*)g_captureWindow
;
4119 bool wxWindowGTK::IsRetained() const
4124 void wxWindowGTK::BlockScrollEvent()
4126 wxASSERT(!m_blockScrollEvent
);
4127 m_blockScrollEvent
= true;
4130 void wxWindowGTK::UnblockScrollEvent()
4132 wxASSERT(m_blockScrollEvent
);
4133 m_blockScrollEvent
= false;
4136 void wxWindowGTK::SetScrollbar(int orient
,
4140 bool WXUNUSED(update
))
4142 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4143 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4147 m_hasScrolling
= true;
4151 // GtkRange requires upper > lower
4156 if (pos
> range
- thumbVisible
)
4157 pos
= range
- thumbVisible
;
4160 GtkAdjustment
* adj
= m_scrollBar
[ScrollDirFromOrient(orient
)]->adjustment
;
4161 adj
->step_increment
= 1;
4162 adj
->page_increment
=
4163 adj
->page_size
= thumbVisible
;
4165 SetScrollPos(orient
, pos
);
4166 gtk_adjustment_changed(adj
);
4169 void wxWindowGTK::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4171 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4172 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4174 // This check is more than an optimization. Without it, the slider
4175 // will not move smoothly while tracking when using wxScrollHelper.
4176 if (GetScrollPos(orient
) != pos
)
4178 const int dir
= ScrollDirFromOrient(orient
);
4179 GtkAdjustment
* adj
= m_scrollBar
[dir
]->adjustment
;
4180 const int max
= int(adj
->upper
- adj
->page_size
);
4187 // If a "value_changed" signal emission is not already in progress
4188 if (!m_blockValueChanged
[dir
])
4190 gtk_adjustment_value_changed(adj
);
4195 int wxWindowGTK::GetScrollThumb(int orient
) const
4197 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4198 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4200 return int(m_scrollBar
[ScrollDirFromOrient(orient
)]->adjustment
->page_size
);
4203 int wxWindowGTK::GetScrollPos( int orient
) const
4205 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4206 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4208 return int(m_scrollBar
[ScrollDirFromOrient(orient
)]->adjustment
->value
+ 0.5);
4211 int wxWindowGTK::GetScrollRange( int orient
) const
4213 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4214 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4216 return int(m_scrollBar
[ScrollDirFromOrient(orient
)]->adjustment
->upper
);
4219 // Determine if increment is the same as +/-x, allowing for some small
4220 // difference due to possible inexactness in floating point arithmetic
4221 static inline bool IsScrollIncrement(double increment
, double x
)
4223 wxASSERT(increment
> 0);
4224 const double tolerance
= 1.0 / 1024;
4225 return fabs(increment
- fabs(x
)) < tolerance
;
4228 wxEventType
wxWindowGTK::GetScrollEventType(GtkRange
* range
)
4233 wxapp_install_idle_handler();
4235 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4237 const int barIndex
= range
== m_scrollBar
[1];
4238 GtkAdjustment
* adj
= range
->adjustment
;
4239 const int value
= int(adj
->value
+ 0.5);
4240 // save previous position
4241 const double oldPos
= m_scrollPos
[barIndex
];
4242 // update current position
4243 m_scrollPos
[barIndex
] = adj
->value
;
4244 // If event should be ignored, or integral position has not changed
4245 if (!m_hasVMT
|| g_blockEventsOnDrag
|| value
== int(oldPos
+ 0.5))
4250 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4253 // Difference from last change event
4254 const double diff
= adj
->value
- oldPos
;
4255 const bool isDown
= diff
> 0;
4257 if (IsScrollIncrement(adj
->step_increment
, diff
))
4259 eventType
= isDown
? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4261 else if (IsScrollIncrement(adj
->page_increment
, diff
))
4263 eventType
= isDown
? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4265 else if (m_mouseButtonDown
)
4267 // Assume track event
4268 m_isScrolling
= true;
4274 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4276 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4278 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4280 // No scrolling requested.
4281 if ((dx
== 0) && (dy
== 0)) return;
4283 m_clipPaintRegion
= true;
4285 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), -dx
, -dy
);
4287 m_clipPaintRegion
= false;
4290 void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4292 //RN: Note that static controls usually have no border on gtk, so maybe
4293 //it makes sense to treat that as simply no border at the wx level
4295 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4297 GtkShadowType gtkstyle
;
4299 if(wxstyle
& wxBORDER_RAISED
)
4300 gtkstyle
= GTK_SHADOW_OUT
;
4301 else if (wxstyle
& wxBORDER_SUNKEN
)
4302 gtkstyle
= GTK_SHADOW_IN
;
4303 else if (wxstyle
& wxBORDER_DOUBLE
)
4304 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4306 gtkstyle
= GTK_SHADOW_IN
;
4308 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4313 void wxWindowGTK::SetWindowStyleFlag( long style
)
4315 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4316 wxWindowBase::SetWindowStyleFlag(style
);
4319 // Find the wxWindow at the current mouse position, also returning the mouse
4321 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4323 pt
= wxGetMousePosition();
4324 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4328 // Get the current mouse position.
4329 wxPoint
wxGetMousePosition()
4331 /* This crashes when used within wxHelpContext,
4332 so we have to use the X-specific implementation below.
4334 GdkModifierType *mask;
4335 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4337 return wxPoint(x, y);
4341 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4343 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4344 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4345 Window rootReturn
, childReturn
;
4346 int rootX
, rootY
, winX
, winY
;
4347 unsigned int maskReturn
;
4349 XQueryPointer (display
,
4353 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4354 return wxPoint(rootX
, rootY
);
4358 // Needed for implementing e.g. combobox on wxGTK within a modal dialog.
4359 void wxAddGrab(wxWindow
* window
)
4361 gtk_grab_add( (GtkWidget
*) window
->GetHandle() );
4364 void wxRemoveGrab(wxWindow
* window
)
4366 gtk_grab_remove( (GtkWidget
*) window
->GetHandle() );