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 //-----------------------------------------------------------------------------
260 // make it extern because wxStaticText needs to disconnect this one
262 void 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_scanCode
= gdk_event
->keyval
;
687 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
688 event
.m_rawFlags
= 0;
690 event
.m_uniChar
= gdk_keyval_to_unicode(gdk_event
->keyval
);
692 wxGetMousePosition( &x
, &y
);
693 win
->ScreenToClient( &x
, &y
);
696 event
.SetEventObject( win
);
701 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
703 GdkEventKey
*gdk_event
)
705 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
706 // but only event->keyval which is quite useless to us, so remember
707 // the last character from GDK_KEY_PRESS and reuse it as last resort
709 // NB: should be MT-safe as we're always called from the main thread only
714 } s_lastKeyPress
= { 0, 0 };
716 KeySym keysym
= gdk_event
->keyval
;
718 wxLogTrace(TRACE_KEYS
, _T("Key %s event: keysym = %ld"),
719 event
.GetEventType() == wxEVT_KEY_UP
? _T("release")
723 long key_code
= wxTranslateKeySymToWXKey(keysym
, false /* !isChar */);
727 // do we have the translation or is it a plain ASCII character?
728 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
730 // we should use keysym if it is ASCII as X does some translations
731 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
732 // which we don't want here (but which we do use for OnChar())
733 if ( !wxIsAsciiKeysym(keysym
) )
735 keysym
= (KeySym
)gdk_event
->string
[0];
738 // we want to always get the same key code when the same key is
739 // pressed regardless of the state of the modifiers, i.e. on a
740 // standard US keyboard pressing '5' or '%' ('5' key with
741 // Shift) should result in the same key code in OnKeyDown():
742 // '5' (although OnChar() will get either '5' or '%').
744 // to do it we first translate keysym to keycode (== scan code)
745 // and then back but always using the lower register
746 Display
*dpy
= (Display
*)wxGetDisplay();
747 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
749 wxLogTrace(TRACE_KEYS
, _T("\t-> keycode %d"), keycode
);
751 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
753 // use the normalized, i.e. lower register, keysym if we've
755 key_code
= keysymNormalized
? keysymNormalized
: keysym
;
757 // as explained above, we want to have lower register key codes
758 // normally but for the letter keys we want to have the upper ones
760 // NB: don't use XConvertCase() here, we want to do it for letters
762 key_code
= toupper(key_code
);
764 else // non ASCII key, what to do?
766 // by default, ignore it
769 // but if we have cached information from the last KEY_PRESS
770 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
773 if ( keysym
== s_lastKeyPress
.keysym
)
775 key_code
= s_lastKeyPress
.keycode
;
780 if ( gdk_event
->type
== GDK_KEY_PRESS
)
782 // remember it to be reused for KEY_UP event later
783 s_lastKeyPress
.keysym
= keysym
;
784 s_lastKeyPress
.keycode
= key_code
;
788 wxLogTrace(TRACE_KEYS
, _T("\t-> wxKeyCode %ld"), key_code
);
790 // sending unknown key events doesn't really make sense
794 // now fill all the other fields
795 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
797 event
.m_keyCode
= key_code
;
799 if ( gdk_event
->type
== GDK_KEY_PRESS
|| gdk_event
->type
== GDK_KEY_RELEASE
)
801 event
.m_uniChar
= key_code
;
811 GtkIMContext
*context
;
812 GdkEventKey
*lastKeyEvent
;
816 context
= gtk_im_multicontext_new();
821 g_object_unref (context
);
827 gtk_window_key_press_callback( GtkWidget
*WXUNUSED(widget
),
828 GdkEventKey
*gdk_event
,
833 if (g_blockEventsOnDrag
)
836 wxKeyEvent
event( wxEVT_KEY_DOWN
);
838 bool return_after_IM
= false;
840 if( wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
842 // Emit KEY_DOWN event
843 ret
= win
->HandleWindowEvent( event
);
847 // Return after IM processing as we cannot do
848 // anything with it anyhow.
849 return_after_IM
= true;
852 if ((!ret
) && (win
->m_imData
!= NULL
))
854 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
855 // docs, if IM filter returns true, no further processing should be done.
856 // we should send the key_down event anyway.
857 bool intercepted_by_IM
= gtk_im_context_filter_keypress(win
->m_imData
->context
, gdk_event
);
858 win
->m_imData
->lastKeyEvent
= NULL
;
859 if (intercepted_by_IM
)
861 wxLogTrace(TRACE_KEYS
, _T("Key event intercepted by IM"));
872 wxWindowGTK
*ancestor
= win
;
875 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
878 wxCommandEvent
menu_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
879 ret
= ancestor
->HandleWindowEvent( menu_event
);
883 // if the accelerator wasn't handled as menu event, try
884 // it as button click (for compatibility with other
886 wxCommandEvent
button_event( wxEVT_COMMAND_BUTTON_CLICKED
, command
);
887 ret
= ancestor
->HandleWindowEvent( button_event
);
892 if (ancestor
->IsTopLevel())
894 ancestor
= ancestor
->GetParent();
897 #endif // wxUSE_ACCEL
899 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
900 // will only be sent if it is not in an accelerator table.
904 KeySym keysym
= gdk_event
->keyval
;
905 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
906 key_code
= wxTranslateKeySymToWXKey(keysym
, true /* isChar */);
909 if ( wxIsAsciiKeysym(keysym
) )
912 key_code
= (unsigned char)keysym
;
914 // gdk_event->string is actually deprecated
915 else if ( gdk_event
->length
== 1 )
917 key_code
= (unsigned char)gdk_event
->string
[0];
923 wxLogTrace(TRACE_KEYS
, _T("Char event: %ld"), key_code
);
925 event
.m_keyCode
= key_code
;
927 // To conform to the docs we need to translate Ctrl-alpha
928 // characters to values in the range 1-26.
929 if ( event
.ControlDown() &&
930 ( wxIsLowerChar(key_code
) || wxIsUpperChar(key_code
) ))
932 if ( wxIsLowerChar(key_code
) )
933 event
.m_keyCode
= key_code
- 'a' + 1;
934 if ( wxIsUpperChar(key_code
) )
935 event
.m_keyCode
= key_code
- 'A' + 1;
937 event
.m_uniChar
= event
.m_keyCode
;
941 // Implement OnCharHook by checking ancestor top level windows
942 wxWindow
*parent
= win
;
943 while (parent
&& !parent
->IsTopLevel())
944 parent
= parent
->GetParent();
947 event
.SetEventType( wxEVT_CHAR_HOOK
);
948 ret
= parent
->HandleWindowEvent( event
);
953 event
.SetEventType(wxEVT_CHAR
);
954 ret
= win
->HandleWindowEvent( event
);
965 gtk_wxwindow_commit_cb (GtkIMContext
* WXUNUSED(context
),
969 wxKeyEvent
event( wxEVT_KEY_DOWN
);
971 // take modifiers, cursor position, timestamp etc. from the last
972 // key_press_event that was fed into Input Method:
973 if (window
->m_imData
->lastKeyEvent
)
975 wxFillOtherKeyEventFields(event
,
976 window
, window
->m_imData
->lastKeyEvent
);
980 event
.SetEventObject( window
);
983 const wxString
data(wxGTK_CONV_BACK_SYS(str
));
989 // Implement OnCharHook by checking ancestor top level windows
990 wxWindow
*parent
= window
;
991 while (parent
&& !parent
->IsTopLevel())
992 parent
= parent
->GetParent();
994 for( wxString::const_iterator pstr
= data
.begin(); pstr
!= data
.end(); ++pstr
)
997 event
.m_uniChar
= *pstr
;
998 // Backward compatible for ISO-8859-1
999 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
1000 wxLogTrace(TRACE_KEYS
, _T("IM sent character '%c'"), event
.m_uniChar
);
1002 event
.m_keyCode
= (char)*pstr
;
1003 #endif // wxUSE_UNICODE
1005 // To conform to the docs we need to translate Ctrl-alpha
1006 // characters to values in the range 1-26.
1007 if ( event
.ControlDown() &&
1008 ( wxIsLowerChar(*pstr
) || wxIsUpperChar(*pstr
) ))
1010 if ( wxIsLowerChar(*pstr
) )
1011 event
.m_keyCode
= *pstr
- 'a' + 1;
1012 if ( wxIsUpperChar(*pstr
) )
1013 event
.m_keyCode
= *pstr
- 'A' + 1;
1015 event
.m_keyCode
= *pstr
- 'a' + 1;
1017 event
.m_uniChar
= event
.m_keyCode
;
1023 event
.SetEventType( wxEVT_CHAR_HOOK
);
1024 ret
= parent
->HandleWindowEvent( event
);
1029 event
.SetEventType(wxEVT_CHAR
);
1030 ret
= window
->HandleWindowEvent( event
);
1037 //-----------------------------------------------------------------------------
1038 // "key_release_event" from any window
1039 //-----------------------------------------------------------------------------
1043 gtk_window_key_release_callback( GtkWidget
* WXUNUSED(widget
),
1044 GdkEventKey
*gdk_event
,
1050 if (g_blockEventsOnDrag
)
1053 wxKeyEvent
event( wxEVT_KEY_UP
);
1054 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1056 // unknown key pressed, ignore (the event would be useless anyhow)
1060 return win
->GTKProcessEvent(event
);
1064 // ============================================================================
1066 // ============================================================================
1068 // ----------------------------------------------------------------------------
1069 // mouse event processing helpers
1070 // ----------------------------------------------------------------------------
1072 // init wxMouseEvent with the info from GdkEventXXX struct
1073 template<typename T
> void InitMouseEvent(wxWindowGTK
*win
,
1074 wxMouseEvent
& event
,
1077 event
.SetTimestamp( gdk_event
->time
);
1078 event
.m_shiftDown
= gdk_event
->state
& GDK_SHIFT_MASK
;
1079 event
.m_controlDown
= gdk_event
->state
& GDK_CONTROL_MASK
;
1080 event
.m_altDown
= gdk_event
->state
& GDK_MOD1_MASK
;
1081 event
.m_metaDown
= gdk_event
->state
& GDK_META_MASK
;
1082 event
.m_leftDown
= gdk_event
->state
& GDK_BUTTON1_MASK
;
1083 event
.m_middleDown
= gdk_event
->state
& GDK_BUTTON2_MASK
;
1084 event
.m_rightDown
= gdk_event
->state
& GDK_BUTTON3_MASK
;
1085 event
.m_aux1Down
= gdk_event
->state
& GDK_BUTTON4_MASK
;
1086 event
.m_aux2Down
= gdk_event
->state
& GDK_BUTTON5_MASK
;
1088 wxPoint pt
= win
->GetClientAreaOrigin();
1089 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1090 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1092 if ((win
->m_wxwindow
) && (win
->GetLayoutDirection() == wxLayout_RightToLeft
))
1094 // origin in the upper right corner
1095 int window_width
= win
->m_wxwindow
->allocation
.width
;
1096 event
.m_x
= window_width
- event
.m_x
;
1099 event
.SetEventObject( win
);
1100 event
.SetId( win
->GetId() );
1101 event
.SetTimestamp( gdk_event
->time
);
1104 static void AdjustEventButtonState(wxMouseEvent
& event
)
1106 // GDK reports the old state of the button for a button press event, but
1107 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1108 // for a LEFT_DOWN event, not FALSE, so we will invert
1109 // left/right/middleDown for the corresponding click events
1111 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1112 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1113 (event
.GetEventType() == wxEVT_LEFT_UP
))
1115 event
.m_leftDown
= !event
.m_leftDown
;
1119 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1120 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1121 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1123 event
.m_middleDown
= !event
.m_middleDown
;
1127 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1128 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1129 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1131 event
.m_rightDown
= !event
.m_rightDown
;
1136 // find the window to send the mouse event too
1138 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1143 if (win
->m_wxwindow
)
1145 wxPizza
* pizza
= WX_PIZZA(win
->m_wxwindow
);
1146 xx
+= pizza
->m_scroll_x
;
1147 yy
+= pizza
->m_scroll_y
;
1150 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
1153 wxWindowGTK
*child
= node
->GetData();
1155 node
= node
->GetNext();
1156 if (!child
->IsShown())
1159 if (child
->IsTransparentForMouse())
1161 // wxStaticBox is transparent in the box itself
1162 int xx1
= child
->m_x
;
1163 int yy1
= child
->m_y
;
1164 int xx2
= child
->m_x
+ child
->m_width
;
1165 int yy2
= child
->m_y
+ child
->m_height
;
1168 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1170 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1172 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1174 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1185 if ((child
->m_wxwindow
== NULL
) &&
1186 (child
->m_x
<= xx
) &&
1187 (child
->m_y
<= yy
) &&
1188 (child
->m_x
+child
->m_width
>= xx
) &&
1189 (child
->m_y
+child
->m_height
>= yy
))
1202 // ----------------------------------------------------------------------------
1203 // common event handlers helpers
1204 // ----------------------------------------------------------------------------
1206 bool wxWindowGTK::GTKProcessEvent(wxEvent
& event
) const
1208 // nothing special at this level
1209 return HandleWindowEvent(event
);
1212 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny
*event
) const
1216 if (g_blockEventsOnDrag
)
1218 if (g_blockEventsOnScroll
)
1221 if (!GTKIsOwnWindow(event
->window
))
1227 // overloads for all GDK event types we use here: we need to have this as
1228 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1229 // derives from it in the sense that the structs have the same layout
1230 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
1231 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
1233 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1236 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton
)
1237 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion
)
1238 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing
)
1240 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1242 #define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1243 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1247 // all event handlers must have C linkage as they're called from GTK+ C code
1251 //-----------------------------------------------------------------------------
1252 // "button_press_event"
1253 //-----------------------------------------------------------------------------
1256 gtk_window_button_press_callback( GtkWidget
*widget
,
1257 GdkEventButton
*gdk_event
,
1260 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1262 g_lastButtonNumber
= gdk_event
->button
;
1264 // GDK sends surplus button down events
1265 // before a double click event. We
1266 // need to filter these out.
1267 if ((gdk_event
->type
== GDK_BUTTON_PRESS
) && (win
->m_wxwindow
))
1269 GdkEvent
*peek_event
= gdk_event_peek();
1272 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1273 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1275 gdk_event_free( peek_event
);
1280 gdk_event_free( peek_event
);
1285 wxEventType event_type
= wxEVT_NULL
;
1287 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1288 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1290 // Reset GDK internal timestamp variables in order to disable GDK
1291 // triple click events. GDK will then next time believe no button has
1292 // been clicked just before, and send a normal button click event.
1293 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1294 display
->button_click_time
[1] = 0;
1295 display
->button_click_time
[0] = 0;
1298 if (gdk_event
->button
== 1)
1300 // note that GDK generates triple click events which are not supported
1301 // by wxWidgets but still have to be passed to the app as otherwise
1302 // clicks would simply go missing
1303 switch (gdk_event
->type
)
1305 // we shouldn't get triple clicks at all for GTK2 because we
1306 // suppress them artificially using the code above but we still
1307 // should map them to something for GTK1 and not just ignore them
1308 // as this would lose clicks
1309 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1310 case GDK_BUTTON_PRESS
:
1311 event_type
= wxEVT_LEFT_DOWN
;
1314 case GDK_2BUTTON_PRESS
:
1315 event_type
= wxEVT_LEFT_DCLICK
;
1319 // just to silence gcc warnings
1323 else if (gdk_event
->button
== 2)
1325 switch (gdk_event
->type
)
1327 case GDK_3BUTTON_PRESS
:
1328 case GDK_BUTTON_PRESS
:
1329 event_type
= wxEVT_MIDDLE_DOWN
;
1332 case GDK_2BUTTON_PRESS
:
1333 event_type
= wxEVT_MIDDLE_DCLICK
;
1340 else if (gdk_event
->button
== 3)
1342 switch (gdk_event
->type
)
1344 case GDK_3BUTTON_PRESS
:
1345 case GDK_BUTTON_PRESS
:
1346 event_type
= wxEVT_RIGHT_DOWN
;
1349 case GDK_2BUTTON_PRESS
:
1350 event_type
= wxEVT_RIGHT_DCLICK
;
1358 if ( event_type
== wxEVT_NULL
)
1360 // unknown mouse button or click type
1364 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1366 wxMouseEvent
event( event_type
);
1367 InitMouseEvent( win
, event
, gdk_event
);
1369 AdjustEventButtonState(event
);
1371 // wxListBox actually gets mouse events from the item, so we need to give it
1372 // a chance to correct this
1373 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1375 // find the correct window to send the event to: it may be a different one
1376 // from the one which got it at GTK+ level because some controls don't have
1377 // their own X window and thus cannot get any events.
1378 if ( !g_captureWindow
)
1379 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1381 // reset the event object and id in case win changed.
1382 event
.SetEventObject( win
);
1383 event
.SetId( win
->GetId() );
1385 bool ret
= win
->GTKProcessEvent( event
);
1386 g_lastMouseEvent
= NULL
;
1390 if ((event_type
== wxEVT_LEFT_DOWN
) && !win
->IsOfStandardClass() &&
1391 (gs_currentFocus
!= win
) /* && win->IsFocusable() */)
1396 if (event_type
== wxEVT_RIGHT_DOWN
)
1398 // generate a "context menu" event: this is similar to right mouse
1399 // click under many GUIs except that it is generated differently
1400 // (right up under MSW, ctrl-click under Mac, right down here) and
1402 // (a) it's a command event and so is propagated to the parent
1403 // (b) under some ports it can be generated from kbd too
1404 // (c) it uses screen coords (because of (a))
1405 wxContextMenuEvent
evtCtx(
1408 win
->ClientToScreen(event
.GetPosition()));
1409 evtCtx
.SetEventObject(win
);
1410 return win
->GTKProcessEvent(evtCtx
);
1416 //-----------------------------------------------------------------------------
1417 // "button_release_event"
1418 //-----------------------------------------------------------------------------
1421 gtk_window_button_release_callback( GtkWidget
*widget
,
1422 GdkEventButton
*gdk_event
,
1425 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1427 g_lastButtonNumber
= 0;
1429 wxEventType event_type
= wxEVT_NULL
;
1431 switch (gdk_event
->button
)
1434 event_type
= wxEVT_LEFT_UP
;
1438 event_type
= wxEVT_MIDDLE_UP
;
1442 event_type
= wxEVT_RIGHT_UP
;
1446 // unknown button, don't process
1450 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1452 wxMouseEvent
event( event_type
);
1453 InitMouseEvent( win
, event
, gdk_event
);
1455 AdjustEventButtonState(event
);
1457 // same wxListBox hack as above
1458 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1460 if ( !g_captureWindow
)
1461 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1463 // reset the event object and id in case win changed.
1464 event
.SetEventObject( win
);
1465 event
.SetId( win
->GetId() );
1467 bool ret
= win
->GTKProcessEvent(event
);
1469 g_lastMouseEvent
= NULL
;
1474 //-----------------------------------------------------------------------------
1475 // "motion_notify_event"
1476 //-----------------------------------------------------------------------------
1479 gtk_window_motion_notify_callback( GtkWidget
* WXUNUSED(widget
),
1480 GdkEventMotion
*gdk_event
,
1483 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1485 if (gdk_event
->is_hint
)
1489 GdkModifierType state
;
1490 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1495 g_lastMouseEvent
= (GdkEvent
*) gdk_event
;
1497 wxMouseEvent
event( wxEVT_MOTION
);
1498 InitMouseEvent(win
, event
, gdk_event
);
1500 if ( g_captureWindow
)
1502 // synthesise a mouse enter or leave event if needed
1503 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1504 // This seems to be necessary and actually been added to
1505 // GDK itself in version 2.0.X
1508 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1509 if ( hasMouse
!= g_captureWindowHasMouse
)
1511 // the mouse changed window
1512 g_captureWindowHasMouse
= hasMouse
;
1514 wxMouseEvent
eventM(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1515 : wxEVT_LEAVE_WINDOW
);
1516 InitMouseEvent(win
, eventM
, gdk_event
);
1517 eventM
.SetEventObject(win
);
1518 win
->GTKProcessEvent(eventM
);
1523 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1525 // reset the event object and id in case win changed.
1526 event
.SetEventObject( win
);
1527 event
.SetId( win
->GetId() );
1530 if ( !g_captureWindow
)
1532 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1533 if (win
->GTKProcessEvent( cevent
))
1535 win
->SetCursor( cevent
.GetCursor() );
1539 bool ret
= win
->GTKProcessEvent(event
);
1541 g_lastMouseEvent
= NULL
;
1546 //-----------------------------------------------------------------------------
1547 // "scroll_event" (mouse wheel event)
1548 //-----------------------------------------------------------------------------
1551 window_scroll_event_hscrollbar(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1553 if (gdk_event
->direction
!= GDK_SCROLL_LEFT
&&
1554 gdk_event
->direction
!= GDK_SCROLL_RIGHT
)
1559 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1560 InitMouseEvent(win
, event
, gdk_event
);
1562 GtkRange
*range
= win
->m_scrollBar
[wxWindow::ScrollDir_Horz
];
1563 if (!range
) return FALSE
;
1565 if (range
&& GTK_WIDGET_VISIBLE (range
))
1567 GtkAdjustment
*adj
= range
->adjustment
;
1568 gdouble delta
= adj
->step_increment
* 3;
1569 if (gdk_event
->direction
== GDK_SCROLL_LEFT
)
1572 gdouble new_value
= CLAMP (adj
->value
+ delta
, adj
->lower
, adj
->upper
- adj
->page_size
);
1574 gtk_adjustment_set_value (adj
, new_value
);
1583 window_scroll_event(GtkWidget
*, GdkEventScroll
* gdk_event
, wxWindow
* win
)
1585 if (gdk_event
->direction
!= GDK_SCROLL_UP
&&
1586 gdk_event
->direction
!= GDK_SCROLL_DOWN
)
1591 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
1592 InitMouseEvent(win
, event
, gdk_event
);
1594 // FIXME: Get these values from GTK or GDK
1595 event
.m_linesPerAction
= 3;
1596 event
.m_wheelDelta
= 120;
1597 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1598 event
.m_wheelRotation
= 120;
1600 event
.m_wheelRotation
= -120;
1602 if (win
->GTKProcessEvent(event
))
1605 GtkRange
*range
= win
->m_scrollBar
[wxWindow::ScrollDir_Vert
];
1606 if (!range
) return FALSE
;
1608 if (range
&& GTK_WIDGET_VISIBLE (range
))
1610 GtkAdjustment
*adj
= range
->adjustment
;
1611 gdouble delta
= adj
->step_increment
* 3;
1612 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1615 gdouble new_value
= CLAMP (adj
->value
+ delta
, adj
->lower
, adj
->upper
- adj
->page_size
);
1617 gtk_adjustment_set_value (adj
, new_value
);
1625 //-----------------------------------------------------------------------------
1627 //-----------------------------------------------------------------------------
1629 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
1631 wxContextMenuEvent
event(wxEVT_CONTEXT_MENU
, win
->GetId(), wxPoint(-1, -1));
1632 event
.SetEventObject(win
);
1633 return win
->GTKProcessEvent(event
);
1636 //-----------------------------------------------------------------------------
1638 //-----------------------------------------------------------------------------
1641 gtk_window_focus_in_callback( GtkWidget
* WXUNUSED(widget
),
1642 GdkEventFocus
*WXUNUSED(event
),
1645 return win
->GTKHandleFocusIn();
1648 //-----------------------------------------------------------------------------
1649 // "focus_out_event"
1650 //-----------------------------------------------------------------------------
1653 gtk_window_focus_out_callback( GtkWidget
* WXUNUSED(widget
),
1654 GdkEventFocus
* WXUNUSED(gdk_event
),
1657 return win
->GTKHandleFocusOut();
1660 //-----------------------------------------------------------------------------
1662 //-----------------------------------------------------------------------------
1665 wx_window_focus_callback(GtkWidget
*widget
,
1666 GtkDirectionType
WXUNUSED(direction
),
1669 // the default handler for focus signal in GtkScrolledWindow sets
1670 // focus to the window itself even if it doesn't accept focus, i.e. has no
1671 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1672 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1673 // any children which might accept focus (we know we don't accept the focus
1674 // ourselves as this signal is only connected in this case)
1675 if ( win
->GetChildren().empty() )
1676 g_signal_stop_emission_by_name(widget
, "focus");
1678 // we didn't change the focus
1682 //-----------------------------------------------------------------------------
1683 // "enter_notify_event"
1684 //-----------------------------------------------------------------------------
1687 gtk_window_enter_callback( GtkWidget
*widget
,
1688 GdkEventCrossing
*gdk_event
,
1691 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1693 // Event was emitted after a grab
1694 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1698 GdkModifierType state
= (GdkModifierType
)0;
1700 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1702 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1703 InitMouseEvent(win
, event
, gdk_event
);
1704 wxPoint pt
= win
->GetClientAreaOrigin();
1705 event
.m_x
= x
+ pt
.x
;
1706 event
.m_y
= y
+ pt
.y
;
1708 if ( !g_captureWindow
)
1710 wxSetCursorEvent
cevent( event
.m_x
, event
.m_y
);
1711 if (win
->GTKProcessEvent( cevent
))
1713 win
->SetCursor( cevent
.GetCursor() );
1717 return win
->GTKProcessEvent(event
);
1720 //-----------------------------------------------------------------------------
1721 // "leave_notify_event"
1722 //-----------------------------------------------------------------------------
1725 gtk_window_leave_callback( GtkWidget
*widget
,
1726 GdkEventCrossing
*gdk_event
,
1729 wxCOMMON_CALLBACK_PROLOGUE(gdk_event
, win
);
1731 // Event was emitted after an ungrab
1732 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1734 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1738 GdkModifierType state
= (GdkModifierType
)0;
1740 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1742 InitMouseEvent(win
, event
, gdk_event
);
1744 return win
->GTKProcessEvent(event
);
1747 //-----------------------------------------------------------------------------
1748 // "value_changed" from scrollbar
1749 //-----------------------------------------------------------------------------
1752 gtk_scrollbar_value_changed(GtkRange
* range
, wxWindow
* win
)
1754 wxEventType eventType
= win
->GetScrollEventType(range
);
1755 if (eventType
!= wxEVT_NULL
)
1757 // Convert scroll event type to scrollwin event type
1758 eventType
+= wxEVT_SCROLLWIN_TOP
- wxEVT_SCROLL_TOP
;
1760 // find the scrollbar which generated the event
1761 wxWindowGTK::ScrollDir dir
= win
->ScrollDirFromRange(range
);
1763 // generate the corresponding wx event
1764 const int orient
= wxWindow::OrientFromScrollDir(dir
);
1765 wxScrollWinEvent
event(eventType
, win
->GetScrollPos(orient
), orient
);
1766 event
.SetEventObject(win
);
1768 win
->GTKProcessEvent(event
);
1772 //-----------------------------------------------------------------------------
1773 // "button_press_event" from scrollbar
1774 //-----------------------------------------------------------------------------
1777 gtk_scrollbar_button_press_event(GtkRange
*, GdkEventButton
*, wxWindow
* win
)
1779 g_blockEventsOnScroll
= true;
1780 win
->m_mouseButtonDown
= true;
1785 //-----------------------------------------------------------------------------
1786 // "event_after" from scrollbar
1787 //-----------------------------------------------------------------------------
1790 gtk_scrollbar_event_after(GtkRange
* range
, GdkEvent
* event
, wxWindow
* win
)
1792 if (event
->type
== GDK_BUTTON_RELEASE
)
1794 g_signal_handlers_block_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1796 const int orient
= wxWindow::OrientFromScrollDir(
1797 win
->ScrollDirFromRange(range
));
1798 wxScrollWinEvent
evt(wxEVT_SCROLLWIN_THUMBRELEASE
,
1799 win
->GetScrollPos(orient
), orient
);
1800 evt
.SetEventObject(win
);
1801 win
->GTKProcessEvent(evt
);
1805 //-----------------------------------------------------------------------------
1806 // "button_release_event" from scrollbar
1807 //-----------------------------------------------------------------------------
1810 gtk_scrollbar_button_release_event(GtkRange
* range
, GdkEventButton
*, wxWindow
* win
)
1812 g_blockEventsOnScroll
= false;
1813 win
->m_mouseButtonDown
= false;
1814 // If thumb tracking
1815 if (win
->m_isScrolling
)
1817 win
->m_isScrolling
= false;
1818 // Hook up handler to send thumb release event after this emission is finished.
1819 // To allow setting scroll position from event handler, sending event must
1820 // be deferred until after the GtkRange handler for this signal has run
1821 g_signal_handlers_unblock_by_func(range
, (void*)gtk_scrollbar_event_after
, win
);
1827 //-----------------------------------------------------------------------------
1828 // "realize" from m_widget
1829 //-----------------------------------------------------------------------------
1832 gtk_window_realized_callback(GtkWidget
* widget
, wxWindow
* win
)
1836 gtk_im_context_set_client_window( win
->m_imData
->context
,
1840 // We cannot set colours and fonts before the widget
1841 // been realized, so we do this directly after realization
1842 // or otherwise in idle time
1844 if (win
->m_needsStyleChange
)
1846 win
->SetBackgroundStyle(win
->GetBackgroundStyle());
1847 win
->m_needsStyleChange
= false;
1850 wxWindowCreateEvent
event( win
);
1851 event
.SetEventObject( win
);
1852 win
->GTKProcessEvent( event
);
1855 //-----------------------------------------------------------------------------
1856 // "size_allocate" from m_wxwindow or m_widget
1857 //-----------------------------------------------------------------------------
1860 size_allocate(GtkWidget
*, GtkAllocation
* alloc
, wxWindow
* win
)
1862 int w
= alloc
->width
;
1863 int h
= alloc
->height
;
1864 if (win
->m_wxwindow
)
1866 int border_x
, border_y
;
1867 WX_PIZZA(win
->m_wxwindow
)->get_border_widths(border_x
, border_y
);
1873 if (win
->m_oldClientWidth
!= w
|| win
->m_oldClientHeight
!= h
)
1875 win
->m_oldClientWidth
= w
;
1876 win
->m_oldClientHeight
= h
;
1877 // this callback can be connected to m_wxwindow,
1878 // so always get size from m_widget->allocation
1879 win
->m_width
= win
->m_widget
->allocation
.width
;
1880 win
->m_height
= win
->m_widget
->allocation
.height
;
1881 if (!win
->m_nativeSizeEvent
)
1883 wxSizeEvent
event(win
->GetSize(), win
->GetId());
1884 event
.SetEventObject(win
);
1885 win
->GTKProcessEvent(event
);
1890 //-----------------------------------------------------------------------------
1892 //-----------------------------------------------------------------------------
1894 #if GTK_CHECK_VERSION(2, 8, 0)
1896 gtk_window_grab_broken( GtkWidget
*,
1897 GdkEventGrabBroken
*event
,
1900 // Mouse capture has been lost involuntarily, notify the application
1901 if(!event
->keyboard
&& wxWindow::GetCapture() == win
)
1903 wxMouseCaptureLostEvent
evt( win
->GetId() );
1904 evt
.SetEventObject( win
);
1905 win
->HandleWindowEvent( evt
);
1911 //-----------------------------------------------------------------------------
1913 //-----------------------------------------------------------------------------
1916 void gtk_window_style_set_callback( GtkWidget
*WXUNUSED(widget
),
1917 GtkStyle
*previous_style
,
1920 if (win
&& previous_style
)
1922 wxSysColourChangedEvent event
;
1923 event
.SetEventObject(win
);
1925 win
->GTKProcessEvent( event
);
1931 // Helper to suspend colour change event event processing while we change a widget's style
1932 class wxSuspendStyleEvents
1935 wxSuspendStyleEvents(wxWindow
* win
)
1938 if (win
->m_wxwindow
&& win
->IsTopLevel())
1941 g_signal_handlers_block_by_func(
1942 m_win
->m_wxwindow
, (void*)gtk_window_style_set_callback
, m_win
);
1945 ~wxSuspendStyleEvents()
1948 g_signal_handlers_unblock_by_func(
1949 m_win
->m_wxwindow
, (void*)gtk_window_style_set_callback
, m_win
);
1955 // ----------------------------------------------------------------------------
1956 // this wxWindowBase function is implemented here (in platform-specific file)
1957 // because it is static and so couldn't be made virtual
1958 // ----------------------------------------------------------------------------
1960 wxWindow
*wxWindowBase::DoFindFocus()
1962 wxWindowGTK
*focus
= gs_pendingFocus
? gs_pendingFocus
: gs_currentFocus
;
1963 // the cast is necessary when we compile in wxUniversal mode
1964 return static_cast<wxWindow
*>(focus
);
1967 void wxWindowGTK::AddChildGTK(wxWindowGTK
* child
)
1969 /* the window might have been scrolled already, do we
1970 have to adapt the position */
1971 wxPizza
* pizza
= WX_PIZZA(m_wxwindow
);
1972 child
->m_x
+= pizza
->m_scroll_x
;
1973 child
->m_y
+= pizza
->m_scroll_y
;
1975 gtk_widget_set_size_request(
1976 child
->m_widget
, child
->m_width
, child
->m_height
);
1978 GTK_FIXED(m_wxwindow
), child
->m_widget
, child
->m_x
, child
->m_y
);
1981 //-----------------------------------------------------------------------------
1983 //-----------------------------------------------------------------------------
1985 wxWindow
*wxGetActiveWindow()
1987 return wxWindow::FindFocus();
1991 wxMouseState
wxGetMouseState()
1997 GdkModifierType mask
;
1999 gdk_window_get_pointer(NULL
, &x
, &y
, &mask
);
2003 ms
.SetLeftDown(mask
& GDK_BUTTON1_MASK
);
2004 ms
.SetMiddleDown(mask
& GDK_BUTTON2_MASK
);
2005 ms
.SetRightDown(mask
& GDK_BUTTON3_MASK
);
2006 ms
.SetAux1Down(mask
& GDK_BUTTON4_MASK
);
2007 ms
.SetAux2Down(mask
& GDK_BUTTON5_MASK
);
2009 ms
.SetControlDown(mask
& GDK_CONTROL_MASK
);
2010 ms
.SetShiftDown(mask
& GDK_SHIFT_MASK
);
2011 ms
.SetAltDown(mask
& GDK_MOD1_MASK
);
2012 ms
.SetMetaDown(mask
& GDK_META_MASK
);
2017 //-----------------------------------------------------------------------------
2019 //-----------------------------------------------------------------------------
2021 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2023 #ifdef __WXUNIVERSAL__
2024 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2026 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
2027 #endif // __WXUNIVERSAL__/__WXGTK__
2029 void wxWindowGTK::Init()
2034 m_focusWidget
= NULL
;
2044 m_showOnIdle
= false;
2047 m_nativeSizeEvent
= false;
2049 m_isScrolling
= false;
2050 m_mouseButtonDown
= false;
2052 // initialize scrolling stuff
2053 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2055 m_scrollBar
[dir
] = NULL
;
2056 m_scrollPos
[dir
] = 0;
2060 m_oldClientHeight
= 0;
2062 m_clipPaintRegion
= false;
2064 m_needsStyleChange
= false;
2066 m_cursor
= *wxSTANDARD_CURSOR
;
2069 m_dirtyTabOrder
= false;
2072 wxWindowGTK::wxWindowGTK()
2077 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2082 const wxString
&name
)
2086 Create( parent
, id
, pos
, size
, style
, name
);
2089 bool wxWindowGTK::Create( wxWindow
*parent
,
2094 const wxString
&name
)
2096 // Get default border
2097 wxBorder border
= GetBorder(style
);
2098 style
&= ~wxBORDER_MASK
;
2101 if (!PreCreation( parent
, pos
, size
) ||
2102 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2104 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2109 m_wxwindow
= wxPizza::New(m_windowStyle
);
2110 #ifndef __WXUNIVERSAL__
2111 if (HasFlag(wxPizza::BORDER_STYLES
))
2113 g_signal_connect(m_wxwindow
, "parent_set",
2114 G_CALLBACK(parent_set
), this);
2117 if (!HasFlag(wxHSCROLL
) && !HasFlag(wxVSCROLL
))
2118 m_widget
= m_wxwindow
;
2121 m_widget
= gtk_scrolled_window_new( NULL
, NULL
);
2123 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2125 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2126 scroll_class
->scrollbar_spacing
= 0;
2128 // There is a conflict with default bindings at GTK+
2129 // level between scrolled windows and notebooks both of which want to use
2130 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2131 // direction and notebooks for changing pages -- we decide that if we don't
2132 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2133 // means we can get working keyboard navigation in notebooks
2134 if ( !HasFlag(wxHSCROLL
) )
2137 bindings
= gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget
));
2140 gtk_binding_entry_remove(bindings
, GDK_Page_Up
, GDK_CONTROL_MASK
);
2141 gtk_binding_entry_remove(bindings
, GDK_Page_Down
, GDK_CONTROL_MASK
);
2145 if (HasFlag(wxALWAYS_SHOW_SB
))
2147 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_ALWAYS
, GTK_POLICY_ALWAYS
);
2149 scrolledWindow
->hscrollbar_visible
= TRUE
;
2150 scrolledWindow
->vscrollbar_visible
= TRUE
;
2154 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2157 m_scrollBar
[ScrollDir_Horz
] = GTK_RANGE(scrolledWindow
->hscrollbar
);
2158 m_scrollBar
[ScrollDir_Vert
] = GTK_RANGE(scrolledWindow
->vscrollbar
);
2159 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2160 gtk_range_set_inverted( m_scrollBar
[ScrollDir_Horz
], TRUE
);
2162 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2164 // connect various scroll-related events
2165 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
2167 // these handlers block mouse events to any window during scrolling
2168 // such as motion events and prevent GTK and wxWidgets from fighting
2169 // over where the slider should be
2170 g_signal_connect(m_scrollBar
[dir
], "button_press_event",
2171 G_CALLBACK(gtk_scrollbar_button_press_event
), this);
2172 g_signal_connect(m_scrollBar
[dir
], "button_release_event",
2173 G_CALLBACK(gtk_scrollbar_button_release_event
), this);
2175 gulong handler_id
= g_signal_connect(m_scrollBar
[dir
], "event_after",
2176 G_CALLBACK(gtk_scrollbar_event_after
), this);
2177 g_signal_handler_block(m_scrollBar
[dir
], handler_id
);
2179 // these handlers get notified when scrollbar slider moves
2180 g_signal_connect_after(m_scrollBar
[dir
], "value_changed",
2181 G_CALLBACK(gtk_scrollbar_value_changed
), this);
2184 gtk_widget_show( m_wxwindow
);
2186 g_object_ref(m_widget
);
2189 m_parent
->DoAddChild( this );
2191 m_focusWidget
= m_wxwindow
;
2193 SetCanFocus(AcceptsFocus());
2200 wxWindowGTK::~wxWindowGTK()
2204 if (gs_currentFocus
== this)
2205 gs_currentFocus
= NULL
;
2206 if (gs_pendingFocus
== this)
2207 gs_pendingFocus
= NULL
;
2209 if ( gs_deferredFocusOut
== this )
2210 gs_deferredFocusOut
= NULL
;
2214 // destroy children before destroying this window itself
2217 // unhook focus handlers to prevent stray events being
2218 // propagated to this (soon to be) dead object
2219 if (m_focusWidget
!= NULL
)
2221 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2222 (gpointer
) gtk_window_focus_in_callback
,
2224 g_signal_handlers_disconnect_by_func (m_focusWidget
,
2225 (gpointer
) gtk_window_focus_out_callback
,
2232 // delete before the widgets to avoid a crash on solaris
2237 // Note that gtk_widget_destroy() does not destroy the widget, it just
2238 // emits the "destroy" signal. The widget is not actually destroyed
2239 // until its reference count drops to zero.
2240 gtk_widget_destroy(m_widget
);
2241 // Release our reference, should be the last one
2242 g_object_unref(m_widget
);
2248 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2250 if ( GTKNeedsParent() )
2252 wxCHECK_MSG( parent
, false, wxT("Must have non-NULL parent") );
2255 // Use either the given size, or the default if -1 is given.
2256 // See wxWindowBase for these functions.
2257 m_width
= WidthDefault(size
.x
) ;
2258 m_height
= HeightDefault(size
.y
);
2266 void wxWindowGTK::PostCreation()
2268 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2274 // these get reported to wxWidgets -> wxPaintEvent
2276 g_signal_connect (m_wxwindow
, "expose_event",
2277 G_CALLBACK (gtk_window_expose_callback
), this);
2279 if (GetLayoutDirection() == wxLayout_LeftToRight
)
2280 gtk_widget_set_redraw_on_allocate(m_wxwindow
, HasFlag(wxFULL_REPAINT_ON_RESIZE
));
2283 // Create input method handler
2284 m_imData
= new wxGtkIMData
;
2286 // Cannot handle drawing preedited text yet
2287 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2289 g_signal_connect (m_imData
->context
, "commit",
2290 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2295 if (!GTK_IS_WINDOW(m_widget
))
2297 if (m_focusWidget
== NULL
)
2298 m_focusWidget
= m_widget
;
2302 g_signal_connect (m_focusWidget
, "focus_in_event",
2303 G_CALLBACK (gtk_window_focus_in_callback
), this);
2304 g_signal_connect (m_focusWidget
, "focus_out_event",
2305 G_CALLBACK (gtk_window_focus_out_callback
), this);
2309 g_signal_connect_after (m_focusWidget
, "focus_in_event",
2310 G_CALLBACK (gtk_window_focus_in_callback
), this);
2311 g_signal_connect_after (m_focusWidget
, "focus_out_event",
2312 G_CALLBACK (gtk_window_focus_out_callback
), this);
2316 if ( !AcceptsFocusFromKeyboard() )
2320 g_signal_connect(m_widget
, "focus",
2321 G_CALLBACK(wx_window_focus_callback
), this);
2324 // connect to the various key and mouse handlers
2326 GtkWidget
*connect_widget
= GetConnectWidget();
2328 ConnectWidget( connect_widget
);
2330 /* We cannot set colours, fonts and cursors before the widget has
2331 been realized, so we do this directly after realization */
2332 g_signal_connect (connect_widget
, "realize",
2333 G_CALLBACK (gtk_window_realized_callback
), this);
2337 g_signal_connect(m_wxwindow
? m_wxwindow
: m_widget
, "size_allocate",
2338 G_CALLBACK(size_allocate
), this);
2343 #if GTK_CHECK_VERSION(2, 8, 0)
2344 if (!gtk_check_version(2,8,0))
2346 // Make sure we can notify the app when mouse capture is lost
2347 g_signal_connect (m_wxwindow
, "grab_broken_event",
2348 G_CALLBACK (gtk_window_grab_broken
), this);
2353 if ( connect_widget
!= m_wxwindow
)
2355 #if GTK_CHECK_VERSION(2, 8, 0)
2356 if (!gtk_check_version(2,8,0))
2358 // Make sure we can notify app code when mouse capture is lost
2359 g_signal_connect (connect_widget
, "grab_broken_event",
2360 G_CALLBACK (gtk_window_grab_broken
), this);
2365 #ifdef GTK_IS_FILE_CHOOSER_BUTTON
2366 if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget
))
2368 // If we connect to the "size_request" signal of a GtkFileChooserButton
2369 // then that control won't be sized properly when placed inside sizers
2370 // (this can be tested removing this elseif and running XRC or WIDGETS samples)
2371 // FIXME: what should be done here ?
2374 if ( !IsTopLevel() ) // top level windows use their own callback
2376 // This is needed if we want to add our windows into native
2377 // GTK controls, such as the toolbar. With this callback, the
2378 // toolbar gets to know the correct size (the one set by the
2379 // programmer). Sadly, it misbehaves for wxComboBox.
2380 g_signal_connect (m_widget
, "size_request",
2381 G_CALLBACK (wxgtk_window_size_request_callback
),
2385 InheritAttributes();
2389 SetLayoutDirection(wxLayout_Default
);
2391 // unless the window was created initially hidden (i.e. Hide() had been
2392 // called before Create()), we should show it at GTK+ level as well
2394 gtk_widget_show( m_widget
);
2397 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2399 g_signal_connect (widget
, "key_press_event",
2400 G_CALLBACK (gtk_window_key_press_callback
), this);
2401 g_signal_connect (widget
, "key_release_event",
2402 G_CALLBACK (gtk_window_key_release_callback
), this);
2403 g_signal_connect (widget
, "button_press_event",
2404 G_CALLBACK (gtk_window_button_press_callback
), this);
2405 g_signal_connect (widget
, "button_release_event",
2406 G_CALLBACK (gtk_window_button_release_callback
), this);
2407 g_signal_connect (widget
, "motion_notify_event",
2408 G_CALLBACK (gtk_window_motion_notify_callback
), this);
2410 g_signal_connect (widget
, "scroll_event",
2411 G_CALLBACK (window_scroll_event
), this);
2412 if (m_scrollBar
[ScrollDir_Horz
])
2413 g_signal_connect (m_scrollBar
[ScrollDir_Horz
], "scroll_event",
2414 G_CALLBACK (window_scroll_event_hscrollbar
), this);
2415 if (m_scrollBar
[ScrollDir_Vert
])
2416 g_signal_connect (m_scrollBar
[ScrollDir_Vert
], "scroll_event",
2417 G_CALLBACK (window_scroll_event
), this);
2419 g_signal_connect (widget
, "popup_menu",
2420 G_CALLBACK (wxgtk_window_popup_menu_callback
), this);
2421 g_signal_connect (widget
, "enter_notify_event",
2422 G_CALLBACK (gtk_window_enter_callback
), this);
2423 g_signal_connect (widget
, "leave_notify_event",
2424 G_CALLBACK (gtk_window_leave_callback
), this);
2426 if (IsTopLevel() && m_wxwindow
)
2427 g_signal_connect (m_wxwindow
, "style_set",
2428 G_CALLBACK (gtk_window_style_set_callback
), this);
2431 bool wxWindowGTK::Destroy()
2433 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2437 return wxWindowBase::Destroy();
2440 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2442 gtk_widget_set_size_request(m_widget
, width
, height
);
2443 // inform the parent to perform the move
2444 WX_PIZZA(m_parent
->m_wxwindow
)->move(m_widget
, x
, y
);
2447 void wxWindowGTK::ConstrainSize()
2450 // GPE's window manager doesn't like size hints at all, esp. when the user
2451 // has to use the virtual keyboard, so don't constrain size there
2455 const wxSize minSize
= GetMinSize();
2456 const wxSize maxSize
= GetMaxSize();
2457 if (minSize
.x
> 0 && m_width
< minSize
.x
) m_width
= minSize
.x
;
2458 if (minSize
.y
> 0 && m_height
< minSize
.y
) m_height
= minSize
.y
;
2459 if (maxSize
.x
> 0 && m_width
> maxSize
.x
) m_width
= maxSize
.x
;
2460 if (maxSize
.y
> 0 && m_height
> maxSize
.y
) m_height
= maxSize
.y
;
2464 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2466 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2467 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2469 int currentX
, currentY
;
2470 GetPosition(¤tX
, ¤tY
);
2471 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2473 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2475 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2477 // calculate the best size if we should auto size the window
2478 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2479 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2481 const wxSize sizeBest
= GetBestSize();
2482 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2484 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2485 height
= sizeBest
.y
;
2488 const wxSize
oldSize(m_width
, m_height
);
2494 if (m_parent
->m_wxwindow
)
2496 wxPizza
* pizza
= WX_PIZZA(m_parent
->m_wxwindow
);
2497 m_x
= x
+ pizza
->m_scroll_x
;
2498 m_y
= y
+ pizza
->m_scroll_y
;
2500 int left_border
= 0;
2501 int right_border
= 0;
2503 int bottom_border
= 0;
2505 /* the default button has a border around it */
2506 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
2508 GtkBorder
*default_border
= NULL
;
2509 gtk_widget_style_get( m_widget
, "default_border", &default_border
, NULL
);
2512 left_border
+= default_border
->left
;
2513 right_border
+= default_border
->right
;
2514 top_border
+= default_border
->top
;
2515 bottom_border
+= default_border
->bottom
;
2516 gtk_border_free( default_border
);
2520 DoMoveWindow( m_x
- left_border
,
2522 m_width
+left_border
+right_border
,
2523 m_height
+top_border
+bottom_border
);
2526 if (m_width
!= oldSize
.x
|| m_height
!= oldSize
.y
)
2528 // update these variables to keep size_allocate handler
2529 // from sending another size event for this change
2530 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2532 gtk_widget_queue_resize(m_widget
);
2533 if (!m_nativeSizeEvent
)
2535 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2536 event
.SetEventObject( this );
2537 HandleWindowEvent( event
);
2542 bool wxWindowGTK::GtkShowFromOnIdle()
2544 if (IsShown() && m_showOnIdle
&& !GTK_WIDGET_VISIBLE (m_widget
))
2546 GtkAllocation alloc
;
2549 alloc
.width
= m_width
;
2550 alloc
.height
= m_height
;
2551 gtk_widget_size_allocate( m_widget
, &alloc
);
2552 gtk_widget_show( m_widget
);
2553 wxShowEvent
eventShow(GetId(), true);
2554 eventShow
.SetEventObject(this);
2555 HandleWindowEvent(eventShow
);
2556 m_showOnIdle
= false;
2563 void wxWindowGTK::OnInternalIdle()
2565 if ( gs_deferredFocusOut
)
2566 GTKHandleDeferredFocusOut();
2568 // Check if we have to show window now
2569 if (GtkShowFromOnIdle()) return;
2571 if ( m_dirtyTabOrder
)
2573 m_dirtyTabOrder
= false;
2577 // Update style if the window was not yet realized
2578 // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
2579 if (m_needsStyleChange
)
2581 SetBackgroundStyle(GetBackgroundStyle());
2582 m_needsStyleChange
= false;
2585 wxCursor cursor
= m_cursor
;
2586 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
2590 /* I now set the cursor anew in every OnInternalIdle call
2591 as setting the cursor in a parent window also effects the
2592 windows above so that checking for the current cursor is
2595 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
2597 GdkWindow
*window
= m_wxwindow
->window
;
2599 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2601 if (!g_globalCursor
.Ok())
2602 cursor
= *wxSTANDARD_CURSOR
;
2604 window
= m_widget
->window
;
2605 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
2606 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2609 else if ( m_widget
)
2611 GdkWindow
*window
= m_widget
->window
;
2612 if ( window
&& !GTK_WIDGET_NO_WINDOW(m_widget
) )
2613 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2617 if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
2618 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
2621 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
2623 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2625 if (width
) (*width
) = m_width
;
2626 if (height
) (*height
) = m_height
;
2629 void wxWindowGTK::DoSetClientSize( int width
, int height
)
2631 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2633 const wxSize size
= GetSize();
2634 const wxSize clientSize
= GetClientSize();
2635 SetSize(width
+ (size
.x
- clientSize
.x
), height
+ (size
.y
- clientSize
.y
));
2638 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
2640 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2647 // if window is scrollable, account for scrollbars
2648 if ( GTK_IS_SCROLLED_WINDOW(m_widget
) )
2650 GtkPolicyType policy
[ScrollDir_Max
];
2651 gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget
),
2652 &policy
[ScrollDir_Horz
],
2653 &policy
[ScrollDir_Vert
]);
2655 for ( int i
= 0; i
< ScrollDir_Max
; i
++ )
2657 // don't account for the scrollbars we don't have
2658 GtkRange
* const range
= m_scrollBar
[i
];
2662 // nor for the ones we have but don't current show
2663 switch ( policy
[i
] )
2665 case GTK_POLICY_NEVER
:
2666 // never shown so doesn't take any place
2669 case GTK_POLICY_ALWAYS
:
2670 // no checks necessary
2673 case GTK_POLICY_AUTOMATIC
:
2674 // may be shown or not, check
2675 GtkAdjustment
*adj
= gtk_range_get_adjustment(range
);
2676 if ( adj
->upper
<= adj
->page_size
)
2681 gtk_widget_size_request(GTK_WIDGET(range
), &req
);
2682 if (i
== ScrollDir_Horz
)
2689 int border_x
, border_y
;
2690 WX_PIZZA(m_wxwindow
)->get_border_widths(border_x
, border_y
);
2700 if (width
) *width
= w
;
2701 if (height
) *height
= h
;
2704 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
2706 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2710 if (!IsTopLevel() && m_parent
&& m_parent
->m_wxwindow
)
2712 wxPizza
* pizza
= WX_PIZZA(m_parent
->m_wxwindow
);
2713 dx
= pizza
->m_scroll_x
;
2714 dy
= pizza
->m_scroll_y
;
2717 if (m_x
== -1 && m_y
== -1)
2719 GdkWindow
*source
= NULL
;
2721 source
= m_wxwindow
->window
;
2723 source
= m_widget
->window
;
2729 gdk_window_get_origin( source
, &org_x
, &org_y
);
2732 m_parent
->ScreenToClient(&org_x
, &org_y
);
2734 const_cast<wxWindowGTK
*>(this)->m_x
= org_x
;
2735 const_cast<wxWindowGTK
*>(this)->m_y
= org_y
;
2739 if (x
) (*x
) = m_x
- dx
;
2740 if (y
) (*y
) = m_y
- dy
;
2743 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
2745 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2747 if (!m_widget
->window
) return;
2749 GdkWindow
*source
= NULL
;
2751 source
= m_wxwindow
->window
;
2753 source
= m_widget
->window
;
2757 gdk_window_get_origin( source
, &org_x
, &org_y
);
2761 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2763 org_x
+= m_widget
->allocation
.x
;
2764 org_y
+= m_widget
->allocation
.y
;
2771 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2772 *x
= (GetClientSize().x
- *x
) + org_x
;
2780 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
2782 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2784 if (!m_widget
->window
) return;
2786 GdkWindow
*source
= NULL
;
2788 source
= m_wxwindow
->window
;
2790 source
= m_widget
->window
;
2794 gdk_window_get_origin( source
, &org_x
, &org_y
);
2798 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2800 org_x
+= m_widget
->allocation
.x
;
2801 org_y
+= m_widget
->allocation
.y
;
2807 if (GetLayoutDirection() == wxLayout_RightToLeft
)
2808 *x
= (GetClientSize().x
- *x
) - org_x
;
2815 bool wxWindowGTK::Show( bool show
)
2817 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
2819 if (!wxWindowBase::Show(show
))
2825 if (show
&& m_showOnIdle
)
2832 gtk_widget_show(m_widget
);
2834 gtk_widget_hide(m_widget
);
2835 wxShowEvent
eventShow(GetId(), show
);
2836 eventShow
.SetEventObject(this);
2837 HandleWindowEvent(eventShow
);
2843 void wxWindowGTK::DoEnable( bool enable
)
2845 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2847 gtk_widget_set_sensitive( m_widget
, enable
);
2848 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
2849 gtk_widget_set_sensitive( m_wxwindow
, enable
);
2852 int wxWindowGTK::GetCharHeight() const
2854 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
2856 wxFont font
= GetFont();
2857 wxCHECK_MSG( font
.Ok(), 12, wxT("invalid font") );
2859 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
2864 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
2865 PangoLayout
*layout
= pango_layout_new(context
);
2866 pango_layout_set_font_description(layout
, desc
);
2867 pango_layout_set_text(layout
, "H", 1);
2868 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
2870 PangoRectangle rect
;
2871 pango_layout_line_get_extents(line
, NULL
, &rect
);
2873 g_object_unref (layout
);
2875 return (int) PANGO_PIXELS(rect
.height
);
2878 int wxWindowGTK::GetCharWidth() const
2880 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
2882 wxFont font
= GetFont();
2883 wxCHECK_MSG( font
.Ok(), 8, wxT("invalid font") );
2885 PangoContext
* context
= gtk_widget_get_pango_context(m_widget
);
2890 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
2891 PangoLayout
*layout
= pango_layout_new(context
);
2892 pango_layout_set_font_description(layout
, desc
);
2893 pango_layout_set_text(layout
, "g", 1);
2894 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
2896 PangoRectangle rect
;
2897 pango_layout_line_get_extents(line
, NULL
, &rect
);
2899 g_object_unref (layout
);
2901 return (int) PANGO_PIXELS(rect
.width
);
2904 void wxWindowGTK::GetTextExtent( const wxString
& string
,
2908 int *externalLeading
,
2909 const wxFont
*theFont
) const
2911 wxFont fontToUse
= theFont
? *theFont
: GetFont();
2913 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
2922 PangoContext
*context
= NULL
;
2924 context
= gtk_widget_get_pango_context( m_widget
);
2933 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
2934 PangoLayout
*layout
= pango_layout_new(context
);
2935 pango_layout_set_font_description(layout
, desc
);
2937 const wxCharBuffer data
= wxGTK_CONV( string
);
2939 pango_layout_set_text(layout
, data
, strlen(data
));
2942 PangoRectangle rect
;
2943 pango_layout_get_extents(layout
, NULL
, &rect
);
2945 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
2946 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
2949 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
2950 int baseline
= pango_layout_iter_get_baseline(iter
);
2951 pango_layout_iter_free(iter
);
2952 *descent
= *y
- PANGO_PIXELS(baseline
);
2954 if (externalLeading
) (*externalLeading
) = 0; // ??
2956 g_object_unref (layout
);
2959 void wxWindowGTK::GTKDisableFocusOutEvent()
2961 g_signal_handlers_block_by_func( m_focusWidget
,
2962 (gpointer
) gtk_window_focus_out_callback
, this);
2965 void wxWindowGTK::GTKEnableFocusOutEvent()
2967 g_signal_handlers_unblock_by_func( m_focusWidget
,
2968 (gpointer
) gtk_window_focus_out_callback
, this);
2971 bool wxWindowGTK::GTKHandleFocusIn()
2973 // Disable default focus handling for custom windows since the default GTK+
2974 // handler issues a repaint
2975 const bool retval
= m_wxwindow
? true : false;
2978 // NB: if there's still unprocessed deferred focus-out event (see
2979 // GTKHandleFocusOut() for explanation), we need to process it first so
2980 // that the order of focus events -- focus-out first, then focus-in
2981 // elsewhere -- is preserved
2982 if ( gs_deferredFocusOut
)
2984 if ( GTKNeedsToFilterSameWindowFocus() &&
2985 gs_deferredFocusOut
== this )
2987 // GTK+ focus changed from this wxWindow back to itself, so don't
2988 // emit any events at all
2989 wxLogTrace(TRACE_FOCUS
,
2990 "filtered out spurious focus change within %s(%p, %s)",
2991 GetClassInfo()->GetClassName(), this, GetLabel());
2992 gs_deferredFocusOut
= NULL
;
2996 // otherwise we need to send focus-out first
2997 wxASSERT_MSG ( gs_deferredFocusOut
!= this,
2998 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
2999 GTKHandleDeferredFocusOut();
3003 wxLogTrace(TRACE_FOCUS
,
3004 "handling focus_in event for %s(%p, %s)",
3005 GetClassInfo()->GetClassName(), this, GetLabel());
3008 gtk_im_context_focus_in(m_imData
->context
);
3010 gs_currentFocus
= this;
3011 gs_pendingFocus
= NULL
;
3014 // caret needs to be informed about focus change
3015 wxCaret
*caret
= GetCaret();
3018 caret
->OnSetFocus();
3020 #endif // wxUSE_CARET
3022 // Notify the parent keeping track of focus for the kbd navigation
3023 // purposes that we got it.
3024 wxChildFocusEvent
eventChildFocus(static_cast<wxWindow
*>(this));
3025 GTKProcessEvent(eventChildFocus
);
3027 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, GetId());
3028 eventFocus
.SetEventObject(this);
3029 GTKProcessEvent(eventFocus
);
3034 bool wxWindowGTK::GTKHandleFocusOut()
3036 // Disable default focus handling for custom windows since the default GTK+
3037 // handler issues a repaint
3038 const bool retval
= m_wxwindow
? true : false;
3041 // NB: If a control is composed of several GtkWidgets and when focus
3042 // changes from one of them to another within the same wxWindow, we get
3043 // a focus-out event followed by focus-in for another GtkWidget owned
3044 // by the same wx control. We don't want to generate two spurious
3045 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3046 // from GTKHandleFocusOut() until we know for sure it's not coming back
3047 // (i.e. in GTKHandleFocusIn() or at idle time).
3048 if ( GTKNeedsToFilterSameWindowFocus() )
3050 wxASSERT_MSG( gs_deferredFocusOut
== NULL
,
3051 "deferred focus out event already pending" );
3052 wxLogTrace(TRACE_FOCUS
,
3053 "deferring focus_out event for %s(%p, %s)",
3054 GetClassInfo()->GetClassName(), this, GetLabel());
3055 gs_deferredFocusOut
= this;
3059 GTKHandleFocusOutNoDeferring();
3064 void wxWindowGTK::GTKHandleFocusOutNoDeferring()
3066 wxLogTrace(TRACE_FOCUS
,
3067 "handling focus_out event for %s(%p, %s)",
3068 GetClassInfo()->GetClassName(), this, GetLabel());
3071 gtk_im_context_focus_out(m_imData
->context
);
3073 if ( gs_currentFocus
!= this )
3075 // Something is terribly wrong, gs_currentFocus is out of sync with the
3076 // real focus. We will reset it to NULL anyway, because after this
3077 // focus-out event is handled, one of the following with happen:
3079 // * either focus will go out of the app altogether, in which case
3080 // gs_currentFocus _should_ be NULL
3082 // * or it goes to another control, in which case focus-in event will
3083 // follow immediately and it will set gs_currentFocus to the right
3085 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3086 GetClassInfo()->GetClassName(), this, GetLabel());
3088 gs_currentFocus
= NULL
;
3091 // caret needs to be informed about focus change
3092 wxCaret
*caret
= GetCaret();
3095 caret
->OnKillFocus();
3097 #endif // wxUSE_CARET
3099 wxFocusEvent
event( wxEVT_KILL_FOCUS
, GetId() );
3100 event
.SetEventObject( this );
3101 GTKProcessEvent( event
);
3105 void wxWindowGTK::GTKHandleDeferredFocusOut()
3107 // NB: See GTKHandleFocusOut() for explanation. This function is called
3108 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3110 if ( gs_deferredFocusOut
)
3112 wxWindowGTK
*win
= gs_deferredFocusOut
;
3113 gs_deferredFocusOut
= NULL
;
3115 wxLogTrace(TRACE_FOCUS
,
3116 "processing deferred focus_out event for %s(%p, %s)",
3117 win
->GetClassInfo()->GetClassName(), win
, win
->GetLabel());
3119 win
->GTKHandleFocusOutNoDeferring();
3123 void wxWindowGTK::SetFocus()
3125 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3127 // Setting "physical" focus is not immediate in GTK+ and while
3128 // gtk_widget_is_focus ("determines if the widget is the focus widget
3129 // within its toplevel", i.e. returns true for one widget per TLW, not
3130 // globally) returns true immediately after grabbing focus,
3131 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3132 // has focus at the moment) takes affect only after the window is shown
3133 // (if it was hidden at the moment of the call) or at the next event loop
3136 // Because we want to FindFocus() call immediately following
3137 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3139 gs_pendingFocus
= this;
3141 GtkWidget
*widget
= m_wxwindow
? m_wxwindow
: m_focusWidget
;
3143 if ( GTK_IS_CONTAINER(widget
) &&
3144 !GTK_WIDGET_CAN_FOCUS(widget
) )
3146 wxLogTrace(TRACE_FOCUS
,
3147 _T("Setting focus to a child of %s(%p, %s)"),
3148 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3149 gtk_widget_child_focus(widget
, GTK_DIR_TAB_FORWARD
);
3153 wxLogTrace(TRACE_FOCUS
,
3154 _T("Setting focus to %s(%p, %s)"),
3155 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3156 gtk_widget_grab_focus(widget
);
3160 void wxWindowGTK::SetCanFocus(bool canFocus
)
3163 GTK_WIDGET_SET_FLAGS(m_widget
, GTK_CAN_FOCUS
);
3165 GTK_WIDGET_UNSET_FLAGS(m_widget
, GTK_CAN_FOCUS
);
3167 if ( m_wxwindow
&& (m_widget
!= m_wxwindow
) )
3170 GTK_WIDGET_SET_FLAGS(m_wxwindow
, GTK_CAN_FOCUS
);
3172 GTK_WIDGET_UNSET_FLAGS(m_wxwindow
, GTK_CAN_FOCUS
);
3176 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3178 wxCHECK_MSG( (m_widget
!= NULL
), false, wxT("invalid window") );
3180 wxWindowGTK
*oldParent
= m_parent
,
3181 *newParent
= (wxWindowGTK
*)newParentBase
;
3183 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3185 if ( !wxWindowBase::Reparent(newParent
) )
3188 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3191 gtk_container_remove( GTK_CONTAINER(m_widget
->parent
), m_widget
);
3193 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3197 if (GTK_WIDGET_VISIBLE (newParent
->m_widget
))
3199 m_showOnIdle
= true;
3200 gtk_widget_hide( m_widget
);
3202 /* insert GTK representation */
3203 newParent
->AddChildGTK(this);
3206 SetLayoutDirection(wxLayout_Default
);
3211 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3213 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3214 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3219 /* insert GTK representation */
3223 void wxWindowGTK::AddChild(wxWindowBase
*child
)
3225 wxWindowBase::AddChild(child
);
3226 m_dirtyTabOrder
= true;
3227 wxTheApp
->WakeUpIdle();
3230 void wxWindowGTK::RemoveChild(wxWindowBase
*child
)
3232 wxWindowBase::RemoveChild(child
);
3233 m_dirtyTabOrder
= true;
3234 wxTheApp
->WakeUpIdle();
3238 wxLayoutDirection
wxWindowGTK::GTKGetLayout(GtkWidget
*widget
)
3240 return gtk_widget_get_direction(widget
) == GTK_TEXT_DIR_RTL
3241 ? wxLayout_RightToLeft
3242 : wxLayout_LeftToRight
;
3246 void wxWindowGTK::GTKSetLayout(GtkWidget
*widget
, wxLayoutDirection dir
)
3248 wxASSERT_MSG( dir
!= wxLayout_Default
, _T("invalid layout direction") );
3250 gtk_widget_set_direction(widget
,
3251 dir
== wxLayout_RightToLeft
? GTK_TEXT_DIR_RTL
3252 : GTK_TEXT_DIR_LTR
);
3255 wxLayoutDirection
wxWindowGTK::GetLayoutDirection() const
3257 return GTKGetLayout(m_widget
);
3260 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir
)
3262 if ( dir
== wxLayout_Default
)
3264 const wxWindow
*const parent
= GetParent();
3267 // inherit layout from parent.
3268 dir
= parent
->GetLayoutDirection();
3270 else // no parent, use global default layout
3272 dir
= wxTheApp
->GetLayoutDirection();
3276 if ( dir
== wxLayout_Default
)
3279 GTKSetLayout(m_widget
, dir
);
3281 if (m_wxwindow
&& (m_wxwindow
!= m_widget
))
3282 GTKSetLayout(m_wxwindow
, dir
);
3286 wxWindowGTK::AdjustForLayoutDirection(wxCoord x
,
3287 wxCoord
WXUNUSED(width
),
3288 wxCoord
WXUNUSED(widthTotal
)) const
3290 // We now mirror the coordinates of RTL windows in wxPizza
3294 void wxWindowGTK::DoMoveInTabOrder(wxWindow
*win
, WindowOrder move
)
3296 wxWindowBase::DoMoveInTabOrder(win
, move
);
3297 m_dirtyTabOrder
= true;
3298 wxTheApp
->WakeUpIdle();
3301 bool wxWindowGTK::DoNavigateIn(int flags
)
3303 if ( flags
& wxNavigationKeyEvent::WinChange
)
3305 wxFAIL_MSG( _T("not implemented") );
3309 else // navigate inside the container
3311 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3312 wxCHECK_MSG( parent
, false, _T("every window must have a TLW parent") );
3314 GtkDirectionType dir
;
3315 dir
= flags
& wxNavigationKeyEvent::IsForward
? GTK_DIR_TAB_FORWARD
3316 : GTK_DIR_TAB_BACKWARD
;
3319 g_signal_emit_by_name(parent
->m_widget
, "focus", dir
, &rc
);
3325 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3327 // none needed by default
3331 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget
* WXUNUSED(w
))
3333 // nothing to do by default since none is needed
3336 void wxWindowGTK::RealizeTabOrder()
3340 if ( !m_children
.empty() )
3342 // we don't only construct the correct focus chain but also use
3343 // this opportunity to update the mnemonic widgets for the widgets
3346 GList
*chain
= NULL
;
3347 wxWindowGTK
* mnemonicWindow
= NULL
;
3349 for ( wxWindowList::const_iterator i
= m_children
.begin();
3350 i
!= m_children
.end();
3353 wxWindowGTK
*win
= *i
;
3355 if ( mnemonicWindow
)
3357 if ( win
->AcceptsFocusFromKeyboard() )
3359 // wxComboBox et al. needs to focus on on a different
3360 // widget than m_widget, so if the main widget isn't
3361 // focusable try the connect widget
3362 GtkWidget
* w
= win
->m_widget
;
3363 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3365 w
= win
->GetConnectWidget();
3366 if ( !GTK_WIDGET_CAN_FOCUS(w
) )
3372 mnemonicWindow
->GTKWidgetDoSetMnemonic(w
);
3373 mnemonicWindow
= NULL
;
3377 else if ( win
->GTKWidgetNeedsMnemonic() )
3379 mnemonicWindow
= win
;
3382 chain
= g_list_prepend(chain
, win
->m_widget
);
3385 chain
= g_list_reverse(chain
);
3387 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3392 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3397 void wxWindowGTK::Raise()
3399 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3401 if (m_wxwindow
&& m_wxwindow
->window
)
3403 gdk_window_raise( m_wxwindow
->window
);
3405 else if (m_widget
->window
)
3407 gdk_window_raise( m_widget
->window
);
3411 void wxWindowGTK::Lower()
3413 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3415 if (m_wxwindow
&& m_wxwindow
->window
)
3417 gdk_window_lower( m_wxwindow
->window
);
3419 else if (m_widget
->window
)
3421 gdk_window_lower( m_widget
->window
);
3425 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3427 if ( !wxWindowBase::SetCursor(cursor
.Ok() ? cursor
: *wxSTANDARD_CURSOR
) )
3435 void wxWindowGTK::GTKUpdateCursor()
3437 wxCursor
cursor(g_globalCursor
.Ok() ? g_globalCursor
: GetCursor());
3440 wxArrayGdkWindows windowsThis
;
3441 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
3444 gdk_window_set_cursor(winThis
, cursor
.GetCursor());
3448 const size_t count
= windowsThis
.size();
3449 for ( size_t n
= 0; n
< count
; n
++ )
3451 GdkWindow
*win
= windowsThis
[n
];
3454 wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?"));
3458 gdk_window_set_cursor(win
, cursor
.GetCursor());
3464 void wxWindowGTK::WarpPointer( int x
, int y
)
3466 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3468 // We provide this function ourselves as it is
3469 // missing in GDK (top of this file).
3471 GdkWindow
*window
= NULL
;
3473 window
= m_wxwindow
->window
;
3475 window
= GetConnectWidget()->window
;
3478 gdk_window_warp_pointer( window
, x
, y
);
3481 wxWindowGTK::ScrollDir
wxWindowGTK::ScrollDirFromRange(GtkRange
*range
) const
3483 // find the scrollbar which generated the event
3484 for ( int dir
= 0; dir
< ScrollDir_Max
; dir
++ )
3486 if ( range
== m_scrollBar
[dir
] )
3487 return (ScrollDir
)dir
;
3490 wxFAIL_MSG( _T("event from unknown scrollbar received") );
3492 return ScrollDir_Max
;
3495 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir
, ScrollUnit unit
, int units
)
3497 bool changed
= false;
3498 GtkRange
* range
= m_scrollBar
[dir
];
3499 if ( range
&& units
)
3501 GtkAdjustment
* adj
= range
->adjustment
;
3502 gdouble inc
= unit
== ScrollUnit_Line
? adj
->step_increment
3503 : adj
->page_increment
;
3505 const int posOld
= int(adj
->value
+ 0.5);
3506 gtk_range_set_value(range
, posOld
+ units
*inc
);
3508 changed
= int(adj
->value
+ 0.5) != posOld
;
3514 bool wxWindowGTK::ScrollLines(int lines
)
3516 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Line
, lines
);
3519 bool wxWindowGTK::ScrollPages(int pages
)
3521 return DoScrollByUnits(ScrollDir_Vert
, ScrollUnit_Page
, pages
);
3524 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground
),
3529 if (!m_widget
->window
)
3534 if (m_wxwindow
->window
== NULL
) return;
3536 GdkRectangle gdk_rect
,
3540 gdk_rect
.x
= rect
->x
;
3541 gdk_rect
.y
= rect
->y
;
3542 gdk_rect
.width
= rect
->width
;
3543 gdk_rect
.height
= rect
->height
;
3544 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3545 gdk_rect
.x
= GetClientSize().x
- gdk_rect
.x
- gdk_rect
.width
;
3549 else // invalidate everything
3554 gdk_window_invalidate_rect(m_wxwindow
->window
, p
, true);
3558 void wxWindowGTK::Update()
3562 // when we call Update() we really want to update the window immediately on
3563 // screen, even if it means flushing the entire queue and hence slowing down
3564 // everything -- but it should still be done, it's just that Update() should
3565 // be called very rarely
3569 void wxWindowGTK::GtkUpdate()
3571 if (m_wxwindow
&& m_wxwindow
->window
)
3572 gdk_window_process_updates(m_wxwindow
->window
, false);
3573 if (m_widget
&& m_widget
->window
&& (m_wxwindow
!= m_widget
))
3574 gdk_window_process_updates( m_widget
->window
, FALSE
);
3576 // for consistency with other platforms (and also because it's convenient
3577 // to be able to update an entire TLW by calling Update() only once), we
3578 // should also update all our children here
3579 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3581 node
= node
->GetNext() )
3583 node
->GetData()->GtkUpdate();
3587 bool wxWindowGTK::DoIsExposed( int x
, int y
) const
3589 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
3593 bool wxWindowGTK::DoIsExposed( int x
, int y
, int w
, int h
) const
3595 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3596 return m_updateRegion
.Contains(x
-w
, y
, w
, h
) != wxOutRegion
;
3598 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
3601 void wxWindowGTK::GtkSendPaintEvents()
3605 m_updateRegion
.Clear();
3609 // Clip to paint region in wxClientDC
3610 m_clipPaintRegion
= true;
3612 m_nativeUpdateRegion
= m_updateRegion
;
3614 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3616 // Transform m_updateRegion under RTL
3617 m_updateRegion
.Clear();
3620 gdk_drawable_get_size(m_wxwindow
->window
, &width
, NULL
);
3622 wxRegionIterator
upd( m_nativeUpdateRegion
);
3626 rect
.x
= upd
.GetX();
3627 rect
.y
= upd
.GetY();
3628 rect
.width
= upd
.GetWidth();
3629 rect
.height
= upd
.GetHeight();
3631 rect
.x
= width
- rect
.x
- rect
.width
;
3632 m_updateRegion
.Union( rect
);
3638 if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM
))
3640 // find ancestor from which to steal background
3641 wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
3643 parent
= (wxWindow
*)this;
3645 if (GTK_WIDGET_MAPPED(parent
->m_widget
))
3647 wxRegionIterator
upd( m_nativeUpdateRegion
);
3651 rect
.x
= upd
.GetX();
3652 rect
.y
= upd
.GetY();
3653 rect
.width
= upd
.GetWidth();
3654 rect
.height
= upd
.GetHeight();
3656 gtk_paint_flat_box( parent
->m_widget
->style
,
3658 (GtkStateType
)GTK_WIDGET_STATE(m_wxwindow
),
3671 wxWindowDC
dc( (wxWindow
*)this );
3672 dc
.SetDeviceClippingRegion( m_updateRegion
);
3674 // Work around gtk-qt <= 0.60 bug whereby the window colour
3676 if (GetBackgroundStyle() == wxBG_STYLE_COLOUR
&& GetBackgroundColour().Ok() && wxSystemOptions::GetOptionInt(wxT("gtk.window.force-background-colour")) == 1)
3678 dc
.SetBackground(wxBrush(GetBackgroundColour()));
3682 wxEraseEvent
erase_event( GetId(), &dc
);
3683 erase_event
.SetEventObject( this );
3685 HandleWindowEvent(erase_event
);
3688 wxNcPaintEvent
nc_paint_event( GetId() );
3689 nc_paint_event
.SetEventObject( this );
3690 HandleWindowEvent( nc_paint_event
);
3692 wxPaintEvent
paint_event( GetId() );
3693 paint_event
.SetEventObject( this );
3694 HandleWindowEvent( paint_event
);
3696 m_clipPaintRegion
= false;
3698 m_updateRegion
.Clear();
3699 m_nativeUpdateRegion
.Clear();
3702 void wxWindowGTK::SetDoubleBuffered( bool on
)
3704 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3707 gtk_widget_set_double_buffered( m_wxwindow
, on
);
3710 bool wxWindowGTK::IsDoubleBuffered() const
3712 return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow
);
3715 void wxWindowGTK::ClearBackground()
3717 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3721 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3723 wxWindowBase::DoSetToolTip(tip
);
3726 m_tooltip
->Apply( (wxWindow
*)this );
3729 void wxWindowGTK::ApplyToolTip( GtkTooltips
*tips
, const gchar
*tip
)
3731 gtk_tooltips_set_tip(tips
, GetConnectWidget(), tip
, NULL
);
3733 #endif // wxUSE_TOOLTIPS
3735 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
3737 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3739 if (!wxWindowBase::SetBackgroundColour(colour
))
3744 // We need the pixel value e.g. for background clearing.
3745 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3748 // apply style change (forceStyle=true so that new style is applied
3749 // even if the bg colour changed from valid to wxNullColour)
3750 if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM
)
3751 ApplyWidgetStyle(true);
3756 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
3758 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3760 if (!wxWindowBase::SetForegroundColour(colour
))
3767 // We need the pixel value e.g. for background clearing.
3768 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3771 // apply style change (forceStyle=true so that new style is applied
3772 // even if the bg colour changed from valid to wxNullColour):
3773 ApplyWidgetStyle(true);
3778 PangoContext
*wxWindowGTK::GtkGetPangoDefaultContext()
3780 return gtk_widget_get_pango_context( m_widget
);
3783 GtkRcStyle
*wxWindowGTK::CreateWidgetStyle(bool forceStyle
)
3785 // do we need to apply any changes at all?
3788 !m_foregroundColour
.Ok() && !m_backgroundColour
.Ok() )
3793 GtkRcStyle
*style
= gtk_rc_style_new();
3798 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
3801 int flagsNormal
= 0,
3804 flagsInsensitive
= 0;
3806 if ( m_foregroundColour
.Ok() )
3808 const GdkColor
*fg
= m_foregroundColour
.GetColor();
3810 style
->fg
[GTK_STATE_NORMAL
] =
3811 style
->text
[GTK_STATE_NORMAL
] = *fg
;
3812 flagsNormal
|= GTK_RC_FG
| GTK_RC_TEXT
;
3814 style
->fg
[GTK_STATE_PRELIGHT
] =
3815 style
->text
[GTK_STATE_PRELIGHT
] = *fg
;
3816 flagsPrelight
|= GTK_RC_FG
| GTK_RC_TEXT
;
3818 style
->fg
[GTK_STATE_ACTIVE
] =
3819 style
->text
[GTK_STATE_ACTIVE
] = *fg
;
3820 flagsActive
|= GTK_RC_FG
| GTK_RC_TEXT
;
3823 if ( m_backgroundColour
.Ok() )
3825 const GdkColor
*bg
= m_backgroundColour
.GetColor();
3827 style
->bg
[GTK_STATE_NORMAL
] =
3828 style
->base
[GTK_STATE_NORMAL
] = *bg
;
3829 flagsNormal
|= GTK_RC_BG
| GTK_RC_BASE
;
3831 style
->bg
[GTK_STATE_PRELIGHT
] =
3832 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
3833 flagsPrelight
|= GTK_RC_BG
| GTK_RC_BASE
;
3835 style
->bg
[GTK_STATE_ACTIVE
] =
3836 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
3837 flagsActive
|= GTK_RC_BG
| GTK_RC_BASE
;
3839 style
->bg
[GTK_STATE_INSENSITIVE
] =
3840 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
3841 flagsInsensitive
|= GTK_RC_BG
| GTK_RC_BASE
;
3844 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)flagsNormal
;
3845 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)flagsPrelight
;
3846 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)flagsActive
;
3847 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)flagsInsensitive
;
3852 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle
)
3854 GtkRcStyle
*style
= CreateWidgetStyle(forceStyle
);
3857 DoApplyWidgetStyle(style
);
3858 gtk_rc_style_unref(style
);
3861 // Style change may affect GTK+'s size calculation:
3862 InvalidateBestSize();
3865 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
3867 wxSuspendStyleEvents
s(static_cast<wxWindow
*>(this));
3870 gtk_widget_modify_style(m_wxwindow
, style
);
3872 gtk_widget_modify_style(m_widget
, style
);
3875 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style
)
3877 wxWindowBase::SetBackgroundStyle(style
);
3879 if (style
== wxBG_STYLE_CUSTOM
)
3884 window
= m_wxwindow
->window
;
3888 GtkWidget
* const w
= GetConnectWidget();
3889 window
= w
? w
->window
: NULL
;
3894 // Make sure GDK/X11 doesn't refresh the window
3896 gdk_window_set_back_pixmap( window
, None
, False
);
3898 Display
* display
= GDK_WINDOW_DISPLAY(window
);
3901 m_needsStyleChange
= false;
3903 else // window not realized yet
3905 // Do in OnIdle, because the window is not yet available
3906 m_needsStyleChange
= true;
3909 // Don't apply widget style, or we get a grey background
3913 // apply style change (forceStyle=true so that new style is applied
3914 // even if the bg colour changed from valid to wxNullColour):
3915 ApplyWidgetStyle(true);
3920 // ----------------------------------------------------------------------------
3921 // Pop-up menu stuff
3922 // ----------------------------------------------------------------------------
3924 #if wxUSE_MENUS_NATIVE
3926 static void SetInvokingWindow( wxMenu
*menu
, wxWindow
* win
)
3928 menu
->SetInvokingWindow( win
);
3930 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
3933 wxMenuItem
*menuitem
= node
->GetData();
3934 if (menuitem
->IsSubMenu())
3936 SetInvokingWindow( menuitem
->GetSubMenu(), win
);
3939 node
= node
->GetNext();
3945 void wxPopupMenuPositionCallback( GtkMenu
*menu
,
3947 gboolean
* WXUNUSED(whatever
),
3948 gpointer user_data
)
3950 // ensure that the menu appears entirely on screen
3952 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
3954 wxSize sizeScreen
= wxGetDisplaySize();
3955 wxPoint
*pos
= (wxPoint
*)user_data
;
3957 gint xmax
= sizeScreen
.x
- req
.width
,
3958 ymax
= sizeScreen
.y
- req
.height
;
3960 *x
= pos
->x
< xmax
? pos
->x
: xmax
;
3961 *y
= pos
->y
< ymax
? pos
->y
: ymax
;
3965 void wxWindowGTK::DoPopupMenuUpdateUI(wxMenu
* menu
)
3970 bool wxWindowGTK::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
3972 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
3974 wxCHECK_MSG( menu
!= NULL
, false, wxT("invalid popup-menu") );
3976 SetInvokingWindow( menu
, this );
3978 DoPopupMenuUpdateUI(menu
);
3982 GtkMenuPositionFunc posfunc
;
3983 if ( x
== -1 && y
== -1 )
3985 // use GTK's default positioning algorithm
3991 pos
= ClientToScreen(wxPoint(x
, y
));
3993 posfunc
= wxPopupMenuPositionCallback
;
3996 menu
->m_popupShown
= true;
3998 GTK_MENU(menu
->m_menu
),
3999 NULL
, // parent menu shell
4000 NULL
, // parent menu item
4001 posfunc
, // function to position it
4002 userdata
, // client data
4003 0, // button used to activate it
4004 gtk_get_current_event_time()
4007 while (menu
->m_popupShown
)
4009 gtk_main_iteration();
4015 #endif // wxUSE_MENUS_NATIVE
4017 #if wxUSE_DRAG_AND_DROP
4019 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4021 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4023 GtkWidget
*dnd_widget
= GetConnectWidget();
4025 if (m_dropTarget
) m_dropTarget
->GtkUnregisterWidget( dnd_widget
);
4027 if (m_dropTarget
) delete m_dropTarget
;
4028 m_dropTarget
= dropTarget
;
4030 if (m_dropTarget
) m_dropTarget
->GtkRegisterWidget( dnd_widget
);
4033 #endif // wxUSE_DRAG_AND_DROP
4035 GtkWidget
* wxWindowGTK::GetConnectWidget()
4037 GtkWidget
*connect_widget
= m_widget
;
4038 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4040 return connect_widget
;
4043 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow
*window
) const
4045 wxArrayGdkWindows windowsThis
;
4046 GdkWindow
* const winThis
= GTKGetWindow(windowsThis
);
4048 return winThis
? window
== winThis
4049 : windowsThis
.Index(window
) != wxNOT_FOUND
;
4052 GdkWindow
*wxWindowGTK::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
4054 return m_wxwindow
? m_wxwindow
->window
: m_widget
->window
;
4057 bool wxWindowGTK::SetFont( const wxFont
&font
)
4059 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4061 if (!wxWindowBase::SetFont(font
))
4064 // apply style change (forceStyle=true so that new style is applied
4065 // even if the font changed from valid to wxNullFont):
4066 ApplyWidgetStyle(true);
4071 void wxWindowGTK::DoCaptureMouse()
4073 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4075 GdkWindow
*window
= NULL
;
4077 window
= m_wxwindow
->window
;
4079 window
= GetConnectWidget()->window
;
4081 wxCHECK_RET( window
, _T("CaptureMouse() failed") );
4083 const wxCursor
* cursor
= &m_cursor
;
4085 cursor
= wxSTANDARD_CURSOR
;
4087 gdk_pointer_grab( window
, FALSE
,
4089 (GDK_BUTTON_PRESS_MASK
|
4090 GDK_BUTTON_RELEASE_MASK
|
4091 GDK_POINTER_MOTION_HINT_MASK
|
4092 GDK_POINTER_MOTION_MASK
),
4094 cursor
->GetCursor(),
4095 (guint32
)GDK_CURRENT_TIME
);
4096 g_captureWindow
= this;
4097 g_captureWindowHasMouse
= true;
4100 void wxWindowGTK::DoReleaseMouse()
4102 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4104 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4106 g_captureWindow
= NULL
;
4108 GdkWindow
*window
= NULL
;
4110 window
= m_wxwindow
->window
;
4112 window
= GetConnectWidget()->window
;
4117 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4120 void wxWindowGTK::GTKReleaseMouseAndNotify()
4123 wxMouseCaptureLostEvent
evt(GetId());
4124 evt
.SetEventObject( this );
4125 HandleWindowEvent( evt
);
4129 wxWindow
*wxWindowBase::GetCapture()
4131 return (wxWindow
*)g_captureWindow
;
4134 bool wxWindowGTK::IsRetained() const
4139 void wxWindowGTK::SetScrollbar(int orient
,
4143 bool WXUNUSED(update
))
4145 const int dir
= ScrollDirFromOrient(orient
);
4146 GtkRange
* const sb
= m_scrollBar
[dir
];
4147 wxCHECK_RET( sb
, _T("this window is not scrollable") );
4151 // GtkRange requires upper > lower
4156 GtkAdjustment
* const adj
= sb
->adjustment
;
4157 adj
->step_increment
= 1;
4158 adj
->page_increment
=
4159 adj
->page_size
= thumbVisible
;
4162 g_signal_handlers_block_by_func(
4163 sb
, (void*)gtk_scrollbar_value_changed
, this);
4165 gtk_range_set_range(sb
, 0, range
);
4166 m_scrollPos
[dir
] = sb
->adjustment
->value
;
4168 g_signal_handlers_unblock_by_func(
4169 sb
, (void*)gtk_scrollbar_value_changed
, this);
4172 void wxWindowGTK::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
4174 const int dir
= ScrollDirFromOrient(orient
);
4175 GtkRange
* const sb
= m_scrollBar
[dir
];
4176 wxCHECK_RET( sb
, _T("this window is not scrollable") );
4178 // This check is more than an optimization. Without it, the slider
4179 // will not move smoothly while tracking when using wxScrollHelper.
4180 if (GetScrollPos(orient
) != pos
)
4182 g_signal_handlers_block_by_func(
4183 sb
, (void*)gtk_scrollbar_value_changed
, this);
4185 gtk_range_set_value(sb
, pos
);
4186 m_scrollPos
[dir
] = sb
->adjustment
->value
;
4188 g_signal_handlers_unblock_by_func(
4189 sb
, (void*)gtk_scrollbar_value_changed
, this);
4193 int wxWindowGTK::GetScrollThumb(int orient
) const
4195 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4196 wxCHECK_MSG( sb
, 0, _T("this window is not scrollable") );
4198 return int(sb
->adjustment
->page_size
);
4201 int wxWindowGTK::GetScrollPos( int orient
) const
4203 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4204 wxCHECK_MSG( sb
, 0, _T("this window is not scrollable") );
4206 return int(sb
->adjustment
->value
+ 0.5);
4209 int wxWindowGTK::GetScrollRange( int orient
) const
4211 GtkRange
* const sb
= m_scrollBar
[ScrollDirFromOrient(orient
)];
4212 wxCHECK_MSG( sb
, 0, _T("this window is not scrollable") );
4214 return int(sb
->adjustment
->upper
);
4217 // Determine if increment is the same as +/-x, allowing for some small
4218 // difference due to possible inexactness in floating point arithmetic
4219 static inline bool IsScrollIncrement(double increment
, double x
)
4221 wxASSERT(increment
> 0);
4222 const double tolerance
= 1.0 / 1024;
4223 return fabs(increment
- fabs(x
)) < tolerance
;
4226 wxEventType
wxWindowGTK::GetScrollEventType(GtkRange
* range
)
4228 wxASSERT(range
== m_scrollBar
[0] || range
== m_scrollBar
[1]);
4230 const int barIndex
= range
== m_scrollBar
[1];
4231 GtkAdjustment
* adj
= range
->adjustment
;
4233 const int value
= int(adj
->value
+ 0.5);
4235 // save previous position
4236 const double oldPos
= m_scrollPos
[barIndex
];
4237 // update current position
4238 m_scrollPos
[barIndex
] = adj
->value
;
4239 // If event should be ignored, or integral position has not changed
4240 if (!m_hasVMT
|| g_blockEventsOnDrag
|| value
== int(oldPos
+ 0.5))
4245 wxEventType eventType
= wxEVT_SCROLL_THUMBTRACK
;
4248 // Difference from last change event
4249 const double diff
= adj
->value
- oldPos
;
4250 const bool isDown
= diff
> 0;
4252 if (IsScrollIncrement(adj
->step_increment
, diff
))
4254 eventType
= isDown
? wxEVT_SCROLL_LINEDOWN
: wxEVT_SCROLL_LINEUP
;
4256 else if (IsScrollIncrement(adj
->page_increment
, diff
))
4258 eventType
= isDown
? wxEVT_SCROLL_PAGEDOWN
: wxEVT_SCROLL_PAGEUP
;
4260 else if (m_mouseButtonDown
)
4262 // Assume track event
4263 m_isScrolling
= true;
4269 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4271 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4273 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4275 // No scrolling requested.
4276 if ((dx
== 0) && (dy
== 0)) return;
4278 m_clipPaintRegion
= true;
4280 WX_PIZZA(m_wxwindow
)->scroll(dx
, dy
);
4282 m_clipPaintRegion
= false;
4285 bool restoreCaret
= (GetCaret() != NULL
&& GetCaret()->IsVisible());
4288 wxRect
caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4290 caretRect
.width
+= dx
;
4293 caretRect
.x
+= dx
; caretRect
.width
-= dx
;
4296 caretRect
.height
+= dy
;
4299 caretRect
.y
+= dy
; caretRect
.height
-= dy
;
4302 RefreshRect(caretRect
);
4304 #endif // wxUSE_CARET
4307 void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget
* w
, int wxstyle
)
4309 //RN: Note that static controls usually have no border on gtk, so maybe
4310 //it makes sense to treat that as simply no border at the wx level
4312 if (!(wxstyle
& wxNO_BORDER
) && !(wxstyle
& wxBORDER_STATIC
))
4314 GtkShadowType gtkstyle
;
4316 if(wxstyle
& wxBORDER_RAISED
)
4317 gtkstyle
= GTK_SHADOW_OUT
;
4318 else if (wxstyle
& wxBORDER_SUNKEN
)
4319 gtkstyle
= GTK_SHADOW_IN
;
4322 else if (wxstyle
& wxBORDER_DOUBLE
)
4323 gtkstyle
= GTK_SHADOW_ETCHED_IN
;
4326 gtkstyle
= GTK_SHADOW_IN
;
4328 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w
),
4333 void wxWindowGTK::SetWindowStyleFlag( long style
)
4335 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4336 wxWindowBase::SetWindowStyleFlag(style
);
4339 // Find the wxWindow at the current mouse position, also returning the mouse
4341 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4343 pt
= wxGetMousePosition();
4344 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4348 // Get the current mouse position.
4349 wxPoint
wxGetMousePosition()
4351 /* This crashes when used within wxHelpContext,
4352 so we have to use the X-specific implementation below.
4354 GdkModifierType *mask;
4355 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4357 return wxPoint(x, y);
4361 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4363 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4364 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4365 Window rootReturn
, childReturn
;
4366 int rootX
, rootY
, winX
, winY
;
4367 unsigned int maskReturn
;
4369 XQueryPointer (display
,
4373 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4374 return wxPoint(rootX
, rootY
);
4378 GdkWindow
* wxWindowGTK::GTKGetDrawingWindow() const
4380 GdkWindow
* window
= NULL
;
4382 window
= m_wxwindow
->window
;
4386 // ----------------------------------------------------------------------------
4388 // ----------------------------------------------------------------------------
4393 // this is called if we attempted to freeze unrealized widget when it finally
4394 // is realized (and so can be frozen):
4395 static void wx_frozen_widget_realize(GtkWidget
* w
, void* WXUNUSED(data
))
4397 wxASSERT( w
&& !GTK_WIDGET_NO_WINDOW(w
) );
4398 wxASSERT( GTK_WIDGET_REALIZED(w
) );
4400 g_signal_handlers_disconnect_by_func
4403 (void*)wx_frozen_widget_realize
,
4407 gdk_window_freeze_updates(w
->window
);
4412 void wxWindowGTK::GTKFreezeWidget(GtkWidget
*w
)
4414 if ( !w
|| GTK_WIDGET_NO_WINDOW(w
) )
4415 return; // window-less widget, cannot be frozen
4417 if ( !GTK_WIDGET_REALIZED(w
) )
4419 // we can't thaw unrealized widgets because they don't have GdkWindow,
4420 // so set it up to be done immediately after realization:
4421 g_signal_connect_after
4425 G_CALLBACK(wx_frozen_widget_realize
),
4431 gdk_window_freeze_updates(w
->window
);
4434 void wxWindowGTK::GTKThawWidget(GtkWidget
*w
)
4436 if ( !w
|| GTK_WIDGET_NO_WINDOW(w
) )
4437 return; // window-less widget, cannot be frozen
4439 if ( !GTK_WIDGET_REALIZED(w
) )
4441 // the widget wasn't realized yet, no need to thaw
4442 g_signal_handlers_disconnect_by_func
4445 (void*)wx_frozen_widget_realize
,
4451 gdk_window_thaw_updates(w
->window
);
4454 void wxWindowGTK::DoFreeze()
4456 GTKFreezeWidget(m_widget
);
4457 if ( m_wxwindow
&& m_widget
!= m_wxwindow
)
4458 GTKFreezeWidget(m_wxwindow
);
4461 void wxWindowGTK::DoThaw()
4463 GTKThawWidget(m_widget
);
4464 if ( m_wxwindow
&& m_widget
!= m_wxwindow
)
4465 GTKThawWidget(m_wxwindow
);