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"
22 #include "wx/toplevel.h"
23 #include "wx/dcclient.h"
25 #include "wx/settings.h"
26 #include "wx/msgdlg.h"
31 #include "wx/tooltip.h"
33 #include "wx/fontutil.h"
34 #include "wx/sysopt.h"
38 #include "wx/gtk/private.h"
39 #include "wx/gtk/private/win_gtk.h"
40 #include <gdk/gdkkeysyms.h>
43 #if !GTK_CHECK_VERSION(2,10,0)
44 // GTK+ can reliably detect Meta key state only since 2.10 when
45 // GDK_META_MASK was introduced -- there wasn't any way to detect it
46 // in older versions. wxGTK used GDK_MOD2_MASK for this purpose, but
47 // GDK_MOD2_MASK is documented as:
49 // the fifth modifier key (it depends on the modifier mapping of the X
50 // server which key is interpreted as this modifier)
52 // In other words, it isn't guaranteed to map to Meta. This is a real
53 // problem: it is common to map NumLock to it (in fact, it's an exception
54 // if the X server _doesn't_ use it for NumLock). So the old code caused
55 // wxKeyEvent::MetaDown() to always return true as long as NumLock was on
56 // on many systems, which broke all applications using
57 // wxKeyEvent::GetModifiers() to check modifiers state (see e.g. here:
58 // http://tinyurl.com/56lsk2).
60 // Because of this, it's better to not detect Meta key state at all than
61 // to detect it incorrectly. Hence the following #define, which causes
62 // m_metaDown to be always set to false.
63 #define GDK_META_MASK 0
66 //-----------------------------------------------------------------------------
67 // documentation on internals
68 //-----------------------------------------------------------------------------
71 I have been asked several times about writing some documentation about
72 the GTK port of wxWidgets, especially its internal structures. Obviously,
73 you cannot understand wxGTK without knowing a little about the GTK, but
74 some more information about what the wxWindow, which is the base class
75 for all other window classes, does seems required as well.
79 What does wxWindow do? It contains the common interface for the following
80 jobs of its descendants:
82 1) Define the rudimentary behaviour common to all window classes, such as
83 resizing, intercepting user input (so as to make it possible to use these
84 events for special purposes in a derived class), window names etc.
86 2) Provide the possibility to contain and manage children, if the derived
87 class is allowed to contain children, which holds true for those window
88 classes which do not display a native GTK widget. To name them, these
89 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
90 work classes are a special case and are handled a bit differently from
91 the rest. The same holds true for the wxNotebook class.
93 3) Provide the possibility to draw into a client area of a window. This,
94 too, only holds true for classes that do not display a native GTK widget
97 4) Provide the entire mechanism for scrolling widgets. This actual inter-
98 face for this is usually in wxScrolledWindow, but the GTK implementation
101 5) A multitude of helper or extra methods for special purposes, such as
102 Drag'n'Drop, managing validators etc.
104 6) Display a border (sunken, raised, simple or none).
106 Normally one might expect, that one wxWidgets window would always correspond
107 to one GTK widget. Under GTK, there is no such all-round widget that has all
108 the functionality. Moreover, the GTK defines a client area as a different
109 widget from the actual widget you are handling. Last but not least some
110 special classes (e.g. wxFrame) handle different categories of widgets and
111 still have the possibility to draw something in the client area.
112 It was therefore required to write a special purpose GTK widget, that would
113 represent a client area in the sense of wxWidgets capable to do the jobs
114 2), 3) and 4). I have written this class and it resides in win_gtk.c of
117 All windows must have a widget, with which they interact with other under-
118 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
119 the wxWindow class has a member variable called m_widget which holds a
120 pointer to this widget. When the window class represents a GTK native widget,
121 this is (in most cases) the only GTK widget the class manages. E.g. the
122 wxStaticText class handles only a GtkLabel widget a pointer to which you
123 can find in m_widget (defined in wxWindow)
125 When the class has a client area for drawing into and for containing children
126 it has to handle the client area widget (of the type wxPizza, defined in
127 win_gtk.cpp), but there could be any number of widgets, handled by a class.
128 The common rule for all windows is only, that the widget that interacts with
129 the rest of GTK must be referenced in m_widget and all other widgets must be
130 children of this widget on the GTK level. The top-most widget, which also
131 represents the client area, must be in the m_wxwindow field and must be of
134 As I said, the window classes that display a GTK native widget only have
135 one widget, so in the case of e.g. the wxButton class m_widget holds a
136 pointer to a GtkButton widget. But windows with client areas (for drawing
137 and children) have a m_widget field that is a pointer to a GtkScrolled-
138 Window and a m_wxwindow field that is pointer to a wxPizza and this
139 one is (in the GTK sense) a child of the GtkScrolledWindow.
141 If the m_wxwindow field is set, then all input to this widget is inter-
142 cepted and sent to the wxWidgets class. If not, all input to the widget
143 that gets pointed to by m_widget gets intercepted and sent to the class.
147 The design of scrolling in wxWidgets is markedly different from that offered
148 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
149 clicking on a scrollbar belonging to scrolled window will inevitably move
150 the window. In wxWidgets, the scrollbar will only emit an event, send this
151 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
152 which actually moves the window and its sub-windows. Note that wxPizza
153 memorizes how much it has been scrolled but that wxWidgets forgets this
154 so that the two coordinates systems have to be kept in synch. This is done
155 in various places using the pizza->m_scroll_x and pizza->m_scroll_y values.
159 Singularly the most broken code in GTK is the code that is supposed to
160 inform subwindows (child windows) about new positions. Very often, duplicate
161 events are sent without changes in size or position, equally often no
162 events are sent at all (All this is due to a bug in the GtkContainer code
163 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
164 GTK's own system and it simply waits for size events for toplevel windows
165 and then iterates down the respective size events to all window. This has
166 the disadvantage that windows might get size events before the GTK widget
167 actually has the reported size. This doesn't normally pose any problem, but
168 the OpenGL drawing routines rely on correct behaviour. Therefore, I have
169 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
170 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
171 window that is used for OpenGL output really has that size (as reported by
176 If someone at some point of time feels the immense desire to have a look at,
177 change or attempt to optimise the Refresh() logic, this person will need an
178 intimate understanding of what "draw" and "expose" events are and what
179 they are used for, in particular when used in connection with GTK's
180 own windowless widgets. Beware.
184 Cursors, too, have been a constant source of pleasure. The main difficulty
185 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
186 for the parent. To prevent this from doing too much harm, I use idle time
187 to set the cursor over and over again, starting from the toplevel windows
188 and ending with the youngest generation (speaking of parent and child windows).
189 Also don't forget that cursors (like much else) are connected to GdkWindows,
190 not GtkWidgets and that the "window" field of a GtkWidget might very well
191 point to the GdkWindow of the parent widget (-> "window-less widget") and
192 that the two obviously have very different meanings.
196 //-----------------------------------------------------------------------------
198 //-----------------------------------------------------------------------------
200 // Don't allow event propagation during drag
201 bool g_blockEventsOnDrag
;
202 // Don't allow mouse event propagation during scroll
203 bool g_blockEventsOnScroll
;
204 extern wxCursor g_globalCursor
;
206 // mouse capture state: the window which has it and if the mouse is currently
208 static wxWindowGTK
*g_captureWindow
= NULL
;
209 static bool g_captureWindowHasMouse
= false;
211 // The window that currently has focus:
212 static wxWindowGTK
*gs_currentFocus
= NULL
;
213 // The window that is scheduled to get focus in the next event loop iteration
214 // or NULL if there's no pending focus change:
215 static wxWindowGTK
*gs_pendingFocus
= NULL
;
217 // the window that has deferred focus-out event pending, if any (see
218 // GTKAddDeferredFocusOut() for details)
219 static wxWindowGTK
*gs_deferredFocusOut
= NULL
;
221 // global variables because GTK+ DnD want to have the
222 // mouse event that caused it
223 GdkEvent
*g_lastMouseEvent
= NULL
;
224 int g_lastButtonNumber
= 0;
226 //-----------------------------------------------------------------------------
228 //-----------------------------------------------------------------------------
230 // the trace mask used for the focus debugging messages
231 #define TRACE_FOCUS _T("focus")
233 //-----------------------------------------------------------------------------
234 // missing gdk functions
235 //-----------------------------------------------------------------------------
238 gdk_window_warp_pointer (GdkWindow
*window
,
243 window
= gdk_get_default_root_window();
245 if (!GDK_WINDOW_DESTROYED(window
))
247 XWarpPointer (GDK_WINDOW_XDISPLAY(window
),
248 None
, /* not source window -> move from anywhere */
249 GDK_WINDOW_XID(window
), /* dest window */
250 0, 0, 0, 0, /* not source window -> move from anywhere */
256 //-----------------------------------------------------------------------------
257 // "size_request" of m_widget
258 //-----------------------------------------------------------------------------
262 wxgtk_window_size_request_callback(GtkWidget
* WXUNUSED(widget
),
263 GtkRequisition
*requisition
,
267 win
->GetSize( &w
, &h
);
273 requisition
->height
= h
;
274 requisition
->width
= w
;
278 //-----------------------------------------------------------------------------
279 // "expose_event" of m_wxwindow
280 //-----------------------------------------------------------------------------
284 gtk_window_expose_callback( GtkWidget
* widget
,
285 GdkEventExpose
*gdk_event
,
288 if (gdk_event
->window
== widget
->window
)
290 win
->GetUpdateRegion() = wxRegion( gdk_event
->region
);
291 win
->GtkSendPaintEvents();
293 // Let parent window draw window-less widgets
298 #ifndef __WXUNIVERSAL__
299 //-----------------------------------------------------------------------------
300 // "expose_event" from m_wxwindow->parent, for drawing border
301 //-----------------------------------------------------------------------------
305 expose_event_border(GtkWidget
* widget
, GdkEventExpose
* gdk_event
, wxWindow
* win
)
307 if (gdk_event
->window
!= widget
->window
)
310 const GtkAllocation
& alloc
= win
->m_wxwindow
->allocation
;
311 const int x
= alloc
.x
;
312 const int y
= alloc
.y
;
313 const int w
= alloc
.width
;
314 const int h
= alloc
.height
;
316 if (w
<= 0 || h
<= 0)
319 if (win
->HasFlag(wxBORDER_SIMPLE
))
321 gdk_draw_rectangle(gdk_event
->window
,
322 widget
->style
->black_gc
, false, x
, y
, w
- 1, h
- 1);
326 GtkShadowType shadow
= GTK_SHADOW_IN
;
327 if (win
->HasFlag(wxBORDER_RAISED
))
328 shadow
= GTK_SHADOW_OUT
;
330 // Style detail to use
332 if (win
->m_widget
== win
->m_wxwindow
)
333 // for non-scrollable wxWindows
336 // for scrollable ones
340 win
->m_wxwindow
->style
, gdk_event
->window
, GTK_STATE_NORMAL
,
341 shadow
, NULL
, wxGTKPrivate::GetEntryWidget(), detail
, x
, y
, w
, h
);
347 //-----------------------------------------------------------------------------
348 // "parent_set" from m_wxwindow
349 //-----------------------------------------------------------------------------
353 parent_set(GtkWidget
* widget
, GtkObject
* old_parent
, wxWindow
* win
)
357 g_signal_handlers_disconnect_by_func(
358 old_parent
, (void*)expose_event_border
, win
);
362 g_signal_connect_after(widget
->parent
, "expose_event",
363 G_CALLBACK(expose_event_border
), win
);
367 #endif // !__WXUNIVERSAL__
369 //-----------------------------------------------------------------------------
370 // "key_press_event" from any window
371 //-----------------------------------------------------------------------------
373 // These are used when transforming Ctrl-alpha to ascii values 1-26
374 inline bool wxIsLowerChar(int code
)
376 return (code
>= 'a' && code
<= 'z' );
379 inline bool wxIsUpperChar(int code
)
381 return (code
>= 'A' && code
<= 'Z' );
385 // set WXTRACE to this to see the key event codes on the console
386 #define TRACE_KEYS _T("keyevent")
388 // translates an X key symbol to WXK_XXX value
390 // if isChar is true it means that the value returned will be used for EVT_CHAR
391 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
392 // for example, while if it is false it means that the value is going to be
393 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
395 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
401 // Shift, Control and Alt don't generate the CHAR events at all
404 key_code
= isChar
? 0 : WXK_SHIFT
;
408 key_code
= isChar
? 0 : WXK_CONTROL
;
416 key_code
= isChar
? 0 : WXK_ALT
;
419 // neither do the toggle modifies
420 case GDK_Scroll_Lock
:
421 key_code
= isChar
? 0 : WXK_SCROLL
;
425 key_code
= isChar
? 0 : WXK_CAPITAL
;
429 key_code
= isChar
? 0 : WXK_NUMLOCK
;
433 // various other special keys
446 case GDK_ISO_Left_Tab
:
453 key_code
= WXK_RETURN
;
457 key_code
= WXK_CLEAR
;
461 key_code
= WXK_PAUSE
;
465 key_code
= WXK_SELECT
;
469 key_code
= WXK_PRINT
;
473 key_code
= WXK_EXECUTE
;
477 key_code
= WXK_ESCAPE
;
480 // cursor and other extended keyboard keys
482 key_code
= WXK_DELETE
;
498 key_code
= WXK_RIGHT
;
505 case GDK_Prior
: // == GDK_Page_Up
506 key_code
= WXK_PAGEUP
;
509 case GDK_Next
: // == GDK_Page_Down
510 key_code
= WXK_PAGEDOWN
;
522 key_code
= WXK_INSERT
;
537 key_code
= (isChar
? '0' : int(WXK_NUMPAD0
)) + keysym
- GDK_KP_0
;
541 key_code
= isChar
? ' ' : int(WXK_NUMPAD_SPACE
);
545 key_code
= isChar
? WXK_TAB
: WXK_NUMPAD_TAB
;
549 key_code
= isChar
? WXK_RETURN
: WXK_NUMPAD_ENTER
;
553 key_code
= isChar
? WXK_F1
: WXK_NUMPAD_F1
;
557 key_code
= isChar
? WXK_F2
: WXK_NUMPAD_F2
;
561 key_code
= isChar
? WXK_F3
: WXK_NUMPAD_F3
;
565 key_code
= isChar
? WXK_F4
: WXK_NUMPAD_F4
;
569 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_HOME
;
573 key_code
= isChar
? WXK_LEFT
: WXK_NUMPAD_LEFT
;
577 key_code
= isChar
? WXK_UP
: WXK_NUMPAD_UP
;
581 key_code
= isChar
? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
585 key_code
= isChar
? WXK_DOWN
: WXK_NUMPAD_DOWN
;
588 case GDK_KP_Prior
: // == GDK_KP_Page_Up
589 key_code
= isChar
? WXK_PAGEUP
: WXK_NUMPAD_PAGEUP
;
592 case GDK_KP_Next
: // == GDK_KP_Page_Down
593 key_code
= isChar
? WXK_PAGEDOWN
: WXK_NUMPAD_PAGEDOWN
;
597 key_code
= isChar
? WXK_END
: WXK_NUMPAD_END
;
601 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_BEGIN
;
605 key_code
= isChar
? WXK_INSERT
: WXK_NUMPAD_INSERT
;
609 key_code
= isChar
? WXK_DELETE
: WXK_NUMPAD_DELETE
;
613 key_code
= isChar
? '=' : int(WXK_NUMPAD_EQUAL
);
616 case GDK_KP_Multiply
:
617 key_code
= isChar
? '*' : int(WXK_NUMPAD_MULTIPLY
);
621 key_code
= isChar
? '+' : int(WXK_NUMPAD_ADD
);
624 case GDK_KP_Separator
:
625 // FIXME: what is this?
626 key_code
= isChar
? '.' : int(WXK_NUMPAD_SEPARATOR
);
629 case GDK_KP_Subtract
:
630 key_code
= isChar
? '-' : int(WXK_NUMPAD_SUBTRACT
);
634 key_code
= isChar
? '.' : int(WXK_NUMPAD_DECIMAL
);
638 key_code
= isChar
? '/' : int(WXK_NUMPAD_DIVIDE
);
655 key_code
= WXK_F1
+ keysym
- GDK_F1
;
665 static inline bool wxIsAsciiKeysym(KeySym ks
)
670 static void wxFillOtherKeyEventFields(wxKeyEvent
& event
,
672 GdkEventKey
*gdk_event
)
676 GdkModifierType state
;
677 if (gdk_event
->window
)
678 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
680 event
.SetTimestamp( gdk_event
->time
);
681 event
.SetId(win
->GetId());
682 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
683 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
684 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
685 event
.m_metaDown
= (gdk_event
->state
& GDK_META_MASK
) != 0;
686 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
687 event
.m_rawFlags
= 0;
689 event
.m_uniChar
= gdk_keyval_to_unicode(gdk_event
->keyval
);
691 wxGetMousePosition( &x
, &y
);
692 win
->ScreenToClient( &x
, &y
);
695 event
.SetEventObject( win
);
700 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
702 GdkEventKey
*gdk_event
)
704 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
705 // but only event->keyval which is quite useless to us, so remember
706 // the last character from GDK_KEY_PRESS and reuse it as last resort
708 // NB: should be MT-safe as we're always called from the main thread only
713 } s_lastKeyPress
= { 0, 0 };
715 KeySym keysym
= gdk_event
->keyval
;
717 wxLogTrace(TRACE_KEYS
, _T("Key %s event: keysym = %ld"),
718 event
.GetEventType() == wxEVT_KEY_UP
? _T("release")
722 long key_code
= wxTranslateKeySymToWXKey(keysym
, false /* !isChar */);
726 // do we have the translation or is it a plain ASCII character?
727 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
729 // we should use keysym if it is ASCII as X does some translations
730 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
731 // which we don't want here (but which we do use for OnChar())
732 if ( !wxIsAsciiKeysym(keysym
) )
734 keysym
= (KeySym
)gdk_event
->string
[0];
737 // we want to always get the same key code when the same key is
738 // pressed regardless of the state of the modifiers, i.e. on a
739 // standard US keyboard pressing '5' or '%' ('5' key with
740 // Shift) should result in the same key code in OnKeyDown():
741 // '5' (although OnChar() will get either '5' or '%').
743 // to do it we first translate keysym to keycode (== scan code)
744 // and then back but always using the lower register
745 Display
*dpy
= (Display
*)wxGetDisplay();
746 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
748 wxLogTrace(TRACE_KEYS
, _T("\t-> keycode %d"), keycode
);
750 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
752 // use the normalized, i.e. lower register, keysym if we've
754 key_code
= keysymNormalized
? keysymNormalized
: keysym
;
756 // as explained above, we want to have lower register key codes
757 // normally but for the letter keys we want to have the upper ones
759 // NB: don't use XConvertCase() here, we want to do it for letters
761 key_code
= toupper(key_code
);
763 else // non ASCII key, what to do?
765 // by default, ignore it
768 // but if we have cached information from the last KEY_PRESS
769 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
772 if ( keysym
== s_lastKeyPress
.keysym
)
774 key_code
= s_lastKeyPress
.keycode
;
779 if ( gdk_event
->type
== GDK_KEY_PRESS
)
781 // remember it to be reused for KEY_UP event later
782 s_lastKeyPress
.keysym
= keysym
;
783 s_lastKeyPress
.keycode
= key_code
;
787 wxLogTrace(TRACE_KEYS
, _T("\t-> wxKeyCode %ld"), key_code
);
789 // sending unknown key events doesn't really make sense
793 // now fill all the other fields
794 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
796 event
.m_keyCode
= key_code
;
798 if ( gdk_event
->type
== GDK_KEY_PRESS
|| gdk_event
->type
== GDK_KEY_RELEASE
)
800 event
.m_uniChar
= key_code
;
810 GtkIMContext
*context
;
811 GdkEventKey
*lastKeyEvent
;
815 context
= gtk_im_multicontext_new();
820 g_object_unref (context
);
826 gtk_window_key_press_callback( GtkWidget
*WXUNUSED(widget
),
827 GdkEventKey
*gdk_event
,
832 if (g_blockEventsOnDrag
)
835 wxKeyEvent
event( wxEVT_KEY_DOWN
);
837 bool return_after_IM
= false;
839 if( wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
841 // Emit KEY_DOWN event
842 ret
= win
->HandleWindowEvent( event
);
846 // Return after IM processing as we cannot do
847 // anything with it anyhow.
848 return_after_IM
= true;
851 if ((!ret
) && (win
->m_imData
!= NULL
))
853 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
854 // docs, if IM filter returns true, no further processing should be done.
855 // we should send the key_down event anyway.
856 bool intercepted_by_IM
= gtk_im_context_filter_keypress(win
->m_imData
->context
, gdk_event
);
857 win
->m_imData
->lastKeyEvent
= NULL
;
858 if (intercepted_by_IM
)
860 wxLogTrace(TRACE_KEYS
, _T("Key event intercepted by IM"));
871 wxWindowGTK
*ancestor
= win
;
874 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
877 wxCommandEvent
menu_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
878 ret
= ancestor
->HandleWindowEvent( menu_event
);
882 // if the accelerator wasn't handled as menu event, try
883 // it as button click (for compatibility with other
885 wxCommandEvent
button_event( wxEVT_COMMAND_BUTTON_CLICKED
, command
);
886 ret
= ancestor
->HandleWindowEvent( button_event
);
891 if (ancestor
->IsTopLevel())
893 ancestor
= ancestor
->GetParent();
896 #endif // wxUSE_ACCEL
898 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
899 // will only be sent if it is not in an accelerator table.
903 KeySym keysym
= gdk_event
->keyval
;
904 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
905 key_code
= wxTranslateKeySymToWXKey(keysym
, true /* isChar */);
908 if ( wxIsAsciiKeysym(keysym
) )
911 key_code
= (unsigned char)keysym
;
913 // gdk_event->string is actually deprecated
914 else if ( gdk_event
->length
== 1 )
916 key_code
= (unsigned char)gdk_event
->string
[0];
922 wxLogTrace(TRACE_KEYS
, _T("Char event: %ld"), key_code
);
924 event
.m_keyCode
= key_code
;
926 // To conform to the docs we need to translate Ctrl-alpha
927 // characters to values in the range 1-26.
928 if ( event
.ControlDown() &&
929 ( wxIsLowerChar(key_code
) || wxIsUpperChar(key_code
) ))
931 if ( wxIsLowerChar(key_code
) )
932 event
.m_keyCode
= key_code
- 'a' + 1;
933 if ( wxIsUpperChar(key_code
) )
934 event
.m_keyCode
= key_code
- 'A' + 1;
936 event
.m_uniChar
= event
.m_keyCode
;
940 // Implement OnCharHook by checking ancestor top level windows
941 wxWindow
*parent
= win
;
942 while (parent
&& !parent
->IsTopLevel())
943 parent
= parent
->GetParent();
946 event
.SetEventType( wxEVT_CHAR_HOOK
);
947 ret
= parent
->HandleWindowEvent( event
);
952 event
.SetEventType(wxEVT_CHAR
);
953 ret
= win
->HandleWindowEvent( event
);
964 gtk_wxwindow_commit_cb (GtkIMContext
* WXUNUSED(context
),
968 wxKeyEvent
event( wxEVT_KEY_DOWN
);
970 // take modifiers, cursor position, timestamp etc. from the last
971 // key_press_event that was fed into Input Method:
972 if (window
->m_imData
->lastKeyEvent
)
974 wxFillOtherKeyEventFields(event
,
975 window
, window
->m_imData
->lastKeyEvent
);
979 event
.SetEventObject( window
);
982 const wxString
data(wxGTK_CONV_BACK_SYS(str
));
988 // Implement OnCharHook by checking ancestor top level windows
989 wxWindow
*parent
= window
;
990 while (parent
&& !parent
->IsTopLevel())
991 parent
= parent
->GetParent();
993 for( wxString::const_iterator pstr
= data
.begin(); pstr
!= data
.end(); ++pstr
)
996 event
.m_uniChar
= *pstr
;
997 // Backward compatible for ISO-8859-1
998 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
999 wxLogTrace(TRACE_KEYS
, _T("IM sent character '%c'"), event
.m_uniChar
);
1001 event
.m_keyCode
= (char)*pstr
;
1002 #endif // wxUSE_UNICODE
1004 // To conform to the docs we need to translate Ctrl-alpha
1005 // characters to values in the range 1-26.
1006 if ( event
.ControlDown() &&
1007 ( wxIsLowerChar(*pstr
) || wxIsUpperChar(*pstr
) ))
1009 if ( wxIsLowerChar(*pstr
) )
1010 event
.m_keyCode
= *pstr
- 'a' + 1;
1011 if ( wxIsUpperChar(*pstr
) )
1012 event
.m_keyCode
= *pstr
- 'A' + 1;
1014 event
.m_keyCode
= *pstr
- 'a' + 1;
1016 event
.m_uniChar
= event
.m_keyCode
;
1022 event
.SetEventType( wxEVT_CHAR_HOOK
);
1023 ret
= parent
->HandleWindowEvent( event
);
1028 event
.SetEventType(wxEVT_CHAR
);
1029 ret
= window
->HandleWindowEvent( event
);
1036 //-----------------------------------------------------------------------------
1037 // "key_release_event" from any window
1038 //-----------------------------------------------------------------------------
1042 gtk_window_key_release_callback( GtkWidget
* WXUNUSED(widget
),
1043 GdkEventKey
*gdk_event
,
1049 if (g_blockEventsOnDrag
)
1052 wxKeyEvent
event( wxEVT_KEY_UP
);
1053 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1055 // unknown key pressed, ignore (the event would be useless anyhow)
1059 return win
->GTKProcessEvent(event
);
1063 // ============================================================================
1065 // ============================================================================
1067 // ----------------------------------------------------------------------------
1068 // mouse event processing helpers
1069 // ----------------------------------------------------------------------------
1071 // init wxMouseEvent with the info from GdkEventXXX struct
1072 template<typename T
> void InitMouseEvent(wxWindowGTK
*win
,
1073 wxMouseEvent
& event
,
1076 event
.SetTimestamp( gdk_event
->time
);
1077 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
1078 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
1079 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
1080 event
.m_metaDown
= (gdk_event
->state
& GDK_META_MASK
) != 0;
1081 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
) != 0;
1082 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
) != 0;
1083 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
) != 0;
1084 event
.m_aux1Down
= (gdk_event
->state
& GDK_BUTTON4_MASK
) != 0;
1085 event
.m_aux2Down
= (gdk_event
->state
& GDK_BUTTON5_MASK
) != 0;
1087 wxPoint pt
= win
->GetClientAreaOrigin();
1088 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1089 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1091 if ((win
->m_wxwindow
) && (win
->GetLayoutDirection() == wxLayout_RightToLeft
))
1093 // origin in the upper right corner
1094 int window_width
= win
->m_wxwindow
->allocation
.width
;
1095 event
.m_x
= window_width
- event
.m_x
;
1098 event
.SetEventObject( win
);
1099 event
.SetId( win
->GetId() );
1100 event
.SetTimestamp( gdk_event
->time
);
1103 static void AdjustEventButtonState(wxMouseEvent
& event
)
1105 // GDK reports the old state of the button for a button press event, but
1106 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1107 // for a LEFT_DOWN event, not FALSE, so we will invert
1108 // left/right/middleDown for the corresponding click events
1110 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1111 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1112 (event
.GetEventType() == wxEVT_LEFT_UP
))
1114 event
.m_leftDown
= !event
.m_leftDown
;
1118 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1119 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1120 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1122 event
.m_middleDown
= !event
.m_middleDown
;
1126 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1127 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1128 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1130 event
.m_rightDown
= !event
.m_rightDown
;
1135 // find the window to send the mouse event too
1137 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1142 if (win
->m_wxwindow
)
1144 wxPizza
* pizza
= WX_PIZZA(win
->m_wxwindow
);
1145 xx
+= pizza
->m_scroll_x
;
1146 yy
+= pizza
->m_scroll_y
;
1149 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
1152 wxWindowGTK
*child
= node
->GetData();
1154 node
= node
->GetNext();
1155 if (!child
->IsShown())
1158 if (child
->GTKIsTransparentForMouse())
1160 // wxStaticBox is transparent in the box itself
1161 int xx1
= child
->m_x
;
1162 int yy1
= child
->m_y
;
1163 int xx2
= child
->m_x
+ child
->m_width
;
1164 int yy2
= child
->m_y
+ child
->m_height
;
1167 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1169 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1171 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1173 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1184 if ((child
->m_wxwindow
== NULL
) &&
1185 (child
->m_x
<= xx
) &&
1186 (child
->m_y
<= yy
) &&
1187 (child
->m_x
+child
->m_width
>= xx
) &&
1188 (child
->m_y
+child
->m_height
>= yy
))
1201 // ----------------------------------------------------------------------------
1202 // common event handlers helpers
1203 // ----------------------------------------------------------------------------
1205 bool wxWindowGTK::GTKProcessEvent(wxEvent
& event
) const
1207 // nothing special at this level
1208 return HandleWindowEvent(event
);
1211 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny
*event
) const
1215 if (g_blockEventsOnDrag
)
1217 if (g_blockEventsOnScroll
)
1220 if (!GTKIsOwnWindow(event
->window
))
1226 // overloads for all GDK event types we use here: we need to have this as
1227 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1228 // derives from it in the sense that the structs have the same layout
1229 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1230 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1232 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1235 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton
)
1236 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion
)
1237 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing
)
1239 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1241 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1242 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1246 // all event handlers must have C linkage as they're called from GTK+ C code
1250 //-----------------------------------------------------------------------------
1251 // "button_press_event"
1252 //-----------------------------------------------------------------------------
1255 gtk_window_button_press_callback( GtkWidget
*widget
,
1256 GdkEventButton
*gdk_event
,
1259 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1261 g_lastButtonNumber
= gdk_event
->button
;
1263 // GDK sends surplus button down events
1264 // before a double click event. We
1265 // need to filter these out.
1266 if ((gdk_event
->type
== GDK_BUTTON_PRESS
) && (win
->m_wxwindow
))
1268 GdkEvent
*peek_event
= gdk_event_peek();
1271 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1272 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1274 gdk_event_free( peek_event
);
1279 gdk_event_free( peek_event
);
1284 wxEventType event_type
= wxEVT_NULL
;
1286 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1287 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1289 // Reset GDK internal timestamp variables in order to disable GDK
1290 // triple click events. GDK will then next time believe no button has
1291 // been clicked just before, and send a normal button click event.
1292 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1293 display
->button_click_time
[1] = 0;
1294 display
->button_click_time
[0] = 0;
1297 if (gdk_event
->button
== 1)
1299 // note that GDK generates triple click events which are not supported
1300 // by wxWidgets but still have to be passed to the app as otherwise
1301 // clicks would simply go missing
1302 switch (gdk_event
->type
)
1304 // we shouldn't get triple clicks at all for GTK2 because we
1305 // suppress them artificially using the code above but we still
1306 // should map them to something for GTK1 and not just ignore them
1307 // as this would lose clicks
1308 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1309 case GDK_BUTTON_PRESS
:
1310 event_type
= wxEVT_LEFT_DOWN
;
1313 case GDK_2BUTTON_PRESS
:
1314 event_type
= wxEVT_LEFT_DCLICK
;
1318 // just to silence gcc warnings
1322 else if (gdk_event
->button
== 2)
1324 switch (gdk_event
->type
)
1326 case GDK_3BUTTON_PRESS
:
1327 case GDK_BUTTON_PRESS
:
1328 event_type
= wxEVT_MIDDLE_DOWN
;
1331 case GDK_2BUTTON_PRESS
:
1332 event_type
= wxEVT_MIDDLE_DCLICK
;
1339 else if (gdk_event
->button
== 3)
1341 switch (gdk_event
->type
)
1343 case GDK_3BUTTON_PRESS
:
1344 case GDK_BUTTON_PRESS
:
1345 event_type
= wxEVT_RIGHT_DOWN
;
1348 case GDK_2BUTTON_PRESS
:
1349 event_type
= wxEVT_RIGHT_DCLICK
;
1357 if ( event_type
== wxEVT_NULL
)
1359 // unknown mouse button or click type
1363 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1365 wxMouseEvent
event( event_type
);
1366 InitMouseEvent( win
, event
, gdk_event
);
1368 AdjustEventButtonState(event
);
1370 // find the correct window to send the event to: it may be a different one
1371 // from the one which got it at GTK+ level because some controls don't have
1372 // their own X window and thus cannot get any events.
1373 if ( !g_captureWindow
)
1374 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1376 // reset the event object and id in case win changed.
1377 event
.SetEventObject( win
);
1378 event
.SetId( win
->GetId() );
1380 bool ret
= win
->GTKProcessEvent( event
);
1381 g_lastMouseEvent
= NULL
;
1385 if ((event_type
== wxEVT_LEFT_DOWN
) && !win
->IsOfStandardClass() &&
1386 (gs_currentFocus
!= win
) /* && win->IsFocusable() */)
1391 if (event_type
== wxEVT_RIGHT_DOWN
)
1393 // generate a "context menu" event: this is similar to right mouse
1394 // click under many GUIs except that it is generated differently
1395 // (right up under MSW, ctrl-click under Mac, right down here) and
1397 // (a) it's a command event and so is propagated to the parent
1398 // (b) under some ports it can be generated from kbd too
1399 // (c) it uses screen coords (because of (a))
1400 wxContextMenuEvent
evtCtx(
1403 win
->ClientToScreen(event
.GetPosition()));
1404 evtCtx
.SetEventObject(win
);
1405 return win
->GTKProcessEvent(evtCtx
);
1411 //-----------------------------------------------------------------------------
1412 // "button_release_event"
1413 //-----------------------------------------------------------------------------
1416 gtk_window_button_release_callback( GtkWidget
*WXUNUSED(widget
),
1417 GdkEventButton
*gdk_event
,
1420 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1422 g_lastButtonNumber
= 0;
1424 wxEventType event_type
= wxEVT_NULL
;
1426 switch (gdk_event
->button
)
1429 event_type
= wxEVT_LEFT_UP
;
1433 event_type
= wxEVT_MIDDLE_UP
;
1437 event_type
= wxEVT_RIGHT_UP
;
1441 // unknown button, don't process
1445 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1447 wxMouseEvent
event( event_type
);
1448 InitMouseEvent( win
, event
, gdk_event
);
1450 AdjustEventButtonState(event
);
1452 if ( !g_captureWindow
)
1453 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1455 // reset the event object and id in case win changed.
1456 event
.SetEventObject( win
);
1457 event
.SetId( win
->GetId() );
1459 bool ret
= win
->GTKProcessEvent(event
);
1461 g_lastMouseEvent
= NULL
;
1466 //-----------------------------------------------------------------------------
1467 // "motion_notify_event"
1468 //-----------------------------------------------------------------------------
1471 gtk_window_motion_notify_callback( GtkWidget
* WXUNUSED(widget
),
1472 GdkEventMotion
*gdk_event
,
1475 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1477 if (gdk_event
->is_hint
)
1481 GdkModifierType state
;
1482 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1487 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1489 wxMouseEvent
event( wxEVT_MOTION
);
1490 InitMouseEvent(win
, event
, gdk_event
);
1492 if ( g_captureWindow
)
1494 // synthesise a mouse enter or leave event if needed
1495 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1496 // This seems to be necessary and actually been added to
1497 // GDK itself in version 2.0.X
1500 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1501 if ( hasMouse
!= g_captureWindowHasMouse
)
1503 // the mouse changed window
1504 g_captureWindowHasMouse
= hasMouse
;
1506 wxMouseEvent
eventM(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1507 : wxEVT_LEAVE_WINDOW
);
1508 InitMouseEvent(win
, eventM
, gdk_event
);
1509 eventM
.SetEventObject(win
);
1510 win
->GTKProcessEvent(eventM
);
1515 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1517 // reset the event object and id in case win changed.
1518 event
.SetEventObject( win
);
1519 event
.SetId( win
->GetId() );
1522 if ( !g_captureWindow
)
1524 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1525 if (win
->GTKProcessEvent( cevent
))
1527 win
->SetCursor( cevent
.GetCursor() );
1531 bool ret
= win
->GTKProcessEvent(event
);
1533 g_lastMouseEvent
= NULL
;
1538 //-----------------------------------------------------------------------------
1539 // "scroll_event" (mouse wheel event)
1540 //-----------------------------------------------------------------------------
1543 window_scroll_event_hscrollbar(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1545 if (gdk_event
->direction
!= GDK_SCROLL_LEFT
&&
1546 gdk_event
->direction
!= GDK_SCROLL_RIGHT
)
1551 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1552 InitMouseEvent(win
, event
, gdk_event
);
1554 GtkRange
*range
= win
->m_scrollBar
[wxWindow::ScrollDir_Horz
];
1555 if (!range
) return FALSE
;
1557 if (range
&& GTK_WIDGET_VISIBLE (range
))
1559 GtkAdjustment
*adj
= range
->adjustment
;
1560 gdouble delta
= adj
->step_increment
* 3;
1561 if (gdk_event
->direction
== GDK_SCROLL_LEFT
)
1564 gdouble new_value
= CLAMP (adj
->value
+ delta
, adj
->lower
, adj
->upper
- adj
->page_size
);
1566 gtk_adjustment_set_value (adj
, new_value
);
1575 window_scroll_event(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1577 if (gdk_event
->direction
!= GDK_SCROLL_UP
&&
1578 gdk_event
->direction
!= GDK_SCROLL_DOWN
)
1583 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1584 InitMouseEvent(win
, event
, gdk_event
);
1586 // FIXME: Get these values from GTK or GDK
1587 event
.m_linesPerAction
= 3;
1588 event
.m_wheelDelta
= 120;
1589 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1590 event
.m_wheelRotation
= 120;
1592 event
.m_wheelRotation
= -120;
1594 if (win
->GTKProcessEvent(event
))
1597 GtkRange
*range
= win
->m_scrollBar
[wxWindow::ScrollDir_Vert
];
1598 if (!range
) return FALSE
;
1600 if (range
&& GTK_WIDGET_VISIBLE (range
))
1602 GtkAdjustment
*adj
= range
->adjustment
;
1603 gdouble delta
= adj
->step_increment
* 3;
1604 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1607 gdouble new_value
= CLAMP (adj
->value
+ delta
, adj
->lower
, adj
->upper
- adj
->page_size
);
1609 gtk_adjustment_set_value (adj
, new_value
);
1617 //-----------------------------------------------------------------------------
1619 //-----------------------------------------------------------------------------
1621 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
1623 wxContextMenuEvent
event(wxEVT_CONTEXT_MENU
, win
->GetId(), wxPoint(-1, -1));
1624 event
.SetEventObject(win
);
1625 return win
->GTKProcessEvent(event
);
1628 //-----------------------------------------------------------------------------
1630 //-----------------------------------------------------------------------------
1633 gtk_window_focus_in_callback( GtkWidget
* WXUNUSED(widget
),
1634 GdkEventFocus
*WXUNUSED(event
),
1637 return win
->GTKHandleFocusIn();
1640 //-----------------------------------------------------------------------------
1641 // "focus_out_event"
1642 //-----------------------------------------------------------------------------
1645 gtk_window_focus_out_callback( GtkWidget
* WXUNUSED(widget
),
1646 GdkEventFocus
* WXUNUSED(gdk_event
),
1649 return win
->GTKHandleFocusOut();
1652 //-----------------------------------------------------------------------------
1654 //-----------------------------------------------------------------------------
1657 wx_window_focus_callback(GtkWidget
*widget
,
1658 GtkDirectionType
WXUNUSED(direction
),
1661 // the default handler for focus signal in GtkScrolledWindow sets
1662 // focus to the window itself even if it doesn't accept focus, i.e. has no
1663 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1664 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1665 // any children which might accept focus (we know we don't accept the focus
1666 // ourselves as this signal is only connected in this case)
1667 if ( win
->GetChildren().empty() )
1668 g_signal_stop_emission_by_name(widget
, "focus");
1670 // we didn't change the focus
1674 //-----------------------------------------------------------------------------
1675 // "enter_notify_event"
1676 //-----------------------------------------------------------------------------
1679 gtk_window_enter_callback( GtkWidget
*widget
,
1680 GdkEventCrossing
*gdk_event
,
1683 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1685 // Event was emitted after a grab
1686 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1690 GdkModifierType state
= (GdkModifierType
)0;
1692 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1694 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1695 InitMouseEvent(win
, event
, gdk_event
);
1696 wxPoint pt
= win
->GetClientAreaOrigin();
1697 event
.m_x
= x
+ pt
.x
;
1698 event
.m_y
= y
+ pt
.y
;
1700 if ( !g_captureWindow
)
1702 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1703 if (win
->GTKProcessEvent( cevent
))
1705 win
->SetCursor( cevent
.GetCursor() );
1709 return win
->GTKProcessEvent(event
);
1712 //-----------------------------------------------------------------------------
1713 // "leave_notify_event"
1714 //-----------------------------------------------------------------------------
1717 gtk_window_leave_callback( GtkWidget
*widget
,
1718 GdkEventCrossing
*gdk_event
,
1721 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1723 // Event was emitted after an ungrab
1724 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1726 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1730 GdkModifierType state
= (GdkModifierType
)0;
1732 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1734 InitMouseEvent(win
, event
, gdk_event
);
1736 return win
->GTKProcessEvent(event
);
1739 //-----------------------------------------------------------------------------
1740 // "value_changed" from scrollbar
1741 //-----------------------------------------------------------------------------
1744 gtk_scrollbar_value_changed(GtkRange
* range
, wxWindow
* win
)
1746 wxEventType eventType
= win
->GTKGetScrollEventType(range
);
1747 if (eventType
!= wxEVT_NULL
)
1749 // Convert scroll event type to scrollwin event type
1750 eventType
+= wxEVT_SCROLLWIN_TOP
- wxEVT_SCROLL_TOP
;
1752 // find the scrollbar which generated the event
1753 wxWindowGTK::ScrollDir dir
= win
->ScrollDirFromRange(range
);
1755 // generate the corresponding wx event
1756 const int orient
= wxWindow::OrientFromScrollDir(dir
);
1757 wxScrollWinEvent
event(eventType
, win
->GetScrollPos(orient
), orient
);
1758 event
.SetEventObject(win
);
1760 win
->GTKProcessEvent(event
);
1764 //-----------------------------------------------------------------------------
1765 // "button_press_event" from scrollbar
1766 //-----------------------------------------------------------------------------
1769 gtk_scrollbar_button_press_event(GtkRange
*, GdkEventButton
*, wxWindow
* win
)
1771 g_blockEventsOnScroll
= true;
1772 win
->m_mouseButtonDown
= true;
1777 //-----------------------------------------------------------------------------
1778 // "event_after" from scrollbar
1779 //-----------------------------------------------------------------------------
1782 gtk_scrollbar_event_after(GtkRange
* range
, GdkEvent
* event
, wxWindow
* win
)
1784 if (event
->type
== GDK_BUTTON_RELEASE
)
1786 g_signal_handlers_block_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1788 const int orient
= wxWindow::OrientFromScrollDir(
1789 win
->ScrollDirFromRange(range
));
1790 wxScrollWinEvent
evt(wxEVT_SCROLLWIN_THUMBRELEASE
,
1791 win
->GetScrollPos(orient
), orient
);
1792 evt
.SetEventObject(win
);
1793 win
->GTKProcessEvent(evt
);
1797 //-----------------------------------------------------------------------------
1798 // "button_release_event" from scrollbar
1799 //-----------------------------------------------------------------------------
1802 gtk_scrollbar_button_release_event(GtkRange
* range
, GdkEventButton
*, wxWindow
* win
)
1804 g_blockEventsOnScroll
= false;
1805 win
->m_mouseButtonDown
= false;
1806 // If thumb tracking
1807 if (win
->m_isScrolling
)
1809 win
->m_isScrolling
= false;
1810 // Hook up handler to send thumb release event after this emission is finished.
1811 // To allow setting scroll position from event handler, sending event must
1812 // be deferred until after the GtkRange handler for this signal has run
1813 g_signal_handlers_unblock_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1819 //-----------------------------------------------------------------------------
1820 // "realize" from m_widget
1821 //-----------------------------------------------------------------------------
1824 gtk_window_realized_callback(GtkWidget
* widget
, wxWindow
* win
)
1828 gtk_im_context_set_client_window( win
->m_imData
->context
,
1832 // We cannot set colours and fonts before the widget
1833 // been realized, so we do this directly after realization
1834 // or otherwise in idle time
1836 if (win
->m_needsStyleChange
)
1838 win
->SetBackgroundStyle(win
->GetBackgroundStyle());
1839 win
->m_needsStyleChange
= false;
1842 wxWindowCreateEvent
event( win
);
1843 event
.SetEventObject( win
);
1844 win
->GTKProcessEvent( event
);
1847 //-----------------------------------------------------------------------------
1848 // "size_allocate" from m_wxwindow or m_widget
1849 //-----------------------------------------------------------------------------
1852 size_allocate(GtkWidget
*, GtkAllocation
* alloc
, wxWindow
* win
)
1854 int w
= alloc
->width
;
1855 int h
= alloc
->height
;
1856 if (win
->m_wxwindow
)
1858 int border_x
, border_y
;
1859 WX_PIZZA(win
->m_wxwindow
)->get_border_widths(border_x
, border_y
);
1865 if (win
->m_oldClientWidth
!= w
|| win
->m_oldClientHeight
!= h
)
1867 win
->m_oldClientWidth
= w
;
1868 win
->m_oldClientHeight
= h
;
1869 // this callback can be connected to m_wxwindow,
1870 // so always get size from m_widget->allocation
1871 win
->m_width
= win
->m_widget
->allocation
.width
;
1872 win
->m_height
= win
->m_widget
->allocation
.height
;
1873 if (!win
->m_nativeSizeEvent
)
1875 wxSizeEvent
event(win
->GetSize(), win
->GetId());
1876 event
.SetEventObject(win
);
1877 win
->GTKProcessEvent(event
);
1882 //-----------------------------------------------------------------------------
1884 //-----------------------------------------------------------------------------
1886 #if GTK_CHECK_VERSION(2, 8, 0)
1888 gtk_window_grab_broken( GtkWidget
*,
1889 GdkEventGrabBroken
*event
,
1892 // Mouse capture has been lost involuntarily, notify the application
1893 if(!event
->keyboard
&& wxWindow::GetCapture() == win
)
1895 wxMouseCaptureLostEvent
evt( win
->GetId() );
1896 evt
.SetEventObject( win
);
1897 win
->HandleWindowEvent( evt
);
1903 //-----------------------------------------------------------------------------
1905 //-----------------------------------------------------------------------------
1908 void gtk_window_style_set_callback( GtkWidget
*WXUNUSED(widget
),
1909 GtkStyle
*previous_style
,
1912 if (win
&& previous_style
)
1914 wxSysColourChangedEvent event
;
1915 event
.SetEventObject(win
);
1917 win
->GTKProcessEvent( event
);
1923 // Helper to suspend colour change event event processing while we change a widget's style
1924 class wxSuspendStyleEvents
1927 wxSuspendStyleEvents(wxWindow
* win
)
1930 if (win
->m_wxwindow
&& win
->IsTopLevel())
1933 g_signal_handlers_block_by_func(
1934 m_win
->m_wxwindow
, (void*)gtk_window_style_set_callback
, m_win
);
1937 ~wxSuspendStyleEvents()
1940 g_signal_handlers_unblock_by_func(
1941 m_win
->m_wxwindow
, (void*)gtk_window_style_set_callback
, m_win
);
1947 // ----------------------------------------------------------------------------
1948 // this wxWindowBase function is implemented here (in platform-specific file)
1949 // because it is static and so couldn't be made virtual
1950 // ----------------------------------------------------------------------------
1952 wxWindow
*wxWindowBase::DoFindFocus()
1954 wxWindowGTK
*focus
= gs_pendingFocus
? gs_pendingFocus
: gs_currentFocus
;
1955 // the cast is necessary when we compile in wxUniversal mode
1956 return static_cast<wxWindow
*>(focus
);
1959 void wxWindowGTK::AddChildGTK(wxWindowGTK
* child
)
1961 /* the window might have been scrolled already, do we
1962 have to adapt the position */
1963 wxPizza
* pizza
= WX_PIZZA(m_wxwindow
);
1964 child
->m_x
+= pizza
->m_scroll_x
;
1965 child
->m_y
+= pizza
->m_scroll_y
;
1967 gtk_widget_set_size_request(
1968 child
->m_widget
, child
->m_width
, child
->m_height
);
1970 GTK_FIXED(m_wxwindow
), child
->m_widget
, child
->m_x
, child
->m_y
);
1973 //-----------------------------------------------------------------------------
1975 //-----------------------------------------------------------------------------
1977 wxWindow
*wxGetActiveWindow()
1979 return wxWindow::FindFocus();
1983 wxMouseState
wxGetMouseState()
1989 GdkModifierType mask
;
1991 gdk_window_get_pointer(NULL
, &x
, &y
, &mask
);
1995 ms
.SetLeftDown((mask
& GDK_BUTTON1_MASK
) != 0);
1996 ms
.SetMiddleDown((mask
& GDK_BUTTON2_MASK
) != 0);
1997 ms
.SetRightDown((mask
& GDK_BUTTON3_MASK
) != 0);
1998 ms
.SetAux1Down((mask
& GDK_BUTTON4_MASK
) != 0);
1999 ms
.SetAux2Down((mask
& GDK_BUTTON5_MASK
) != 0);
2001 ms
.SetControlDown((mask
& GDK_CONTROL_MASK
) != 0);
2002 ms
.SetShiftDown((mask
& GDK_SHIFT_MASK
) != 0);
2003 ms
.SetAltDown((mask
& GDK_MOD1_MASK
) != 0);
2004 ms
.SetMetaDown((mask
& GDK_META_MASK
) != 0);
2009 //-----------------------------------------------------------------------------
2011 //-----------------------------------------------------------------------------
2013 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2015 #ifdef __WXUNIVERSAL__
2016 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2018 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
2019 #endif // __WXUNIVERSAL__/__WXGTK__
2021 void wxWindowGTK::Init()
2026 m_focusWidget
= NULL
;
2036 m_showOnIdle
= false;
2039 m_nativeSizeEvent
= false;
2041 m_isScrolling
= false;
2042 m_mouseButtonDown
= false;
2044 // initialize scrolling stuff
2045 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2047 m_scrollBar
[dir
] = NULL
;
2048 m_scrollPos
[dir
] = 0;
2052 m_oldClientHeight
= 0;
2054 m_clipPaintRegion
= false;
2056 m_needsStyleChange
= false;
2058 m_cursor
= *wxSTANDARD_CURSOR
;
2061 m_dirtyTabOrder
= false;
2064 wxWindowGTK::wxWindowGTK()
2069 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2074 const wxString
&name
)
2078 Create( parent
, id
, pos
, size
, style
, name
);
2081 bool wxWindowGTK::Create( wxWindow
*parent
,
2086 const wxString
&name
)
2088 // Get default border
2089 wxBorder border
= GetBorder(style
);
2091 style
&= ~wxBORDER_MASK
;
2094 if (!PreCreation( parent
, pos
, size
) ||
2095 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2097 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2101 // We should accept the native look
2103 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2104 scroll_class
->scrollbar_spacing
= 0;
2108 m_wxwindow
= wxPizza::New(m_windowStyle
,this);
2109 #ifndef __WXUNIVERSAL__
2110 if (HasFlag(wxPizza::BORDER_STYLES
))
2112 g_signal_connect(m_wxwindow
, "parent_set",
2113 G_CALLBACK(parent_set
), this);
2116 if (!HasFlag(wxHSCROLL
) && !HasFlag(wxVSCROLL
))
2117 m_widget
= m_wxwindow
;
2120 m_widget
= gtk_scrolled_window_new( NULL
, NULL
);
2122 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2124 // There is a conflict with default bindings at GTK+
2125 // level between scrolled windows and notebooks both of which want to use
2126 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2127 // direction and notebooks for changing pages -- we decide that if we don't
2128 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2129 // means we can get working keyboard navigation in notebooks
2130 if ( !HasFlag(wxHSCROLL
) )
2133 bindings
= gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget
));
2136 gtk_binding_entry_remove(bindings
, GDK_Page_Up
, GDK_CONTROL_MASK
);
2137 gtk_binding_entry_remove(bindings
, GDK_Page_Down
, GDK_CONTROL_MASK
);
2141 if (HasFlag(wxALWAYS_SHOW_SB
))
2143 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_ALWAYS
, GTK_POLICY_ALWAYS
);
2145 scrolledWindow
->hscrollbar_visible
= TRUE
;
2146 scrolledWindow
->vscrollbar_visible
= TRUE
;
2150 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2153 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(scrolledWindow
->hscrollbar
);
2154 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(scrolledWindow
->vscrollbar
);
2155 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2156 gtk_range_set_inverted( m_scrollBar
[ScrollDir_Horz
], TRUE
);
2158 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2160 // connect various scroll-related events
2161 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2163 // these handlers block mouse events to any window during scrolling
2164 // such as motion events and prevent GTK and wxWidgets from fighting
2165 // over where the slider should be
2166 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2167 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2168 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2169 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2171 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2172 G_CALLBACK(gtk_scrollbar_event_after
), this);
2173 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2175 // these handlers get notified when scrollbar slider moves
2176 g_signal_connect_after(m_scrollBar
[dir
], "value_changed",
2177 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2180 gtk_widget_show( m_wxwindow
);
2182 g_object_ref(m_widget
);
2185 m_parent
->DoAddChild( this );
2187 m_focusWidget
= m_wxwindow
;
2189 SetCanFocus(AcceptsFocus());
2196 wxWindowGTK::~wxWindowGTK()
2200 if (gs_currentFocus
== this)
2201 gs_currentFocus
= NULL
;
2202 if (gs_pendingFocus
== this)
2203 gs_pendingFocus
= NULL
;
2205 if ( gs_deferredFocusOut
== this )
2206 gs_deferredFocusOut
= NULL
;
2210 // destroy children before destroying this window itself
2213 // unhook focus handlers to prevent stray events being
2214 // propagated to this (soon to be) dead object
2215 if (m_focusWidget
!= NULL
)
2217 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2218 (gpointer
) gtk_window_focus_in_callback
,
2220 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2221 (gpointer
) gtk_window_focus_out_callback
,
2228 // delete before the widgets to avoid a crash on solaris
2233 // Note that gtk_widget_destroy() does not destroy the widget, it just
2234 // emits the "destroy" signal. The widget is not actually destroyed
2235 // until its reference count drops to zero.
2236 gtk_widget_destroy(m_widget
);
2237 // Release our reference, should be the last one
2238 g_object_unref(m_widget
);
2244 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2246 if ( GTKNeedsParent() )
2248 wxCHECK_MSG( parent
, false, wxT("Must have non-NULL parent") );
2251 // Use either the given size, or the default if -1 is given.
2252 // See wxWindowBase for these functions.
2253 m_width
= WidthDefault(size
.x
) ;
2254 m_height
= HeightDefault(size
.y
);
2262 void wxWindowGTK::PostCreation()
2264 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2270 // these get reported to wxWidgets -> wxPaintEvent
2272 g_signal_connect (m_wxwindow
, "expose_event",
2273 G_CALLBACK (gtk_window_expose_callback
), this);
2275 if (GetLayoutDirection() == wxLayout_LeftToRight
)
2276 gtk_widget_set_redraw_on_allocate(m_wxwindow
, HasFlag(wxFULL_REPAINT_ON_RESIZE
));
2279 // Create input method handler
2280 m_imData
= new wxGtkIMData
;
2282 // Cannot handle drawing preedited text yet
2283 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2285 g_signal_connect (m_imData
->context
, "commit",
2286 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2291 if (!GTK_IS_WINDOW(m_widget
))
2293 if (m_focusWidget
== NULL
)
2294 m_focusWidget
= m_widget
;
2298 g_signal_connect (m_focusWidget
, "focus_in_event",
2299 G_CALLBACK (gtk_window_focus_in_callback
), this);
2300 g_signal_connect (m_focusWidget
, "focus_out_event",
2301 G_CALLBACK (gtk_window_focus_out_callback
), this);
2305 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2306 G_CALLBACK (gtk_window_focus_in_callback
), this);
2307 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2308 G_CALLBACK (gtk_window_focus_out_callback
), this);
2312 if ( !AcceptsFocusFromKeyboard() )
2316 g_signal_connect(m_widget
, "focus",
2317 G_CALLBACK(wx_window_focus_callback
), this);
2320 // connect to the various key and mouse handlers
2322 GtkWidget
*connect_widget
= GetConnectWidget();
2324 ConnectWidget( connect_widget
);
2326 /* We cannot set colours, fonts and cursors before the widget has
2327 been realized, so we do this directly after realization */
2328 g_signal_connect (connect_widget
, "realize",
2329 G_CALLBACK (gtk_window_realized_callback
), this);
2333 g_signal_connect(m_wxwindow
? m_wxwindow
: m_widget
, "size_allocate",
2334 G_CALLBACK(size_allocate
), this);
2339 #if GTK_CHECK_VERSION(2, 8, 0)
2340 if (!gtk_check_version(2,8,0))
2342 // Make sure we can notify the app when mouse capture is lost
2343 g_signal_connect (m_wxwindow
, "grab_broken_event",
2344 G_CALLBACK (gtk_window_grab_broken
), this);
2349 if ( connect_widget
!= m_wxwindow
)
2351 #if GTK_CHECK_VERSION(2, 8, 0)
2352 if (!gtk_check_version(2,8,0))
2354 // Make sure we can notify app code when mouse capture is lost
2355 g_signal_connect (connect_widget
, "grab_broken_event",
2356 G_CALLBACK (gtk_window_grab_broken
), this);
2361 #ifdef GTK_IS_FILE_CHOOSER_BUTTON
2362 if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget
))
2364 // If we connect to the "size_request" signal of a GtkFileChooserButton
2365 // then that control won't be sized properly when placed inside sizers
2366 // (this can be tested removing this elseif and running XRC or WIDGETS samples)
2367 // FIXME: what should be done here ?
2370 if ( !IsTopLevel() ) // top level windows use their own callback
2372 // This is needed if we want to add our windows into native
2373 // GTK controls, such as the toolbar. With this callback, the
2374 // toolbar gets to know the correct size (the one set by the
2375 // programmer). Sadly, it misbehaves for wxComboBox.
2376 g_signal_connect (m_widget
, "size_request",
2377 G_CALLBACK (wxgtk_window_size_request_callback
),
2381 InheritAttributes();
2385 SetLayoutDirection(wxLayout_Default
);
2387 // unless the window was created initially hidden (i.e. Hide() had been
2388 // called before Create()), we should show it at GTK+ level as well
2390 gtk_widget_show( m_widget
);
2393 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2395 g_signal_connect (widget
, "key_press_event",
2396 G_CALLBACK (gtk_window_key_press_callback
), this);
2397 g_signal_connect (widget
, "key_release_event",
2398 G_CALLBACK (gtk_window_key_release_callback
), this);
2399 g_signal_connect (widget
, "button_press_event",
2400 G_CALLBACK (gtk_window_button_press_callback
), this);
2401 g_signal_connect (widget
, "button_release_event",
2402 G_CALLBACK (gtk_window_button_release_callback
), this);
2403 g_signal_connect (widget
, "motion_notify_event",
2404 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2406 g_signal_connect (widget
, "scroll_event",
2407 G_CALLBACK (window_scroll_event
), this);
2408 if (m_scrollBar
[ScrollDir_Horz
])
2409 g_signal_connect (m_scrollBar
[ScrollDir_Horz
], "scroll_event",
2410 G_CALLBACK (window_scroll_event_hscrollbar
), this);
2411 if (m_scrollBar
[ScrollDir_Vert
])
2412 g_signal_connect (m_scrollBar
[ScrollDir_Vert
], "scroll_event",
2413 G_CALLBACK (window_scroll_event
), this);
2415 g_signal_connect (widget
, "popup_menu",
2416 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2417 g_signal_connect (widget
, "enter_notify_event",
2418 G_CALLBACK (gtk_window_enter_callback
), this);
2419 g_signal_connect (widget
, "leave_notify_event",
2420 G_CALLBACK (gtk_window_leave_callback
), this);
2422 if (IsTopLevel() && m_wxwindow
)
2423 g_signal_connect (m_wxwindow
, "style_set",
2424 G_CALLBACK (gtk_window_style_set_callback
), this);
2427 bool wxWindowGTK::Destroy()
2429 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2433 return wxWindowBase::Destroy();
2436 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2438 gtk_widget_set_size_request(m_widget
, width
, height
);
2439 // inform the parent to perform the move
2440 WX_PIZZA(m_parent
->m_wxwindow
)->move(m_widget
, x
, y
);
2443 void wxWindowGTK::ConstrainSize()
2446 // GPE's window manager doesn't like size hints at all, esp. when the user
2447 // has to use the virtual keyboard, so don't constrain size there
2451 const wxSize minSize
= GetMinSize();
2452 const wxSize maxSize
= GetMaxSize();
2453 if (minSize
.x
> 0 && m_width
< minSize
.x
) m_width
= minSize
.x
;
2454 if (minSize
.y
> 0 && m_height
< minSize
.y
) m_height
= minSize
.y
;
2455 if (maxSize
.x
> 0 && m_width
> maxSize
.x
) m_width
= maxSize
.x
;
2456 if (maxSize
.y
> 0 && m_height
> maxSize
.y
) m_height
= maxSize
.y
;
2460 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2462 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2463 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2465 int currentX
, currentY
;
2466 GetPosition(¤tX
, ¤tY
);
2467 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2469 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2471 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2473 // calculate the best size if we should auto size the window
2474 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2475 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2477 const wxSize sizeBest
= GetBestSize();
2478 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2480 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2481 height
= sizeBest
.y
;
2484 const wxSize
oldSize(m_width
, m_height
);
2490 if (m_parent
->m_wxwindow
)
2492 wxPizza
* pizza
= WX_PIZZA(m_parent
->m_wxwindow
);
2493 m_x
= x
+ pizza
->m_scroll_x
;
2494 m_y
= y
+ pizza
->m_scroll_y
;
2496 int left_border
= 0;
2497 int right_border
= 0;
2499 int bottom_border
= 0;
2501 /* the default button has a border around it */
2502 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
2504 GtkBorder
*default_border
= NULL
;
2505 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2508 left_border
+= default_border
->left
;
2509 right_border
+= default_border
->right
;
2510 top_border
+= default_border
->top
;
2511 bottom_border
+= default_border
->bottom
;
2512 gtk_border_free( default_border
);
2516 DoMoveWindow( m_x
- left_border
,
2518 m_width
+left_border
+right_border
,
2519 m_height
+top_border
+bottom_border
);
2522 if (m_width
!= oldSize
.x
|| m_height
!= oldSize
.y
)
2524 // update these variables to keep size_allocate handler
2525 // from sending another size event for this change
2526 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2528 gtk_widget_queue_resize(m_widget
);
2529 if (!m_nativeSizeEvent
)
2531 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2532 event
.SetEventObject( this );
2533 HandleWindowEvent( event
);
2536 if (sizeFlags
& wxSIZE_FORCE_EVENT
)
2538 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2539 event
.SetEventObject( this );
2540 HandleWindowEvent( event
);
2544 bool wxWindowGTK::GTKShowFromOnIdle()
2546 if (IsShown() && m_showOnIdle
&& !GTK_WIDGET_VISIBLE (m_widget
))
2548 GtkAllocation alloc
;
2551 alloc
.width
= m_width
;
2552 alloc
.height
= m_height
;
2553 gtk_widget_size_allocate( m_widget
, &alloc
);
2554 gtk_widget_show( m_widget
);
2555 wxShowEvent
eventShow(GetId(), true);
2556 eventShow
.SetEventObject(this);
2557 HandleWindowEvent(eventShow
);
2558 m_showOnIdle
= false;
2565 void wxWindowGTK::OnInternalIdle()
2567 if ( gs_deferredFocusOut
)
2568 GTKHandleDeferredFocusOut();
2570 // Check if we have to show window now
2571 if (GTKShowFromOnIdle()) return;
2573 if ( m_dirtyTabOrder
)
2575 m_dirtyTabOrder
= false;
2579 // Update style if the window was not yet realized
2580 // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
2581 if (m_needsStyleChange
)
2583 SetBackgroundStyle(GetBackgroundStyle());
2584 m_needsStyleChange
= false;
2587 wxCursor cursor
= m_cursor
;
2588 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
2592 /* I now set the cursor anew in every OnInternalIdle call
2593 as setting the cursor in a parent window also effects the
2594 windows above so that checking for the current cursor is
2597 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
2599 GdkWindow
*window
= m_wxwindow
->window
;
2601 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2603 if (!g_globalCursor
.Ok())
2604 cursor
= *wxSTANDARD_CURSOR
;
2606 window
= m_widget
->window
;
2607 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
2608 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2611 else if ( m_widget
)
2613 GdkWindow
*window
= m_widget
->window
;
2614 if ( window
&& !GTK_WIDGET_NO_WINDOW(m_widget
) )
2615 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2619 if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
2620 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
2623 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
2625 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2627 if (width
) (*width
) = m_width
;
2628 if (height
) (*height
) = m_height
;
2631 void wxWindowGTK::DoSetClientSize( int width
, int height
)
2633 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2635 const wxSize size
= GetSize();
2636 const wxSize clientSize
= GetClientSize();
2637 SetSize(width
+ (size
.x
- clientSize
.x
), height
+ (size
.y
- clientSize
.y
));
2640 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
2642 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2649 // if window is scrollable, account for scrollbars
2650 if ( GTK_IS_SCROLLED_WINDOW(m_widget
) )
2652 GtkPolicyType policy
[ScrollDir_Max
];
2653 gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget
),
2654 &policy
[ScrollDir_Horz
],
2655 &policy
[ScrollDir_Vert
]);
2657 for ( int i
= 0; i
< ScrollDir_Max
; i
++ )
2659 // don't account for the scrollbars we don't have
2660 GtkRange
* const range
= m_scrollBar
[i
];
2664 // nor for the ones we have but don't current show
2665 switch ( policy
[i
] )
2667 case GTK_POLICY_NEVER
:
2668 // never shown so doesn't take any place
2671 case GTK_POLICY_ALWAYS
:
2672 // no checks necessary
2675 case GTK_POLICY_AUTOMATIC
:
2676 // may be shown or not, check
2677 GtkAdjustment
*adj
= gtk_range_get_adjustment(range
);
2678 if ( adj
->upper
<= adj
->page_size
)
2682 GtkScrolledWindowClass
*scroll_class
=
2683 GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2686 gtk_widget_size_request(GTK_WIDGET(range
), &req
);
2687 if (i
== ScrollDir_Horz
)
2688 h
-= req
.height
+ scroll_class
->scrollbar_spacing
;
2690 w
-= req
.width
+ scroll_class
->scrollbar_spacing
;
2694 int border_x
, border_y
;
2695 WX_PIZZA(m_wxwindow
)->get_border_widths(border_x
, border_y
);
2705 if (width
) *width
= w
;
2706 if (height
) *height
= h
;
2709 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
2711 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2715 if (!IsTopLevel() && m_parent
&& m_parent
->m_wxwindow
)
2717 wxPizza
* pizza
= WX_PIZZA(m_parent
->m_wxwindow
);
2718 dx
= pizza
->m_scroll_x
;
2719 dy
= pizza
->m_scroll_y
;
2722 if (m_x
== -1 && m_y
== -1)
2724 GdkWindow
*source
= NULL
;
2726 source
= m_wxwindow
->window
;
2728 source
= m_widget
->window
;
2734 gdk_window_get_origin( source
, &org_x
, &org_y
);
2737 m_parent
->ScreenToClient(&org_x
, &org_y
);
2739 const_cast<wxWindowGTK
*>(this)->m_x
= org_x
;
2740 const_cast<wxWindowGTK
*>(this)->m_y
= org_y
;
2744 if (x
) (*x
) = m_x
- dx
;
2745 if (y
) (*y
) = m_y
- dy
;
2748 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
2750 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2752 if (!m_widget
->window
) return;
2754 GdkWindow
*source
= NULL
;
2756 source
= m_wxwindow
->window
;
2758 source
= m_widget
->window
;
2762 gdk_window_get_origin( source
, &org_x
, &org_y
);
2766 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2768 org_x
+= m_widget
->allocation
.x
;
2769 org_y
+= m_widget
->allocation
.y
;
2776 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2777 *x
= (GetClientSize().x
- *x
) + org_x
;
2785 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
2787 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2789 if (!m_widget
->window
) return;
2791 GdkWindow
*source
= NULL
;
2793 source
= m_wxwindow
->window
;
2795 source
= m_widget
->window
;
2799 gdk_window_get_origin( source
, &org_x
, &org_y
);
2803 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2805 org_x
+= m_widget
->allocation
.x
;
2806 org_y
+= m_widget
->allocation
.y
;
2812 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2813 *x
= (GetClientSize().x
- *x
) - org_x
;
2820 bool wxWindowGTK::Show( bool show
)
2822 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
2824 if (!wxWindowBase::Show(show
))
2830 if (show
&& m_showOnIdle
)
2837 gtk_widget_show(m_widget
);
2839 gtk_widget_hide(m_widget
);
2840 wxShowEvent
eventShow(GetId(), show
);
2841 eventShow
.SetEventObject(this);
2842 HandleWindowEvent(eventShow
);
2848 void wxWindowGTK::DoEnable( bool enable
)
2850 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2852 gtk_widget_set_sensitive( m_widget
, enable
);
2853 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
2854 gtk_widget_set_sensitive( m_wxwindow
, enable
);
2857 int wxWindowGTK::GetCharHeight() const
2859 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
2861 wxFont font
= GetFont();
2862 wxCHECK_MSG( font
.Ok(), 12, wxT("invalid font") );
2864 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
2869 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
2870 PangoLayout
*layout
= pango_layout_new(context
);
2871 pango_layout_set_font_description(layout
, desc
);
2872 pango_layout_set_text(layout
, "H", 1);
2873 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
2875 PangoRectangle rect
;
2876 pango_layout_line_get_extents(line
, NULL
, &rect
);
2878 g_object_unref (layout
);
2880 return (int) PANGO_PIXELS(rect
.height
);
2883 int wxWindowGTK::GetCharWidth() const
2885 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
2887 wxFont font
= GetFont();
2888 wxCHECK_MSG( font
.Ok(), 8, wxT("invalid font") );
2890 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
2895 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
2896 PangoLayout
*layout
= pango_layout_new(context
);
2897 pango_layout_set_font_description(layout
, desc
);
2898 pango_layout_set_text(layout
, "g", 1);
2899 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
2901 PangoRectangle rect
;
2902 pango_layout_line_get_extents(line
, NULL
, &rect
);
2904 g_object_unref (layout
);
2906 return (int) PANGO_PIXELS(rect
.width
);
2909 void wxWindowGTK::GetTextExtent( const wxString
& string
,
2913 int *externalLeading
,
2914 const wxFont
*theFont
) const
2916 wxFont fontToUse
= theFont
? *theFont
: GetFont();
2918 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
2927 PangoContext
*context
= NULL
;
2929 context
= gtk_widget_get_pango_context( m_widget
);
2938 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
2939 PangoLayout
*layout
= pango_layout_new(context
);
2940 pango_layout_set_font_description(layout
, desc
);
2942 const wxCharBuffer data
= wxGTK_CONV( string
);
2944 pango_layout_set_text(layout
, data
, strlen(data
));
2947 PangoRectangle rect
;
2948 pango_layout_get_extents(layout
, NULL
, &rect
);
2950 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
2951 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
2954 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
2955 int baseline
= pango_layout_iter_get_baseline(iter
);
2956 pango_layout_iter_free(iter
);
2957 *descent
= *y
- PANGO_PIXELS(baseline
);
2959 if (externalLeading
) (*externalLeading
) = 0; // ??
2961 g_object_unref (layout
);
2964 void wxWindowGTK::GTKDisableFocusOutEvent()
2966 g_signal_handlers_block_by_func( m_focusWidget
,
2967 (gpointer
) gtk_window_focus_out_callback
, this);
2970 void wxWindowGTK::GTKEnableFocusOutEvent()
2972 g_signal_handlers_unblock_by_func( m_focusWidget
,
2973 (gpointer
) gtk_window_focus_out_callback
, this);
2976 bool wxWindowGTK::GTKHandleFocusIn()
2978 // Disable default focus handling for custom windows since the default GTK+
2979 // handler issues a repaint
2980 const bool retval
= m_wxwindow
? true : false;
2983 // NB: if there's still unprocessed deferred focus-out event (see
2984 // GTKHandleFocusOut() for explanation), we need to process it first so
2985 // that the order of focus events -- focus-out first, then focus-in
2986 // elsewhere -- is preserved
2987 if ( gs_deferredFocusOut
)
2989 if ( GTKNeedsToFilterSameWindowFocus() &&
2990 gs_deferredFocusOut
== this )
2992 // GTK+ focus changed from this wxWindow back to itself, so don't
2993 // emit any events at all
2994 wxLogTrace(TRACE_FOCUS
,
2995 "filtered out spurious focus change within %s(%p, %s)",
2996 GetClassInfo()->GetClassName(), this, GetLabel());
2997 gs_deferredFocusOut
= NULL
;
3001 // otherwise we need to send focus-out first
3002 wxASSERT_MSG ( gs_deferredFocusOut
!= this,
3003 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
3004 GTKHandleDeferredFocusOut();
3008 wxLogTrace(TRACE_FOCUS
,
3009 "handling focus_in event for %s(%p, %s)",
3010 GetClassInfo()->GetClassName(), this, GetLabel());
3013 gtk_im_context_focus_in(m_imData
->context
);
3015 gs_currentFocus
= this;
3016 gs_pendingFocus
= NULL
;
3019 // caret needs to be informed about focus change
3020 wxCaret
*caret
= GetCaret();
3023 caret
->OnSetFocus();
3025 #endif // wxUSE_CARET
3027 // Notify the parent keeping track of focus for the kbd navigation
3028 // purposes that we got it.
3029 wxChildFocusEvent
eventChildFocus(static_cast<wxWindow
*>(this));
3030 GTKProcessEvent(eventChildFocus
);
3032 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, GetId());
3033 eventFocus
.SetEventObject(this);
3034 GTKProcessEvent(eventFocus
);
3039 bool wxWindowGTK::GTKHandleFocusOut()
3041 // Disable default focus handling for custom windows since the default GTK+
3042 // handler issues a repaint
3043 const bool retval
= m_wxwindow
? true : false;
3046 // NB: If a control is composed of several GtkWidgets and when focus
3047 // changes from one of them to another within the same wxWindow, we get
3048 // a focus-out event followed by focus-in for another GtkWidget owned
3049 // by the same wx control. We don't want to generate two spurious
3050 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3051 // from GTKHandleFocusOut() until we know for sure it's not coming back
3052 // (i.e. in GTKHandleFocusIn() or at idle time).
3053 if ( GTKNeedsToFilterSameWindowFocus() )
3055 wxASSERT_MSG( gs_deferredFocusOut
== NULL
,
3056 "deferred focus out event already pending" );
3057 wxLogTrace(TRACE_FOCUS
,
3058 "deferring focus_out event for %s(%p, %s)",
3059 GetClassInfo()->GetClassName(), this, GetLabel());
3060 gs_deferredFocusOut
= this;
3064 GTKHandleFocusOutNoDeferring();
3069 void wxWindowGTK::GTKHandleFocusOutNoDeferring()
3071 wxLogTrace(TRACE_FOCUS
,
3072 "handling focus_out event for %s(%p, %s)",
3073 GetClassInfo()->GetClassName(), this, GetLabel());
3076 gtk_im_context_focus_out(m_imData
->context
);
3078 if ( gs_currentFocus
!= this )
3080 // Something is terribly wrong, gs_currentFocus is out of sync with the
3081 // real focus. We will reset it to NULL anyway, because after this
3082 // focus-out event is handled, one of the following with happen:
3084 // * either focus will go out of the app altogether, in which case
3085 // gs_currentFocus _should_ be NULL
3087 // * or it goes to another control, in which case focus-in event will
3088 // follow immediately and it will set gs_currentFocus to the right
3090 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3091 GetClassInfo()->GetClassName(), this, GetLabel());
3093 gs_currentFocus
= NULL
;
3096 // caret needs to be informed about focus change
3097 wxCaret
*caret
= GetCaret();
3100 caret
->OnKillFocus();
3102 #endif // wxUSE_CARET
3104 wxFocusEvent
event( wxEVT_KILL_FOCUS
, GetId() );
3105 event
.SetEventObject( this );
3106 GTKProcessEvent( event
);
3110 void wxWindowGTK::GTKHandleDeferredFocusOut()
3112 // NB: See GTKHandleFocusOut() for explanation. This function is called
3113 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3115 if ( gs_deferredFocusOut
)
3117 wxWindowGTK
*win
= gs_deferredFocusOut
;
3118 gs_deferredFocusOut
= NULL
;
3120 wxLogTrace(TRACE_FOCUS
,
3121 "processing deferred focus_out event for %s(%p, %s)",
3122 win
->GetClassInfo()->GetClassName(), win
, win
->GetLabel());
3124 win
->GTKHandleFocusOutNoDeferring();
3128 void wxWindowGTK::SetFocus()
3130 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3132 // Setting "physical" focus is not immediate in GTK+ and while
3133 // gtk_widget_is_focus ("determines if the widget is the focus widget
3134 // within its toplevel", i.e. returns true for one widget per TLW, not
3135 // globally) returns true immediately after grabbing focus,
3136 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3137 // has focus at the moment) takes affect only after the window is shown
3138 // (if it was hidden at the moment of the call) or at the next event loop
3141 // Because we want to FindFocus() call immediately following
3142 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3144 gs_pendingFocus
= this;
3146 GtkWidget
*widget
= m_wxwindow
? m_wxwindow
: m_focusWidget
;
3148 if ( GTK_IS_CONTAINER(widget
) &&
3149 !GTK_WIDGET_CAN_FOCUS(widget
) )
3151 wxLogTrace(TRACE_FOCUS
,
3152 _T("Setting focus to a child of %s(%p, %s)"),
3153 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3154 gtk_widget_child_focus(widget
, GTK_DIR_TAB_FORWARD
);
3158 wxLogTrace(TRACE_FOCUS
,
3159 _T("Setting focus to %s(%p, %s)"),
3160 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3161 gtk_widget_grab_focus(widget
);
3165 void wxWindowGTK::SetCanFocus(bool canFocus
)
3168 GTK_WIDGET_SET_FLAGS(m_widget
, GTK_CAN_FOCUS
);
3170 GTK_WIDGET_UNSET_FLAGS(m_widget
, GTK_CAN_FOCUS
);
3172 if ( m_wxwindow
&& (m_widget
!= m_wxwindow
) )
3175 GTK_WIDGET_SET_FLAGS(m_wxwindow
, GTK_CAN_FOCUS
);
3177 GTK_WIDGET_UNSET_FLAGS(m_wxwindow
, GTK_CAN_FOCUS
);
3181 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3183 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3185 wxWindowGTK
*oldParent
= m_parent
,
3186 *newParent
= (wxWindowGTK
*)newParentBase
;
3188 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3190 if ( !wxWindowBase::Reparent(newParent
) )
3193 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3196 gtk_container_remove( GTK_CONTAINER(m_widget
->parent
), m_widget
);
3198 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3202 if (GTK_WIDGET_VISIBLE (newParent
->m_widget
))
3204 m_showOnIdle
= true;
3205 gtk_widget_hide( m_widget
);
3207 /* insert GTK representation */
3208 newParent
->AddChildGTK(this);
3211 SetLayoutDirection(wxLayout_Default
);
3216 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3218 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3219 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3224 /* insert GTK representation */
3228 void wxWindowGTK::AddChild(wxWindowBase
*child
)
3230 wxWindowBase::AddChild(child
);
3231 m_dirtyTabOrder
= true;
3232 wxTheApp
->WakeUpIdle();
3235 void wxWindowGTK::RemoveChild(wxWindowBase
*child
)
3237 wxWindowBase::RemoveChild(child
);
3238 m_dirtyTabOrder
= true;
3239 wxTheApp
->WakeUpIdle();
3243 wxLayoutDirection
wxWindowGTK::GTKGetLayout(GtkWidget
*widget
)
3245 return gtk_widget_get_direction(widget
) == GTK_TEXT_DIR_RTL
3246 ? wxLayout_RightToLeft
3247 : wxLayout_LeftToRight
;
3251 void wxWindowGTK::GTKSetLayout(GtkWidget
*widget
, wxLayoutDirection dir
)
3253 wxASSERT_MSG( dir
!= wxLayout_Default
, _T("invalid layout direction") );
3255 gtk_widget_set_direction(widget
,
3256 dir
== wxLayout_RightToLeft
? GTK_TEXT_DIR_RTL
3257 : GTK_TEXT_DIR_LTR
);
3260 wxLayoutDirection
wxWindowGTK::GetLayoutDirection() const
3262 return GTKGetLayout(m_widget
);
3265 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir
)
3267 if ( dir
== wxLayout_Default
)
3269 const wxWindow
*const parent
= GetParent();
3272 // inherit layout from parent.
3273 dir
= parent
->GetLayoutDirection();
3275 else // no parent, use global default layout
3277 dir
= wxTheApp
->GetLayoutDirection();
3281 if ( dir
== wxLayout_Default
)
3284 GTKSetLayout(m_widget
, dir
);
3286 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3287 GTKSetLayout(m_wxwindow
, dir
);
3291 wxWindowGTK::AdjustForLayoutDirection(wxCoord x
,
3292 wxCoord
WXUNUSED(width
),
3293 wxCoord
WXUNUSED(widthTotal
)) const
3295 // We now mirror the coordinates of RTL windows in wxPizza
3299 void wxWindowGTK::DoMoveInTabOrder(wxWindow
*win
, WindowOrder move
)
3301 wxWindowBase::DoMoveInTabOrder(win
, move
);
3302 m_dirtyTabOrder
= true;
3303 wxTheApp
->WakeUpIdle();
3306 bool wxWindowGTK::DoNavigateIn(int flags
)
3308 if ( flags
& wxNavigationKeyEvent::WinChange
)
3310 wxFAIL_MSG( _T("not implemented") );
3314 else // navigate inside the container
3316 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3317 wxCHECK_MSG( parent
, false, _T("every window must have a TLW parent") );
3319 GtkDirectionType dir
;
3320 dir
= flags
& wxNavigationKeyEvent::IsForward
? GTK_DIR_TAB_FORWARD
3321 : GTK_DIR_TAB_BACKWARD
;
3324 g_signal_emit_by_name(parent
->m_widget
, "focus", dir
, &rc
);
3330 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3332 // none needed by default
3336 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3338 // nothing to do by default since none is needed
3341 void wxWindowGTK::RealizeTabOrder()
3345 if ( !m_children
.empty() )
3347 // we don't only construct the correct focus chain but also use
3348 // this opportunity to update the mnemonic widgets for the widgets
3351 GList
*chain
= NULL
;
3352 wxWindowGTK
* mnemonicWindow
= NULL
;
3354 for ( wxWindowList::const_iterator i
= m_children
.begin();
3355 i
!= m_children
.end();
3358 wxWindowGTK
*win
= *i
;
3360 if ( mnemonicWindow
)
3362 if ( win
->AcceptsFocusFromKeyboard() )
3364 // wxComboBox et al. needs to focus on on a different
3365 // widget than m_widget, so if the main widget isn't
3366 // focusable try the connect widget
3367 GtkWidget
* w
= win
->m_widget
;
3368 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3370 w
= win
->GetConnectWidget();
3371 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3377 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3378 mnemonicWindow
= NULL
;
3382 else if ( win
->GTKWidgetNeedsMnemonic() )
3384 mnemonicWindow
= win
;
3387 chain
= g_list_prepend(chain
, win
->m_widget
);
3390 chain
= g_list_reverse(chain
);
3392 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3397 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3402 void wxWindowGTK::Raise()
3404 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3406 if (m_wxwindow
&& m_wxwindow
->window
)
3408 gdk_window_raise( m_wxwindow
->window
);
3410 else if (m_widget
->window
)
3412 gdk_window_raise( m_widget
->window
);
3416 void wxWindowGTK::Lower()
3418 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3420 if (m_wxwindow
&& m_wxwindow
->window
)
3422 gdk_window_lower( m_wxwindow
->window
);
3424 else if (m_widget
->window
)
3426 gdk_window_lower( m_widget
->window
);
3430 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3432 if ( !wxWindowBase::SetCursor(cursor
.Ok() ? cursor
: *wxSTANDARD_CURSOR
) )
3440 void wxWindowGTK::GTKUpdateCursor()
3442 wxCursor
cursor(g_globalCursor
.Ok() ? g_globalCursor
: GetCursor());
3445 wxArrayGdkWindows windowsThis
;
3446 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
3449 gdk_window_set_cursor(winThis
, cursor
.GetCursor());
3453 const size_t count
= windowsThis
.size();
3454 for ( size_t n
= 0; n
< count
; n
++ )
3456 GdkWindow
*win
= windowsThis
[n
];
3459 wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?"));
3463 gdk_window_set_cursor(win
, cursor
.GetCursor());
3469 void wxWindowGTK::WarpPointer( int x
, int y
)
3471 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3473 // We provide this function ourselves as it is
3474 // missing in GDK (top of this file).
3476 GdkWindow
*window
= NULL
;
3478 window
= m_wxwindow
->window
;
3480 window
= GetConnectWidget()->window
;
3483 gdk_window_warp_pointer( window
, x
, y
);
3486 wxWindowGTK::ScrollDir
wxWindowGTK::ScrollDirFromRange(GtkRange
*range
) const
3488 // find the scrollbar which generated the event
3489 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3491 if ( range
== m_scrollBar
[dir
] )
3492 return (ScrollDir
)dir
;
3495 wxFAIL_MSG( _T("event from unknown scrollbar received") );
3497 return ScrollDir_Max
;
3500 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3502 bool changed
= false;
3503 GtkRange
* range
= m_scrollBar
[dir
];
3504 if ( range
&& units
)
3506 GtkAdjustment
* adj
= range
->adjustment
;
3507 gdouble inc
= unit
== ScrollUnit_Line
? adj
->step_increment
3508 : adj
->page_increment
;
3510 const int posOld
= int(adj
->value
+ 0.5);
3511 gtk_range_set_value(range
, posOld
+ units
*inc
);
3513 changed
= int(adj
->value
+ 0.5) != posOld
;
3519 bool wxWindowGTK::ScrollLines(int lines
)
3521 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3524 bool wxWindowGTK::ScrollPages(int pages
)
3526 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3529 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground
),
3534 widget
= m_wxwindow
;
3540 if (!widget
->window
)
3544 gtk_widget_queue_draw(widget
);
3548 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3549 x
= GetClientSize().x
- x
- rect
->width
;
3552 gtk_widget_queue_draw_area(widget
, x
, rect
->y
, rect
->width
, rect
->height
);
3557 r
.width
= rect
->width
;
3558 r
.height
= rect
->height
;
3559 gdk_window_invalidate_rect( m_wxwindow
->window
, &r
, TRUE
);
3564 void wxWindowGTK::Update()
3566 if (m_widget
&& m_widget
->window
)
3568 GdkDisplay
* display
= gtk_widget_get_display(m_widget
);
3569 // Flush everything out to the server, and wait for it to finish.
3570 // This ensures nothing will overwrite the drawing we are about to do.
3571 gdk_display_sync(display
);
3573 gdk_window_process_updates(m_widget
->window
, true);
3575 // Flush again, but no need to wait for it to finish
3576 gdk_display_flush(display
);
3580 bool wxWindowGTK::DoIsExposed( int x
, int y
) const
3582 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
3585 bool wxWindowGTK::DoIsExposed( int x
, int y
, int w
, int h
) const
3587 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3588 return m_updateRegion
.Contains(x
-w
, y
, w
, h
) != wxOutRegion
;
3590 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
3593 void wxWindowGTK::GtkSendPaintEvents()
3597 m_updateRegion
.Clear();
3601 // Clip to paint region in wxClientDC
3602 m_clipPaintRegion
= true;
3604 m_nativeUpdateRegion
= m_updateRegion
;
3606 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3608 // Transform m_updateRegion under RTL
3609 m_updateRegion
.Clear();
3612 gdk_drawable_get_size(m_wxwindow
->window
, &width
, NULL
);
3614 wxRegionIterator
upd( m_nativeUpdateRegion
);
3618 rect
.x
= upd
.GetX();
3619 rect
.y
= upd
.GetY();
3620 rect
.width
= upd
.GetWidth();
3621 rect
.height
= upd
.GetHeight();
3623 rect
.x
= width
- rect
.x
- rect
.width
;
3624 m_updateRegion
.Union( rect
);
3630 if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM
))
3632 // find ancestor from which to steal background
3633 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3635 parent
= (wxWindow
*)this;
3637 if (GTK_WIDGET_MAPPED(parent
->m_widget
))
3639 wxRegionIterator
upd( m_nativeUpdateRegion
);
3643 rect
.x
= upd
.GetX();
3644 rect
.y
= upd
.GetY();
3645 rect
.width
= upd
.GetWidth();
3646 rect
.height
= upd
.GetHeight();
3648 gtk_paint_flat_box( parent
->m_widget
->style
,
3650 (GtkStateType
)GTK_WIDGET_STATE(m_wxwindow
),
3663 wxWindowDC
dc( (wxWindow
*)this );
3664 dc
.SetDeviceClippingRegion( m_updateRegion
);
3666 // Work around gtk-qt <= 0.60 bug whereby the window colour
3668 if (GetBackgroundStyle() == wxBG_STYLE_COLOUR
&& GetBackgroundColour().Ok() && wxSystemOptions::GetOptionInt(wxT("gtk.window.force-background-colour")) == 1)
3670 dc
.SetBackground(wxBrush(GetBackgroundColour()));
3674 wxEraseEvent
erase_event( GetId(), &dc
);
3675 erase_event
.SetEventObject( this );
3677 HandleWindowEvent(erase_event
);
3680 wxNcPaintEvent
nc_paint_event( GetId() );
3681 nc_paint_event
.SetEventObject( this );
3682 HandleWindowEvent( nc_paint_event
);
3684 wxPaintEvent
paint_event( GetId() );
3685 paint_event
.SetEventObject( this );
3686 HandleWindowEvent( paint_event
);
3688 m_clipPaintRegion
= false;
3690 m_updateRegion
.Clear();
3691 m_nativeUpdateRegion
.Clear();
3694 void wxWindowGTK::SetDoubleBuffered( bool on
)
3696 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3699 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3702 bool wxWindowGTK::IsDoubleBuffered() const
3704 return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow
);
3707 void wxWindowGTK::ClearBackground()
3709 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3713 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3715 wxWindowBase::DoSetToolTip(tip
);
3718 m_tooltip
->GTKApply( (wxWindow
*)this );
3721 void wxWindowGTK::GTKApplyToolTip( GtkTooltips
*tips
, const gchar
*tip
)
3723 gtk_tooltips_set_tip(tips
, GetConnectWidget(), tip
, NULL
);
3725 #endif // wxUSE_TOOLTIPS
3727 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
3729 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3731 if (!wxWindowBase::SetBackgroundColour(colour
))
3736 // We need the pixel value e.g. for background clearing.
3737 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3740 // apply style change (forceStyle=true so that new style is applied
3741 // even if the bg colour changed from valid to wxNullColour)
3742 if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM
)
3743 GTKApplyWidgetStyle(true);
3748 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
3750 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3752 if (!wxWindowBase::SetForegroundColour(colour
))
3759 // We need the pixel value e.g. for background clearing.
3760 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3763 // apply style change (forceStyle=true so that new style is applied
3764 // even if the bg colour changed from valid to wxNullColour):
3765 GTKApplyWidgetStyle(true);
3770 PangoContext
*wxWindowGTK::GTKGetPangoDefaultContext()
3772 return gtk_widget_get_pango_context( m_widget
);
3775 GtkRcStyle
*wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle
)
3777 // do we need to apply any changes at all?
3780 !m_foregroundColour
.Ok() && !m_backgroundColour
.Ok() )
3785 GtkRcStyle
*style
= gtk_rc_style_new();
3790 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
3793 int flagsNormal
= 0,
3796 flagsInsensitive
= 0;
3798 if ( m_foregroundColour
.Ok() )
3800 const GdkColor
*fg
= m_foregroundColour
.GetColor();
3802 style
->fg
[GTK_STATE_NORMAL
] =
3803 style
->text
[GTK_STATE_NORMAL
] = *fg
;
3804 flagsNormal
|= GTK_RC_FG
| GTK_RC_TEXT
;
3806 style
->fg
[GTK_STATE_PRELIGHT
] =
3807 style
->text
[GTK_STATE_PRELIGHT
] = *fg
;
3808 flagsPrelight
|= GTK_RC_FG
| GTK_RC_TEXT
;
3810 style
->fg
[GTK_STATE_ACTIVE
] =
3811 style
->text
[GTK_STATE_ACTIVE
] = *fg
;
3812 flagsActive
|= GTK_RC_FG
| GTK_RC_TEXT
;
3815 if ( m_backgroundColour
.Ok() )
3817 const GdkColor
*bg
= m_backgroundColour
.GetColor();
3819 style
->bg
[GTK_STATE_NORMAL
] =
3820 style
->base
[GTK_STATE_NORMAL
] = *bg
;
3821 flagsNormal
|= GTK_RC_BG
| GTK_RC_BASE
;
3823 style
->bg
[GTK_STATE_PRELIGHT
] =
3824 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
3825 flagsPrelight
|= GTK_RC_BG
| GTK_RC_BASE
;
3827 style
->bg
[GTK_STATE_ACTIVE
] =
3828 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
3829 flagsActive
|= GTK_RC_BG
| GTK_RC_BASE
;
3831 style
->bg
[GTK_STATE_INSENSITIVE
] =
3832 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
3833 flagsInsensitive
|= GTK_RC_BG
| GTK_RC_BASE
;
3836 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)flagsNormal
;
3837 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)flagsPrelight
;
3838 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)flagsActive
;
3839 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)flagsInsensitive
;
3844 void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle
)
3846 GtkRcStyle
*style
= GTKCreateWidgetStyle(forceStyle
);
3849 DoApplyWidgetStyle(style
);
3850 gtk_rc_style_unref(style
);
3853 // Style change may affect GTK+'s size calculation:
3854 InvalidateBestSize();
3857 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
3859 wxSuspendStyleEvents
s(static_cast<wxWindow
*>(this));
3862 gtk_widget_modify_style(m_wxwindow
, style
);
3864 gtk_widget_modify_style(m_widget
, style
);
3867 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style
)
3869 wxWindowBase::SetBackgroundStyle(style
);
3871 if (style
== wxBG_STYLE_CUSTOM
)
3876 window
= m_wxwindow
->window
;
3880 GtkWidget
* const w
= GetConnectWidget();
3881 window
= w
? w
->window
: NULL
;
3886 // Make sure GDK/X11 doesn't refresh the window
3888 gdk_window_set_back_pixmap( window
, None
, False
);
3890 Display
* display
= GDK_WINDOW_DISPLAY(window
);
3893 m_needsStyleChange
= false;
3895 else // window not realized yet
3897 // Do in OnIdle, because the window is not yet available
3898 m_needsStyleChange
= true;
3901 // Don't apply widget style, or we get a grey background
3905 // apply style change (forceStyle=true so that new style is applied
3906 // even if the bg colour changed from valid to wxNullColour):
3907 GTKApplyWidgetStyle(true);
3912 // ----------------------------------------------------------------------------
3913 // Pop-up menu stuff
3914 // ----------------------------------------------------------------------------
3916 #if wxUSE_MENUS_NATIVE
3918 static void SetInvokingWindow( wxMenu
*menu
, wxWindow
* win
)
3920 menu
->SetInvokingWindow( win
);
3922 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
3925 wxMenuItem
*menuitem
= node
->GetData();
3926 if (menuitem
->IsSubMenu())
3928 SetInvokingWindow( menuitem
->GetSubMenu(), win
);
3931 node
= node
->GetNext();
3937 void wxPopupMenuPositionCallback( GtkMenu
*menu
,
3939 gboolean
* WXUNUSED(whatever
),
3940 gpointer user_data
)
3942 // ensure that the menu appears entirely on screen
3944 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
3946 wxSize sizeScreen
= wxGetDisplaySize();
3947 wxPoint
*pos
= (wxPoint
*)user_data
;
3949 gint xmax
= sizeScreen
.x
- req
.width
,
3950 ymax
= sizeScreen
.y
- req
.height
;
3952 *x
= pos
->x
< xmax
? pos
->x
: xmax
;
3953 *y
= pos
->y
< ymax
? pos
->y
: ymax
;
3957 bool wxWindowGTK::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
3959 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3961 wxCHECK_MSG( menu
!= NULL
, false, wxT("invalid popup-menu") );
3963 SetInvokingWindow( menu
, this );
3969 GtkMenuPositionFunc posfunc
;
3970 if ( x
== -1 && y
== -1 )
3972 // use GTK's default positioning algorithm
3978 pos
= ClientToScreen(wxPoint(x
, y
));
3980 posfunc
= wxPopupMenuPositionCallback
;
3983 menu
->m_popupShown
= true;
3985 GTK_MENU(menu
->m_menu
),
3986 NULL
, // parent menu shell
3987 NULL
, // parent menu item
3988 posfunc
, // function to position it
3989 userdata
, // client data
3990 0, // button used to activate it
3991 gtk_get_current_event_time()
3994 while (menu
->m_popupShown
)
3996 gtk_main_iteration();
4002 #endif // wxUSE_MENUS_NATIVE
4004 #if wxUSE_DRAG_AND_DROP
4006 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4008 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4010 GtkWidget
*dnd_widget
= GetConnectWidget();
4012 if (m_dropTarget
) m_dropTarget
->GtkUnregisterWidget( dnd_widget
);
4014 if (m_dropTarget
) delete m_dropTarget
;
4015 m_dropTarget
= dropTarget
;
4017 if (m_dropTarget
) m_dropTarget
->GtkRegisterWidget( dnd_widget
);
4020 #endif // wxUSE_DRAG_AND_DROP
4022 GtkWidget
* wxWindowGTK::GetConnectWidget()
4024 GtkWidget
*connect_widget
= m_widget
;
4025 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4027 return connect_widget
;
4030 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow
*window
) const
4032 wxArrayGdkWindows windowsThis
;
4033 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
4035 return winThis
? window
== winThis
4036 : windowsThis
.Index(window
) != wxNOT_FOUND
;
4039 GdkWindow
*wxWindowGTK::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
4041 return m_wxwindow
? m_wxwindow
->window
: m_widget
->window
;
4044 bool wxWindowGTK::SetFont( const wxFont
&font
)
4046 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4048 if (!wxWindowBase::SetFont(font
))
4051 // apply style change (forceStyle=true so that new style is applied
4052 // even if the font changed from valid to wxNullFont):
4053 GTKApplyWidgetStyle(true);
4058 void wxWindowGTK::DoCaptureMouse()
4060 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4062 GdkWindow
*window
= NULL
;
4064 window
= m_wxwindow
->window
;
4066 window
= GetConnectWidget()->window
;
4068 wxCHECK_RET( window
, _T("CaptureMouse() failed") );
4070 const wxCursor
* cursor
= &m_cursor
;
4072 cursor
= wxSTANDARD_CURSOR
;
4074 gdk_pointer_grab( window
, FALSE
,
4076 (GDK_BUTTON_PRESS_MASK
|
4077 GDK_BUTTON_RELEASE_MASK
|
4078 GDK_POINTER_MOTION_HINT_MASK
|
4079 GDK_POINTER_MOTION_MASK
),
4081 cursor
->GetCursor(),
4082 (guint32
)GDK_CURRENT_TIME
);
4083 g_captureWindow
= this;
4084 g_captureWindowHasMouse
= true;
4087 void wxWindowGTK::DoReleaseMouse()
4089 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4091 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4093 g_captureWindow
= NULL
;
4095 GdkWindow
*window
= NULL
;
4097 window
= m_wxwindow
->window
;
4099 window
= GetConnectWidget()->window
;
4104 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4107 void wxWindowGTK::GTKReleaseMouseAndNotify()
4110 wxMouseCaptureLostEvent
evt(GetId());
4111 evt
.SetEventObject( this );
4112 HandleWindowEvent( evt
);
4116 wxWindow
*wxWindowBase::GetCapture()
4118 return (wxWindow
*)g_captureWindow
;
4121 bool wxWindowGTK::IsRetained() const
4126 void wxWindowGTK::SetScrollbar(int orient
,
4130 bool WXUNUSED(update
))
4132 const int dir
= ScrollDirFromOrient(orient
);
4133 GtkRange
* const sb
= m_scrollBar
[dir
];
4134 wxCHECK_RET( sb
, _T("this window is not scrollable") );
4138 // GtkRange requires upper > lower
4143 GtkAdjustment
* const adj
= sb
->adjustment
;
4144 adj
->step_increment
= 1;
4145 adj
->page_increment
=
4146 adj
->page_size
= thumbVisible
;
4149 g_signal_handlers_block_by_func(
4150 sb
, (void*)gtk_scrollbar_value_changed
, this);
4152 gtk_range_set_range(sb
, 0, range
);
4153 m_scrollPos
[dir
] = sb
->adjustment
->value
;
4155 g_signal_handlers_unblock_by_func(
4156 sb
, (void*)gtk_scrollbar_value_changed
, this);
4159 void wxWindowGTK::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4161 const int dir
= ScrollDirFromOrient(orient
);
4162 GtkRange
* const sb
= m_scrollBar
[dir
];
4163 wxCHECK_RET( sb
, _T("this window is not scrollable") );
4165 // This check is more than an optimization. Without it, the slider
4166 // will not move smoothly while tracking when using wxScrollHelper.
4167 if (GetScrollPos(orient
) != pos
)
4169 g_signal_handlers_block_by_func(
4170 sb
, (void*)gtk_scrollbar_value_changed
, this);
4172 gtk_range_set_value(sb
, pos
);
4173 m_scrollPos
[dir
] = sb
->adjustment
->value
;
4175 g_signal_handlers_unblock_by_func(
4176 sb
, (void*)gtk_scrollbar_value_changed
, this);
4180 int wxWindowGTK::GetScrollThumb(int orient
) const
4182 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4183 wxCHECK_MSG( sb
, 0, _T("this window is not scrollable") );
4185 return wxRound(sb
->adjustment
->page_size
);
4188 int wxWindowGTK::GetScrollPos( int orient
) const
4190 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4191 wxCHECK_MSG( sb
, 0, _T("this window is not scrollable") );
4193 return wxRound(sb
->adjustment
->value
);
4196 int wxWindowGTK::GetScrollRange( int orient
) const
4198 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4199 wxCHECK_MSG( sb
, 0, _T("this window is not scrollable") );
4201 return wxRound(sb
->adjustment
->upper
);
4204 // Determine if increment is the same as +/-x, allowing for some small
4205 // difference due to possible inexactness in floating point arithmetic
4206 static inline bool IsScrollIncrement(double increment
, double x
)
4208 wxASSERT(increment
> 0);
4209 const double tolerance
= 1.0 / 1024;
4210 return fabs(increment
- fabs(x
)) < tolerance
;
4213 wxEventType
wxWindowGTK::GTKGetScrollEventType(GtkRange
* range
)
4215 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4217 const int barIndex
= range
== m_scrollBar
[1];
4218 GtkAdjustment
* adj
= range
->adjustment
;
4220 const int value
= wxRound(adj
->value
);
4222 // save previous position
4223 const double oldPos
= m_scrollPos
[barIndex
];
4224 // update current position
4225 m_scrollPos
[barIndex
] = adj
->value
;
4226 // If event should be ignored, or integral position has not changed
4227 if (!m_hasVMT
|| g_blockEventsOnDrag
|| value
== wxRound(oldPos
))
4232 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4235 // Difference from last change event
4236 const double diff
= adj
->value
- oldPos
;
4237 const bool isDown
= diff
> 0;
4239 if (IsScrollIncrement(adj
->step_increment
, diff
))
4241 eventType
= isDown
? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4243 else if (IsScrollIncrement(adj
->page_increment
, diff
))
4245 eventType
= isDown
? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4247 else if (m_mouseButtonDown
)
4249 // Assume track event
4250 m_isScrolling
= true;
4256 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4258 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4260 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4262 // No scrolling requested.
4263 if ((dx
== 0) && (dy
== 0)) return;
4265 m_clipPaintRegion
= true;
4267 WX_PIZZA(m_wxwindow
)->scroll(dx
, dy
);
4269 m_clipPaintRegion
= false;
4272 bool restoreCaret
= (GetCaret() != NULL
&& GetCaret()->IsVisible());
4275 wxRect
caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4277 caretRect
.width
+= dx
;
4280 caretRect
.x
+= dx
; caretRect
.width
-= dx
;
4283 caretRect
.height
+= dy
;
4286 caretRect
.y
+= dy
; caretRect
.height
-= dy
;
4289 RefreshRect(caretRect
);
4291 #endif // wxUSE_CARET
4294 void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4296 //RN: Note that static controls usually have no border on gtk, so maybe
4297 //it makes sense to treat that as simply no border at the wx level
4299 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4301 GtkShadowType gtkstyle
;
4303 if(wxstyle
& wxBORDER_RAISED
)
4304 gtkstyle
= GTK_SHADOW_OUT
;
4305 else if (wxstyle
& wxBORDER_SUNKEN
)
4306 gtkstyle
= GTK_SHADOW_IN
;
4309 else if (wxstyle
& wxBORDER_DOUBLE
)
4310 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4313 gtkstyle
= GTK_SHADOW_IN
;
4315 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4320 void wxWindowGTK::SetWindowStyleFlag( long style
)
4322 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4323 wxWindowBase::SetWindowStyleFlag(style
);
4326 // Find the wxWindow at the current mouse position, also returning the mouse
4328 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4330 pt
= wxGetMousePosition();
4331 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4335 // Get the current mouse position.
4336 wxPoint
wxGetMousePosition()
4338 /* This crashes when used within wxHelpContext,
4339 so we have to use the X-specific implementation below.
4341 GdkModifierType *mask;
4342 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4344 return wxPoint(x, y);
4348 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4350 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4351 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4352 Window rootReturn
, childReturn
;
4353 int rootX
, rootY
, winX
, winY
;
4354 unsigned int maskReturn
;
4356 XQueryPointer (display
,
4360 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4361 return wxPoint(rootX
, rootY
);
4365 GdkWindow
* wxWindowGTK::GTKGetDrawingWindow() const
4367 GdkWindow
* window
= NULL
;
4369 window
= m_wxwindow
->window
;
4373 // ----------------------------------------------------------------------------
4375 // ----------------------------------------------------------------------------
4380 // this is called if we attempted to freeze unrealized widget when it finally
4381 // is realized (and so can be frozen):
4382 static void wx_frozen_widget_realize(GtkWidget
* w
, void* WXUNUSED(data
))
4384 wxASSERT( w
&& !GTK_WIDGET_NO_WINDOW(w
) );
4385 wxASSERT( GTK_WIDGET_REALIZED(w
) );
4387 g_signal_handlers_disconnect_by_func
4390 (void*)wx_frozen_widget_realize
,
4394 gdk_window_freeze_updates(w
->window
);
4399 void wxWindowGTK::GTKFreezeWidget(GtkWidget
*w
)
4401 if ( !w
|| GTK_WIDGET_NO_WINDOW(w
) )
4402 return; // window-less widget, cannot be frozen
4404 if ( !GTK_WIDGET_REALIZED(w
) )
4406 // we can't thaw unrealized widgets because they don't have GdkWindow,
4407 // so set it up to be done immediately after realization:
4408 g_signal_connect_after
4412 G_CALLBACK(wx_frozen_widget_realize
),
4418 gdk_window_freeze_updates(w
->window
);
4421 void wxWindowGTK::GTKThawWidget(GtkWidget
*w
)
4423 if ( !w
|| GTK_WIDGET_NO_WINDOW(w
) )
4424 return; // window-less widget, cannot be frozen
4426 if ( !GTK_WIDGET_REALIZED(w
) )
4428 // the widget wasn't realized yet, no need to thaw
4429 g_signal_handlers_disconnect_by_func
4432 (void*)wx_frozen_widget_realize
,
4438 gdk_window_thaw_updates(w
->window
);
4441 void wxWindowGTK::DoFreeze()
4443 GTKFreezeWidget(m_widget
);
4444 if ( m_wxwindow
&& m_widget
!= m_wxwindow
)
4445 GTKFreezeWidget(m_wxwindow
);
4448 void wxWindowGTK::DoThaw()
4450 GTKThawWidget(m_widget
);
4451 if ( m_wxwindow
&& m_widget
!= m_wxwindow
)
4452 GTKThawWidget(m_wxwindow
);