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())
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
)
969 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
971 GdkEventKey
*gdk_event
)
973 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
974 // but only event->keyval which is quite useless to us, so remember
975 // the last character from GDK_KEY_PRESS and reuse it as last resort
977 // NB: should be MT-safe as we're always called from the main thread only
982 } s_lastKeyPress
= { 0, 0 };
984 KeySym keysym
= gdk_event
->keyval
;
986 wxLogTrace(TRACE_KEYS
, _T("Key %s event: keysym = %ld"),
987 event
.GetEventType() == wxEVT_KEY_UP
? _T("release")
991 long key_code
= wxTranslateKeySymToWXKey(keysym
, FALSE
/* !isChar */);
995 // do we have the translation or is it a plain ASCII character?
996 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
998 // we should use keysym if it is ASCII as X does some translations
999 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
1000 // which we don't want here (but which we do use for OnChar())
1001 if ( !wxIsAsciiKeysym(keysym
) )
1003 keysym
= (KeySym
)gdk_event
->string
[0];
1006 // we want to always get the same key code when the same key is
1007 // pressed regardless of the state of the modifies, i.e. on a
1008 // standard US keyboard pressing '5' or '%' ('5' key with
1009 // Shift) should result in the same key code in OnKeyDown():
1010 // '5' (although OnChar() will get either '5' or '%').
1012 // to do it we first translate keysym to keycode (== scan code)
1013 // and then back but always using the lower register
1014 Display
*dpy
= (Display
*)wxGetDisplay();
1015 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
1017 wxLogTrace(TRACE_KEYS
, _T("\t-> keycode %d"), keycode
);
1019 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
1021 // use the normalized, i.e. lower register, keysym if we've
1023 key_code
= keysymNormalized
? keysymNormalized
: keysym
;
1025 // as explained above, we want to have lower register key codes
1026 // normally but for the letter keys we want to have the upper ones
1028 // NB: don't use XConvertCase() here, we want to do it for letters
1030 key_code
= toupper(key_code
);
1032 else // non ASCII key, what to do?
1034 // by default, ignore it
1037 // but if we have cached information from the last KEY_PRESS
1038 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
1041 if ( keysym
== s_lastKeyPress
.keysym
)
1043 key_code
= s_lastKeyPress
.keycode
;
1048 if ( gdk_event
->type
== GDK_KEY_PRESS
)
1050 // remember it to be reused for KEY_UP event later
1051 s_lastKeyPress
.keysym
= keysym
;
1052 s_lastKeyPress
.keycode
= key_code
;
1056 wxLogTrace(TRACE_KEYS
, _T("\t-> wxKeyCode %ld"), key_code
);
1058 // sending unknown key events doesn't really make sense
1062 // now fill all the other fields
1065 GdkModifierType state
;
1066 if (gdk_event
->window
)
1067 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1069 event
.SetTimestamp( gdk_event
->time
);
1070 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
1071 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
1072 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
1073 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
) != 0;
1074 event
.m_keyCode
= key_code
;
1075 event
.m_scanCode
= gdk_event
->keyval
;
1076 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
1077 event
.m_rawFlags
= 0;
1080 event
.SetEventObject( win
);
1086 static gint
gtk_window_key_press_callback( GtkWidget
*widget
,
1087 GdkEventKey
*gdk_event
,
1093 wxapp_install_idle_handler();
1097 if (g_blockEventsOnDrag
)
1101 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1102 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1104 // unknown key pressed, ignore (the event would be useless anyhow)
1108 // Emit KEY_DOWN event
1109 bool ret
= win
->GetEventHandler()->ProcessEvent( event
);
1114 wxWindowGTK
*ancestor
= win
;
1117 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
1120 wxCommandEvent
command_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
1121 ret
= ancestor
->GetEventHandler()->ProcessEvent( command_event
);
1124 if (ancestor
->IsTopLevel())
1126 ancestor
= ancestor
->GetParent();
1129 #endif // wxUSE_ACCEL
1131 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1132 // will only be sent if it is not in an accelerator table.
1136 KeySym keysym
= gdk_event
->keyval
;
1138 // In GTK 2.0, we need to hand over the key event to an input method
1139 // and the IM will emit a "commit" event containing the actual utf8
1140 // character. In that case the EVT_CHAR events will be sent from
1141 // there. But only do it this way for non-KeySym keys.
1142 key_code
= wxTranslateKeySymToWXKey(gdk_event
->keyval
, FALSE
/* isChar */);
1143 if ( !key_code
&& win
->m_imContext
)
1145 gtk_im_context_filter_keypress ( (GtkIMContext
*) win
->m_imContext
, gdk_event
);
1151 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1152 key_code
= wxTranslateKeySymToWXKey(keysym
, TRUE
/* isChar */);
1155 if ( gdk_event
->length
== 1 )
1157 key_code
= (unsigned char)gdk_event
->string
[0];
1159 else if ( wxIsAsciiKeysym(keysym
) )
1162 key_code
= (unsigned char)keysym
;
1168 wxLogTrace(TRACE_KEYS
, _T("Char event: %ld"), key_code
);
1170 event
.m_keyCode
= key_code
;
1172 // Implement OnCharHook by checking ancesteror top level windows
1173 wxWindow
*parent
= win
;
1174 while (parent
&& !parent
->IsTopLevel())
1175 parent
= parent
->GetParent();
1178 event
.SetEventType( wxEVT_CHAR_HOOK
);
1179 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1184 event
.SetEventType(wxEVT_CHAR
);
1185 ret
= win
->GetEventHandler()->ProcessEvent( event
);
1191 // win is a control: tab can be propagated up
1193 ((gdk_event
->keyval
== GDK_Tab
) || (gdk_event
->keyval
== GDK_ISO_Left_Tab
)) &&
1194 // VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may
1195 // have this style, yet choose not to process this particular TAB in which
1196 // case TAB must still work as a navigational character
1197 // JS: enabling again to make consistent with other platforms
1198 // (with wxTE_PROCESS_TAB you have to call Navigate to get default
1199 // navigation behaviour)
1201 (! (win
->HasFlag(wxTE_PROCESS_TAB
) && win
->IsKindOf(CLASSINFO(wxTextCtrl
)) )) &&
1203 win
->GetParent() && (win
->GetParent()->HasFlag( wxTAB_TRAVERSAL
)) )
1205 wxNavigationKeyEvent new_event
;
1206 new_event
.SetEventObject( win
->GetParent() );
1207 // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
1208 new_event
.SetDirection( (gdk_event
->keyval
== GDK_Tab
) );
1209 // CTRL-TAB changes the (parent) window, i.e. switch notebook page
1210 new_event
.SetWindowChange( (gdk_event
->state
& GDK_CONTROL_MASK
) );
1211 new_event
.SetCurrentFocus( win
);
1212 ret
= win
->GetParent()->GetEventHandler()->ProcessEvent( new_event
);
1215 // generate wxID_CANCEL if <esc> has been pressed (typically in dialogs)
1217 (gdk_event
->keyval
== GDK_Escape
) )
1219 // however only do it if we have a Cancel button in the dialog,
1220 // otherwise the user code may get confused by the events from a
1221 // non-existing button and, worse, a wxButton might get button event
1222 // from another button which is not really expected
1223 wxWindow
*winForCancel
= win
,
1225 while ( winForCancel
)
1227 btnCancel
= winForCancel
->FindWindow(wxID_CANCEL
);
1230 // found a cancel button
1234 if ( winForCancel
->IsTopLevel() )
1236 // no need to look further
1240 // maybe our parent has a cancel button?
1241 winForCancel
= winForCancel
->GetParent();
1246 wxCommandEvent
event(wxEVT_COMMAND_BUTTON_CLICKED
, wxID_CANCEL
);
1247 event
.SetEventObject(btnCancel
);
1248 ret
= btnCancel
->GetEventHandler()->ProcessEvent(event
);
1254 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_press_event" );
1262 static void gtk_wxwindow_commit_cb (GtkIMContext
*context
,
1268 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1271 event
.m_uniChar
= g_utf8_get_char( str
);
1273 // Backward compatible for ISO-8859
1274 if (event
.m_uniChar
< 256)
1275 event
.m_keyCode
= event
.m_uniChar
;
1277 gunichar uniChar
= g_utf8_get_char( str
);
1278 // We cannot handle Unicode in non-Unicode mode
1279 if (uniChar
> 255) return;
1281 event
.m_keyCode
= uniChar
;
1285 // TODO: We still need to set all the extra attributes of the
1286 // event, modifiers and such...
1289 // Implement OnCharHook by checking ancestor top level windows
1290 wxWindow
*parent
= window
;
1291 while (parent
&& !parent
->IsTopLevel())
1292 parent
= parent
->GetParent();
1295 event
.SetEventType( wxEVT_CHAR_HOOK
);
1296 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1301 event
.SetEventType(wxEVT_CHAR
);
1302 ret
= window
->GetEventHandler()->ProcessEvent( event
);
1308 //-----------------------------------------------------------------------------
1309 // "key_release_event" from any window
1310 //-----------------------------------------------------------------------------
1312 static gint
gtk_window_key_release_callback( GtkWidget
*widget
,
1313 GdkEventKey
*gdk_event
,
1319 wxapp_install_idle_handler();
1324 if (g_blockEventsOnDrag
)
1327 wxKeyEvent
event( wxEVT_KEY_UP
);
1328 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1330 // unknown key pressed, ignore (the event would be useless anyhow
1334 if ( !win
->GetEventHandler()->ProcessEvent( event
) )
1337 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_release_event" );
1341 // ============================================================================
1343 // ============================================================================
1345 // ----------------------------------------------------------------------------
1346 // mouse event processing helpers
1347 // ----------------------------------------------------------------------------
1349 // init wxMouseEvent with the info from GdkEventXXX struct
1350 template<typename T
> void InitMouseEvent(wxWindowGTK
*win
,
1351 wxMouseEvent
& event
,
1354 event
.SetTimestamp( gdk_event
->time
);
1355 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1356 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1357 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1358 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1359 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1360 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1361 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1362 if (event
.GetEventType() == wxEVT_MOUSEWHEEL
)
1364 event
.m_linesPerAction
= 3;
1365 if (((GdkEventButton
*)gdk_event
)->button
== 4)
1366 event
.m_wheelRotation
= 120;
1367 else if (((GdkEventButton
*)gdk_event
)->button
== 5)
1368 event
.m_wheelRotation
= -120;
1371 wxPoint pt
= win
->GetClientAreaOrigin();
1372 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1373 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1375 event
.SetEventObject( win
);
1376 event
.SetId( win
->GetId() );
1377 event
.SetTimestamp( gdk_event
->time
);
1380 static void AdjustEventButtonState(wxMouseEvent
& event
)
1382 // GDK reports the old state of the button for a button press event, but
1383 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1384 // for a LEFT_DOWN event, not FALSE, so we will invert
1385 // left/right/middleDown for the corresponding click events
1387 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1388 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1389 (event
.GetEventType() == wxEVT_LEFT_UP
))
1391 event
.m_leftDown
= !event
.m_leftDown
;
1395 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1396 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1397 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1399 event
.m_middleDown
= !event
.m_middleDown
;
1403 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1404 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1405 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1407 event
.m_rightDown
= !event
.m_rightDown
;
1412 // find the window to send the mouse event too
1414 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1419 if (win
->m_wxwindow
)
1421 GtkPizza
*pizza
= GTK_PIZZA(win
->m_wxwindow
);
1422 xx
+= pizza
->xoffset
;
1423 yy
+= pizza
->yoffset
;
1426 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
1429 wxWindowGTK
*child
= node
->GetData();
1431 node
= node
->GetNext();
1432 if (!child
->IsShown())
1435 if (child
->IsTransparentForMouse())
1437 // wxStaticBox is transparent in the box itself
1438 int xx1
= child
->m_x
;
1439 int yy1
= child
->m_y
;
1440 int xx2
= child
->m_x
+ child
->m_width
;
1441 int yy2
= child
->m_y
+ child
->m_height
;
1444 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1446 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1448 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1450 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1461 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1462 (child
->m_x
<= xx
) &&
1463 (child
->m_y
<= yy
) &&
1464 (child
->m_x
+child
->m_width
>= xx
) &&
1465 (child
->m_y
+child
->m_height
>= yy
))
1478 //-----------------------------------------------------------------------------
1479 // "button_press_event"
1480 //-----------------------------------------------------------------------------
1482 static gint
gtk_window_button_press_callback( GtkWidget
*widget
,
1483 GdkEventButton
*gdk_event
,
1489 wxapp_install_idle_handler();
1492 wxPrintf( wxT("1) OnButtonPress from ") );
1493 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1494 wxPrintf( win->GetClassInfo()->GetClassName() );
1495 wxPrintf( wxT(".\n") );
1497 if (!win
->m_hasVMT
) return FALSE
;
1498 if (g_blockEventsOnDrag
) return TRUE
;
1499 if (g_blockEventsOnScroll
) return TRUE
;
1501 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1503 if (win
->m_wxwindow
&& (g_focusWindow
!= win
) && win
->AcceptsFocus())
1505 gtk_widget_grab_focus( win
->m_wxwindow
);
1507 wxPrintf( wxT("GrabFocus from ") );
1508 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1509 wxPrintf( win->GetClassInfo()->GetClassName() );
1510 wxPrintf( wxT(".\n") );
1514 // GDK sends surplus button down event
1515 // before a double click event. We
1516 // need to filter these out.
1517 if (gdk_event
->type
== GDK_BUTTON_PRESS
)
1519 GdkEvent
*peek_event
= gdk_event_peek();
1522 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1523 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1525 gdk_event_free( peek_event
);
1530 gdk_event_free( peek_event
);
1535 wxEventType event_type
= wxEVT_NULL
;
1537 // GdkDisplay is a GTK+ 2.1.0 thing
1538 #if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 1, 0)
1539 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1540 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1542 // Reset GDK internal timestamp variables in order to disable GDK
1543 // triple click events. GDK will then next time believe no button has
1544 // been clicked just before, and send a normal button click event.
1545 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1546 display
->button_click_time
[1] = 0;
1547 display
->button_click_time
[0] = 0;
1551 if (gdk_event
->button
== 1)
1553 // note that GDK generates triple click events which are not supported
1554 // by wxWidgets but still have to be passed to the app as otherwise
1555 // clicks would simply go missing
1556 switch (gdk_event
->type
)
1558 // we shouldn't get triple clicks at all for GTK2 because we
1559 // suppress them artificially using the code above but we still
1560 // should map them to something for GTK1 and not just ignore them
1561 // as this would lose clicks
1562 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1563 case GDK_BUTTON_PRESS
:
1564 event_type
= wxEVT_LEFT_DOWN
;
1567 case GDK_2BUTTON_PRESS
:
1568 event_type
= wxEVT_LEFT_DCLICK
;
1572 // just to silence gcc warnings
1576 else if (gdk_event
->button
== 2)
1578 switch (gdk_event
->type
)
1580 case GDK_3BUTTON_PRESS
:
1581 case GDK_BUTTON_PRESS
:
1582 event_type
= wxEVT_MIDDLE_DOWN
;
1585 case GDK_2BUTTON_PRESS
:
1586 event_type
= wxEVT_MIDDLE_DCLICK
;
1593 else if (gdk_event
->button
== 3)
1595 switch (gdk_event
->type
)
1597 case GDK_3BUTTON_PRESS
:
1598 case GDK_BUTTON_PRESS
:
1599 event_type
= wxEVT_RIGHT_DOWN
;
1602 case GDK_2BUTTON_PRESS
:
1603 event_type
= wxEVT_RIGHT_DCLICK
;
1610 else if (gdk_event
->button
== 4 || gdk_event
->button
== 5)
1612 if (gdk_event
->type
== GDK_BUTTON_PRESS
)
1614 event_type
= wxEVT_MOUSEWHEEL
;
1618 if ( event_type
== wxEVT_NULL
)
1620 // unknown mouse button or click type
1624 wxMouseEvent
event( event_type
);
1625 InitMouseEvent( win
, event
, gdk_event
);
1627 AdjustEventButtonState(event
);
1629 // wxListBox actually get mouse events from the item, so we need to give it
1630 // a chance to correct this
1631 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1633 // find the correct window to send the event too: it may be a different one
1634 // from the one which got it at GTK+ level because some control don't have
1635 // their own X window and thus cannot get any events.
1636 if ( !g_captureWindow
)
1637 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1639 gs_timeLastClick
= gdk_event
->time
;
1642 wxPrintf( wxT("2) OnButtonPress from ") );
1643 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1644 wxPrintf( win->GetClassInfo()->GetClassName() );
1645 wxPrintf( wxT(".\n") );
1649 if (event_type
== wxEVT_LEFT_DCLICK
)
1651 // GTK 1.2 crashes when intercepting double
1652 // click events from both wxSpinButton and
1654 if (GTK_IS_SPIN_BUTTON(win
->m_widget
))
1656 // Just disable this event for now.
1662 if (win
->GetEventHandler()->ProcessEvent( event
))
1664 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_press_event" );
1671 //-----------------------------------------------------------------------------
1672 // "button_release_event"
1673 //-----------------------------------------------------------------------------
1675 static gint
gtk_window_button_release_callback( GtkWidget
*widget
,
1676 GdkEventButton
*gdk_event
,
1682 wxapp_install_idle_handler();
1684 if (!win
->m_hasVMT
) return FALSE
;
1685 if (g_blockEventsOnDrag
) return FALSE
;
1686 if (g_blockEventsOnScroll
) return FALSE
;
1688 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1690 wxEventType event_type
= wxEVT_NULL
;
1692 switch (gdk_event
->button
)
1695 event_type
= wxEVT_LEFT_UP
;
1699 event_type
= wxEVT_MIDDLE_UP
;
1703 event_type
= wxEVT_RIGHT_UP
;
1707 // unknwon button, don't process
1711 wxMouseEvent
event( event_type
);
1712 InitMouseEvent( win
, event
, gdk_event
);
1714 AdjustEventButtonState(event
);
1716 // same wxListBox hack as above
1717 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1719 if ( event_type
== wxEVT_RIGHT_UP
)
1721 // generate a "context menu" event: this is similar to wxEVT_RIGHT_UP
1724 // (a) it's a command event and so is propagated to the parent
1725 // (b) under MSW it can be generated from kbd too
1726 // (c) it uses screen coords (because of (a))
1727 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
,
1729 win
->ClientToScreen(event
.GetPosition()));
1730 (void)win
->GetEventHandler()->ProcessEvent(evtCtx
);
1733 if ( !g_captureWindow
)
1734 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1736 if (win
->GetEventHandler()->ProcessEvent( event
))
1738 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_release_event" );
1745 //-----------------------------------------------------------------------------
1746 // "motion_notify_event"
1747 //-----------------------------------------------------------------------------
1749 static gint
gtk_window_motion_notify_callback( GtkWidget
*widget
,
1750 GdkEventMotion
*gdk_event
,
1756 wxapp_install_idle_handler();
1758 if (!win
->m_hasVMT
) return FALSE
;
1759 if (g_blockEventsOnDrag
) return FALSE
;
1760 if (g_blockEventsOnScroll
) return FALSE
;
1762 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1764 if (gdk_event
->is_hint
)
1768 GdkModifierType state
;
1769 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1775 printf( "OnMotion from " );
1776 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1777 printf( win->GetClassInfo()->GetClassName() );
1781 wxMouseEvent
event( wxEVT_MOTION
);
1782 InitMouseEvent(win
, event
, gdk_event
);
1784 if ( g_captureWindow
)
1786 // synthetize a mouse enter or leave event if needed
1787 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1788 // This seems to be necessary and actually been added to
1789 // GDK itself in version 2.0.X
1792 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1793 if ( hasMouse
!= g_captureWindowHasMouse
)
1795 // the mouse changed window
1796 g_captureWindowHasMouse
= hasMouse
;
1798 wxMouseEvent
event(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1799 : wxEVT_LEAVE_WINDOW
);
1800 InitMouseEvent(win
, event
, gdk_event
);
1801 event
.SetEventObject(win
);
1802 win
->GetEventHandler()->ProcessEvent(event
);
1807 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1810 if (win
->GetEventHandler()->ProcessEvent( event
))
1812 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "motion_notify_event" );
1820 //-----------------------------------------------------------------------------
1821 // "mouse_wheel_event"
1822 //-----------------------------------------------------------------------------
1824 static gint
gtk_window_wheel_callback (GtkWidget
* widget
,
1825 GdkEventScroll
* gdk_event
,
1831 wxapp_install_idle_handler();
1833 wxEventType event_type
= wxEVT_NULL
;
1834 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1835 event_type
= wxEVT_MOUSEWHEEL
;
1836 else if (gdk_event
->direction
== GDK_SCROLL_DOWN
)
1837 event_type
= wxEVT_MOUSEWHEEL
;
1841 wxMouseEvent
event( event_type
);
1842 // Can't use InitMouse macro because scroll events don't have button
1843 event
.SetTimestamp( gdk_event
->time
);
1844 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1845 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1846 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1847 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1848 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1849 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1850 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1851 event
.m_linesPerAction
= 3;
1852 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1853 event
.m_wheelRotation
= 120;
1855 event
.m_wheelRotation
= -120;
1857 wxPoint pt
= win
->GetClientAreaOrigin();
1858 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1859 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1861 event
.SetEventObject( win
);
1862 event
.SetId( win
->GetId() );
1863 event
.SetTimestamp( gdk_event
->time
);
1865 if (win
->GetEventHandler()->ProcessEvent( event
))
1867 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "scroll_event" );
1875 //-----------------------------------------------------------------------------
1877 //-----------------------------------------------------------------------------
1879 // send the wxChildFocusEvent and wxFocusEvent, common code of
1880 // gtk_window_focus_in_callback() and SetFocus()
1881 static bool DoSendFocusEvents(wxWindow
*win
)
1883 // Notify the parent keeping track of focus for the kbd navigation
1884 // purposes that we got it.
1885 wxChildFocusEvent
eventChildFocus(win
);
1886 (void)win
->GetEventHandler()->ProcessEvent(eventChildFocus
);
1888 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, win
->GetId());
1889 eventFocus
.SetEventObject(win
);
1891 return win
->GetEventHandler()->ProcessEvent(eventFocus
);
1894 static gint
gtk_window_focus_in_callback( GtkWidget
*widget
,
1895 GdkEvent
*WXUNUSED(event
),
1901 wxapp_install_idle_handler();
1903 if (!win
->m_hasVMT
) return FALSE
;
1904 if (g_blockEventsOnDrag
) return FALSE
;
1906 switch ( g_sendActivateEvent
)
1909 // we've got focus from outside, synthetize wxActivateEvent
1910 g_sendActivateEvent
= 1;
1914 // another our window just lost focus, it was already ours before
1915 // - don't send any wxActivateEvent
1916 g_sendActivateEvent
= -1;
1921 g_focusWindow
= win
;
1923 wxLogTrace(TRACE_FOCUS
,
1924 _T("%s: focus in"), win
->GetName().c_str());
1928 gdk_im_begin(win
->m_ic
, win
->m_wxwindow
->window
);
1932 // caret needs to be informed about focus change
1933 wxCaret
*caret
= win
->GetCaret();
1936 caret
->OnSetFocus();
1938 #endif // wxUSE_CARET
1940 g_activeFrameLostFocus
= FALSE
;
1942 wxWindowGTK
*active
= wxGetTopLevelParent(win
);
1943 if ( active
!= g_activeFrame
)
1945 if ( g_activeFrame
)
1947 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from focus_in)"), g_activeFrame
);
1948 wxActivateEvent
event(wxEVT_ACTIVATE
, FALSE
, g_activeFrame
->GetId());
1949 event
.SetEventObject(g_activeFrame
);
1950 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
1953 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), active
);
1954 g_activeFrame
= active
;
1955 wxActivateEvent
event(wxEVT_ACTIVATE
, TRUE
, g_activeFrame
->GetId());
1956 event
.SetEventObject(g_activeFrame
);
1957 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
1959 // Don't send focus events in addition to activate
1960 // if (win == g_activeFrame)
1964 // does the window itself think that it has the focus?
1965 if ( !win
->m_hasFocus
)
1967 // not yet, notify it
1968 win
->m_hasFocus
= TRUE
;
1970 if ( DoSendFocusEvents(win
) )
1972 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_in_event" );
1980 //-----------------------------------------------------------------------------
1981 // "focus_out_event"
1982 //-----------------------------------------------------------------------------
1984 static gint
gtk_window_focus_out_callback( GtkWidget
*widget
, GdkEventFocus
*gdk_event
, wxWindowGTK
*win
)
1989 wxapp_install_idle_handler();
1991 if (!win
->m_hasVMT
) return FALSE
;
1992 if (g_blockEventsOnDrag
) return FALSE
;
1994 wxLogTrace( TRACE_FOCUS
,
1995 _T("%s: focus out"), win
->GetName().c_str() );
1997 if ( !g_activeFrameLostFocus
&& g_activeFrame
)
1999 // VZ: commenting this out because it does happen (although not easy
2000 // to reproduce, I only see it when using wxMiniFrame and not
2001 // always) and makes using Mahogany quite annoying
2003 wxASSERT_MSG( wxGetTopLevelParent(win
) == g_activeFrame
,
2004 wxT("unfocusing window that hasn't gained focus properly") );
2007 g_activeFrameLostFocus
= TRUE
;
2010 // if the focus goes out of our app alltogether, OnIdle() will send
2011 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
2012 // g_sendActivateEvent to -1
2013 g_sendActivateEvent
= 0;
2015 wxWindowGTK
*winFocus
= wxFindFocusedChild(win
);
2019 g_focusWindow
= (wxWindowGTK
*)NULL
;
2027 // caret needs to be informed about focus change
2028 wxCaret
*caret
= win
->GetCaret();
2031 caret
->OnKillFocus();
2033 #endif // wxUSE_CARET
2035 // don't send the window a kill focus event if it thinks that it doesn't
2036 // have focus already
2037 if ( win
->m_hasFocus
)
2039 win
->m_hasFocus
= FALSE
;
2041 wxFocusEvent
event( wxEVT_KILL_FOCUS
, win
->GetId() );
2042 event
.SetEventObject( win
);
2044 if (win
->GetEventHandler()->ProcessEvent( event
))
2046 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_out_event" );
2054 //-----------------------------------------------------------------------------
2055 // "enter_notify_event"
2056 //-----------------------------------------------------------------------------
2059 gint
gtk_window_enter_callback( GtkWidget
*widget
,
2060 GdkEventCrossing
*gdk_event
,
2066 wxapp_install_idle_handler();
2068 if (!win
->m_hasVMT
) return FALSE
;
2069 if (g_blockEventsOnDrag
) return FALSE
;
2071 // Event was emitted after a grab
2072 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
2074 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
2078 GdkModifierType state
= (GdkModifierType
)0;
2080 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
2082 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
2083 InitMouseEvent(win
, event
, gdk_event
);
2084 wxPoint pt
= win
->GetClientAreaOrigin();
2085 event
.m_x
= x
+ pt
.x
;
2086 event
.m_y
= y
+ pt
.y
;
2088 if (win
->GetEventHandler()->ProcessEvent( event
))
2090 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "enter_notify_event" );
2097 //-----------------------------------------------------------------------------
2098 // "leave_notify_event"
2099 //-----------------------------------------------------------------------------
2101 static gint
gtk_window_leave_callback( GtkWidget
*widget
, GdkEventCrossing
*gdk_event
, wxWindowGTK
*win
)
2106 wxapp_install_idle_handler();
2108 if (!win
->m_hasVMT
) return FALSE
;
2109 if (g_blockEventsOnDrag
) return FALSE
;
2111 // Event was emitted after an ungrab
2112 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
2114 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
2116 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
2117 event
.SetTimestamp( gdk_event
->time
);
2118 event
.SetEventObject( win
);
2122 GdkModifierType state
= (GdkModifierType
)0;
2124 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
2126 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
) != 0;
2127 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
) != 0;
2128 event
.m_altDown
= (state
& GDK_MOD1_MASK
) != 0;
2129 event
.m_metaDown
= (state
& GDK_MOD2_MASK
) != 0;
2130 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
) != 0;
2131 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
) != 0;
2132 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
) != 0;
2134 wxPoint pt
= win
->GetClientAreaOrigin();
2135 event
.m_x
= x
+ pt
.x
;
2136 event
.m_y
= y
+ pt
.y
;
2138 if (win
->GetEventHandler()->ProcessEvent( event
))
2140 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "leave_notify_event" );
2147 //-----------------------------------------------------------------------------
2148 // "value_changed" from m_vAdjust
2149 //-----------------------------------------------------------------------------
2151 static void gtk_window_vscroll_callback( GtkAdjustment
*adjust
,
2158 wxapp_install_idle_handler();
2160 if (g_blockEventsOnDrag
) return;
2162 if (!win
->m_hasVMT
) return;
2164 float diff
= adjust
->value
- win
->m_oldVerticalPos
;
2165 if (fabs(diff
) < 0.2) return;
2167 win
->m_oldVerticalPos
= adjust
->value
;
2170 GtkScrolledWindow
*sw
= GTK_SCROLLED_WINDOW(win
->m_widget
);
2172 wxEventType command
= GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw
->vscrollbar
));
2174 int value
= (int)(adjust
->value
+0.5);
2176 wxScrollWinEvent
event( command
, value
, wxVERTICAL
);
2177 event
.SetEventObject( win
);
2178 win
->GetEventHandler()->ProcessEvent( event
);
2181 //-----------------------------------------------------------------------------
2182 // "value_changed" from m_hAdjust
2183 //-----------------------------------------------------------------------------
2185 static void gtk_window_hscroll_callback( GtkAdjustment
*adjust
,
2192 wxapp_install_idle_handler();
2194 if (g_blockEventsOnDrag
) return;
2195 if (!win
->m_hasVMT
) return;
2197 float diff
= adjust
->value
- win
->m_oldHorizontalPos
;
2198 if (fabs(diff
) < 0.2) return;
2201 GtkScrolledWindow
*sw
= GTK_SCROLLED_WINDOW(win
->m_widget
);
2203 wxEventType command
= GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw
->hscrollbar
));
2205 win
->m_oldHorizontalPos
= adjust
->value
;
2207 int value
= (int)(adjust
->value
+0.5);
2209 wxScrollWinEvent
event( command
, value
, wxHORIZONTAL
);
2210 event
.SetEventObject( win
);
2211 win
->GetEventHandler()->ProcessEvent( event
);
2214 //-----------------------------------------------------------------------------
2215 // "button_press_event" from scrollbar
2216 //-----------------------------------------------------------------------------
2218 static gint
gtk_scrollbar_button_press_callback( GtkRange
*widget
,
2219 GdkEventButton
*gdk_event
,
2225 wxapp_install_idle_handler();
2228 g_blockEventsOnScroll
= TRUE
;
2230 // FIXME: there is no 'slider' field in GTK+ 2.0 any more
2232 win
->m_isScrolling
= (gdk_event
->window
== widget
->slider
);
2238 //-----------------------------------------------------------------------------
2239 // "button_release_event" from scrollbar
2240 //-----------------------------------------------------------------------------
2242 static gint
gtk_scrollbar_button_release_callback( GtkRange
*widget
,
2243 GdkEventButton
*WXUNUSED(gdk_event
),
2248 // don't test here as we can release the mouse while being over
2249 // a different window than the slider
2251 // if (gdk_event->window != widget->slider) return FALSE;
2253 g_blockEventsOnScroll
= FALSE
;
2255 if (win
->m_isScrolling
)
2257 wxEventType command
= wxEVT_SCROLLWIN_THUMBRELEASE
;
2261 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(win
->m_widget
);
2262 if (widget
== GTK_RANGE(scrolledWindow
->hscrollbar
))
2264 value
= (int)(win
->m_hAdjust
->value
+0.5);
2267 if (widget
== GTK_RANGE(scrolledWindow
->vscrollbar
))
2269 value
= (int)(win
->m_vAdjust
->value
+0.5);
2273 wxScrollWinEvent
event( command
, value
, dir
);
2274 event
.SetEventObject( win
);
2275 win
->GetEventHandler()->ProcessEvent( event
);
2278 win
->m_isScrolling
= FALSE
;
2283 // ----------------------------------------------------------------------------
2284 // this wxWindowBase function is implemented here (in platform-specific file)
2285 // because it is static and so couldn't be made virtual
2286 // ----------------------------------------------------------------------------
2288 wxWindow
*wxWindowBase::FindFocus()
2290 // the cast is necessary when we compile in wxUniversal mode
2291 return (wxWindow
*)g_focusWindow
;
2295 //-----------------------------------------------------------------------------
2296 // "realize" from m_widget
2297 //-----------------------------------------------------------------------------
2299 /* We cannot set colours and fonts before the widget has
2300 been realized, so we do this directly after realization. */
2303 gtk_window_realized_callback( GtkWidget
*m_widget
, wxWindow
*win
)
2308 wxapp_install_idle_handler();
2311 if (win
->m_imContext
)
2313 GtkPizza
*pizza
= GTK_PIZZA( m_widget
);
2314 gtk_im_context_set_client_window( (GtkIMContext
*) win
->m_imContext
, pizza
->bin_window
);
2318 wxWindowCreateEvent
event( win
);
2319 event
.SetEventObject( win
);
2320 win
->GetEventHandler()->ProcessEvent( event
);
2325 //-----------------------------------------------------------------------------
2327 //-----------------------------------------------------------------------------
2330 void gtk_window_size_callback( GtkWidget
*WXUNUSED(widget
),
2331 GtkAllocation
*WXUNUSED(alloc
),
2335 wxapp_install_idle_handler();
2337 if (!win
->m_hasScrolling
) return;
2339 int client_width
= 0;
2340 int client_height
= 0;
2341 win
->GetClientSize( &client_width
, &client_height
);
2342 if ((client_width
== win
->m_oldClientWidth
) && (client_height
== win
->m_oldClientHeight
))
2345 win
->m_oldClientWidth
= client_width
;
2346 win
->m_oldClientHeight
= client_height
;
2348 if (!win
->m_nativeSizeEvent
)
2350 wxSizeEvent
event( win
->GetSize(), win
->GetId() );
2351 event
.SetEventObject( win
);
2352 win
->GetEventHandler()->ProcessEvent( event
);
2358 #define WXUNUSED_UNLESS_XIM(param) param
2360 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2363 /* Resize XIM window */
2366 void gtk_wxwindow_size_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2367 GtkAllocation
* WXUNUSED_UNLESS_XIM(alloc
),
2368 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2371 wxapp_install_idle_handler();
2377 if (gdk_ic_get_style (win
->m_ic
) & GDK_IM_PREEDIT_POSITION
)
2381 gdk_window_get_size (widget
->window
, &width
, &height
);
2382 win
->m_icattr
->preedit_area
.width
= width
;
2383 win
->m_icattr
->preedit_area
.height
= height
;
2384 gdk_ic_set_attr (win
->m_ic
, win
->m_icattr
, GDK_IC_PREEDIT_AREA
);
2389 //-----------------------------------------------------------------------------
2390 // "realize" from m_wxwindow
2391 //-----------------------------------------------------------------------------
2393 /* Initialize XIM support */
2396 gtk_wxwindow_realized_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2397 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2400 wxapp_install_idle_handler();
2403 if (win
->m_ic
) return FALSE
;
2404 if (!widget
) return FALSE
;
2405 if (!gdk_im_ready()) return FALSE
;
2407 win
->m_icattr
= gdk_ic_attr_new();
2408 if (!win
->m_icattr
) return FALSE
;
2412 GdkColormap
*colormap
;
2413 GdkICAttr
*attr
= win
->m_icattr
;
2414 unsigned attrmask
= GDK_IC_ALL_REQ
;
2416 GdkIMStyle supported_style
= (GdkIMStyle
)
2417 (GDK_IM_PREEDIT_NONE
|
2418 GDK_IM_PREEDIT_NOTHING
|
2419 GDK_IM_PREEDIT_POSITION
|
2420 GDK_IM_STATUS_NONE
|
2421 GDK_IM_STATUS_NOTHING
);
2423 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2424 supported_style
= (GdkIMStyle
)(supported_style
& ~GDK_IM_PREEDIT_POSITION
);
2426 attr
->style
= style
= gdk_im_decide_style (supported_style
);
2427 attr
->client_window
= widget
->window
;
2429 if ((colormap
= gtk_widget_get_colormap (widget
)) !=
2430 gtk_widget_get_default_colormap ())
2432 attrmask
|= GDK_IC_PREEDIT_COLORMAP
;
2433 attr
->preedit_colormap
= colormap
;
2436 attrmask
|= GDK_IC_PREEDIT_FOREGROUND
;
2437 attrmask
|= GDK_IC_PREEDIT_BACKGROUND
;
2438 attr
->preedit_foreground
= widget
->style
->fg
[GTK_STATE_NORMAL
];
2439 attr
->preedit_background
= widget
->style
->base
[GTK_STATE_NORMAL
];
2441 switch (style
& GDK_IM_PREEDIT_MASK
)
2443 case GDK_IM_PREEDIT_POSITION
:
2444 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2446 g_warning ("over-the-spot style requires fontset");
2450 gdk_window_get_size (widget
->window
, &width
, &height
);
2452 attrmask
|= GDK_IC_PREEDIT_POSITION_REQ
;
2453 attr
->spot_location
.x
= 0;
2454 attr
->spot_location
.y
= height
;
2455 attr
->preedit_area
.x
= 0;
2456 attr
->preedit_area
.y
= 0;
2457 attr
->preedit_area
.width
= width
;
2458 attr
->preedit_area
.height
= height
;
2459 attr
->preedit_fontset
= widget
->style
->font
;
2464 win
->m_ic
= gdk_ic_new (attr
, (GdkICAttributesType
)attrmask
);
2466 if (win
->m_ic
== NULL
)
2467 g_warning ("Can't create input context.");
2470 mask
= gdk_window_get_events (widget
->window
);
2471 mask
= (GdkEventMask
)(mask
| gdk_ic_get_events (win
->m_ic
));
2472 gdk_window_set_events (widget
->window
, mask
);
2474 if (GTK_WIDGET_HAS_FOCUS(widget
))
2475 gdk_im_begin (win
->m_ic
, widget
->window
);
2482 //-----------------------------------------------------------------------------
2483 // InsertChild for wxWindowGTK.
2484 //-----------------------------------------------------------------------------
2486 /* Callback for wxWindowGTK. This very strange beast has to be used because
2487 * C++ has no virtual methods in a constructor. We have to emulate a
2488 * virtual function here as wxNotebook requires a different way to insert
2489 * a child in it. I had opted for creating a wxNotebookPage window class
2490 * which would have made this superfluous (such in the MDI window system),
2491 * but no-one was listening to me... */
2493 static void wxInsertChildInWindow( wxWindowGTK
* parent
, wxWindowGTK
* child
)
2495 /* the window might have been scrolled already, do we
2496 have to adapt the position */
2497 GtkPizza
*pizza
= GTK_PIZZA(parent
->m_wxwindow
);
2498 child
->m_x
+= pizza
->xoffset
;
2499 child
->m_y
+= pizza
->yoffset
;
2501 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
2502 GTK_WIDGET(child
->m_widget
),
2509 //-----------------------------------------------------------------------------
2511 //-----------------------------------------------------------------------------
2513 wxWindow
*wxGetActiveWindow()
2515 return wxWindow::FindFocus();
2518 //-----------------------------------------------------------------------------
2520 //-----------------------------------------------------------------------------
2522 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2524 #ifdef __WXUNIVERSAL__
2525 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2527 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
2528 #endif // __WXUNIVERSAL__/__WXGTK__
2530 void wxWindowGTK::Init()
2533 m_widget
= (GtkWidget
*) NULL
;
2534 m_wxwindow
= (GtkWidget
*) NULL
;
2535 m_focusWidget
= (GtkWidget
*) NULL
;
2545 m_needParent
= TRUE
;
2546 m_isBeingDeleted
= FALSE
;
2549 m_nativeSizeEvent
= FALSE
;
2551 m_hasScrolling
= FALSE
;
2552 m_isScrolling
= FALSE
;
2554 m_hAdjust
= (GtkAdjustment
*) NULL
;
2555 m_vAdjust
= (GtkAdjustment
*) NULL
;
2556 m_oldHorizontalPos
=
2557 m_oldVerticalPos
= 0.0;
2559 m_oldClientHeight
= 0;
2563 m_insertCallback
= (wxInsertChildFunction
) NULL
;
2565 m_acceptsFocus
= FALSE
;
2568 m_clipPaintRegion
= FALSE
;
2570 m_cursor
= *wxSTANDARD_CURSOR
;
2574 m_x11Context
= NULL
;
2577 m_ic
= (GdkIC
*) NULL
;
2578 m_icattr
= (GdkICAttr
*) NULL
;
2583 wxWindowGTK::wxWindowGTK()
2588 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2593 const wxString
&name
)
2597 Create( parent
, id
, pos
, size
, style
, name
);
2600 bool wxWindowGTK::Create( wxWindow
*parent
,
2605 const wxString
&name
)
2607 if (!PreCreation( parent
, pos
, size
) ||
2608 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2610 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2614 m_insertCallback
= wxInsertChildInWindow
;
2616 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
2617 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
2619 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2621 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2622 scroll_class
->scrollbar_spacing
= 0;
2624 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2626 m_hAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->hscrollbar
) );
2627 m_vAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->vscrollbar
) );
2629 m_wxwindow
= gtk_pizza_new();
2631 #ifndef __WXUNIVERSAL__
2632 GtkPizza
*pizza
= GTK_PIZZA(m_wxwindow
);
2634 if (HasFlag(wxRAISED_BORDER
))
2636 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_OUT
);
2638 else if (HasFlag(wxSUNKEN_BORDER
))
2640 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_IN
);
2642 else if (HasFlag(wxSIMPLE_BORDER
))
2644 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_THIN
);
2648 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_NONE
);
2650 #endif // __WXUNIVERSAL__
2652 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2654 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
2655 m_acceptsFocus
= TRUE
;
2657 // I _really_ don't want scrollbars in the beginning
2658 m_vAdjust
->lower
= 0.0;
2659 m_vAdjust
->upper
= 1.0;
2660 m_vAdjust
->value
= 0.0;
2661 m_vAdjust
->step_increment
= 1.0;
2662 m_vAdjust
->page_increment
= 1.0;
2663 m_vAdjust
->page_size
= 5.0;
2664 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
2665 m_hAdjust
->lower
= 0.0;
2666 m_hAdjust
->upper
= 1.0;
2667 m_hAdjust
->value
= 0.0;
2668 m_hAdjust
->step_increment
= 1.0;
2669 m_hAdjust
->page_increment
= 1.0;
2670 m_hAdjust
->page_size
= 5.0;
2671 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
2673 // these handlers block mouse events to any window during scrolling such as
2674 // motion events and prevent GTK and wxWidgets from fighting over where the
2677 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_press_event",
2678 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
2680 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_press_event",
2681 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
2683 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_release_event",
2684 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
2686 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_release_event",
2687 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
2689 // these handlers get notified when screen updates are required either when
2690 // scrolling or when the window size (and therefore scrollbar configuration)
2693 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
2694 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
2695 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
2696 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
2699 // Create input method handler
2700 m_imContext
= (GtkIMMulticontext
*) gtk_im_multicontext_new ();
2702 // Cannot handle drawing preedited text yet
2703 gtk_im_context_set_use_preedit( (GtkIMContext
*) m_imContext
, FALSE
);
2705 g_signal_connect (G_OBJECT (m_imContext
), "commit",
2706 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2709 gtk_widget_show( m_wxwindow
);
2712 m_parent
->DoAddChild( this );
2714 m_focusWidget
= m_wxwindow
;
2721 wxWindowGTK::~wxWindowGTK()
2725 if (g_focusWindow
== this)
2726 g_focusWindow
= NULL
;
2728 if (g_activeFrame
== this)
2729 g_activeFrame
= NULL
;
2731 if ( g_delayedFocus
== this )
2732 g_delayedFocus
= NULL
;
2734 m_isBeingDeleted
= TRUE
;
2744 gdk_ic_destroy (m_ic
);
2746 gdk_ic_attr_destroy (m_icattr
);
2751 gtk_widget_destroy( m_wxwindow
);
2752 m_wxwindow
= (GtkWidget
*) NULL
;
2757 gtk_widget_destroy( m_widget
);
2758 m_widget
= (GtkWidget
*) NULL
;
2762 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2764 wxCHECK_MSG( !m_needParent
|| parent
, FALSE
, wxT("Need complete parent.") );
2766 // Use either the given size, or the default if -1 is given.
2767 // See wxWindowBase for these functions.
2768 m_width
= WidthDefault(size
.x
) ;
2769 m_height
= HeightDefault(size
.y
);
2777 void wxWindowGTK::PostCreation()
2779 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2785 // these get reported to wxWidgets -> wxPaintEvent
2787 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow
), TRUE
);
2789 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "expose_event",
2790 GTK_SIGNAL_FUNC(gtk_window_expose_callback
), (gpointer
)this );
2793 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "draw",
2794 GTK_SIGNAL_FUNC(gtk_window_draw_callback
), (gpointer
)this );
2796 if (!HasFlag(wxFULL_REPAINT_ON_RESIZE
))
2798 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "event",
2799 GTK_SIGNAL_FUNC(gtk_window_event_event_callback
), (gpointer
)this );
2802 // gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), !HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
2806 // Create input method handler
2807 m_imContext
= (GtkIMMulticontext
*) gtk_im_multicontext_new ();
2809 // Cannot handle drawing preedited text yet
2810 gtk_im_context_set_use_preedit( (GtkIMContext
*) m_imContext
, FALSE
);
2812 g_signal_connect (G_OBJECT (m_imContext
), "commit",
2813 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2817 // these are called when the "sunken" or "raised" borders are drawn
2818 gtk_signal_connect( GTK_OBJECT(m_widget
), "expose_event",
2819 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback
), (gpointer
)this );
2822 gtk_signal_connect( GTK_OBJECT(m_widget
), "draw",
2823 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback
), (gpointer
)this );
2829 if (m_focusWidget
== NULL
)
2830 m_focusWidget
= m_widget
;
2832 gtk_signal_connect( GTK_OBJECT(m_focusWidget
), "focus_in_event",
2833 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback
), (gpointer
)this );
2835 gtk_signal_connect( GTK_OBJECT(m_focusWidget
), "focus_out_event",
2836 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback
), (gpointer
)this );
2838 // connect to the various key and mouse handlers
2840 GtkWidget
*connect_widget
= GetConnectWidget();
2842 ConnectWidget( connect_widget
);
2844 /* We cannot set colours, fonts and cursors before the widget has
2845 been realized, so we do this directly after realization */
2846 gtk_signal_connect( GTK_OBJECT(connect_widget
), "realize",
2847 GTK_SIGNAL_FUNC(gtk_window_realized_callback
), (gpointer
) this );
2851 // Catch native resize events
2852 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "size_allocate",
2853 GTK_SIGNAL_FUNC(gtk_window_size_callback
), (gpointer
)this );
2855 // Initialize XIM support
2856 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "realize",
2857 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback
), (gpointer
) this );
2859 // And resize XIM window
2860 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "size_allocate",
2861 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback
), (gpointer
)this );
2864 if ( !GTK_IS_COMBO(m_widget
))
2866 // This is needed if we want to add our windows into native
2867 // GTK control, such as the toolbar. With this callback, the
2868 // toolbar gets to know the correct size (the one set by the
2869 // programmer). Sadly, it misbehaves for wxComboBox. FIXME
2870 // when moving to GTK 2.0.
2871 gtk_signal_connect( GTK_OBJECT(m_widget
), "size_request",
2872 GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback
),
2878 // unless the window was created initially hidden (i.e. Hide() had been
2879 // called before Create()), we should show it at GTK+ level as well
2881 gtk_widget_show( m_widget
);
2884 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2886 gtk_signal_connect( GTK_OBJECT(widget
), "key_press_event",
2887 GTK_SIGNAL_FUNC(gtk_window_key_press_callback
), (gpointer
)this );
2889 gtk_signal_connect( GTK_OBJECT(widget
), "key_release_event",
2890 GTK_SIGNAL_FUNC(gtk_window_key_release_callback
), (gpointer
)this );
2892 gtk_signal_connect( GTK_OBJECT(widget
), "button_press_event",
2893 GTK_SIGNAL_FUNC(gtk_window_button_press_callback
), (gpointer
)this );
2895 gtk_signal_connect( GTK_OBJECT(widget
), "button_release_event",
2896 GTK_SIGNAL_FUNC(gtk_window_button_release_callback
), (gpointer
)this );
2898 gtk_signal_connect( GTK_OBJECT(widget
), "motion_notify_event",
2899 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback
), (gpointer
)this );
2902 gtk_signal_connect( GTK_OBJECT(widget
), "scroll_event",
2903 GTK_SIGNAL_FUNC(gtk_window_wheel_callback
), (gpointer
)this );
2906 gtk_signal_connect( GTK_OBJECT(widget
), "enter_notify_event",
2907 GTK_SIGNAL_FUNC(gtk_window_enter_callback
), (gpointer
)this );
2909 gtk_signal_connect( GTK_OBJECT(widget
), "leave_notify_event",
2910 GTK_SIGNAL_FUNC(gtk_window_leave_callback
), (gpointer
)this );
2913 bool wxWindowGTK::Destroy()
2915 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2919 return wxWindowBase::Destroy();
2922 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2924 gtk_pizza_set_size( GTK_PIZZA(m_parent
->m_wxwindow
), m_widget
, x
, y
, width
, height
);
2927 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2929 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2930 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2933 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
2936 if (m_resizing
) return; /* I don't like recursions */
2939 int currentX
, currentY
;
2940 GetPosition(¤tX
, ¤tY
);
2941 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2943 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2945 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2947 if (m_parent
->m_wxwindow
== NULL
) /* i.e. wxNotebook */
2949 /* don't set the size for children of wxNotebook, just take the values. */
2957 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
2958 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
2960 if (x
!= -1) m_x
= x
+ pizza
->xoffset
;
2961 if (y
!= -1) m_y
= y
+ pizza
->yoffset
;
2965 m_x
= x
+ pizza
->xoffset
;
2966 m_y
= y
+ pizza
->yoffset
;
2969 // calculate the best size if we should auto size the window
2970 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2971 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2973 const wxSize sizeBest
= GetBestSize();
2974 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2976 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2977 height
= sizeBest
.y
;
2985 int minWidth
= GetMinWidth(),
2986 minHeight
= GetMinHeight(),
2987 maxWidth
= GetMaxWidth(),
2988 maxHeight
= GetMaxHeight();
2990 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
2991 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
2992 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
2993 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
2996 int bottom_border
= 0;
2999 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
3001 /* the default button has a border around it */
3007 DoMoveWindow( m_x
-border
,
3010 m_height
+border
+bottom_border
);
3015 /* Sometimes the client area changes size without the
3016 whole windows's size changing, but if the whole
3017 windows's size doesn't change, no wxSizeEvent will
3018 normally be sent. Here we add an extra test if
3019 the client test has been changed and this will
3021 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
3025 wxPrintf( "OnSize sent from " );
3026 if (GetClassInfo() && GetClassInfo()->GetClassName())
3027 wxPrintf( GetClassInfo()->GetClassName() );
3028 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
3031 if (!m_nativeSizeEvent
)
3033 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
3034 event
.SetEventObject( this );
3035 GetEventHandler()->ProcessEvent( event
);
3041 void wxWindowGTK::OnInternalIdle()
3043 // Update invalidated regions.
3046 // Synthetize activate events.
3047 if ( g_sendActivateEvent
!= -1 )
3049 bool activate
= g_sendActivateEvent
!= 0;
3052 g_sendActivateEvent
= -1;
3054 wxTheApp
->SetActive(activate
, (wxWindow
*)g_focusWindowLast
);
3057 if ( g_activeFrameLostFocus
)
3059 if ( g_activeFrame
)
3061 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame
);
3062 wxActivateEvent
event(wxEVT_ACTIVATE
, FALSE
, g_activeFrame
->GetId());
3063 event
.SetEventObject(g_activeFrame
);
3064 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
3065 g_activeFrame
= NULL
;
3067 g_activeFrameLostFocus
= FALSE
;
3070 wxCursor cursor
= m_cursor
;
3071 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
3075 /* I now set the cursor anew in every OnInternalIdle call
3076 as setting the cursor in a parent window also effects the
3077 windows above so that checking for the current cursor is
3082 GdkWindow
*window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3084 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3086 if (!g_globalCursor
.Ok())
3087 cursor
= *wxSTANDARD_CURSOR
;
3089 window
= m_widget
->window
;
3090 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
3091 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3097 GdkWindow
*window
= m_widget
->window
;
3098 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
3099 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3104 if (wxUpdateUIEvent::CanUpdate(this))
3105 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
3108 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
3110 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3112 if (width
) (*width
) = m_width
;
3113 if (height
) (*height
) = m_height
;
3116 void wxWindowGTK::DoSetClientSize( int width
, int height
)
3118 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3122 SetSize( width
, height
);
3129 #ifndef __WXUNIVERSAL__
3130 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
3132 /* when using GTK 1.2 we set the shadow border size to 2 */
3136 if (HasFlag(wxSIMPLE_BORDER
))
3138 /* when using GTK 1.2 we set the simple border size to 1 */
3142 #endif // __WXUNIVERSAL__
3146 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
3148 GtkRequisition vscroll_req
;
3149 vscroll_req
.width
= 2;
3150 vscroll_req
.height
= 2;
3151 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
3152 (scroll_window
->vscrollbar
, &vscroll_req
);
3154 GtkRequisition hscroll_req
;
3155 hscroll_req
.width
= 2;
3156 hscroll_req
.height
= 2;
3157 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
3158 (scroll_window
->hscrollbar
, &hscroll_req
);
3160 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
3162 if (scroll_window
->vscrollbar_visible
)
3164 dw
+= vscroll_req
.width
;
3165 dw
+= scroll_class
->scrollbar_spacing
;
3168 if (scroll_window
->hscrollbar_visible
)
3170 dh
+= hscroll_req
.height
;
3171 dh
+= scroll_class
->scrollbar_spacing
;
3175 SetSize( width
+dw
, height
+dh
);
3179 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
3181 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3185 if (width
) (*width
) = m_width
;
3186 if (height
) (*height
) = m_height
;
3193 #ifndef __WXUNIVERSAL__
3194 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
3196 /* when using GTK 1.2 we set the shadow border size to 2 */
3200 if (HasFlag(wxSIMPLE_BORDER
))
3202 /* when using GTK 1.2 we set the simple border size to 1 */
3206 #endif // __WXUNIVERSAL__
3210 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
3212 GtkRequisition vscroll_req
;
3213 vscroll_req
.width
= 2;
3214 vscroll_req
.height
= 2;
3215 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
3216 (scroll_window
->vscrollbar
, &vscroll_req
);
3218 GtkRequisition hscroll_req
;
3219 hscroll_req
.width
= 2;
3220 hscroll_req
.height
= 2;
3221 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
3222 (scroll_window
->hscrollbar
, &hscroll_req
);
3224 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
3226 if (scroll_window
->vscrollbar_visible
)
3228 dw
+= vscroll_req
.width
;
3229 dw
+= scroll_class
->scrollbar_spacing
;
3232 if (scroll_window
->hscrollbar_visible
)
3234 dh
+= hscroll_req
.height
;
3235 dh
+= scroll_class
->scrollbar_spacing
;
3239 if (width
) (*width
) = m_width
- dw
;
3240 if (height
) (*height
) = m_height
- dh
;
3244 printf( "GetClientSize, name %s ", GetName().c_str() );
3245 if (width) printf( " width = %d", (*width) );
3246 if (height) printf( " height = %d", (*height) );
3251 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
3253 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3257 if (m_parent
&& m_parent
->m_wxwindow
)
3259 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
3260 dx
= pizza
->xoffset
;
3261 dy
= pizza
->yoffset
;
3264 if (x
) (*x
) = m_x
- dx
;
3265 if (y
) (*y
) = m_y
- dy
;
3268 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
3270 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3272 if (!m_widget
->window
) return;
3274 GdkWindow
*source
= (GdkWindow
*) NULL
;
3276 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3278 source
= m_widget
->window
;
3282 gdk_window_get_origin( source
, &org_x
, &org_y
);
3286 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3288 org_x
+= m_widget
->allocation
.x
;
3289 org_y
+= m_widget
->allocation
.y
;
3297 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
3299 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3301 if (!m_widget
->window
) return;
3303 GdkWindow
*source
= (GdkWindow
*) NULL
;
3305 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3307 source
= m_widget
->window
;
3311 gdk_window_get_origin( source
, &org_x
, &org_y
);
3315 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3317 org_x
+= m_widget
->allocation
.x
;
3318 org_y
+= m_widget
->allocation
.y
;
3326 bool wxWindowGTK::Show( bool show
)
3328 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3330 if (!wxWindowBase::Show(show
))
3337 gtk_widget_show( m_widget
);
3339 gtk_widget_hide( m_widget
);
3341 wxShowEvent
eventShow(GetId(), show
);
3342 eventShow
.m_eventObject
= this;
3344 GetEventHandler()->ProcessEvent(eventShow
);
3349 static void wxWindowNotifyEnable(wxWindowGTK
* win
, bool enable
)
3351 win
->OnParentEnable(enable
);
3353 // Recurse, so that children have the opportunity to Do The Right Thing
3354 // and reset colours that have been messed up by a parent's (really ancestor's)
3356 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
3358 node
= node
->GetNext() )
3360 wxWindow
*child
= node
->GetData();
3361 if (!child
->IsKindOf(CLASSINFO(wxDialog
)) && !child
->IsKindOf(CLASSINFO(wxFrame
)))
3362 wxWindowNotifyEnable(child
, enable
);
3366 bool wxWindowGTK::Enable( bool enable
)
3368 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3370 if (!wxWindowBase::Enable(enable
))
3376 gtk_widget_set_sensitive( m_widget
, enable
);
3378 gtk_widget_set_sensitive( m_wxwindow
, enable
);
3380 wxWindowNotifyEnable(this, enable
);
3385 int wxWindowGTK::GetCharHeight() const
3387 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
3389 wxFont font
= GetFont();
3390 wxCHECK_MSG( font
.Ok(), 12, wxT("invalid font") );
3393 PangoContext
*context
= NULL
;
3395 context
= gtk_widget_get_pango_context( m_widget
);
3400 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3401 PangoLayout
*layout
= pango_layout_new(context
);
3402 pango_layout_set_font_description(layout
, desc
);
3403 pango_layout_set_text(layout
, "H", 1);
3404 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3406 PangoRectangle rect
;
3407 pango_layout_line_get_extents(line
, NULL
, &rect
);
3409 g_object_unref( G_OBJECT( layout
) );
3411 return (int) (rect
.height
/ PANGO_SCALE
);
3413 GdkFont
*gfont
= font
.GetInternalFont( 1.0 );
3415 return gfont
->ascent
+ gfont
->descent
;
3419 int wxWindowGTK::GetCharWidth() const
3421 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
3423 wxFont font
= GetFont();
3424 wxCHECK_MSG( font
.Ok(), 8, wxT("invalid font") );
3427 PangoContext
*context
= NULL
;
3429 context
= gtk_widget_get_pango_context( m_widget
);
3434 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3435 PangoLayout
*layout
= pango_layout_new(context
);
3436 pango_layout_set_font_description(layout
, desc
);
3437 pango_layout_set_text(layout
, "g", 1);
3438 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3440 PangoRectangle rect
;
3441 pango_layout_line_get_extents(line
, NULL
, &rect
);
3443 g_object_unref( G_OBJECT( layout
) );
3445 return (int) (rect
.width
/ PANGO_SCALE
);
3447 GdkFont
*gfont
= font
.GetInternalFont( 1.0 );
3449 return gdk_string_width( gfont
, "g" );
3453 void wxWindowGTK::GetTextExtent( const wxString
& string
,
3457 int *externalLeading
,
3458 const wxFont
*theFont
) const
3460 wxFont fontToUse
= theFont
? *theFont
: GetFont();
3462 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
3464 if (string
.IsEmpty())
3472 PangoContext
*context
= NULL
;
3474 context
= gtk_widget_get_pango_context( m_widget
);
3483 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3484 PangoLayout
*layout
= pango_layout_new(context
);
3485 pango_layout_set_font_description(layout
, desc
);
3488 const wxCharBuffer data
= wxConvUTF8
.cWC2MB( string
);
3489 pango_layout_set_text(layout
, (const char*) data
, strlen( (const char*) data
));
3491 const wxWCharBuffer wdata
= wxConvLocal
.cMB2WC( string
);
3492 const wxCharBuffer data
= wxConvUTF8
.cWC2MB( wdata
);
3493 pango_layout_set_text(layout
, (const char*) data
, strlen( (const char*) data
));
3496 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3498 PangoRectangle rect
;
3499 pango_layout_line_get_extents(line
, NULL
, &rect
);
3501 if (x
) (*x
) = (wxCoord
) (rect
.width
/ PANGO_SCALE
);
3502 if (y
) (*y
) = (wxCoord
) (rect
.height
/ PANGO_SCALE
);
3505 // Do something about metrics here
3508 if (externalLeading
) (*externalLeading
) = 0; // ??
3510 g_object_unref( G_OBJECT( layout
) );
3512 GdkFont
*font
= fontToUse
.GetInternalFont( 1.0 );
3513 if (x
) (*x
) = gdk_string_width( font
, wxGTK_CONV( string
) );
3514 if (y
) (*y
) = font
->ascent
+ font
->descent
;
3515 if (descent
) (*descent
) = font
->descent
;
3516 if (externalLeading
) (*externalLeading
) = 0; // ??
3520 void wxWindowGTK::SetFocus()
3522 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3526 // don't do anything if we already have focus
3532 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow
))
3534 gtk_widget_grab_focus (m_wxwindow
);
3539 if (GTK_WIDGET_CAN_FOCUS(m_widget
) && !GTK_WIDGET_HAS_FOCUS (m_widget
) )
3541 if (!GTK_WIDGET_REALIZED(m_widget
))
3543 // we can't set the focus to the widget now so we remember that
3544 // it should be focused and will do it later, during the idle
3545 // time, as soon as we can
3546 wxLogTrace(TRACE_FOCUS
,
3547 _T("Delaying setting focus to %s(%s)"),
3548 GetClassInfo()->GetClassName(), GetLabel().c_str());
3550 g_delayedFocus
= this;
3554 wxLogTrace(TRACE_FOCUS
,
3555 _T("Setting focus to %s(%s)"),
3556 GetClassInfo()->GetClassName(), GetLabel().c_str());
3558 gtk_widget_grab_focus (m_widget
);
3561 else if (GTK_IS_CONTAINER(m_widget
))
3563 SET_CONTAINER_FOCUS( m_widget
, GTK_DIR_TAB_FORWARD
);
3567 wxLogTrace(TRACE_FOCUS
,
3568 _T("Can't set focus to %s(%s)"),
3569 GetClassInfo()->GetClassName(), GetLabel().c_str());
3574 bool wxWindowGTK::AcceptsFocus() const
3576 return m_acceptsFocus
&& wxWindowBase::AcceptsFocus();
3579 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3581 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3583 wxWindowGTK
*oldParent
= m_parent
,
3584 *newParent
= (wxWindowGTK
*)newParentBase
;
3586 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3588 if ( !wxWindowBase::Reparent(newParent
) )
3591 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3593 /* prevent GTK from deleting the widget arbitrarily */
3594 gtk_widget_ref( m_widget
);
3598 gtk_container_remove( GTK_CONTAINER(m_widget
->parent
), m_widget
);
3601 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3605 /* insert GTK representation */
3606 (*(newParent
->m_insertCallback
))(newParent
, this);
3609 /* reverse: prevent GTK from deleting the widget arbitrarily */
3610 gtk_widget_unref( m_widget
);
3615 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3617 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3619 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3621 wxASSERT_MSG( (m_insertCallback
!= NULL
), wxT("invalid child insertion function") );
3626 /* insert GTK representation */
3627 (*m_insertCallback
)(this, child
);
3630 void wxWindowGTK::Raise()
3632 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3634 if (!m_widget
->window
) return;
3636 gdk_window_raise( m_widget
->window
);
3639 void wxWindowGTK::Lower()
3641 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3643 if (!m_widget
->window
) return;
3645 gdk_window_lower( m_widget
->window
);
3648 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3650 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3652 if (cursor
== m_cursor
)
3656 wxapp_install_idle_handler();
3658 if (cursor
== wxNullCursor
)
3659 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR
);
3661 return wxWindowBase::SetCursor( cursor
);
3664 void wxWindowGTK::WarpPointer( int x
, int y
)
3666 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3668 // We provide this function ourselves as it is
3669 // missing in GDK (top of this file).
3671 GdkWindow
*window
= (GdkWindow
*) NULL
;
3673 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3675 window
= GetConnectWidget()->window
;
3678 gdk_window_warp_pointer( window
, x
, y
);
3682 void wxWindowGTK::Refresh( bool eraseBackground
, const wxRect
*rect
)
3684 if (!m_widget
) return;
3685 if (!m_widget
->window
) return;
3689 wxapp_install_idle_handler();
3691 wxRect
myRect(0,0,0,0);
3692 if (m_wxwindow
&& rect
)
3694 myRect
.SetSize(wxSize( m_wxwindow
->allocation
.width
,
3695 m_wxwindow
->allocation
.height
));
3696 myRect
.Intersect(*rect
);
3697 if (!myRect
.width
|| !myRect
.height
)
3698 // nothing to do, rectangle is empty
3703 if (eraseBackground
&& m_wxwindow
&& m_wxwindow
->window
)
3707 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3708 m_clearRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3712 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3713 m_clearRegion
.Clear();
3714 m_clearRegion
.Union( 0, 0, m_wxwindow
->allocation
.width
, m_wxwindow
->allocation
.height
);
3722 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3723 m_updateRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3727 GdkRectangle gdk_rect
;
3728 gdk_rect
.x
= rect
->x
;
3729 gdk_rect
.y
= rect
->y
;
3730 gdk_rect
.width
= rect
->width
;
3731 gdk_rect
.height
= rect
->height
;
3732 gtk_widget_draw( m_widget
, &gdk_rect
);
3739 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3740 m_updateRegion
.Clear();
3741 m_updateRegion
.Union( 0, 0, m_wxwindow
->allocation
.width
, m_wxwindow
->allocation
.height
);
3745 gtk_widget_draw( m_widget
, (GdkRectangle
*) NULL
);
3753 GdkRectangle gdk_rect
;
3754 gdk_rect
.x
= rect
->x
;
3755 gdk_rect
.y
= rect
->y
;
3756 gdk_rect
.width
= rect
->width
;
3757 gdk_rect
.height
= rect
->height
;
3758 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, &gdk_rect
, TRUE
);
3762 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, NULL
, TRUE
);
3768 void wxWindowGTK::Update()
3773 void wxWindowGTK::GtkUpdate()
3776 if (m_wxwindow
&& GTK_PIZZA(m_wxwindow
)->bin_window
)
3777 gdk_window_process_updates( GTK_PIZZA(m_wxwindow
)->bin_window
, FALSE
);
3779 if (!m_updateRegion
.IsEmpty())
3780 GtkSendPaintEvents();
3784 void wxWindowGTK::GtkSendPaintEvents()
3789 m_clearRegion
.Clear();
3791 m_updateRegion
.Clear();
3795 // Clip to paint region in wxClientDC
3796 m_clipPaintRegion
= TRUE
;
3798 // widget to draw on
3799 GtkPizza
*pizza
= GTK_PIZZA (m_wxwindow
);
3801 if (GetThemeEnabled())
3803 // find ancestor from which to steal background
3804 wxWindow
*parent
= GetParent();
3805 while (parent
&& !parent
->IsTopLevel())
3806 parent
= parent
->GetParent();
3808 parent
= (wxWindow
*)this;
3810 wxRegionIterator
upd( m_updateRegion
);
3814 rect
.x
= upd
.GetX();
3815 rect
.y
= upd
.GetY();
3816 rect
.width
= upd
.GetWidth();
3817 rect
.height
= upd
.GetHeight();
3819 gtk_paint_flat_box( parent
->m_widget
->style
,
3821 (GtkStateType
)GTK_WIDGET_STATE(m_wxwindow
),
3835 wxWindowDC
dc( (wxWindow
*)this );
3836 dc
.SetClippingRegion( m_updateRegion
);
3838 wxEraseEvent
erase_event( GetId(), &dc
);
3839 erase_event
.SetEventObject( this );
3841 GetEventHandler()->ProcessEvent(erase_event
);
3844 // if (!m_clearRegion.IsEmpty()) // Always send an erase event under GTK 1.2
3846 wxWindowDC
dc( (wxWindow
*)this );
3847 if (m_clearRegion
.IsEmpty())
3848 dc
.SetClippingRegion( m_updateRegion
);
3850 dc
.SetClippingRegion( m_clearRegion
);
3852 wxEraseEvent
erase_event( GetId(), &dc
);
3853 erase_event
.SetEventObject( this );
3855 if (!GetEventHandler()->ProcessEvent(erase_event
))
3859 g_eraseGC
= gdk_gc_new( pizza
->bin_window
);
3860 gdk_gc_set_fill( g_eraseGC
, GDK_SOLID
);
3862 gdk_gc_set_foreground( g_eraseGC
, GetBackgroundColour().GetColor() );
3864 wxRegionIterator
upd( m_clearRegion
);
3867 gdk_draw_rectangle( pizza
->bin_window
, g_eraseGC
, 1,
3868 upd
.GetX(), upd
.GetY(), upd
.GetWidth(), upd
.GetHeight() );
3872 m_clearRegion
.Clear();
3876 wxNcPaintEvent
nc_paint_event( GetId() );
3877 nc_paint_event
.SetEventObject( this );
3878 GetEventHandler()->ProcessEvent( nc_paint_event
);
3880 wxPaintEvent
paint_event( GetId() );
3881 paint_event
.SetEventObject( this );
3882 GetEventHandler()->ProcessEvent( paint_event
);
3884 m_clipPaintRegion
= FALSE
;
3886 #ifndef __WXUNIVERSAL__
3888 // The following code will result in all window-less widgets
3889 // being redrawn because the wxWidgets class is allowed to
3890 // paint over the window-less widgets.
3892 GList
*children
= pizza
->children
;
3895 GtkPizzaChild
*child
= (GtkPizzaChild
*) children
->data
;
3896 children
= children
->next
;
3898 if (GTK_WIDGET_NO_WINDOW (child
->widget
) &&
3899 GTK_WIDGET_DRAWABLE (child
->widget
))
3901 // Get intersection of widget area and update region
3902 wxRegion
region( m_updateRegion
);
3904 GdkEventExpose gdk_event
;
3905 gdk_event
.type
= GDK_EXPOSE
;
3906 gdk_event
.window
= pizza
->bin_window
;
3907 gdk_event
.count
= 0;
3909 wxRegionIterator
upd( m_updateRegion
);
3913 rect
.x
= upd
.GetX();
3914 rect
.y
= upd
.GetY();
3915 rect
.width
= upd
.GetWidth();
3916 rect
.height
= upd
.GetHeight();
3918 if (gtk_widget_intersect (child
->widget
, &rect
, &gdk_event
.area
))
3920 gtk_widget_event (child
->widget
, (GdkEvent
*) &gdk_event
);
3930 m_updateRegion
.Clear();
3933 void wxWindowGTK::ClearBackground()
3935 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3938 if (m_wxwindow
&& m_wxwindow
->window
)
3940 m_clearRegion
.Clear();
3941 wxSize
size( GetClientSize() );
3942 m_clearRegion
.Union( 0,0,size
.x
,size
.y
);
3944 // Better do this in idle?
3951 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3953 wxWindowBase::DoSetToolTip(tip
);
3956 m_tooltip
->Apply( (wxWindow
*)this );
3959 void wxWindowGTK::ApplyToolTip( GtkTooltips
*tips
, const wxChar
*tip
)
3961 wxString
tmp( tip
);
3962 gtk_tooltips_set_tip( tips
, GetConnectWidget(), wxGTK_CONV(tmp
), (gchar
*) NULL
);
3964 #endif // wxUSE_TOOLTIPS
3966 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
3968 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
3970 if (!wxWindowBase::SetBackgroundColour(colour
))
3975 // We need the pixel value e.g. for background clearing.
3976 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3979 // apply style change (forceStyle=true so that new style is applied
3980 // even if the bg colour changed from valid to wxNullColour):
3981 ApplyWidgetStyle(true);
3986 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
3988 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
3990 if (!wxWindowBase::SetForegroundColour(colour
))
3997 // We need the pixel value e.g. for background clearing.
3998 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
4001 // apply style change (forceStyle=true so that new style is applied
4002 // even if the bg colour changed from valid to wxNullColour):
4003 ApplyWidgetStyle(true);
4009 PangoContext
*wxWindowGTK::GtkGetPangoDefaultContext()
4011 return gtk_widget_get_pango_context( m_widget
);
4014 PangoContext
*wxWindowGTK::GtkGetPangoX11Context()
4017 m_x11Context
= pango_x_get_context( gdk_display
);
4019 return m_x11Context
;
4023 GtkRcStyle
*wxWindowGTK::CreateWidgetStyle(bool forceStyle
)
4025 // do we need to apply any changes at all?
4027 !m_hasFont
&& !m_hasFgCol
&&
4028 (!m_hasBgCol
|| !m_backgroundColour
.Ok()) )
4033 GtkRcStyle
*style
= gtk_rc_style_new();
4039 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
4041 wxString xfontname
= m_font
.GetNativeFontInfo()->GetXFontName();
4042 style
->fontset_name
= g_strdup(xfontname
.c_str());
4046 if ( m_foregroundColour
.Ok() )
4048 GdkColor
*fg
= m_foregroundColour
.GetColor();
4050 style
->fg
[GTK_STATE_NORMAL
] = *fg
;
4051 style
->color_flags
[GTK_STATE_NORMAL
] = GTK_RC_FG
;
4053 style
->fg
[GTK_STATE_PRELIGHT
] = *fg
;
4054 style
->color_flags
[GTK_STATE_PRELIGHT
] = GTK_RC_FG
;
4056 style
->fg
[GTK_STATE_ACTIVE
] = *fg
;
4057 style
->color_flags
[GTK_STATE_ACTIVE
] = GTK_RC_FG
;
4060 if ( m_backgroundColour
.Ok() )
4062 GdkColor
*bg
= m_backgroundColour
.GetColor();
4064 style
->bg
[GTK_STATE_NORMAL
] = *bg
;
4065 style
->base
[GTK_STATE_NORMAL
] = *bg
;
4066 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)
4067 (style
->color_flags
[GTK_STATE_NORMAL
] | GTK_RC_BG
| GTK_RC_BASE
);
4069 style
->bg
[GTK_STATE_PRELIGHT
] = *bg
;
4070 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
4071 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)
4072 (style
->color_flags
[GTK_STATE_PRELIGHT
] | GTK_RC_BG
| GTK_RC_BASE
);
4074 style
->bg
[GTK_STATE_ACTIVE
] = *bg
;
4075 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
4076 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)
4077 (style
->color_flags
[GTK_STATE_ACTIVE
] | GTK_RC_BG
| GTK_RC_BASE
);
4079 style
->bg
[GTK_STATE_INSENSITIVE
] = *bg
;
4080 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
4081 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)
4082 (style
->color_flags
[GTK_STATE_INSENSITIVE
] | GTK_RC_BG
| GTK_RC_BASE
);
4088 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle
)
4090 GtkRcStyle
*style
= CreateWidgetStyle(forceStyle
);
4093 DoApplyWidgetStyle(style
);
4094 gtk_rc_style_unref(style
);
4098 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
4101 // should we also do m_widget in this case?
4102 gtk_widget_modify_style(m_wxwindow
, style
);
4104 gtk_widget_modify_style(m_widget
, style
);
4108 //-----------------------------------------------------------------------------
4109 // Pop-up menu stuff
4110 //-----------------------------------------------------------------------------
4112 #if wxUSE_MENUS_NATIVE
4115 void gtk_pop_hide_callback( GtkWidget
*WXUNUSED(widget
), bool* is_waiting
)
4117 *is_waiting
= FALSE
;
4120 static void SetInvokingWindow( wxMenu
*menu
, wxWindowGTK
*win
)
4122 menu
->SetInvokingWindow( win
);
4123 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
4126 wxMenuItem
*menuitem
= node
->GetData();
4127 if (menuitem
->IsSubMenu())
4129 SetInvokingWindow( menuitem
->GetSubMenu(), win
);
4132 node
= node
->GetNext();
4136 extern "C" void wxPopupMenuPositionCallback( GtkMenu
*menu
,
4139 gboolean
* WXUNUSED(whatever
),
4141 gpointer user_data
)
4143 // ensure that the menu appears entirely on screen
4145 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
4147 wxSize sizeScreen
= wxGetDisplaySize();
4148 wxPoint
*pos
= (wxPoint
*)user_data
;
4150 gint xmax
= sizeScreen
.x
- req
.width
,
4151 ymax
= sizeScreen
.y
- req
.height
;
4153 *x
= pos
->x
< xmax
? pos
->x
: xmax
;
4154 *y
= pos
->y
< ymax
? pos
->y
: ymax
;
4157 bool wxWindowGTK::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
4159 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4161 wxCHECK_MSG( menu
!= NULL
, false, wxT("invalid popup-menu") );
4163 SetInvokingWindow( menu
, this );
4167 bool is_waiting
= true;
4169 gtk_signal_connect( GTK_OBJECT(menu
->m_menu
),
4171 GTK_SIGNAL_FUNC(gtk_pop_hide_callback
),
4172 (gpointer
)&is_waiting
);
4176 GtkMenuPositionFunc posfunc
;
4177 if ( x
== -1 && y
== -1 )
4179 // use GTK's default positioning algorithm
4185 pos
= ClientToScreen(wxPoint(x
, y
));
4187 posfunc
= wxPopupMenuPositionCallback
;
4191 GTK_MENU(menu
->m_menu
),
4192 (GtkWidget
*) NULL
, // parent menu shell
4193 (GtkWidget
*) NULL
, // parent menu item
4194 posfunc
, // function to position it
4195 userdata
, // client data
4196 0, // button used to activate it
4198 gtk_get_current_event_time()
4200 gs_timeLastClick
// the time of activation
4206 gtk_main_iteration();
4212 #endif // wxUSE_MENUS_NATIVE
4214 #if wxUSE_DRAG_AND_DROP
4216 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4218 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4220 GtkWidget
*dnd_widget
= GetConnectWidget();
4222 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
4224 if (m_dropTarget
) delete m_dropTarget
;
4225 m_dropTarget
= dropTarget
;
4227 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
4230 #endif // wxUSE_DRAG_AND_DROP
4232 GtkWidget
* wxWindowGTK::GetConnectWidget()
4234 GtkWidget
*connect_widget
= m_widget
;
4235 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4237 return connect_widget
;
4240 bool wxWindowGTK::IsOwnGtkWindow( GdkWindow
*window
)
4243 return (window
== GTK_PIZZA(m_wxwindow
)->bin_window
);
4245 return (window
== m_widget
->window
);
4248 bool wxWindowGTK::SetFont( const wxFont
&font
)
4250 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
4252 if (!wxWindowBase::SetFont(font
))
4255 // apply style change (forceStyle=true so that new style is applied
4256 // even if the font changed from valid to wxNullFont):
4257 ApplyWidgetStyle(true);
4262 void wxWindowGTK::DoCaptureMouse()
4264 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4266 GdkWindow
*window
= (GdkWindow
*) NULL
;
4268 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4270 window
= GetConnectWidget()->window
;
4272 wxCHECK_RET( window
, _T("CaptureMouse() failed") );
4274 wxCursor
* cursor
= & m_cursor
;
4276 cursor
= wxSTANDARD_CURSOR
;
4278 gdk_pointer_grab( window
, FALSE
,
4280 (GDK_BUTTON_PRESS_MASK
|
4281 GDK_BUTTON_RELEASE_MASK
|
4282 GDK_POINTER_MOTION_HINT_MASK
|
4283 GDK_POINTER_MOTION_MASK
),
4285 cursor
->GetCursor(),
4286 (guint32
)GDK_CURRENT_TIME
);
4287 g_captureWindow
= this;
4288 g_captureWindowHasMouse
= TRUE
;
4291 void wxWindowGTK::DoReleaseMouse()
4293 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4295 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4297 g_captureWindow
= (wxWindowGTK
*) NULL
;
4299 GdkWindow
*window
= (GdkWindow
*) NULL
;
4301 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4303 window
= GetConnectWidget()->window
;
4308 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4312 wxWindow
*wxWindowBase::GetCapture()
4314 return (wxWindow
*)g_captureWindow
;
4317 bool wxWindowGTK::IsRetained() const
4322 void wxWindowGTK::SetScrollbar( int orient
, int pos
, int thumbVisible
,
4323 int range
, bool refresh
)
4325 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4327 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4329 m_hasScrolling
= TRUE
;
4331 if (orient
== wxHORIZONTAL
)
4333 float fpos
= (float)pos
;
4334 float frange
= (float)range
;
4335 float fthumb
= (float)thumbVisible
;
4336 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
4337 if (fpos
< 0.0) fpos
= 0.0;
4339 if ((fabs(frange
-m_hAdjust
->upper
) < 0.2) &&
4340 (fabs(fthumb
-m_hAdjust
->page_size
) < 0.2))
4342 SetScrollPos( orient
, pos
, refresh
);
4346 m_oldHorizontalPos
= fpos
;
4348 m_hAdjust
->lower
= 0.0;
4349 m_hAdjust
->upper
= frange
;
4350 m_hAdjust
->value
= fpos
;
4351 m_hAdjust
->step_increment
= 1.0;
4352 m_hAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
4353 m_hAdjust
->page_size
= fthumb
;
4357 float fpos
= (float)pos
;
4358 float frange
= (float)range
;
4359 float fthumb
= (float)thumbVisible
;
4360 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
4361 if (fpos
< 0.0) fpos
= 0.0;
4363 if ((fabs(frange
-m_vAdjust
->upper
) < 0.2) &&
4364 (fabs(fthumb
-m_vAdjust
->page_size
) < 0.2))
4366 SetScrollPos( orient
, pos
, refresh
);
4370 m_oldVerticalPos
= fpos
;
4372 m_vAdjust
->lower
= 0.0;
4373 m_vAdjust
->upper
= frange
;
4374 m_vAdjust
->value
= fpos
;
4375 m_vAdjust
->step_increment
= 1.0;
4376 m_vAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
4377 m_vAdjust
->page_size
= fthumb
;
4380 if (orient
== wxHORIZONTAL
)
4381 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
4383 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
4386 void wxWindowGTK::SetScrollPos( int orient
, int pos
, bool WXUNUSED(refresh
) )
4388 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4390 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4392 if (orient
== wxHORIZONTAL
)
4394 float fpos
= (float)pos
;
4395 if (fpos
> m_hAdjust
->upper
- m_hAdjust
->page_size
) fpos
= m_hAdjust
->upper
- m_hAdjust
->page_size
;
4396 if (fpos
< 0.0) fpos
= 0.0;
4397 m_oldHorizontalPos
= fpos
;
4399 if (fabs(fpos
-m_hAdjust
->value
) < 0.2) return;
4400 m_hAdjust
->value
= fpos
;
4404 float fpos
= (float)pos
;
4405 if (fpos
> m_vAdjust
->upper
- m_vAdjust
->page_size
) fpos
= m_vAdjust
->upper
- m_vAdjust
->page_size
;
4406 if (fpos
< 0.0) fpos
= 0.0;
4407 m_oldVerticalPos
= fpos
;
4409 if (fabs(fpos
-m_vAdjust
->value
) < 0.2) return;
4410 m_vAdjust
->value
= fpos
;
4413 if (m_wxwindow
->window
)
4415 if (orient
== wxHORIZONTAL
)
4417 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust
),
4418 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
4420 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "value_changed" );
4422 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
4423 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
4427 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust
),
4428 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
4430 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "value_changed" );
4432 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
4433 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
4438 int wxWindowGTK::GetScrollThumb( int orient
) const
4440 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4442 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4444 if (orient
== wxHORIZONTAL
)
4445 return (int)(m_hAdjust
->page_size
+0.5);
4447 return (int)(m_vAdjust
->page_size
+0.5);
4450 int wxWindowGTK::GetScrollPos( int orient
) const
4452 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4454 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4456 if (orient
== wxHORIZONTAL
)
4457 return (int)(m_hAdjust
->value
+0.5);
4459 return (int)(m_vAdjust
->value
+0.5);
4462 int wxWindowGTK::GetScrollRange( int orient
) const
4464 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4466 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4468 if (orient
== wxHORIZONTAL
)
4469 return (int)(m_hAdjust
->upper
+0.5);
4471 return (int)(m_vAdjust
->upper
+0.5);
4474 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4476 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4478 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4480 // No scrolling requested.
4481 if ((dx
== 0) && (dy
== 0)) return;
4484 if (!m_updateRegion
.IsEmpty())
4486 m_updateRegion
.Offset( dx
, dy
);
4490 GetClientSize( &cw
, &ch
);
4491 m_updateRegion
.Intersect( 0, 0, cw
, ch
);
4494 if (!m_clearRegion
.IsEmpty())
4496 m_clearRegion
.Offset( dx
, dy
);
4500 GetClientSize( &cw
, &ch
);
4501 m_clearRegion
.Intersect( 0, 0, cw
, ch
);
4505 m_clipPaintRegion
= TRUE
;
4507 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), -dx
, -dy
);
4509 m_clipPaintRegion
= FALSE
;
4513 // Find the wxWindow at the current mouse position, also returning the mouse
4515 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4517 pt
= wxGetMousePosition();
4518 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4522 // Get the current mouse position.
4523 wxPoint
wxGetMousePosition()
4525 /* This crashes when used within wxHelpContext,
4526 so we have to use the X-specific implementation below.
4528 GdkModifierType *mask;
4529 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4531 return wxPoint(x, y);
4535 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4537 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4538 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4539 Window rootReturn
, childReturn
;
4540 int rootX
, rootY
, winX
, winY
;
4541 unsigned int maskReturn
;
4543 XQueryPointer (display
,
4547 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4548 return wxPoint(rootX
, rootY
);
4552 // ----------------------------------------------------------------------------
4554 // ----------------------------------------------------------------------------
4556 class wxWinModule
: public wxModule
4563 DECLARE_DYNAMIC_CLASS(wxWinModule
)
4566 IMPLEMENT_DYNAMIC_CLASS(wxWinModule
, wxModule
)
4568 bool wxWinModule::OnInit()
4570 // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
4571 // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
4576 void wxWinModule::OnExit()
4579 gdk_gc_unref( g_eraseGC
);