1 /////////////////////////////////////////////////////////////////////////////
2 // Name: gtk/window.cpp
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling, Julian Smart
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
11 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
12 #pragma implementation "window.h"
15 // For compilers that support precompilation, includes "wx.h".
16 #include "wx/wxprec.h"
19 #define XWarpPointer XWARPPOINTER
22 #include "wx/window.h"
23 #include "wx/dcclient.h"
26 #include "wx/layout.h"
28 #include "wx/dialog.h"
29 #include "wx/msgdlg.h"
30 #include "wx/module.h"
32 #if wxUSE_DRAG_AND_DROP
37 #include "wx/tooltip.h"
45 #include "wx/textctrl.h"
49 #include "wx/statusbr.h"
51 #include "wx/settings.h"
53 #include "wx/fontutil.h"
56 #include "wx/thread.h"
62 #include "wx/gtk/private.h"
63 #include <gdk/gdkprivate.h>
64 #include <gdk/gdkkeysyms.h>
68 #include <gtk/gtkprivate.h>
70 #include "wx/gtk/win_gtk.h"
73 #include <pango/pangox.h>
77 #define SET_CONTAINER_FOCUS(w, d) gtk_widget_child_focus((w), (d))
79 #define SET_CONTAINER_FOCUS(w, d) gtk_container_focus(GTK_CONTAINER(w), (d))
89 extern GtkContainerClass
*pizza_parent_class
;
92 //-----------------------------------------------------------------------------
93 // documentation on internals
94 //-----------------------------------------------------------------------------
97 I have been asked several times about writing some documentation about
98 the GTK port of wxWidgets, especially its internal structures. Obviously,
99 you cannot understand wxGTK without knowing a little about the GTK, but
100 some more information about what the wxWindow, which is the base class
101 for all other window classes, does seems required as well.
105 What does wxWindow do? It contains the common interface for the following
106 jobs of its descendants:
108 1) Define the rudimentary behaviour common to all window classes, such as
109 resizing, intercepting user input (so as to make it possible to use these
110 events for special purposes in a derived class), window names etc.
112 2) Provide the possibility to contain and manage children, if the derived
113 class is allowed to contain children, which holds true for those window
114 classes which do not display a native GTK widget. To name them, these
115 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
116 work classes are a special case and are handled a bit differently from
117 the rest. The same holds true for the wxNotebook class.
119 3) Provide the possibility to draw into a client area of a window. This,
120 too, only holds true for classes that do not display a native GTK widget
123 4) Provide the entire mechanism for scrolling widgets. This actual inter-
124 face for this is usually in wxScrolledWindow, but the GTK implementation
127 5) A multitude of helper or extra methods for special purposes, such as
128 Drag'n'Drop, managing validators etc.
130 6) Display a border (sunken, raised, simple or none).
132 Normally one might expect, that one wxWidgets window would always correspond
133 to one GTK widget. Under GTK, there is no such allround widget that has all
134 the functionality. Moreover, the GTK defines a client area as a different
135 widget from the actual widget you are handling. Last but not least some
136 special classes (e.g. wxFrame) handle different categories of widgets and
137 still have the possibility to draw something in the client area.
138 It was therefore required to write a special purpose GTK widget, that would
139 represent a client area in the sense of wxWidgets capable to do the jobs
140 2), 3) and 4). I have written this class and it resides in win_gtk.c of
143 All windows must have a widget, with which they interact with other under-
144 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
145 thw wxWindow class has a member variable called m_widget which holds a
146 pointer to this widget. When the window class represents a GTK native widget,
147 this is (in most cases) the only GTK widget the class manages. E.g. the
148 wxStaticText class handles only a GtkLabel widget a pointer to which you
149 can find in m_widget (defined in wxWindow)
151 When the class has a client area for drawing into and for containing children
152 it has to handle the client area widget (of the type GtkPizza, defined in
153 win_gtk.c), but there could be any number of widgets, handled by a class
154 The common rule for all windows is only, that the widget that interacts with
155 the rest of GTK must be referenced in m_widget and all other widgets must be
156 children of this widget on the GTK level. The top-most widget, which also
157 represents the client area, must be in the m_wxwindow field and must be of
160 As I said, the window classes that display a GTK native widget only have
161 one widget, so in the case of e.g. the wxButton class m_widget holds a
162 pointer to a GtkButton widget. But windows with client areas (for drawing
163 and children) have a m_widget field that is a pointer to a GtkScrolled-
164 Window and a m_wxwindow field that is pointer to a GtkPizza and this
165 one is (in the GTK sense) a child of the GtkScrolledWindow.
167 If the m_wxwindow field is set, then all input to this widget is inter-
168 cepted and sent to the wxWidgets class. If not, all input to the widget
169 that gets pointed to by m_widget gets intercepted and sent to the class.
173 The design of scrolling in wxWidgets is markedly different from that offered
174 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
175 clicking on a scrollbar belonging to scrolled window will inevitably move
176 the window. In wxWidgets, the scrollbar will only emit an event, send this
177 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
178 which actually moves the window and its subchildren. Note that GtkPizza
179 memorizes how much it has been scrolled but that wxWidgets forgets this
180 so that the two coordinates systems have to be kept in synch. This is done
181 in various places using the pizza->xoffset and pizza->yoffset values.
185 Singularily the most broken code in GTK is the code that is supposes to
186 inform subwindows (child windows) about new positions. Very often, duplicate
187 events are sent without changes in size or position, equally often no
188 events are sent at all (All this is due to a bug in the GtkContainer code
189 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
190 GTK's own system and it simply waits for size events for toplevel windows
191 and then iterates down the respective size events to all window. This has
192 the disadvantage, that windows might get size events before the GTK widget
193 actually has the reported size. This doesn't normally pose any problem, but
194 the OpenGl drawing routines rely on correct behaviour. Therefore, I have
195 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
196 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
197 window that is used for OpenGl output really has that size (as reported by
202 If someone at some point of time feels the immense desire to have a look at,
203 change or attempt to optimse the Refresh() logic, this person will need an
204 intimate understanding of what a "draw" and what an "expose" events are and
205 what there are used for, in particular when used in connection with GTK's
206 own windowless widgets. Beware.
210 Cursors, too, have been a constant source of pleasure. The main difficulty
211 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
212 for the parent. To prevent this from doing too much harm, I use idle time
213 to set the cursor over and over again, starting from the toplevel windows
214 and ending with the youngest generation (speaking of parent and child windows).
215 Also don't forget that cursors (like much else) are connected to GdkWindows,
216 not GtkWidgets and that the "window" field of a GtkWidget might very well
217 point to the GdkWindow of the parent widget (-> "window less widget") and
218 that the two obviously have very different meanings.
222 //-----------------------------------------------------------------------------
224 //-----------------------------------------------------------------------------
226 extern wxList wxPendingDelete
;
227 extern bool g_blockEventsOnDrag
;
228 extern bool g_blockEventsOnScroll
;
229 extern wxCursor g_globalCursor
;
231 static GdkGC
*g_eraseGC
= NULL
;
233 // mouse capture state: the window which has it and if the mouse is currently
235 static wxWindowGTK
*g_captureWindow
= (wxWindowGTK
*) NULL
;
236 static bool g_captureWindowHasMouse
= FALSE
;
238 /* extern */ wxWindowGTK
*g_focusWindow
= (wxWindowGTK
*) NULL
;
240 // the last window which had the focus - this is normally never NULL (except
241 // if we never had focus at all) as even when g_focusWindow is NULL it still
242 // keeps its previous value
243 static wxWindowGTK
*g_focusWindowLast
= (wxWindowGTK
*) NULL
;
245 // the frame that is currently active (i.e. its child has focus). It is
246 // used to generate wxActivateEvents
247 static wxWindowGTK
*g_activeFrame
= (wxWindowGTK
*) NULL
;
248 static bool g_activeFrameLostFocus
= FALSE
;
250 // If a window get the focus set but has not been realized
251 // yet, defer setting the focus to idle time.
252 wxWindowGTK
*g_delayedFocus
= (wxWindowGTK
*) NULL
;
254 // if we detect that the app has got/lost the focus, we set this variable to
255 // either TRUE or FALSE and an activate event will be sent during the next
256 // OnIdle() call and it is reset to -1: this value means that we shouldn't
257 // send any activate events at all
258 static int g_sendActivateEvent
= -1;
260 // hack: we need something to pass to gtk_menu_popup, so we store the time of
261 // the last click here
262 static guint32 gs_timeLastClick
= 0;
264 extern bool g_mainThreadLocked
;
266 //-----------------------------------------------------------------------------
268 //-----------------------------------------------------------------------------
273 # define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
275 # define DEBUG_MAIN_THREAD
278 #define DEBUG_MAIN_THREAD
281 // the trace mask used for the focus debugging messages
282 #define TRACE_FOCUS _T("focus")
284 //-----------------------------------------------------------------------------
285 // missing gdk functions
286 //-----------------------------------------------------------------------------
289 gdk_window_warp_pointer (GdkWindow
*window
,
294 GdkWindowPrivate
*priv
;
298 window
= GDK_ROOT_PARENT();
301 if (!GDK_WINDOW_DESTROYED(window
))
303 XWarpPointer (GDK_WINDOW_XDISPLAY(window
),
304 None
, /* not source window -> move from anywhere */
305 GDK_WINDOW_XID(window
), /* dest window */
306 0, 0, 0, 0, /* not source window -> move from anywhere */
310 priv
= (GdkWindowPrivate
*) window
;
312 if (!priv
->destroyed
)
314 XWarpPointer (priv
->xdisplay
,
315 None
, /* not source window -> move from anywhere */
316 priv
->xwindow
, /* dest window */
317 0, 0, 0, 0, /* not source window -> move from anywhere */
323 //-----------------------------------------------------------------------------
325 //-----------------------------------------------------------------------------
327 extern void wxapp_install_idle_handler();
328 extern bool g_isIdle
;
330 //-----------------------------------------------------------------------------
331 // local code (see below)
332 //-----------------------------------------------------------------------------
334 // returns the child of win which currently has focus or NULL if not found
336 // Note: can't be static, needed by textctrl.cpp.
337 wxWindow
*wxFindFocusedChild(wxWindowGTK
*win
)
339 wxWindow
*winFocus
= wxWindowGTK::FindFocus();
341 return (wxWindow
*)NULL
;
343 if ( winFocus
== win
)
344 return (wxWindow
*)win
;
346 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
348 node
= node
->GetNext() )
350 wxWindow
*child
= wxFindFocusedChild(node
->GetData());
355 return (wxWindow
*)NULL
;
358 static void draw_frame( GtkWidget
*widget
, wxWindowGTK
*win
)
360 // wxUniversal widgets draw the borders and scrollbars themselves
361 #ifndef __WXUNIVERSAL__
368 if (win
->m_hasScrolling
)
370 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(widget
);
372 GtkRequisition vscroll_req
;
373 vscroll_req
.width
= 2;
374 vscroll_req
.height
= 2;
375 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
376 (scroll_window
->vscrollbar
, &vscroll_req
);
378 GtkRequisition hscroll_req
;
379 hscroll_req
.width
= 2;
380 hscroll_req
.height
= 2;
381 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
382 (scroll_window
->hscrollbar
, &hscroll_req
);
384 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(widget
) );
386 if (scroll_window
->vscrollbar_visible
)
388 dw
+= vscroll_req
.width
;
389 dw
+= scroll_class
->scrollbar_spacing
;
392 if (scroll_window
->hscrollbar_visible
)
394 dh
+= hscroll_req
.height
;
395 dh
+= scroll_class
->scrollbar_spacing
;
401 if (GTK_WIDGET_NO_WINDOW (widget
))
403 dx
+= widget
->allocation
.x
;
404 dy
+= widget
->allocation
.y
;
407 if (win
->HasFlag(wxRAISED_BORDER
))
409 gtk_draw_shadow( widget
->style
,
414 widget
->allocation
.width
-dw
, widget
->allocation
.height
-dh
);
418 if (win
->HasFlag(wxSUNKEN_BORDER
))
420 gtk_draw_shadow( widget
->style
,
425 widget
->allocation
.width
-dw
, widget
->allocation
.height
-dh
);
429 if (win
->HasFlag(wxSIMPLE_BORDER
))
432 gc
= gdk_gc_new( widget
->window
);
433 gdk_gc_set_foreground( gc
, &widget
->style
->black
);
434 gdk_draw_rectangle( widget
->window
, gc
, FALSE
,
436 widget
->allocation
.width
-dw
-1, widget
->allocation
.height
-dh
-1 );
440 #endif // __WXUNIVERSAL__
443 //-----------------------------------------------------------------------------
444 // "expose_event" of m_widget
445 //-----------------------------------------------------------------------------
447 gint
gtk_window_own_expose_callback( GtkWidget
*widget
, GdkEventExpose
*gdk_event
, wxWindowGTK
*win
)
449 if (gdk_event
->count
> 0) return FALSE
;
451 draw_frame( widget
, win
);
455 (* GTK_WIDGET_CLASS (pizza_parent_class
)->expose_event
) (widget
, gdk_event
);
461 //-----------------------------------------------------------------------------
462 // "draw" of m_widget
463 //-----------------------------------------------------------------------------
467 static void gtk_window_own_draw_callback( GtkWidget
*widget
, GdkRectangle
*WXUNUSED(rect
), wxWindowGTK
*win
)
469 draw_frame( widget
, win
);
474 //-----------------------------------------------------------------------------
475 // "size_request" of m_widget
476 //-----------------------------------------------------------------------------
478 // make it extern because wxStatitText needs to disconnect this one
480 void wxgtk_window_size_request_callback(GtkWidget
*widget
,
481 GtkRequisition
*requisition
,
485 win
->GetSize( &w
, &h
);
491 requisition
->height
= h
;
492 requisition
->width
= w
;
495 //-----------------------------------------------------------------------------
496 // "expose_event" of m_wxwindow
497 //-----------------------------------------------------------------------------
499 static int gtk_window_expose_callback( GtkWidget
*widget
,
500 GdkEventExpose
*gdk_event
,
506 wxapp_install_idle_handler();
509 // This callback gets called in drawing-idle time under
510 // GTK 2.0, so we don't need to defer anything to idle
513 GtkPizza
*pizza
= GTK_PIZZA( widget
);
514 if (gdk_event
->window
!= pizza
->bin_window
) return FALSE
;
519 wxPrintf( wxT("OnExpose from ") );
520 if (win
->GetClassInfo() && win
->GetClassInfo()->GetClassName())
521 wxPrintf( win
->GetClassInfo()->GetClassName() );
522 wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event
->area
.x
,
523 (int)gdk_event
->area
.y
,
524 (int)gdk_event
->area
.width
,
525 (int)gdk_event
->area
.height
);
530 win
->m_wxwindow
->style
,
534 (GdkRectangle
*) NULL
,
536 (char *)"button", // const_cast
541 win
->GetUpdateRegion() = wxRegion( gdk_event
->region
);
543 win
->GtkSendPaintEvents();
546 // Let parent window draw window less widgets
547 (* GTK_WIDGET_CLASS (pizza_parent_class
)->expose_event
) (widget
, gdk_event
);
549 // This gets called immediately after an expose event
550 // under GTK 1.2 so we collect the calls and wait for
551 // the idle handler to pick things up.
553 win
->GetUpdateRegion().Union( gdk_event
->area
.x
,
555 gdk_event
->area
.width
,
556 gdk_event
->area
.height
);
557 win
->m_clearRegion
.Union( gdk_event
->area
.x
,
559 gdk_event
->area
.width
,
560 gdk_event
->area
.height
);
562 // Actual redrawing takes place in idle time.
569 //-----------------------------------------------------------------------------
570 // "event" of m_wxwindow
571 //-----------------------------------------------------------------------------
573 // GTK thinks it is clever and filters out a certain amount of "unneeded"
574 // expose events. We need them, of course, so we override the main event
575 // procedure in GtkWidget by giving our own handler for all system events.
576 // There, we look for expose events ourselves whereas all other events are
579 gint
gtk_window_event_event_callback( GtkWidget
*widget
,
580 GdkEventExpose
*event
,
583 if (event
->type
== GDK_EXPOSE
)
585 gint ret
= gtk_window_expose_callback( widget
, event
, win
);
592 //-----------------------------------------------------------------------------
593 // "draw" of m_wxwindow
594 //-----------------------------------------------------------------------------
598 // This callback is a complete replacement of the gtk_pizza_draw() function,
599 // which is disabled.
601 static void gtk_window_draw_callback( GtkWidget
*widget
,
608 wxapp_install_idle_handler();
610 // if there are any children we must refresh everything
613 if ( !win
->HasFlag(wxFULL_REPAINT_ON_RESIZE
) &&
614 win
->GetChildren().IsEmpty() )
622 wxPrintf( wxT("OnDraw from ") );
623 if (win
->GetClassInfo() && win
->GetClassInfo()->GetClassName())
624 wxPrintf( win
->GetClassInfo()->GetClassName() );
625 wxPrintf( wxT(" %d %d %d %d\n"), (int)rect
->x
,
632 #ifndef __WXUNIVERSAL__
633 GtkPizza
*pizza
= GTK_PIZZA (widget
);
635 if (win
->GetThemeEnabled() && win
->GetBackgroundStyle() != wxBG_STYLE_CUSTOM
)
637 wxWindow
*parent
= win
->GetParent();
638 while (parent
&& !parent
->IsTopLevel())
639 parent
= parent
->GetParent();
643 gtk_paint_flat_box (parent
->m_widget
->style
,
654 win
->m_clearRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
655 win
->GetUpdateRegion().Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
657 // Update immediately, not in idle time.
660 #ifndef __WXUNIVERSAL__
661 // Redraw child widgets
662 GList
*children
= pizza
->children
;
665 GtkPizzaChild
*child
= (GtkPizzaChild
*) children
->data
;
666 children
= children
->next
;
668 GdkRectangle child_area
;
669 if (gtk_widget_intersect (child
->widget
, rect
, &child_area
))
671 gtk_widget_draw (child
->widget
, &child_area
/* (GdkRectangle*) NULL*/ );
679 //-----------------------------------------------------------------------------
680 // "key_press_event" from any window
681 //-----------------------------------------------------------------------------
683 // set WXTRACE to this to see the key event codes on the console
684 #define TRACE_KEYS _T("keyevent")
686 // translates an X key symbol to WXK_XXX value
688 // if isChar is true it means that the value returned will be used for EVT_CHAR
689 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
690 // for example, while if it is false it means that the value is going to be
691 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
693 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
699 // Shift, Control and Alt don't generate the CHAR events at all
702 key_code
= isChar
? 0 : WXK_SHIFT
;
706 key_code
= isChar
? 0 : WXK_CONTROL
;
714 key_code
= isChar
? 0 : WXK_ALT
;
717 // neither do the toggle modifies
718 case GDK_Scroll_Lock
:
719 key_code
= isChar
? 0 : WXK_SCROLL
;
723 key_code
= isChar
? 0 : WXK_CAPITAL
;
727 key_code
= isChar
? 0 : WXK_NUMLOCK
;
731 // various other special keys
744 case GDK_ISO_Left_Tab
:
751 key_code
= WXK_RETURN
;
755 key_code
= WXK_CLEAR
;
759 key_code
= WXK_PAUSE
;
763 key_code
= WXK_SELECT
;
767 key_code
= WXK_PRINT
;
771 key_code
= WXK_EXECUTE
;
775 key_code
= WXK_ESCAPE
;
778 // cursor and other extended keyboard keys
780 key_code
= WXK_DELETE
;
796 key_code
= WXK_RIGHT
;
803 case GDK_Prior
: // == GDK_Page_Up
804 key_code
= WXK_PRIOR
;
807 case GDK_Next
: // == GDK_Page_Down
820 key_code
= WXK_INSERT
;
835 key_code
= (isChar
? '0' : WXK_NUMPAD0
) + keysym
- GDK_KP_0
;
839 key_code
= isChar
? ' ' : WXK_NUMPAD_SPACE
;
843 key_code
= isChar
? WXK_TAB
: WXK_NUMPAD_TAB
;
847 key_code
= isChar
? WXK_RETURN
: WXK_NUMPAD_ENTER
;
851 key_code
= isChar
? WXK_F1
: WXK_NUMPAD_F1
;
855 key_code
= isChar
? WXK_F2
: WXK_NUMPAD_F2
;
859 key_code
= isChar
? WXK_F3
: WXK_NUMPAD_F3
;
863 key_code
= isChar
? WXK_F4
: WXK_NUMPAD_F4
;
867 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_HOME
;
871 key_code
= isChar
? WXK_LEFT
: WXK_NUMPAD_LEFT
;
875 key_code
= isChar
? WXK_UP
: WXK_NUMPAD_UP
;
879 key_code
= isChar
? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
883 key_code
= isChar
? WXK_DOWN
: WXK_NUMPAD_DOWN
;
886 case GDK_KP_Prior
: // == GDK_KP_Page_Up
887 key_code
= isChar
? WXK_PRIOR
: WXK_NUMPAD_PRIOR
;
890 case GDK_KP_Next
: // == GDK_KP_Page_Down
891 key_code
= isChar
? WXK_NEXT
: WXK_NUMPAD_NEXT
;
895 key_code
= isChar
? WXK_END
: WXK_NUMPAD_END
;
899 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_BEGIN
;
903 key_code
= isChar
? WXK_INSERT
: WXK_NUMPAD_INSERT
;
907 key_code
= isChar
? WXK_DELETE
: WXK_NUMPAD_DELETE
;
911 key_code
= isChar
? '=' : WXK_NUMPAD_EQUAL
;
914 case GDK_KP_Multiply
:
915 key_code
= isChar
? '*' : WXK_NUMPAD_MULTIPLY
;
919 key_code
= isChar
? '+' : WXK_NUMPAD_ADD
;
922 case GDK_KP_Separator
:
923 // FIXME: what is this?
924 key_code
= isChar
? '.' : WXK_NUMPAD_SEPARATOR
;
927 case GDK_KP_Subtract
:
928 key_code
= isChar
? '-' : WXK_NUMPAD_SUBTRACT
;
932 key_code
= isChar
? '.' : WXK_NUMPAD_DECIMAL
;
936 key_code
= isChar
? '/' : WXK_NUMPAD_DIVIDE
;
953 key_code
= WXK_F1
+ keysym
- GDK_F1
;
963 static inline bool wxIsAsciiKeysym(KeySym ks
)
968 static void wxFillOtherKeyEventFields(wxKeyEvent
& event
,
970 GdkEventKey
*gdk_event
)
974 GdkModifierType state
;
975 if (gdk_event
->window
)
976 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
978 event
.SetTimestamp( gdk_event
->time
);
979 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
980 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
981 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
982 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
) != 0;
983 event
.m_scanCode
= gdk_event
->keyval
;
984 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
985 event
.m_rawFlags
= 0;
988 event
.SetEventObject( win
);
993 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
995 GdkEventKey
*gdk_event
)
997 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
998 // but only event->keyval which is quite useless to us, so remember
999 // the last character from GDK_KEY_PRESS and reuse it as last resort
1001 // NB: should be MT-safe as we're always called from the main thread only
1006 } s_lastKeyPress
= { 0, 0 };
1008 KeySym keysym
= gdk_event
->keyval
;
1010 wxLogTrace(TRACE_KEYS
, _T("Key %s event: keysym = %ld"),
1011 event
.GetEventType() == wxEVT_KEY_UP
? _T("release")
1015 long key_code
= wxTranslateKeySymToWXKey(keysym
, FALSE
/* !isChar */);
1019 // do we have the translation or is it a plain ASCII character?
1020 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
1022 // we should use keysym if it is ASCII as X does some translations
1023 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
1024 // which we don't want here (but which we do use for OnChar())
1025 if ( !wxIsAsciiKeysym(keysym
) )
1027 keysym
= (KeySym
)gdk_event
->string
[0];
1030 // we want to always get the same key code when the same key is
1031 // pressed regardless of the state of the modifies, i.e. on a
1032 // standard US keyboard pressing '5' or '%' ('5' key with
1033 // Shift) should result in the same key code in OnKeyDown():
1034 // '5' (although OnChar() will get either '5' or '%').
1036 // to do it we first translate keysym to keycode (== scan code)
1037 // and then back but always using the lower register
1038 Display
*dpy
= (Display
*)wxGetDisplay();
1039 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
1041 wxLogTrace(TRACE_KEYS
, _T("\t-> keycode %d"), keycode
);
1043 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
1045 // use the normalized, i.e. lower register, keysym if we've
1047 key_code
= keysymNormalized
? keysymNormalized
: keysym
;
1049 // as explained above, we want to have lower register key codes
1050 // normally but for the letter keys we want to have the upper ones
1052 // NB: don't use XConvertCase() here, we want to do it for letters
1054 key_code
= toupper(key_code
);
1056 else // non ASCII key, what to do?
1058 // by default, ignore it
1061 // but if we have cached information from the last KEY_PRESS
1062 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
1065 if ( keysym
== s_lastKeyPress
.keysym
)
1067 key_code
= s_lastKeyPress
.keycode
;
1072 if ( gdk_event
->type
== GDK_KEY_PRESS
)
1074 // remember it to be reused for KEY_UP event later
1075 s_lastKeyPress
.keysym
= keysym
;
1076 s_lastKeyPress
.keycode
= key_code
;
1080 wxLogTrace(TRACE_KEYS
, _T("\t-> wxKeyCode %ld"), key_code
);
1082 // sending unknown key events doesn't really make sense
1086 // now fill all the other fields
1087 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
1089 event
.m_keyCode
= key_code
;
1098 GtkIMContext
*context
;
1099 GdkEventKey
*lastKeyEvent
;
1103 context
= gtk_im_multicontext_new();
1104 lastKeyEvent
= NULL
;
1108 g_object_unref(context
);
1113 static gint
gtk_window_key_press_callback( GtkWidget
*widget
,
1114 GdkEventKey
*gdk_event
,
1120 wxapp_install_idle_handler();
1124 if (g_blockEventsOnDrag
)
1128 // We have to pass key press events through GTK+'s Input Method context
1129 // object in order to get correct characters. By doing so, we loose the
1130 // ability to let other GTK+'s handlers (namely, widgets' default signal
1131 // handlers) handle the signal by returning false from this callback.
1132 // Because GTK+ sends the events to parent widgets as well, we can't
1133 // afford loosing it, otherwise native widgets inserted into wxPanel
1134 // would break in subtle ways (e.g. spacebar would no longer toggle
1135 // wxCheckButton's state). Therefore, we only pass the event to IM if it
1136 // originated in this window's widget, which we detect by checking if we've
1137 // seen the same event before (no events from children are lost this way,
1138 // because gtk_window_key_press_callback is installed for native controls
1139 // as well and the wxKeyEvent it creates propagates upwards).
1140 static GdkEventKey s_lastEvent
;
1142 bool useIM
= (win
->m_imData
!= NULL
) &&
1143 memcmp(gdk_event
, &s_lastEvent
, sizeof(GdkEventKey
)) != 0;
1145 s_lastEvent
= *gdk_event
;
1148 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1149 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1151 // unknown key pressed, ignore (the event would be useless anyhow)
1155 // it may be useful for the input method, though:
1156 win
->m_imData
->lastKeyEvent
= gdk_event
;
1157 bool ret
= gtk_im_context_filter_keypress(win
->m_imData
->context
,
1159 win
->m_imData
->lastKeyEvent
= NULL
;
1166 // Emit KEY_DOWN event
1167 bool ret
= win
->GetEventHandler()->ProcessEvent( event
);
1172 wxWindowGTK
*ancestor
= win
;
1175 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
1178 wxCommandEvent
command_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
1179 ret
= ancestor
->GetEventHandler()->ProcessEvent( command_event
);
1182 if (ancestor
->IsTopLevel())
1184 ancestor
= ancestor
->GetParent();
1187 #endif // wxUSE_ACCEL
1189 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1190 // will only be sent if it is not in an accelerator table.
1196 // In GTK 2.0, we need to hand over the key event to an input method
1197 // and the IM will emit a "commit" event containing the actual utf8
1198 // character. In that case the EVT_CHAR events will be sent from
1200 win
->m_imData
->lastKeyEvent
= gdk_event
;
1201 if ( gtk_im_context_filter_keypress(win
->m_imData
->context
,
1204 win
->m_imData
->lastKeyEvent
= NULL
;
1205 wxLogTrace(TRACE_KEYS
, _T("Key event intercepted by IM"));
1209 win
->m_imData
->lastKeyEvent
= NULL
;
1214 KeySym keysym
= gdk_event
->keyval
;
1215 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1216 key_code
= wxTranslateKeySymToWXKey(keysym
, TRUE
/* isChar */);
1219 if ( gdk_event
->length
== 1 )
1221 key_code
= (unsigned char)gdk_event
->string
[0];
1223 else if ( wxIsAsciiKeysym(keysym
) )
1226 key_code
= (unsigned char)keysym
;
1232 wxLogTrace(TRACE_KEYS
, _T("Char event: %ld"), key_code
);
1234 event
.m_keyCode
= key_code
;
1236 // Implement OnCharHook by checking ancesteror top level windows
1237 wxWindow
*parent
= win
;
1238 while (parent
&& !parent
->IsTopLevel())
1239 parent
= parent
->GetParent();
1242 event
.SetEventType( wxEVT_CHAR_HOOK
);
1243 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1248 event
.SetEventType(wxEVT_CHAR
);
1249 ret
= win
->GetEventHandler()->ProcessEvent( event
);
1254 // win is a control: tab can be propagated up
1256 ((gdk_event
->keyval
== GDK_Tab
) || (gdk_event
->keyval
== GDK_ISO_Left_Tab
)) &&
1257 // VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may
1258 // have this style, yet choose not to process this particular TAB in which
1259 // case TAB must still work as a navigational character
1260 // JS: enabling again to make consistent with other platforms
1261 // (with wxTE_PROCESS_TAB you have to call Navigate to get default
1262 // navigation behaviour)
1264 (! (win
->HasFlag(wxTE_PROCESS_TAB
) && win
->IsKindOf(CLASSINFO(wxTextCtrl
)) )) &&
1266 win
->GetParent() && (win
->GetParent()->HasFlag( wxTAB_TRAVERSAL
)) )
1268 wxNavigationKeyEvent new_event
;
1269 new_event
.SetEventObject( win
->GetParent() );
1270 // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
1271 new_event
.SetDirection( (gdk_event
->keyval
== GDK_Tab
) );
1272 // CTRL-TAB changes the (parent) window, i.e. switch notebook page
1273 new_event
.SetWindowChange( (gdk_event
->state
& GDK_CONTROL_MASK
) );
1274 new_event
.SetCurrentFocus( win
);
1275 ret
= win
->GetParent()->GetEventHandler()->ProcessEvent( new_event
);
1278 // generate wxID_CANCEL if <esc> has been pressed (typically in dialogs)
1280 (gdk_event
->keyval
== GDK_Escape
) )
1282 // however only do it if we have a Cancel button in the dialog,
1283 // otherwise the user code may get confused by the events from a
1284 // non-existing button and, worse, a wxButton might get button event
1285 // from another button which is not really expected
1286 wxWindow
*winForCancel
= win
,
1288 while ( winForCancel
)
1290 btnCancel
= winForCancel
->FindWindow(wxID_CANCEL
);
1293 // found a cancel button
1297 if ( winForCancel
->IsTopLevel() )
1299 // no need to look further
1303 // maybe our parent has a cancel button?
1304 winForCancel
= winForCancel
->GetParent();
1309 wxCommandEvent
event(wxEVT_COMMAND_BUTTON_CLICKED
, wxID_CANCEL
);
1310 event
.SetEventObject(btnCancel
);
1311 ret
= btnCancel
->GetEventHandler()->ProcessEvent(event
);
1317 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_press_event" );
1325 static void gtk_wxwindow_commit_cb (GtkIMContext
*context
,
1329 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1331 // take modifiers, cursor position, timestamp etc. from the last
1332 // key_press_event that was fed into Input Method:
1333 if (window
->m_imData
->lastKeyEvent
)
1335 wxFillOtherKeyEventFields(event
,
1336 window
, window
->m_imData
->lastKeyEvent
);
1340 event
.m_uniChar
= g_utf8_get_char( str
);
1342 // Backward compatible for ISO-8859
1343 if (event
.m_uniChar
< 256)
1344 event
.m_keyCode
= event
.m_uniChar
;
1345 wxLogTrace(TRACE_KEYS
, _T("IM sent character '%c'"), event
.m_uniChar
);
1348 unistr
[0] = g_utf8_get_char(str
);
1350 wxCharBuffer
ansistr(wxConvLocal
.cWC2MB(unistr
));
1351 // We cannot handle characters that cannot be represented in
1352 // current locale's charset in non-Unicode mode:
1353 if (ansistr
.data() == NULL
)
1355 event
.m_keyCode
= ansistr
[0u];
1356 wxLogTrace(TRACE_KEYS
, _T("IM sent character '%c'"), (wxChar
)event
.m_keyCode
);
1357 #endif // wxUSE_UNICODE
1361 // Implement OnCharHook by checking ancestor top level windows
1362 wxWindow
*parent
= window
;
1363 while (parent
&& !parent
->IsTopLevel())
1364 parent
= parent
->GetParent();
1367 event
.SetEventType( wxEVT_CHAR_HOOK
);
1368 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1373 event
.SetEventType(wxEVT_CHAR
);
1374 ret
= window
->GetEventHandler()->ProcessEvent( event
);
1380 //-----------------------------------------------------------------------------
1381 // "key_release_event" from any window
1382 //-----------------------------------------------------------------------------
1384 static gint
gtk_window_key_release_callback( GtkWidget
*widget
,
1385 GdkEventKey
*gdk_event
,
1391 wxapp_install_idle_handler();
1396 if (g_blockEventsOnDrag
)
1399 wxKeyEvent
event( wxEVT_KEY_UP
);
1400 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1402 // unknown key pressed, ignore (the event would be useless anyhow
1406 if ( !win
->GetEventHandler()->ProcessEvent( event
) )
1409 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_release_event" );
1413 // ============================================================================
1415 // ============================================================================
1417 // ----------------------------------------------------------------------------
1418 // mouse event processing helpers
1419 // ----------------------------------------------------------------------------
1421 // init wxMouseEvent with the info from GdkEventXXX struct
1422 template<typename T
> void InitMouseEvent(wxWindowGTK
*win
,
1423 wxMouseEvent
& event
,
1426 event
.SetTimestamp( gdk_event
->time
);
1427 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1428 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1429 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1430 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1431 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1432 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1433 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1434 if (event
.GetEventType() == wxEVT_MOUSEWHEEL
)
1436 event
.m_linesPerAction
= 3;
1437 event
.m_wheelDelta
= 120;
1438 if (((GdkEventButton
*)gdk_event
)->button
== 4)
1439 event
.m_wheelRotation
= 120;
1440 else if (((GdkEventButton
*)gdk_event
)->button
== 5)
1441 event
.m_wheelRotation
= -120;
1444 wxPoint pt
= win
->GetClientAreaOrigin();
1445 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1446 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1448 event
.SetEventObject( win
);
1449 event
.SetId( win
->GetId() );
1450 event
.SetTimestamp( gdk_event
->time
);
1453 static void AdjustEventButtonState(wxMouseEvent
& event
)
1455 // GDK reports the old state of the button for a button press event, but
1456 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1457 // for a LEFT_DOWN event, not FALSE, so we will invert
1458 // left/right/middleDown for the corresponding click events
1460 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1461 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1462 (event
.GetEventType() == wxEVT_LEFT_UP
))
1464 event
.m_leftDown
= !event
.m_leftDown
;
1468 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1469 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1470 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1472 event
.m_middleDown
= !event
.m_middleDown
;
1476 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1477 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1478 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1480 event
.m_rightDown
= !event
.m_rightDown
;
1485 // find the window to send the mouse event too
1487 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1492 if (win
->m_wxwindow
)
1494 GtkPizza
*pizza
= GTK_PIZZA(win
->m_wxwindow
);
1495 xx
+= pizza
->xoffset
;
1496 yy
+= pizza
->yoffset
;
1499 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
1502 wxWindowGTK
*child
= node
->GetData();
1504 node
= node
->GetNext();
1505 if (!child
->IsShown())
1508 if (child
->IsTransparentForMouse())
1510 // wxStaticBox is transparent in the box itself
1511 int xx1
= child
->m_x
;
1512 int yy1
= child
->m_y
;
1513 int xx2
= child
->m_x
+ child
->m_width
;
1514 int yy2
= child
->m_y
+ child
->m_height
;
1517 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1519 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1521 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1523 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1534 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1535 (child
->m_x
<= xx
) &&
1536 (child
->m_y
<= yy
) &&
1537 (child
->m_x
+child
->m_width
>= xx
) &&
1538 (child
->m_y
+child
->m_height
>= yy
))
1551 //-----------------------------------------------------------------------------
1552 // "button_press_event"
1553 //-----------------------------------------------------------------------------
1555 static gint
gtk_window_button_press_callback( GtkWidget
*widget
,
1556 GdkEventButton
*gdk_event
,
1562 wxapp_install_idle_handler();
1565 wxPrintf( wxT("1) OnButtonPress from ") );
1566 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1567 wxPrintf( win->GetClassInfo()->GetClassName() );
1568 wxPrintf( wxT(".\n") );
1570 if (!win
->m_hasVMT
) return FALSE
;
1571 if (g_blockEventsOnDrag
) return TRUE
;
1572 if (g_blockEventsOnScroll
) return TRUE
;
1574 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1576 if (win
->m_wxwindow
&& (g_focusWindow
!= win
) && win
->AcceptsFocus())
1578 gtk_widget_grab_focus( win
->m_wxwindow
);
1580 wxPrintf( wxT("GrabFocus from ") );
1581 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1582 wxPrintf( win->GetClassInfo()->GetClassName() );
1583 wxPrintf( wxT(".\n") );
1587 // GDK sends surplus button down event
1588 // before a double click event. We
1589 // need to filter these out.
1590 if (gdk_event
->type
== GDK_BUTTON_PRESS
)
1592 GdkEvent
*peek_event
= gdk_event_peek();
1595 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1596 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1598 gdk_event_free( peek_event
);
1603 gdk_event_free( peek_event
);
1608 wxEventType event_type
= wxEVT_NULL
;
1610 // GdkDisplay is a GTK+ 2.2.0 thing
1611 #if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0)
1612 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1613 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1615 // Reset GDK internal timestamp variables in order to disable GDK
1616 // triple click events. GDK will then next time believe no button has
1617 // been clicked just before, and send a normal button click event.
1618 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1619 display
->button_click_time
[1] = 0;
1620 display
->button_click_time
[0] = 0;
1624 if (gdk_event
->button
== 1)
1626 // note that GDK generates triple click events which are not supported
1627 // by wxWidgets but still have to be passed to the app as otherwise
1628 // clicks would simply go missing
1629 switch (gdk_event
->type
)
1631 // we shouldn't get triple clicks at all for GTK2 because we
1632 // suppress them artificially using the code above but we still
1633 // should map them to something for GTK1 and not just ignore them
1634 // as this would lose clicks
1635 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1636 case GDK_BUTTON_PRESS
:
1637 event_type
= wxEVT_LEFT_DOWN
;
1640 case GDK_2BUTTON_PRESS
:
1641 event_type
= wxEVT_LEFT_DCLICK
;
1645 // just to silence gcc warnings
1649 else if (gdk_event
->button
== 2)
1651 switch (gdk_event
->type
)
1653 case GDK_3BUTTON_PRESS
:
1654 case GDK_BUTTON_PRESS
:
1655 event_type
= wxEVT_MIDDLE_DOWN
;
1658 case GDK_2BUTTON_PRESS
:
1659 event_type
= wxEVT_MIDDLE_DCLICK
;
1666 else if (gdk_event
->button
== 3)
1668 switch (gdk_event
->type
)
1670 case GDK_3BUTTON_PRESS
:
1671 case GDK_BUTTON_PRESS
:
1672 event_type
= wxEVT_RIGHT_DOWN
;
1675 case GDK_2BUTTON_PRESS
:
1676 event_type
= wxEVT_RIGHT_DCLICK
;
1683 else if (gdk_event
->button
== 4 || gdk_event
->button
== 5)
1685 if (gdk_event
->type
== GDK_BUTTON_PRESS
)
1687 event_type
= wxEVT_MOUSEWHEEL
;
1691 if ( event_type
== wxEVT_NULL
)
1693 // unknown mouse button or click type
1697 wxMouseEvent
event( event_type
);
1698 InitMouseEvent( win
, event
, gdk_event
);
1700 AdjustEventButtonState(event
);
1702 // wxListBox actually get mouse events from the item, so we need to give it
1703 // a chance to correct this
1704 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1706 if ( event_type
== wxEVT_RIGHT_DOWN
)
1708 // generate a "context menu" event: this is similar to right mouse
1709 // click under many GUIs except that it is generated differently
1710 // (right up under MSW, ctrl-click under Mac, right down here) and
1712 // (a) it's a command event and so is propagated to the parent
1713 // (b) under MSW it can be generated from kbd too
1714 // (c) it uses screen coords (because of (a))
1715 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
,
1717 win
->ClientToScreen(event
.GetPosition()));
1718 (void)win
->GetEventHandler()->ProcessEvent(evtCtx
);
1721 // find the correct window to send the event too: it may be a different one
1722 // from the one which got it at GTK+ level because some control don't have
1723 // their own X window and thus cannot get any events.
1724 if ( !g_captureWindow
)
1725 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1727 gs_timeLastClick
= gdk_event
->time
;
1730 if (event_type
== wxEVT_LEFT_DCLICK
)
1732 // GTK 1.2 crashes when intercepting double
1733 // click events from both wxSpinButton and
1735 if (GTK_IS_SPIN_BUTTON(win
->m_widget
))
1737 // Just disable this event for now.
1743 if (win
->GetEventHandler()->ProcessEvent( event
))
1745 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_press_event" );
1752 //-----------------------------------------------------------------------------
1753 // "button_release_event"
1754 //-----------------------------------------------------------------------------
1756 static gint
gtk_window_button_release_callback( GtkWidget
*widget
,
1757 GdkEventButton
*gdk_event
,
1763 wxapp_install_idle_handler();
1765 if (!win
->m_hasVMT
) return FALSE
;
1766 if (g_blockEventsOnDrag
) return FALSE
;
1767 if (g_blockEventsOnScroll
) return FALSE
;
1769 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1771 wxEventType event_type
= wxEVT_NULL
;
1773 switch (gdk_event
->button
)
1776 event_type
= wxEVT_LEFT_UP
;
1780 event_type
= wxEVT_MIDDLE_UP
;
1784 event_type
= wxEVT_RIGHT_UP
;
1788 // unknwon button, don't process
1792 wxMouseEvent
event( event_type
);
1793 InitMouseEvent( win
, event
, gdk_event
);
1795 AdjustEventButtonState(event
);
1797 // same wxListBox hack as above
1798 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1800 if ( !g_captureWindow
)
1801 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1803 if (win
->GetEventHandler()->ProcessEvent( event
))
1805 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_release_event" );
1812 //-----------------------------------------------------------------------------
1813 // "motion_notify_event"
1814 //-----------------------------------------------------------------------------
1816 static gint
gtk_window_motion_notify_callback( GtkWidget
*widget
,
1817 GdkEventMotion
*gdk_event
,
1823 wxapp_install_idle_handler();
1825 if (!win
->m_hasVMT
) return FALSE
;
1826 if (g_blockEventsOnDrag
) return FALSE
;
1827 if (g_blockEventsOnScroll
) return FALSE
;
1829 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1831 if (gdk_event
->is_hint
)
1835 GdkModifierType state
;
1836 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1842 printf( "OnMotion from " );
1843 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1844 printf( win->GetClassInfo()->GetClassName() );
1848 wxMouseEvent
event( wxEVT_MOTION
);
1849 InitMouseEvent(win
, event
, gdk_event
);
1851 if ( g_captureWindow
)
1853 // synthetize a mouse enter or leave event if needed
1854 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1855 // This seems to be necessary and actually been added to
1856 // GDK itself in version 2.0.X
1859 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1860 if ( hasMouse
!= g_captureWindowHasMouse
)
1862 // the mouse changed window
1863 g_captureWindowHasMouse
= hasMouse
;
1865 wxMouseEvent
event(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1866 : wxEVT_LEAVE_WINDOW
);
1867 InitMouseEvent(win
, event
, gdk_event
);
1868 event
.SetEventObject(win
);
1869 win
->GetEventHandler()->ProcessEvent(event
);
1874 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1877 if (win
->GetEventHandler()->ProcessEvent( event
))
1879 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "motion_notify_event" );
1887 //-----------------------------------------------------------------------------
1888 // "mouse_wheel_event"
1889 //-----------------------------------------------------------------------------
1891 static gint
gtk_window_wheel_callback (GtkWidget
* widget
,
1892 GdkEventScroll
* gdk_event
,
1898 wxapp_install_idle_handler();
1900 wxEventType event_type
= wxEVT_NULL
;
1901 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1902 event_type
= wxEVT_MOUSEWHEEL
;
1903 else if (gdk_event
->direction
== GDK_SCROLL_DOWN
)
1904 event_type
= wxEVT_MOUSEWHEEL
;
1908 wxMouseEvent
event( event_type
);
1909 // Can't use InitMouse macro because scroll events don't have button
1910 event
.SetTimestamp( gdk_event
->time
);
1911 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1912 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1913 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1914 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1915 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1916 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1917 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1918 event
.m_linesPerAction
= 3;
1919 event
.m_wheelDelta
= 120;
1920 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1921 event
.m_wheelRotation
= 120;
1923 event
.m_wheelRotation
= -120;
1925 wxPoint pt
= win
->GetClientAreaOrigin();
1926 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1927 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1929 event
.SetEventObject( win
);
1930 event
.SetId( win
->GetId() );
1931 event
.SetTimestamp( gdk_event
->time
);
1933 if (win
->GetEventHandler()->ProcessEvent( event
))
1935 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "scroll_event" );
1943 //-----------------------------------------------------------------------------
1945 //-----------------------------------------------------------------------------
1947 // send the wxChildFocusEvent and wxFocusEvent, common code of
1948 // gtk_window_focus_in_callback() and SetFocus()
1949 static bool DoSendFocusEvents(wxWindow
*win
)
1951 // Notify the parent keeping track of focus for the kbd navigation
1952 // purposes that we got it.
1953 wxChildFocusEvent
eventChildFocus(win
);
1954 (void)win
->GetEventHandler()->ProcessEvent(eventChildFocus
);
1956 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, win
->GetId());
1957 eventFocus
.SetEventObject(win
);
1959 return win
->GetEventHandler()->ProcessEvent(eventFocus
);
1962 static gint
gtk_window_focus_in_callback( GtkWidget
*widget
,
1963 GdkEvent
*WXUNUSED(event
),
1969 wxapp_install_idle_handler();
1973 gtk_im_context_focus_in(win
->m_imData
->context
);
1976 if (!win
->m_hasVMT
) return FALSE
;
1977 if (g_blockEventsOnDrag
) return FALSE
;
1979 switch ( g_sendActivateEvent
)
1982 // we've got focus from outside, synthetize wxActivateEvent
1983 g_sendActivateEvent
= 1;
1987 // another our window just lost focus, it was already ours before
1988 // - don't send any wxActivateEvent
1989 g_sendActivateEvent
= -1;
1994 g_focusWindow
= win
;
1996 wxLogTrace(TRACE_FOCUS
,
1997 _T("%s: focus in"), win
->GetName().c_str());
2001 gdk_im_begin(win
->m_ic
, win
->m_wxwindow
->window
);
2005 // caret needs to be informed about focus change
2006 wxCaret
*caret
= win
->GetCaret();
2009 caret
->OnSetFocus();
2011 #endif // wxUSE_CARET
2013 g_activeFrameLostFocus
= FALSE
;
2015 wxWindowGTK
*active
= wxGetTopLevelParent(win
);
2016 if ( active
!= g_activeFrame
)
2018 if ( g_activeFrame
)
2020 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from focus_in)"), g_activeFrame
);
2021 wxActivateEvent
event(wxEVT_ACTIVATE
, FALSE
, g_activeFrame
->GetId());
2022 event
.SetEventObject(g_activeFrame
);
2023 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
2026 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), active
);
2027 g_activeFrame
= active
;
2028 wxActivateEvent
event(wxEVT_ACTIVATE
, TRUE
, g_activeFrame
->GetId());
2029 event
.SetEventObject(g_activeFrame
);
2030 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
2032 // Don't send focus events in addition to activate
2033 // if (win == g_activeFrame)
2037 // does the window itself think that it has the focus?
2038 if ( !win
->m_hasFocus
)
2040 // not yet, notify it
2041 win
->m_hasFocus
= TRUE
;
2043 if ( DoSendFocusEvents(win
) )
2045 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_in_event" );
2053 //-----------------------------------------------------------------------------
2054 // "focus_out_event"
2055 //-----------------------------------------------------------------------------
2057 static gint
gtk_window_focus_out_callback( GtkWidget
*widget
, GdkEventFocus
*gdk_event
, wxWindowGTK
*win
)
2062 wxapp_install_idle_handler();
2066 gtk_im_context_focus_out(win
->m_imData
->context
);
2069 if (!win
->m_hasVMT
) return FALSE
;
2070 if (g_blockEventsOnDrag
) return FALSE
;
2072 wxLogTrace( TRACE_FOCUS
,
2073 _T("%s: focus out"), win
->GetName().c_str() );
2075 if ( !g_activeFrameLostFocus
&& g_activeFrame
)
2077 // VZ: commenting this out because it does happen (although not easy
2078 // to reproduce, I only see it when using wxMiniFrame and not
2079 // always) and makes using Mahogany quite annoying
2081 wxASSERT_MSG( wxGetTopLevelParent(win
) == g_activeFrame
,
2082 wxT("unfocusing window that hasn't gained focus properly") );
2085 g_activeFrameLostFocus
= TRUE
;
2088 // if the focus goes out of our app alltogether, OnIdle() will send
2089 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
2090 // g_sendActivateEvent to -1
2091 g_sendActivateEvent
= 0;
2093 wxWindowGTK
*winFocus
= wxFindFocusedChild(win
);
2097 g_focusWindow
= (wxWindowGTK
*)NULL
;
2105 // caret needs to be informed about focus change
2106 wxCaret
*caret
= win
->GetCaret();
2109 caret
->OnKillFocus();
2111 #endif // wxUSE_CARET
2113 // don't send the window a kill focus event if it thinks that it doesn't
2114 // have focus already
2115 if ( win
->m_hasFocus
)
2117 win
->m_hasFocus
= FALSE
;
2119 wxFocusEvent
event( wxEVT_KILL_FOCUS
, win
->GetId() );
2120 event
.SetEventObject( win
);
2122 if (win
->GetEventHandler()->ProcessEvent( event
))
2124 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_out_event" );
2132 //-----------------------------------------------------------------------------
2133 // "enter_notify_event"
2134 //-----------------------------------------------------------------------------
2137 gint
gtk_window_enter_callback( GtkWidget
*widget
,
2138 GdkEventCrossing
*gdk_event
,
2144 wxapp_install_idle_handler();
2146 if (!win
->m_hasVMT
) return FALSE
;
2147 if (g_blockEventsOnDrag
) return FALSE
;
2149 // Event was emitted after a grab
2150 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
2152 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
2156 GdkModifierType state
= (GdkModifierType
)0;
2158 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
2160 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
2161 InitMouseEvent(win
, event
, gdk_event
);
2162 wxPoint pt
= win
->GetClientAreaOrigin();
2163 event
.m_x
= x
+ pt
.x
;
2164 event
.m_y
= y
+ pt
.y
;
2166 if (win
->GetEventHandler()->ProcessEvent( event
))
2168 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "enter_notify_event" );
2175 //-----------------------------------------------------------------------------
2176 // "leave_notify_event"
2177 //-----------------------------------------------------------------------------
2179 static gint
gtk_window_leave_callback( GtkWidget
*widget
, GdkEventCrossing
*gdk_event
, wxWindowGTK
*win
)
2184 wxapp_install_idle_handler();
2186 if (!win
->m_hasVMT
) return FALSE
;
2187 if (g_blockEventsOnDrag
) return FALSE
;
2189 // Event was emitted after an ungrab
2190 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
2192 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
2194 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
2195 event
.SetTimestamp( gdk_event
->time
);
2196 event
.SetEventObject( win
);
2200 GdkModifierType state
= (GdkModifierType
)0;
2202 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
2204 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
) != 0;
2205 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
) != 0;
2206 event
.m_altDown
= (state
& GDK_MOD1_MASK
) != 0;
2207 event
.m_metaDown
= (state
& GDK_MOD2_MASK
) != 0;
2208 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
) != 0;
2209 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
) != 0;
2210 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
) != 0;
2212 wxPoint pt
= win
->GetClientAreaOrigin();
2213 event
.m_x
= x
+ pt
.x
;
2214 event
.m_y
= y
+ pt
.y
;
2216 if (win
->GetEventHandler()->ProcessEvent( event
))
2218 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "leave_notify_event" );
2225 //-----------------------------------------------------------------------------
2226 // "value_changed" from m_vAdjust
2227 //-----------------------------------------------------------------------------
2229 static void gtk_window_vscroll_callback( GtkAdjustment
*adjust
,
2236 wxapp_install_idle_handler();
2238 if (g_blockEventsOnDrag
) return;
2240 if (!win
->m_hasVMT
) return;
2242 float diff
= adjust
->value
- win
->m_oldVerticalPos
;
2243 if (fabs(diff
) < 0.2) return;
2245 win
->m_oldVerticalPos
= adjust
->value
;
2248 GtkScrolledWindow
*sw
= GTK_SCROLLED_WINDOW(win
->m_widget
);
2250 wxEventType command
= GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw
->vscrollbar
));
2252 int value
= (int)(adjust
->value
+0.5);
2254 wxScrollWinEvent
event( command
, value
, wxVERTICAL
);
2255 event
.SetEventObject( win
);
2256 win
->GetEventHandler()->ProcessEvent( event
);
2259 //-----------------------------------------------------------------------------
2260 // "value_changed" from m_hAdjust
2261 //-----------------------------------------------------------------------------
2263 static void gtk_window_hscroll_callback( GtkAdjustment
*adjust
,
2270 wxapp_install_idle_handler();
2272 if (g_blockEventsOnDrag
) return;
2273 if (!win
->m_hasVMT
) return;
2275 float diff
= adjust
->value
- win
->m_oldHorizontalPos
;
2276 if (fabs(diff
) < 0.2) return;
2279 GtkScrolledWindow
*sw
= GTK_SCROLLED_WINDOW(win
->m_widget
);
2281 wxEventType command
= GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw
->hscrollbar
));
2283 win
->m_oldHorizontalPos
= adjust
->value
;
2285 int value
= (int)(adjust
->value
+0.5);
2287 wxScrollWinEvent
event( command
, value
, wxHORIZONTAL
);
2288 event
.SetEventObject( win
);
2289 win
->GetEventHandler()->ProcessEvent( event
);
2292 //-----------------------------------------------------------------------------
2293 // "button_press_event" from scrollbar
2294 //-----------------------------------------------------------------------------
2296 static gint
gtk_scrollbar_button_press_callback( GtkRange
*widget
,
2297 GdkEventButton
*gdk_event
,
2303 wxapp_install_idle_handler();
2306 g_blockEventsOnScroll
= TRUE
;
2308 // FIXME: there is no 'slider' field in GTK+ 2.0 any more
2310 win
->m_isScrolling
= (gdk_event
->window
== widget
->slider
);
2316 //-----------------------------------------------------------------------------
2317 // "button_release_event" from scrollbar
2318 //-----------------------------------------------------------------------------
2320 static gint
gtk_scrollbar_button_release_callback( GtkRange
*widget
,
2321 GdkEventButton
*WXUNUSED(gdk_event
),
2326 // don't test here as we can release the mouse while being over
2327 // a different window than the slider
2329 // if (gdk_event->window != widget->slider) return FALSE;
2331 g_blockEventsOnScroll
= FALSE
;
2333 if (win
->m_isScrolling
)
2335 wxEventType command
= wxEVT_SCROLLWIN_THUMBRELEASE
;
2339 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(win
->m_widget
);
2340 if (widget
== GTK_RANGE(scrolledWindow
->hscrollbar
))
2342 value
= (int)(win
->m_hAdjust
->value
+0.5);
2345 if (widget
== GTK_RANGE(scrolledWindow
->vscrollbar
))
2347 value
= (int)(win
->m_vAdjust
->value
+0.5);
2351 wxScrollWinEvent
event( command
, value
, dir
);
2352 event
.SetEventObject( win
);
2353 win
->GetEventHandler()->ProcessEvent( event
);
2356 win
->m_isScrolling
= FALSE
;
2361 // ----------------------------------------------------------------------------
2362 // this wxWindowBase function is implemented here (in platform-specific file)
2363 // because it is static and so couldn't be made virtual
2364 // ----------------------------------------------------------------------------
2366 wxWindow
*wxWindowBase::FindFocus()
2368 // the cast is necessary when we compile in wxUniversal mode
2369 return (wxWindow
*)g_focusWindow
;
2373 //-----------------------------------------------------------------------------
2374 // "realize" from m_widget
2375 //-----------------------------------------------------------------------------
2377 /* We cannot set colours and fonts before the widget has
2378 been realized, so we do this directly after realization. */
2381 gtk_window_realized_callback( GtkWidget
*m_widget
, wxWindow
*win
)
2386 wxapp_install_idle_handler();
2391 GtkPizza
*pizza
= GTK_PIZZA( m_widget
);
2392 gtk_im_context_set_client_window( win
->m_imData
->context
,
2393 pizza
->bin_window
);
2397 wxWindowCreateEvent
event( win
);
2398 event
.SetEventObject( win
);
2399 win
->GetEventHandler()->ProcessEvent( event
);
2404 //-----------------------------------------------------------------------------
2406 //-----------------------------------------------------------------------------
2409 void gtk_window_size_callback( GtkWidget
*WXUNUSED(widget
),
2410 GtkAllocation
*WXUNUSED(alloc
),
2414 wxapp_install_idle_handler();
2416 if (!win
->m_hasScrolling
) return;
2418 int client_width
= 0;
2419 int client_height
= 0;
2420 win
->GetClientSize( &client_width
, &client_height
);
2421 if ((client_width
== win
->m_oldClientWidth
) && (client_height
== win
->m_oldClientHeight
))
2424 win
->m_oldClientWidth
= client_width
;
2425 win
->m_oldClientHeight
= client_height
;
2427 if (!win
->m_nativeSizeEvent
)
2429 wxSizeEvent
event( win
->GetSize(), win
->GetId() );
2430 event
.SetEventObject( win
);
2431 win
->GetEventHandler()->ProcessEvent( event
);
2437 #define WXUNUSED_UNLESS_XIM(param) param
2439 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2442 /* Resize XIM window */
2445 void gtk_wxwindow_size_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2446 GtkAllocation
* WXUNUSED_UNLESS_XIM(alloc
),
2447 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2450 wxapp_install_idle_handler();
2456 if (gdk_ic_get_style (win
->m_ic
) & GDK_IM_PREEDIT_POSITION
)
2460 gdk_window_get_size (widget
->window
, &width
, &height
);
2461 win
->m_icattr
->preedit_area
.width
= width
;
2462 win
->m_icattr
->preedit_area
.height
= height
;
2463 gdk_ic_set_attr (win
->m_ic
, win
->m_icattr
, GDK_IC_PREEDIT_AREA
);
2468 //-----------------------------------------------------------------------------
2469 // "realize" from m_wxwindow
2470 //-----------------------------------------------------------------------------
2472 /* Initialize XIM support */
2475 gtk_wxwindow_realized_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2476 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2479 wxapp_install_idle_handler();
2482 if (win
->m_ic
) return FALSE
;
2483 if (!widget
) return FALSE
;
2484 if (!gdk_im_ready()) return FALSE
;
2486 win
->m_icattr
= gdk_ic_attr_new();
2487 if (!win
->m_icattr
) return FALSE
;
2491 GdkColormap
*colormap
;
2492 GdkICAttr
*attr
= win
->m_icattr
;
2493 unsigned attrmask
= GDK_IC_ALL_REQ
;
2495 GdkIMStyle supported_style
= (GdkIMStyle
)
2496 (GDK_IM_PREEDIT_NONE
|
2497 GDK_IM_PREEDIT_NOTHING
|
2498 GDK_IM_PREEDIT_POSITION
|
2499 GDK_IM_STATUS_NONE
|
2500 GDK_IM_STATUS_NOTHING
);
2502 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2503 supported_style
= (GdkIMStyle
)(supported_style
& ~GDK_IM_PREEDIT_POSITION
);
2505 attr
->style
= style
= gdk_im_decide_style (supported_style
);
2506 attr
->client_window
= widget
->window
;
2508 if ((colormap
= gtk_widget_get_colormap (widget
)) !=
2509 gtk_widget_get_default_colormap ())
2511 attrmask
|= GDK_IC_PREEDIT_COLORMAP
;
2512 attr
->preedit_colormap
= colormap
;
2515 attrmask
|= GDK_IC_PREEDIT_FOREGROUND
;
2516 attrmask
|= GDK_IC_PREEDIT_BACKGROUND
;
2517 attr
->preedit_foreground
= widget
->style
->fg
[GTK_STATE_NORMAL
];
2518 attr
->preedit_background
= widget
->style
->base
[GTK_STATE_NORMAL
];
2520 switch (style
& GDK_IM_PREEDIT_MASK
)
2522 case GDK_IM_PREEDIT_POSITION
:
2523 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2525 g_warning ("over-the-spot style requires fontset");
2529 gdk_window_get_size (widget
->window
, &width
, &height
);
2531 attrmask
|= GDK_IC_PREEDIT_POSITION_REQ
;
2532 attr
->spot_location
.x
= 0;
2533 attr
->spot_location
.y
= height
;
2534 attr
->preedit_area
.x
= 0;
2535 attr
->preedit_area
.y
= 0;
2536 attr
->preedit_area
.width
= width
;
2537 attr
->preedit_area
.height
= height
;
2538 attr
->preedit_fontset
= widget
->style
->font
;
2543 win
->m_ic
= gdk_ic_new (attr
, (GdkICAttributesType
)attrmask
);
2545 if (win
->m_ic
== NULL
)
2546 g_warning ("Can't create input context.");
2549 mask
= gdk_window_get_events (widget
->window
);
2550 mask
= (GdkEventMask
)(mask
| gdk_ic_get_events (win
->m_ic
));
2551 gdk_window_set_events (widget
->window
, mask
);
2553 if (GTK_WIDGET_HAS_FOCUS(widget
))
2554 gdk_im_begin (win
->m_ic
, widget
->window
);
2561 //-----------------------------------------------------------------------------
2562 // InsertChild for wxWindowGTK.
2563 //-----------------------------------------------------------------------------
2565 /* Callback for wxWindowGTK. This very strange beast has to be used because
2566 * C++ has no virtual methods in a constructor. We have to emulate a
2567 * virtual function here as wxNotebook requires a different way to insert
2568 * a child in it. I had opted for creating a wxNotebookPage window class
2569 * which would have made this superfluous (such in the MDI window system),
2570 * but no-one was listening to me... */
2572 static void wxInsertChildInWindow( wxWindowGTK
* parent
, wxWindowGTK
* child
)
2574 /* the window might have been scrolled already, do we
2575 have to adapt the position */
2576 GtkPizza
*pizza
= GTK_PIZZA(parent
->m_wxwindow
);
2577 child
->m_x
+= pizza
->xoffset
;
2578 child
->m_y
+= pizza
->yoffset
;
2580 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
2581 GTK_WIDGET(child
->m_widget
),
2588 //-----------------------------------------------------------------------------
2590 //-----------------------------------------------------------------------------
2592 wxWindow
*wxGetActiveWindow()
2594 return wxWindow::FindFocus();
2597 //-----------------------------------------------------------------------------
2599 //-----------------------------------------------------------------------------
2601 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2603 #ifdef __WXUNIVERSAL__
2604 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2606 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
2607 #endif // __WXUNIVERSAL__/__WXGTK__
2609 void wxWindowGTK::Init()
2612 m_widget
= (GtkWidget
*) NULL
;
2613 m_wxwindow
= (GtkWidget
*) NULL
;
2614 m_focusWidget
= (GtkWidget
*) NULL
;
2624 m_needParent
= TRUE
;
2625 m_isBeingDeleted
= FALSE
;
2628 m_nativeSizeEvent
= FALSE
;
2630 m_hasScrolling
= FALSE
;
2631 m_isScrolling
= FALSE
;
2633 m_hAdjust
= (GtkAdjustment
*) NULL
;
2634 m_vAdjust
= (GtkAdjustment
*) NULL
;
2635 m_oldHorizontalPos
=
2636 m_oldVerticalPos
= 0.0;
2638 m_oldClientHeight
= 0;
2642 m_insertCallback
= (wxInsertChildFunction
) NULL
;
2644 m_acceptsFocus
= FALSE
;
2647 m_clipPaintRegion
= FALSE
;
2649 m_needsStyleChange
= false;
2651 m_cursor
= *wxSTANDARD_CURSOR
;
2655 m_x11Context
= NULL
;
2656 m_dirtyTabOrder
= false;
2659 m_ic
= (GdkIC
*) NULL
;
2660 m_icattr
= (GdkICAttr
*) NULL
;
2665 wxWindowGTK::wxWindowGTK()
2670 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2675 const wxString
&name
)
2679 Create( parent
, id
, pos
, size
, style
, name
);
2682 bool wxWindowGTK::Create( wxWindow
*parent
,
2687 const wxString
&name
)
2689 if (!PreCreation( parent
, pos
, size
) ||
2690 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2692 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2696 m_insertCallback
= wxInsertChildInWindow
;
2698 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
2699 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
2701 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2703 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2704 scroll_class
->scrollbar_spacing
= 0;
2706 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2708 m_hAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->hscrollbar
) );
2709 m_vAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->vscrollbar
) );
2711 m_wxwindow
= gtk_pizza_new();
2713 #ifndef __WXUNIVERSAL__
2714 GtkPizza
*pizza
= GTK_PIZZA(m_wxwindow
);
2716 if (HasFlag(wxRAISED_BORDER
))
2718 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_OUT
);
2720 else if (HasFlag(wxSUNKEN_BORDER
))
2722 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_IN
);
2724 else if (HasFlag(wxSIMPLE_BORDER
))
2726 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_THIN
);
2730 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_NONE
);
2732 #endif // __WXUNIVERSAL__
2734 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2736 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
2737 m_acceptsFocus
= TRUE
;
2739 // I _really_ don't want scrollbars in the beginning
2740 m_vAdjust
->lower
= 0.0;
2741 m_vAdjust
->upper
= 1.0;
2742 m_vAdjust
->value
= 0.0;
2743 m_vAdjust
->step_increment
= 1.0;
2744 m_vAdjust
->page_increment
= 1.0;
2745 m_vAdjust
->page_size
= 5.0;
2746 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
2747 m_hAdjust
->lower
= 0.0;
2748 m_hAdjust
->upper
= 1.0;
2749 m_hAdjust
->value
= 0.0;
2750 m_hAdjust
->step_increment
= 1.0;
2751 m_hAdjust
->page_increment
= 1.0;
2752 m_hAdjust
->page_size
= 5.0;
2753 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
2755 // these handlers block mouse events to any window during scrolling such as
2756 // motion events and prevent GTK and wxWidgets from fighting over where the
2759 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_press_event",
2760 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
2762 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_press_event",
2763 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
2765 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_release_event",
2766 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
2768 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_release_event",
2769 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
2771 // these handlers get notified when screen updates are required either when
2772 // scrolling or when the window size (and therefore scrollbar configuration)
2775 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
2776 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
2777 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
2778 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
2780 gtk_widget_show( m_wxwindow
);
2783 m_parent
->DoAddChild( this );
2785 m_focusWidget
= m_wxwindow
;
2792 wxWindowGTK::~wxWindowGTK()
2796 if (g_focusWindow
== this)
2797 g_focusWindow
= NULL
;
2799 if (g_activeFrame
== this)
2800 g_activeFrame
= NULL
;
2802 if ( g_delayedFocus
== this )
2803 g_delayedFocus
= NULL
;
2805 m_isBeingDeleted
= TRUE
;
2815 gdk_ic_destroy (m_ic
);
2817 gdk_ic_attr_destroy (m_icattr
);
2822 gtk_widget_destroy( m_wxwindow
);
2823 m_wxwindow
= (GtkWidget
*) NULL
;
2828 gtk_widget_destroy( m_widget
);
2829 m_widget
= (GtkWidget
*) NULL
;
2837 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2839 wxCHECK_MSG( !m_needParent
|| parent
, FALSE
, wxT("Need complete parent.") );
2841 // Use either the given size, or the default if -1 is given.
2842 // See wxWindowBase for these functions.
2843 m_width
= WidthDefault(size
.x
) ;
2844 m_height
= HeightDefault(size
.y
);
2852 void wxWindowGTK::PostCreation()
2854 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2860 // these get reported to wxWidgets -> wxPaintEvent
2862 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow
), TRUE
);
2864 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "expose_event",
2865 GTK_SIGNAL_FUNC(gtk_window_expose_callback
), (gpointer
)this );
2868 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "draw",
2869 GTK_SIGNAL_FUNC(gtk_window_draw_callback
), (gpointer
)this );
2871 if (!HasFlag(wxFULL_REPAINT_ON_RESIZE
))
2873 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "event",
2874 GTK_SIGNAL_FUNC(gtk_window_event_event_callback
), (gpointer
)this );
2877 // gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), !HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
2882 // Create input method handler
2883 m_imData
= new wxGtkIMData
;
2885 // Cannot handle drawing preedited text yet
2886 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2888 g_signal_connect (G_OBJECT (m_imData
->context
), "commit",
2889 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2892 // these are called when the "sunken" or "raised" borders are drawn
2893 gtk_signal_connect( GTK_OBJECT(m_widget
), "expose_event",
2894 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback
), (gpointer
)this );
2897 gtk_signal_connect( GTK_OBJECT(m_widget
), "draw",
2898 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback
), (gpointer
)this );
2904 if (m_focusWidget
== NULL
)
2905 m_focusWidget
= m_widget
;
2907 gtk_signal_connect( GTK_OBJECT(m_focusWidget
), "focus_in_event",
2908 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback
), (gpointer
)this );
2910 gtk_signal_connect( GTK_OBJECT(m_focusWidget
), "focus_out_event",
2911 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback
), (gpointer
)this );
2913 // connect to the various key and mouse handlers
2915 GtkWidget
*connect_widget
= GetConnectWidget();
2917 ConnectWidget( connect_widget
);
2919 /* We cannot set colours, fonts and cursors before the widget has
2920 been realized, so we do this directly after realization */
2921 gtk_signal_connect( GTK_OBJECT(connect_widget
), "realize",
2922 GTK_SIGNAL_FUNC(gtk_window_realized_callback
), (gpointer
) this );
2926 // Catch native resize events
2927 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "size_allocate",
2928 GTK_SIGNAL_FUNC(gtk_window_size_callback
), (gpointer
)this );
2930 // Initialize XIM support
2931 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "realize",
2932 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback
), (gpointer
) this );
2934 // And resize XIM window
2935 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "size_allocate",
2936 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback
), (gpointer
)this );
2939 if ( !GTK_IS_COMBO(m_widget
))
2941 // This is needed if we want to add our windows into native
2942 // GTK control, such as the toolbar. With this callback, the
2943 // toolbar gets to know the correct size (the one set by the
2944 // programmer). Sadly, it misbehaves for wxComboBox. FIXME
2945 // when moving to GTK 2.0.
2946 gtk_signal_connect( GTK_OBJECT(m_widget
), "size_request",
2947 GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback
),
2951 InheritAttributes();
2955 // unless the window was created initially hidden (i.e. Hide() had been
2956 // called before Create()), we should show it at GTK+ level as well
2958 gtk_widget_show( m_widget
);
2961 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2963 gtk_signal_connect( GTK_OBJECT(widget
), "key_press_event",
2964 GTK_SIGNAL_FUNC(gtk_window_key_press_callback
), (gpointer
)this );
2966 gtk_signal_connect( GTK_OBJECT(widget
), "key_release_event",
2967 GTK_SIGNAL_FUNC(gtk_window_key_release_callback
), (gpointer
)this );
2969 gtk_signal_connect( GTK_OBJECT(widget
), "button_press_event",
2970 GTK_SIGNAL_FUNC(gtk_window_button_press_callback
), (gpointer
)this );
2972 gtk_signal_connect( GTK_OBJECT(widget
), "button_release_event",
2973 GTK_SIGNAL_FUNC(gtk_window_button_release_callback
), (gpointer
)this );
2975 gtk_signal_connect( GTK_OBJECT(widget
), "motion_notify_event",
2976 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback
), (gpointer
)this );
2979 gtk_signal_connect( GTK_OBJECT(widget
), "scroll_event",
2980 GTK_SIGNAL_FUNC(gtk_window_wheel_callback
), (gpointer
)this );
2983 gtk_signal_connect( GTK_OBJECT(widget
), "enter_notify_event",
2984 GTK_SIGNAL_FUNC(gtk_window_enter_callback
), (gpointer
)this );
2986 gtk_signal_connect( GTK_OBJECT(widget
), "leave_notify_event",
2987 GTK_SIGNAL_FUNC(gtk_window_leave_callback
), (gpointer
)this );
2990 bool wxWindowGTK::Destroy()
2992 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2996 return wxWindowBase::Destroy();
2999 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
3001 gtk_pizza_set_size( GTK_PIZZA(m_parent
->m_wxwindow
), m_widget
, x
, y
, width
, height
);
3004 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
3006 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3007 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
3010 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
3013 if (m_resizing
) return; /* I don't like recursions */
3016 int currentX
, currentY
;
3017 GetPosition(¤tX
, ¤tY
);
3018 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
3020 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
3022 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
3024 if (m_parent
->m_wxwindow
== NULL
) /* i.e. wxNotebook */
3026 /* don't set the size for children of wxNotebook, just take the values. */
3034 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
3035 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
3037 if (x
!= -1) m_x
= x
+ pizza
->xoffset
;
3038 if (y
!= -1) m_y
= y
+ pizza
->yoffset
;
3042 m_x
= x
+ pizza
->xoffset
;
3043 m_y
= y
+ pizza
->yoffset
;
3046 // calculate the best size if we should auto size the window
3047 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
3048 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
3050 const wxSize sizeBest
= GetBestSize();
3051 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
3053 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
3054 height
= sizeBest
.y
;
3062 int minWidth
= GetMinWidth(),
3063 minHeight
= GetMinHeight(),
3064 maxWidth
= GetMaxWidth(),
3065 maxHeight
= GetMaxHeight();
3067 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
3068 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
3069 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
3070 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
3073 int bottom_border
= 0;
3076 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
3078 /* the default button has a border around it */
3084 DoMoveWindow( m_x
-border
,
3087 m_height
+border
+bottom_border
);
3092 /* Sometimes the client area changes size without the
3093 whole windows's size changing, but if the whole
3094 windows's size doesn't change, no wxSizeEvent will
3095 normally be sent. Here we add an extra test if
3096 the client test has been changed and this will
3098 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
3102 wxPrintf( "OnSize sent from " );
3103 if (GetClassInfo() && GetClassInfo()->GetClassName())
3104 wxPrintf( GetClassInfo()->GetClassName() );
3105 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
3108 if (!m_nativeSizeEvent
)
3110 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
3111 event
.SetEventObject( this );
3112 GetEventHandler()->ProcessEvent( event
);
3118 void wxWindowGTK::OnInternalIdle()
3121 if ( m_dirtyTabOrder
)
3124 // Update style if the window was not yet realized
3125 // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
3126 if (m_needsStyleChange
)
3128 SetBackgroundStyle(GetBackgroundStyle());
3129 m_needsStyleChange
= false;
3132 // Update invalidated regions.
3135 // Synthetize activate events.
3136 if ( g_sendActivateEvent
!= -1 )
3138 bool activate
= g_sendActivateEvent
!= 0;
3141 g_sendActivateEvent
= -1;
3143 wxTheApp
->SetActive(activate
, (wxWindow
*)g_focusWindowLast
);
3146 if ( g_activeFrameLostFocus
)
3148 if ( g_activeFrame
)
3150 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame
);
3151 wxActivateEvent
event(wxEVT_ACTIVATE
, FALSE
, g_activeFrame
->GetId());
3152 event
.SetEventObject(g_activeFrame
);
3153 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
3154 g_activeFrame
= NULL
;
3156 g_activeFrameLostFocus
= FALSE
;
3159 wxCursor cursor
= m_cursor
;
3160 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
3164 /* I now set the cursor anew in every OnInternalIdle call
3165 as setting the cursor in a parent window also effects the
3166 windows above so that checking for the current cursor is
3171 GdkWindow
*window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3173 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3175 if (!g_globalCursor
.Ok())
3176 cursor
= *wxSTANDARD_CURSOR
;
3178 window
= m_widget
->window
;
3179 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
3180 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3186 GdkWindow
*window
= m_widget
->window
;
3187 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
3188 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3193 if (wxUpdateUIEvent::CanUpdate(this))
3194 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
3197 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
3199 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3201 if (width
) (*width
) = m_width
;
3202 if (height
) (*height
) = m_height
;
3205 void wxWindowGTK::DoSetClientSize( int width
, int height
)
3207 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3211 SetSize( width
, height
);
3218 #ifndef __WXUNIVERSAL__
3219 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
3221 /* when using GTK 1.2 we set the shadow border size to 2 */
3225 if (HasFlag(wxSIMPLE_BORDER
))
3227 /* when using GTK 1.2 we set the simple border size to 1 */
3231 #endif // __WXUNIVERSAL__
3235 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
3237 GtkRequisition vscroll_req
;
3238 vscroll_req
.width
= 2;
3239 vscroll_req
.height
= 2;
3240 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
3241 (scroll_window
->vscrollbar
, &vscroll_req
);
3243 GtkRequisition hscroll_req
;
3244 hscroll_req
.width
= 2;
3245 hscroll_req
.height
= 2;
3246 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
3247 (scroll_window
->hscrollbar
, &hscroll_req
);
3249 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
3251 if (scroll_window
->vscrollbar_visible
)
3253 dw
+= vscroll_req
.width
;
3254 dw
+= scroll_class
->scrollbar_spacing
;
3257 if (scroll_window
->hscrollbar_visible
)
3259 dh
+= hscroll_req
.height
;
3260 dh
+= scroll_class
->scrollbar_spacing
;
3264 SetSize( width
+dw
, height
+dh
);
3268 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
3270 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3274 if (width
) (*width
) = m_width
;
3275 if (height
) (*height
) = m_height
;
3282 #ifndef __WXUNIVERSAL__
3283 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
3285 /* when using GTK 1.2 we set the shadow border size to 2 */
3289 if (HasFlag(wxSIMPLE_BORDER
))
3291 /* when using GTK 1.2 we set the simple border size to 1 */
3295 #endif // __WXUNIVERSAL__
3299 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
3301 GtkRequisition vscroll_req
;
3302 vscroll_req
.width
= 2;
3303 vscroll_req
.height
= 2;
3304 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
3305 (scroll_window
->vscrollbar
, &vscroll_req
);
3307 GtkRequisition hscroll_req
;
3308 hscroll_req
.width
= 2;
3309 hscroll_req
.height
= 2;
3310 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
3311 (scroll_window
->hscrollbar
, &hscroll_req
);
3313 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
3315 if (scroll_window
->vscrollbar_visible
)
3317 dw
+= vscroll_req
.width
;
3318 dw
+= scroll_class
->scrollbar_spacing
;
3321 if (scroll_window
->hscrollbar_visible
)
3323 dh
+= hscroll_req
.height
;
3324 dh
+= scroll_class
->scrollbar_spacing
;
3328 if (width
) (*width
) = m_width
- dw
;
3329 if (height
) (*height
) = m_height
- dh
;
3333 printf( "GetClientSize, name %s ", GetName().c_str() );
3334 if (width) printf( " width = %d", (*width) );
3335 if (height) printf( " height = %d", (*height) );
3340 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
3342 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3346 if (m_parent
&& m_parent
->m_wxwindow
)
3348 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
3349 dx
= pizza
->xoffset
;
3350 dy
= pizza
->yoffset
;
3353 if (x
) (*x
) = m_x
- dx
;
3354 if (y
) (*y
) = m_y
- dy
;
3357 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
3359 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3361 if (!m_widget
->window
) return;
3363 GdkWindow
*source
= (GdkWindow
*) NULL
;
3365 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3367 source
= m_widget
->window
;
3371 gdk_window_get_origin( source
, &org_x
, &org_y
);
3375 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3377 org_x
+= m_widget
->allocation
.x
;
3378 org_y
+= m_widget
->allocation
.y
;
3386 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
3388 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3390 if (!m_widget
->window
) return;
3392 GdkWindow
*source
= (GdkWindow
*) NULL
;
3394 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3396 source
= m_widget
->window
;
3400 gdk_window_get_origin( source
, &org_x
, &org_y
);
3404 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3406 org_x
+= m_widget
->allocation
.x
;
3407 org_y
+= m_widget
->allocation
.y
;
3415 bool wxWindowGTK::Show( bool show
)
3417 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3419 if (!wxWindowBase::Show(show
))
3426 gtk_widget_show( m_widget
);
3428 gtk_widget_hide( m_widget
);
3430 wxShowEvent
eventShow(GetId(), show
);
3431 eventShow
.m_eventObject
= this;
3433 GetEventHandler()->ProcessEvent(eventShow
);
3438 static void wxWindowNotifyEnable(wxWindowGTK
* win
, bool enable
)
3440 win
->OnParentEnable(enable
);
3442 // Recurse, so that children have the opportunity to Do The Right Thing
3443 // and reset colours that have been messed up by a parent's (really ancestor's)
3445 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
3447 node
= node
->GetNext() )
3449 wxWindow
*child
= node
->GetData();
3450 if (!child
->IsKindOf(CLASSINFO(wxDialog
)) && !child
->IsKindOf(CLASSINFO(wxFrame
)))
3451 wxWindowNotifyEnable(child
, enable
);
3455 bool wxWindowGTK::Enable( bool enable
)
3457 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3459 if (!wxWindowBase::Enable(enable
))
3465 gtk_widget_set_sensitive( m_widget
, enable
);
3467 gtk_widget_set_sensitive( m_wxwindow
, enable
);
3469 wxWindowNotifyEnable(this, enable
);
3474 int wxWindowGTK::GetCharHeight() const
3476 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
3478 wxFont font
= GetFont();
3479 wxCHECK_MSG( font
.Ok(), 12, wxT("invalid font") );
3482 PangoContext
*context
= NULL
;
3484 context
= gtk_widget_get_pango_context( m_widget
);
3489 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3490 PangoLayout
*layout
= pango_layout_new(context
);
3491 pango_layout_set_font_description(layout
, desc
);
3492 pango_layout_set_text(layout
, "H", 1);
3493 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3495 PangoRectangle rect
;
3496 pango_layout_line_get_extents(line
, NULL
, &rect
);
3498 g_object_unref( G_OBJECT( layout
) );
3500 return (int) PANGO_PIXELS(rect
.height
);
3502 GdkFont
*gfont
= font
.GetInternalFont( 1.0 );
3504 return gfont
->ascent
+ gfont
->descent
;
3508 int wxWindowGTK::GetCharWidth() const
3510 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
3512 wxFont font
= GetFont();
3513 wxCHECK_MSG( font
.Ok(), 8, wxT("invalid font") );
3516 PangoContext
*context
= NULL
;
3518 context
= gtk_widget_get_pango_context( m_widget
);
3523 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3524 PangoLayout
*layout
= pango_layout_new(context
);
3525 pango_layout_set_font_description(layout
, desc
);
3526 pango_layout_set_text(layout
, "g", 1);
3527 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3529 PangoRectangle rect
;
3530 pango_layout_line_get_extents(line
, NULL
, &rect
);
3532 g_object_unref( G_OBJECT( layout
) );
3534 return (int) PANGO_PIXELS(rect
.width
);
3536 GdkFont
*gfont
= font
.GetInternalFont( 1.0 );
3538 return gdk_string_width( gfont
, "g" );
3542 void wxWindowGTK::GetTextExtent( const wxString
& string
,
3546 int *externalLeading
,
3547 const wxFont
*theFont
) const
3549 wxFont fontToUse
= theFont
? *theFont
: GetFont();
3551 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
3553 if (string
.IsEmpty())
3561 PangoContext
*context
= NULL
;
3563 context
= gtk_widget_get_pango_context( m_widget
);
3572 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3573 PangoLayout
*layout
= pango_layout_new(context
);
3574 pango_layout_set_font_description(layout
, desc
);
3577 const wxCharBuffer data
= wxConvUTF8
.cWC2MB( string
);
3578 pango_layout_set_text(layout
, (const char*) data
, strlen( (const char*) data
));
3580 const wxWCharBuffer wdata
= wxConvLocal
.cMB2WC( string
);
3581 const wxCharBuffer data
= wxConvUTF8
.cWC2MB( wdata
);
3582 pango_layout_set_text(layout
, (const char*) data
, strlen( (const char*) data
));
3586 PangoRectangle rect
;
3587 pango_layout_get_extents(layout
, NULL
, &rect
);
3589 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
3590 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
3593 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
3594 int baseline
= pango_layout_iter_get_baseline(iter
);
3595 pango_layout_iter_free(iter
);
3596 *descent
= *y
- PANGO_PIXELS(baseline
);
3598 if (externalLeading
) (*externalLeading
) = 0; // ??
3600 g_object_unref( G_OBJECT( layout
) );
3602 GdkFont
*font
= fontToUse
.GetInternalFont( 1.0 );
3603 if (x
) (*x
) = gdk_string_width( font
, wxGTK_CONV( string
) );
3604 if (y
) (*y
) = font
->ascent
+ font
->descent
;
3605 if (descent
) (*descent
) = font
->descent
;
3606 if (externalLeading
) (*externalLeading
) = 0; // ??
3610 void wxWindowGTK::SetFocus()
3612 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3615 // don't do anything if we already have focus
3621 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow
))
3623 gtk_widget_grab_focus (m_wxwindow
);
3628 if (GTK_WIDGET_CAN_FOCUS(m_widget
) && !GTK_WIDGET_HAS_FOCUS (m_widget
) )
3630 if (!GTK_WIDGET_REALIZED(m_widget
))
3632 // we can't set the focus to the widget now so we remember that
3633 // it should be focused and will do it later, during the idle
3634 // time, as soon as we can
3635 wxLogTrace(TRACE_FOCUS
,
3636 _T("Delaying setting focus to %s(%s)"),
3637 GetClassInfo()->GetClassName(), GetLabel().c_str());
3639 g_delayedFocus
= this;
3643 wxLogTrace(TRACE_FOCUS
,
3644 _T("Setting focus to %s(%s)"),
3645 GetClassInfo()->GetClassName(), GetLabel().c_str());
3647 gtk_widget_grab_focus (m_widget
);
3650 else if (GTK_IS_CONTAINER(m_widget
))
3652 SET_CONTAINER_FOCUS( m_widget
, GTK_DIR_TAB_FORWARD
);
3656 wxLogTrace(TRACE_FOCUS
,
3657 _T("Can't set focus to %s(%s)"),
3658 GetClassInfo()->GetClassName(), GetLabel().c_str());
3663 bool wxWindowGTK::AcceptsFocus() const
3665 return m_acceptsFocus
&& wxWindowBase::AcceptsFocus();
3668 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3670 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3672 wxWindowGTK
*oldParent
= m_parent
,
3673 *newParent
= (wxWindowGTK
*)newParentBase
;
3675 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3677 if ( !wxWindowBase::Reparent(newParent
) )
3680 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3682 /* prevent GTK from deleting the widget arbitrarily */
3683 gtk_widget_ref( m_widget
);
3687 gtk_container_remove( GTK_CONTAINER(m_widget
->parent
), m_widget
);
3690 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3694 /* insert GTK representation */
3695 (*(newParent
->m_insertCallback
))(newParent
, this);
3698 /* reverse: prevent GTK from deleting the widget arbitrarily */
3699 gtk_widget_unref( m_widget
);
3704 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3706 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3708 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3710 wxASSERT_MSG( (m_insertCallback
!= NULL
), wxT("invalid child insertion function") );
3715 /* insert GTK representation */
3716 (*m_insertCallback
)(this, child
);
3721 void wxWindowGTK::AddChild(wxWindowBase
*child
)
3723 wxWindowBase::AddChild(child
);
3724 m_dirtyTabOrder
= true;
3726 wxapp_install_idle_handler();
3729 void wxWindowGTK::RemoveChild(wxWindowBase
*child
)
3731 wxWindowBase::RemoveChild(child
);
3732 m_dirtyTabOrder
= true;
3734 wxapp_install_idle_handler();
3737 void wxWindowGTK::DoMoveInTabOrder(wxWindow
*win
, MoveKind move
)
3739 wxWindowBase::DoMoveInTabOrder(win
, move
);
3740 m_dirtyTabOrder
= true;
3742 wxapp_install_idle_handler();
3745 void wxWindowGTK::RealizeTabOrder()
3749 if (m_children
.size() > 0)
3751 GList
*chain
= NULL
;
3753 for (wxWindowList::const_iterator i
= m_children
.begin();
3754 i
!= m_children
.end(); ++i
)
3756 chain
= g_list_prepend(chain
, (*i
)->m_widget
);
3759 chain
= g_list_reverse(chain
);
3761 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3766 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3770 m_dirtyTabOrder
= false;
3773 #endif // __WXGTK20__
3775 void wxWindowGTK::Raise()
3777 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3779 if (!m_widget
->window
) return;
3781 gdk_window_raise( m_widget
->window
);
3784 void wxWindowGTK::Lower()
3786 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3788 if (!m_widget
->window
) return;
3790 gdk_window_lower( m_widget
->window
);
3793 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3795 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3797 if (cursor
== m_cursor
)
3801 wxapp_install_idle_handler();
3803 if (cursor
== wxNullCursor
)
3804 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR
);
3806 return wxWindowBase::SetCursor( cursor
);
3809 void wxWindowGTK::WarpPointer( int x
, int y
)
3811 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3813 // We provide this function ourselves as it is
3814 // missing in GDK (top of this file).
3816 GdkWindow
*window
= (GdkWindow
*) NULL
;
3818 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3820 window
= GetConnectWidget()->window
;
3823 gdk_window_warp_pointer( window
, x
, y
);
3827 void wxWindowGTK::Refresh( bool eraseBackground
, const wxRect
*rect
)
3829 if (!m_widget
) return;
3830 if (!m_widget
->window
) return;
3834 wxapp_install_idle_handler();
3836 wxRect
myRect(0,0,0,0);
3837 if (m_wxwindow
&& rect
)
3839 myRect
.SetSize(wxSize( m_wxwindow
->allocation
.width
,
3840 m_wxwindow
->allocation
.height
));
3841 myRect
.Intersect(*rect
);
3842 if (!myRect
.width
|| !myRect
.height
)
3843 // nothing to do, rectangle is empty
3848 if (eraseBackground
&& m_wxwindow
&& m_wxwindow
->window
)
3852 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3853 m_clearRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3857 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3858 m_clearRegion
.Clear();
3859 m_clearRegion
.Union( 0, 0, m_wxwindow
->allocation
.width
, m_wxwindow
->allocation
.height
);
3867 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3868 m_updateRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3872 GdkRectangle gdk_rect
;
3873 gdk_rect
.x
= rect
->x
;
3874 gdk_rect
.y
= rect
->y
;
3875 gdk_rect
.width
= rect
->width
;
3876 gdk_rect
.height
= rect
->height
;
3877 gtk_widget_draw( m_widget
, &gdk_rect
);
3884 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3885 m_updateRegion
.Clear();
3886 m_updateRegion
.Union( 0, 0, m_wxwindow
->allocation
.width
, m_wxwindow
->allocation
.height
);
3890 gtk_widget_draw( m_widget
, (GdkRectangle
*) NULL
);
3898 GdkRectangle gdk_rect
;
3899 gdk_rect
.x
= rect
->x
;
3900 gdk_rect
.y
= rect
->y
;
3901 gdk_rect
.width
= rect
->width
;
3902 gdk_rect
.height
= rect
->height
;
3903 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, &gdk_rect
, TRUE
);
3907 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, NULL
, TRUE
);
3913 void wxWindowGTK::Update()
3918 void wxWindowGTK::GtkUpdate()
3921 if (m_wxwindow
&& GTK_PIZZA(m_wxwindow
)->bin_window
)
3922 gdk_window_process_updates( GTK_PIZZA(m_wxwindow
)->bin_window
, FALSE
);
3924 if (!m_updateRegion
.IsEmpty())
3925 GtkSendPaintEvents();
3929 void wxWindowGTK::GtkSendPaintEvents()
3934 m_clearRegion
.Clear();
3936 m_updateRegion
.Clear();
3940 // Clip to paint region in wxClientDC
3941 m_clipPaintRegion
= TRUE
;
3943 // widget to draw on
3944 GtkPizza
*pizza
= GTK_PIZZA (m_wxwindow
);
3946 if (GetThemeEnabled() && GetBackgroundStyle() != wxBG_STYLE_CUSTOM
)
3948 // find ancestor from which to steal background
3949 wxWindow
*parent
= GetParent();
3950 while (parent
&& !parent
->IsTopLevel())
3951 parent
= parent
->GetParent();
3953 parent
= (wxWindow
*)this;
3955 wxRegionIterator
upd( m_updateRegion
);
3959 rect
.x
= upd
.GetX();
3960 rect
.y
= upd
.GetY();
3961 rect
.width
= upd
.GetWidth();
3962 rect
.height
= upd
.GetHeight();
3964 gtk_paint_flat_box( parent
->m_widget
->style
,
3966 (GtkStateType
)GTK_WIDGET_STATE(m_wxwindow
),
3980 wxWindowDC
dc( (wxWindow
*)this );
3981 dc
.SetClippingRegion( m_updateRegion
);
3983 wxEraseEvent
erase_event( GetId(), &dc
);
3984 erase_event
.SetEventObject( this );
3986 GetEventHandler()->ProcessEvent(erase_event
);
3989 // if (!m_clearRegion.IsEmpty()) // Always send an erase event under GTK 1.2
3991 wxWindowDC
dc( (wxWindow
*)this );
3992 if (m_clearRegion
.IsEmpty())
3993 dc
.SetClippingRegion( m_updateRegion
);
3995 dc
.SetClippingRegion( m_clearRegion
);
3997 wxEraseEvent
erase_event( GetId(), &dc
);
3998 erase_event
.SetEventObject( this );
4000 if (!GetEventHandler()->ProcessEvent(erase_event
) && GetBackgroundStyle() != wxBG_STYLE_CUSTOM
)
4004 g_eraseGC
= gdk_gc_new( pizza
->bin_window
);
4005 gdk_gc_set_fill( g_eraseGC
, GDK_SOLID
);
4007 gdk_gc_set_foreground( g_eraseGC
, GetBackgroundColour().GetColor() );
4009 wxRegionIterator
upd( m_clearRegion
);
4012 gdk_draw_rectangle( pizza
->bin_window
, g_eraseGC
, 1,
4013 upd
.GetX(), upd
.GetY(), upd
.GetWidth(), upd
.GetHeight() );
4017 m_clearRegion
.Clear();
4021 wxNcPaintEvent
nc_paint_event( GetId() );
4022 nc_paint_event
.SetEventObject( this );
4023 GetEventHandler()->ProcessEvent( nc_paint_event
);
4025 wxPaintEvent
paint_event( GetId() );
4026 paint_event
.SetEventObject( this );
4027 GetEventHandler()->ProcessEvent( paint_event
);
4029 m_clipPaintRegion
= FALSE
;
4031 #ifndef __WXUNIVERSAL__
4033 // The following code will result in all window-less widgets
4034 // being redrawn because the wxWidgets class is allowed to
4035 // paint over the window-less widgets.
4037 GList
*children
= pizza
->children
;
4040 GtkPizzaChild
*child
= (GtkPizzaChild
*) children
->data
;
4041 children
= children
->next
;
4043 if (GTK_WIDGET_NO_WINDOW (child
->widget
) &&
4044 GTK_WIDGET_DRAWABLE (child
->widget
))
4046 // Get intersection of widget area and update region
4047 wxRegion
region( m_updateRegion
);
4049 GdkEventExpose gdk_event
;
4050 gdk_event
.type
= GDK_EXPOSE
;
4051 gdk_event
.window
= pizza
->bin_window
;
4052 gdk_event
.count
= 0;
4054 wxRegionIterator
upd( m_updateRegion
);
4058 rect
.x
= upd
.GetX();
4059 rect
.y
= upd
.GetY();
4060 rect
.width
= upd
.GetWidth();
4061 rect
.height
= upd
.GetHeight();
4063 if (gtk_widget_intersect (child
->widget
, &rect
, &gdk_event
.area
))
4065 gtk_widget_event (child
->widget
, (GdkEvent
*) &gdk_event
);
4075 m_updateRegion
.Clear();
4078 void wxWindowGTK::ClearBackground()
4080 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4083 if (m_wxwindow
&& m_wxwindow
->window
)
4085 m_clearRegion
.Clear();
4086 wxSize
size( GetClientSize() );
4087 m_clearRegion
.Union( 0,0,size
.x
,size
.y
);
4089 // Better do this in idle?
4096 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
4098 wxWindowBase::DoSetToolTip(tip
);
4101 m_tooltip
->Apply( (wxWindow
*)this );
4104 void wxWindowGTK::ApplyToolTip( GtkTooltips
*tips
, const wxChar
*tip
)
4106 wxString
tmp( tip
);
4107 gtk_tooltips_set_tip( tips
, GetConnectWidget(), wxGTK_CONV(tmp
), (gchar
*) NULL
);
4109 #endif // wxUSE_TOOLTIPS
4111 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
4113 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
4115 if (!wxWindowBase::SetBackgroundColour(colour
))
4120 // We need the pixel value e.g. for background clearing.
4121 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
4124 // apply style change (forceStyle=true so that new style is applied
4125 // even if the bg colour changed from valid to wxNullColour)
4126 if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM
)
4127 ApplyWidgetStyle(true);
4132 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
4134 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
4136 if (!wxWindowBase::SetForegroundColour(colour
))
4143 // We need the pixel value e.g. for background clearing.
4144 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
4147 // apply style change (forceStyle=true so that new style is applied
4148 // even if the bg colour changed from valid to wxNullColour):
4149 ApplyWidgetStyle(true);
4155 PangoContext
*wxWindowGTK::GtkGetPangoDefaultContext()
4157 return gtk_widget_get_pango_context( m_widget
);
4160 PangoContext
*wxWindowGTK::GtkGetPangoX11Context()
4163 m_x11Context
= pango_x_get_context( gdk_display
);
4165 return m_x11Context
;
4169 GtkRcStyle
*wxWindowGTK::CreateWidgetStyle(bool forceStyle
)
4171 // do we need to apply any changes at all?
4174 !m_foregroundColour
.Ok() && !m_backgroundColour
.Ok() )
4179 GtkRcStyle
*style
= gtk_rc_style_new();
4185 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
4187 wxString xfontname
= m_font
.GetNativeFontInfo()->GetXFontName();
4188 style
->fontset_name
= g_strdup(xfontname
.c_str());
4192 if ( m_foregroundColour
.Ok() )
4194 GdkColor
*fg
= m_foregroundColour
.GetColor();
4196 style
->fg
[GTK_STATE_NORMAL
] = *fg
;
4197 style
->color_flags
[GTK_STATE_NORMAL
] = GTK_RC_FG
;
4199 style
->fg
[GTK_STATE_PRELIGHT
] = *fg
;
4200 style
->color_flags
[GTK_STATE_PRELIGHT
] = GTK_RC_FG
;
4202 style
->fg
[GTK_STATE_ACTIVE
] = *fg
;
4203 style
->color_flags
[GTK_STATE_ACTIVE
] = GTK_RC_FG
;
4206 if ( m_backgroundColour
.Ok() )
4208 GdkColor
*bg
= m_backgroundColour
.GetColor();
4210 style
->bg
[GTK_STATE_NORMAL
] = *bg
;
4211 style
->base
[GTK_STATE_NORMAL
] = *bg
;
4212 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)
4213 (style
->color_flags
[GTK_STATE_NORMAL
] | GTK_RC_BG
| GTK_RC_BASE
);
4215 style
->bg
[GTK_STATE_PRELIGHT
] = *bg
;
4216 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
4217 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)
4218 (style
->color_flags
[GTK_STATE_PRELIGHT
] | GTK_RC_BG
| GTK_RC_BASE
);
4220 style
->bg
[GTK_STATE_ACTIVE
] = *bg
;
4221 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
4222 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)
4223 (style
->color_flags
[GTK_STATE_ACTIVE
] | GTK_RC_BG
| GTK_RC_BASE
);
4225 style
->bg
[GTK_STATE_INSENSITIVE
] = *bg
;
4226 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
4227 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)
4228 (style
->color_flags
[GTK_STATE_INSENSITIVE
] | GTK_RC_BG
| GTK_RC_BASE
);
4234 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle
)
4236 GtkRcStyle
*style
= CreateWidgetStyle(forceStyle
);
4239 DoApplyWidgetStyle(style
);
4240 gtk_rc_style_unref(style
);
4243 // Style change may affect GTK+'s size calculation:
4244 InvalidateBestSize();
4247 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
4250 gtk_widget_modify_style(m_wxwindow
, style
);
4251 gtk_widget_modify_style(m_widget
, style
);
4254 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style
)
4256 wxWindowBase::SetBackgroundStyle(style
);
4258 if (style
== wxBG_STYLE_CUSTOM
)
4260 GdkWindow
*window
= (GdkWindow
*) NULL
;
4262 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4264 window
= GetConnectWidget()->window
;
4268 // Make sure GDK/X11 doesn't refresh the window
4270 gdk_window_set_back_pixmap( window
, None
, False
);
4272 Display
* display
= GDK_WINDOW_DISPLAY(window
);
4275 m_needsStyleChange
= false;
4278 // Do in OnIdle, because the window is not yet available
4279 m_needsStyleChange
= true;
4281 // Don't apply widget style, or we get a grey background
4285 // apply style change (forceStyle=true so that new style is applied
4286 // even if the bg colour changed from valid to wxNullColour):
4287 ApplyWidgetStyle(true);
4292 //-----------------------------------------------------------------------------
4293 // Pop-up menu stuff
4294 //-----------------------------------------------------------------------------
4296 #if wxUSE_MENUS_NATIVE
4299 void gtk_pop_hide_callback( GtkWidget
*WXUNUSED(widget
), bool* is_waiting
)
4301 *is_waiting
= FALSE
;
4304 static void SetInvokingWindow( wxMenu
*menu
, wxWindowGTK
*win
)
4306 menu
->SetInvokingWindow( win
);
4307 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
4310 wxMenuItem
*menuitem
= node
->GetData();
4311 if (menuitem
->IsSubMenu())
4313 SetInvokingWindow( menuitem
->GetSubMenu(), win
);
4316 node
= node
->GetNext();
4320 extern "C" void wxPopupMenuPositionCallback( GtkMenu
*menu
,
4323 gboolean
* WXUNUSED(whatever
),
4325 gpointer user_data
)
4327 // ensure that the menu appears entirely on screen
4329 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
4331 wxSize sizeScreen
= wxGetDisplaySize();
4332 wxPoint
*pos
= (wxPoint
*)user_data
;
4334 gint xmax
= sizeScreen
.x
- req
.width
,
4335 ymax
= sizeScreen
.y
- req
.height
;
4337 *x
= pos
->x
< xmax
? pos
->x
: xmax
;
4338 *y
= pos
->y
< ymax
? pos
->y
: ymax
;
4341 bool wxWindowGTK::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
4343 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4345 wxCHECK_MSG( menu
!= NULL
, false, wxT("invalid popup-menu") );
4347 SetInvokingWindow( menu
, this );
4351 bool is_waiting
= true;
4353 gulong handler
= gtk_signal_connect( GTK_OBJECT(menu
->m_menu
),
4355 GTK_SIGNAL_FUNC(gtk_pop_hide_callback
),
4356 (gpointer
)&is_waiting
);
4360 GtkMenuPositionFunc posfunc
;
4361 if ( x
== -1 && y
== -1 )
4363 // use GTK's default positioning algorithm
4369 pos
= ClientToScreen(wxPoint(x
, y
));
4371 posfunc
= wxPopupMenuPositionCallback
;
4375 GTK_MENU(menu
->m_menu
),
4376 (GtkWidget
*) NULL
, // parent menu shell
4377 (GtkWidget
*) NULL
, // parent menu item
4378 posfunc
, // function to position it
4379 userdata
, // client data
4380 0, // button used to activate it
4382 gtk_get_current_event_time()
4384 gs_timeLastClick
// the time of activation
4390 gtk_main_iteration();
4393 gtk_signal_disconnect(GTK_OBJECT(menu
->m_menu
), handler
);
4398 #endif // wxUSE_MENUS_NATIVE
4400 #if wxUSE_DRAG_AND_DROP
4402 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4404 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4406 GtkWidget
*dnd_widget
= GetConnectWidget();
4408 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
4410 if (m_dropTarget
) delete m_dropTarget
;
4411 m_dropTarget
= dropTarget
;
4413 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
4416 #endif // wxUSE_DRAG_AND_DROP
4418 GtkWidget
* wxWindowGTK::GetConnectWidget()
4420 GtkWidget
*connect_widget
= m_widget
;
4421 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4423 return connect_widget
;
4426 bool wxWindowGTK::IsOwnGtkWindow( GdkWindow
*window
)
4429 return (window
== GTK_PIZZA(m_wxwindow
)->bin_window
);
4431 return (window
== m_widget
->window
);
4434 bool wxWindowGTK::SetFont( const wxFont
&font
)
4436 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
4438 if (!wxWindowBase::SetFont(font
))
4441 // apply style change (forceStyle=true so that new style is applied
4442 // even if the font changed from valid to wxNullFont):
4443 ApplyWidgetStyle(true);
4448 void wxWindowGTK::DoCaptureMouse()
4450 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4452 GdkWindow
*window
= (GdkWindow
*) NULL
;
4454 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4456 window
= GetConnectWidget()->window
;
4458 wxCHECK_RET( window
, _T("CaptureMouse() failed") );
4460 wxCursor
* cursor
= & m_cursor
;
4462 cursor
= wxSTANDARD_CURSOR
;
4464 gdk_pointer_grab( window
, FALSE
,
4466 (GDK_BUTTON_PRESS_MASK
|
4467 GDK_BUTTON_RELEASE_MASK
|
4468 GDK_POINTER_MOTION_HINT_MASK
|
4469 GDK_POINTER_MOTION_MASK
),
4471 cursor
->GetCursor(),
4472 (guint32
)GDK_CURRENT_TIME
);
4473 g_captureWindow
= this;
4474 g_captureWindowHasMouse
= TRUE
;
4477 void wxWindowGTK::DoReleaseMouse()
4479 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4481 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4483 g_captureWindow
= (wxWindowGTK
*) NULL
;
4485 GdkWindow
*window
= (GdkWindow
*) NULL
;
4487 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4489 window
= GetConnectWidget()->window
;
4494 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4498 wxWindow
*wxWindowBase::GetCapture()
4500 return (wxWindow
*)g_captureWindow
;
4503 bool wxWindowGTK::IsRetained() const
4508 void wxWindowGTK::SetScrollbar( int orient
, int pos
, int thumbVisible
,
4509 int range
, bool refresh
)
4511 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4513 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4515 m_hasScrolling
= TRUE
;
4517 if (orient
== wxHORIZONTAL
)
4519 float fpos
= (float)pos
;
4520 float frange
= (float)range
;
4521 float fthumb
= (float)thumbVisible
;
4522 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
4523 if (fpos
< 0.0) fpos
= 0.0;
4525 if ((fabs(frange
-m_hAdjust
->upper
) < 0.2) &&
4526 (fabs(fthumb
-m_hAdjust
->page_size
) < 0.2))
4528 SetScrollPos( orient
, pos
, refresh
);
4532 m_oldHorizontalPos
= fpos
;
4534 m_hAdjust
->lower
= 0.0;
4535 m_hAdjust
->upper
= frange
;
4536 m_hAdjust
->value
= fpos
;
4537 m_hAdjust
->step_increment
= 1.0;
4538 m_hAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
4539 m_hAdjust
->page_size
= fthumb
;
4543 float fpos
= (float)pos
;
4544 float frange
= (float)range
;
4545 float fthumb
= (float)thumbVisible
;
4546 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
4547 if (fpos
< 0.0) fpos
= 0.0;
4549 if ((fabs(frange
-m_vAdjust
->upper
) < 0.2) &&
4550 (fabs(fthumb
-m_vAdjust
->page_size
) < 0.2))
4552 SetScrollPos( orient
, pos
, refresh
);
4556 m_oldVerticalPos
= fpos
;
4558 m_vAdjust
->lower
= 0.0;
4559 m_vAdjust
->upper
= frange
;
4560 m_vAdjust
->value
= fpos
;
4561 m_vAdjust
->step_increment
= 1.0;
4562 m_vAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
4563 m_vAdjust
->page_size
= fthumb
;
4566 if (orient
== wxHORIZONTAL
)
4567 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
4569 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
4572 void wxWindowGTK::SetScrollPos( int orient
, int pos
, bool WXUNUSED(refresh
) )
4574 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4576 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4578 if (orient
== wxHORIZONTAL
)
4580 float fpos
= (float)pos
;
4581 if (fpos
> m_hAdjust
->upper
- m_hAdjust
->page_size
) fpos
= m_hAdjust
->upper
- m_hAdjust
->page_size
;
4582 if (fpos
< 0.0) fpos
= 0.0;
4583 m_oldHorizontalPos
= fpos
;
4585 if (fabs(fpos
-m_hAdjust
->value
) < 0.2) return;
4586 m_hAdjust
->value
= fpos
;
4590 float fpos
= (float)pos
;
4591 if (fpos
> m_vAdjust
->upper
- m_vAdjust
->page_size
) fpos
= m_vAdjust
->upper
- m_vAdjust
->page_size
;
4592 if (fpos
< 0.0) fpos
= 0.0;
4593 m_oldVerticalPos
= fpos
;
4595 if (fabs(fpos
-m_vAdjust
->value
) < 0.2) return;
4596 m_vAdjust
->value
= fpos
;
4599 if (m_wxwindow
->window
)
4601 if (orient
== wxHORIZONTAL
)
4603 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust
),
4604 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
4606 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "value_changed" );
4608 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
4609 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
4613 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust
),
4614 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
4616 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "value_changed" );
4618 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
4619 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
4624 int wxWindowGTK::GetScrollThumb( int orient
) const
4626 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4628 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4630 if (orient
== wxHORIZONTAL
)
4631 return (int)(m_hAdjust
->page_size
+0.5);
4633 return (int)(m_vAdjust
->page_size
+0.5);
4636 int wxWindowGTK::GetScrollPos( int orient
) const
4638 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4640 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4642 if (orient
== wxHORIZONTAL
)
4643 return (int)(m_hAdjust
->value
+0.5);
4645 return (int)(m_vAdjust
->value
+0.5);
4648 int wxWindowGTK::GetScrollRange( int orient
) const
4650 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4652 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4654 if (orient
== wxHORIZONTAL
)
4655 return (int)(m_hAdjust
->upper
+0.5);
4657 return (int)(m_vAdjust
->upper
+0.5);
4660 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4662 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4664 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4666 // No scrolling requested.
4667 if ((dx
== 0) && (dy
== 0)) return;
4670 if (!m_updateRegion
.IsEmpty())
4672 m_updateRegion
.Offset( dx
, dy
);
4676 GetClientSize( &cw
, &ch
);
4677 m_updateRegion
.Intersect( 0, 0, cw
, ch
);
4680 if (!m_clearRegion
.IsEmpty())
4682 m_clearRegion
.Offset( dx
, dy
);
4686 GetClientSize( &cw
, &ch
);
4687 m_clearRegion
.Intersect( 0, 0, cw
, ch
);
4691 m_clipPaintRegion
= TRUE
;
4693 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), -dx
, -dy
);
4695 m_clipPaintRegion
= FALSE
;
4699 // Find the wxWindow at the current mouse position, also returning the mouse
4701 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4703 pt
= wxGetMousePosition();
4704 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4708 // Get the current mouse position.
4709 wxPoint
wxGetMousePosition()
4711 /* This crashes when used within wxHelpContext,
4712 so we have to use the X-specific implementation below.
4714 GdkModifierType *mask;
4715 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4717 return wxPoint(x, y);
4721 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4723 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4724 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4725 Window rootReturn
, childReturn
;
4726 int rootX
, rootY
, winX
, winY
;
4727 unsigned int maskReturn
;
4729 XQueryPointer (display
,
4733 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4734 return wxPoint(rootX
, rootY
);
4738 // ----------------------------------------------------------------------------
4740 // ----------------------------------------------------------------------------
4742 class wxWinModule
: public wxModule
4749 DECLARE_DYNAMIC_CLASS(wxWinModule
)
4752 IMPLEMENT_DYNAMIC_CLASS(wxWinModule
, wxModule
)
4754 bool wxWinModule::OnInit()
4756 // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
4757 // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
4762 void wxWinModule::OnExit()
4765 gdk_gc_unref( g_eraseGC
);