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(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
;
1278 unistr
[0] = g_utf8_get_char(str
);
1280 wxCharBuffer
ansistr(wxConvLocal
.cWC2MB(unistr
));
1281 // We cannot handle characters that cannot be represented in
1282 // current locale's charset in non-Unicode mode:
1283 if (ansistr
.data() == NULL
) return;
1285 event
.m_keyCode
= ansistr
[0u];
1289 // TODO: We still need to set all the extra attributes of the
1290 // event, modifiers and such...
1293 // Implement OnCharHook by checking ancestor top level windows
1294 wxWindow
*parent
= window
;
1295 while (parent
&& !parent
->IsTopLevel())
1296 parent
= parent
->GetParent();
1299 event
.SetEventType( wxEVT_CHAR_HOOK
);
1300 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1305 event
.SetEventType(wxEVT_CHAR
);
1306 ret
= window
->GetEventHandler()->ProcessEvent( event
);
1312 //-----------------------------------------------------------------------------
1313 // "key_release_event" from any window
1314 //-----------------------------------------------------------------------------
1316 static gint
gtk_window_key_release_callback( GtkWidget
*widget
,
1317 GdkEventKey
*gdk_event
,
1323 wxapp_install_idle_handler();
1328 if (g_blockEventsOnDrag
)
1331 wxKeyEvent
event( wxEVT_KEY_UP
);
1332 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1334 // unknown key pressed, ignore (the event would be useless anyhow
1338 if ( !win
->GetEventHandler()->ProcessEvent( event
) )
1341 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_release_event" );
1345 // ============================================================================
1347 // ============================================================================
1349 // ----------------------------------------------------------------------------
1350 // mouse event processing helpers
1351 // ----------------------------------------------------------------------------
1353 // init wxMouseEvent with the info from GdkEventXXX struct
1354 template<typename T
> void InitMouseEvent(wxWindowGTK
*win
,
1355 wxMouseEvent
& event
,
1358 event
.SetTimestamp( gdk_event
->time
);
1359 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1360 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1361 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1362 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1363 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1364 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1365 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1366 if (event
.GetEventType() == wxEVT_MOUSEWHEEL
)
1368 event
.m_linesPerAction
= 3;
1369 if (((GdkEventButton
*)gdk_event
)->button
== 4)
1370 event
.m_wheelRotation
= 120;
1371 else if (((GdkEventButton
*)gdk_event
)->button
== 5)
1372 event
.m_wheelRotation
= -120;
1375 wxPoint pt
= win
->GetClientAreaOrigin();
1376 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1377 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1379 event
.SetEventObject( win
);
1380 event
.SetId( win
->GetId() );
1381 event
.SetTimestamp( gdk_event
->time
);
1384 static void AdjustEventButtonState(wxMouseEvent
& event
)
1386 // GDK reports the old state of the button for a button press event, but
1387 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1388 // for a LEFT_DOWN event, not FALSE, so we will invert
1389 // left/right/middleDown for the corresponding click events
1391 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1392 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1393 (event
.GetEventType() == wxEVT_LEFT_UP
))
1395 event
.m_leftDown
= !event
.m_leftDown
;
1399 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1400 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1401 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1403 event
.m_middleDown
= !event
.m_middleDown
;
1407 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1408 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1409 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1411 event
.m_rightDown
= !event
.m_rightDown
;
1416 // find the window to send the mouse event too
1418 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1423 if (win
->m_wxwindow
)
1425 GtkPizza
*pizza
= GTK_PIZZA(win
->m_wxwindow
);
1426 xx
+= pizza
->xoffset
;
1427 yy
+= pizza
->yoffset
;
1430 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
1433 wxWindowGTK
*child
= node
->GetData();
1435 node
= node
->GetNext();
1436 if (!child
->IsShown())
1439 if (child
->IsTransparentForMouse())
1441 // wxStaticBox is transparent in the box itself
1442 int xx1
= child
->m_x
;
1443 int yy1
= child
->m_y
;
1444 int xx2
= child
->m_x
+ child
->m_width
;
1445 int yy2
= child
->m_y
+ child
->m_height
;
1448 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1450 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1452 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1454 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1465 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1466 (child
->m_x
<= xx
) &&
1467 (child
->m_y
<= yy
) &&
1468 (child
->m_x
+child
->m_width
>= xx
) &&
1469 (child
->m_y
+child
->m_height
>= yy
))
1482 //-----------------------------------------------------------------------------
1483 // "button_press_event"
1484 //-----------------------------------------------------------------------------
1486 static gint
gtk_window_button_press_callback( GtkWidget
*widget
,
1487 GdkEventButton
*gdk_event
,
1493 wxapp_install_idle_handler();
1496 wxPrintf( wxT("1) OnButtonPress from ") );
1497 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1498 wxPrintf( win->GetClassInfo()->GetClassName() );
1499 wxPrintf( wxT(".\n") );
1501 if (!win
->m_hasVMT
) return FALSE
;
1502 if (g_blockEventsOnDrag
) return TRUE
;
1503 if (g_blockEventsOnScroll
) return TRUE
;
1505 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1507 if (win
->m_wxwindow
&& (g_focusWindow
!= win
) && win
->AcceptsFocus())
1509 gtk_widget_grab_focus( win
->m_wxwindow
);
1511 wxPrintf( wxT("GrabFocus from ") );
1512 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1513 wxPrintf( win->GetClassInfo()->GetClassName() );
1514 wxPrintf( wxT(".\n") );
1518 // GDK sends surplus button down event
1519 // before a double click event. We
1520 // need to filter these out.
1521 if (gdk_event
->type
== GDK_BUTTON_PRESS
)
1523 GdkEvent
*peek_event
= gdk_event_peek();
1526 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1527 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1529 gdk_event_free( peek_event
);
1534 gdk_event_free( peek_event
);
1539 wxEventType event_type
= wxEVT_NULL
;
1541 // GdkDisplay is a GTK+ 2.2.0 thing
1542 #if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0)
1543 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1544 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1546 // Reset GDK internal timestamp variables in order to disable GDK
1547 // triple click events. GDK will then next time believe no button has
1548 // been clicked just before, and send a normal button click event.
1549 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1550 display
->button_click_time
[1] = 0;
1551 display
->button_click_time
[0] = 0;
1555 if (gdk_event
->button
== 1)
1557 // note that GDK generates triple click events which are not supported
1558 // by wxWidgets but still have to be passed to the app as otherwise
1559 // clicks would simply go missing
1560 switch (gdk_event
->type
)
1562 // we shouldn't get triple clicks at all for GTK2 because we
1563 // suppress them artificially using the code above but we still
1564 // should map them to something for GTK1 and not just ignore them
1565 // as this would lose clicks
1566 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1567 case GDK_BUTTON_PRESS
:
1568 event_type
= wxEVT_LEFT_DOWN
;
1571 case GDK_2BUTTON_PRESS
:
1572 event_type
= wxEVT_LEFT_DCLICK
;
1576 // just to silence gcc warnings
1580 else if (gdk_event
->button
== 2)
1582 switch (gdk_event
->type
)
1584 case GDK_3BUTTON_PRESS
:
1585 case GDK_BUTTON_PRESS
:
1586 event_type
= wxEVT_MIDDLE_DOWN
;
1589 case GDK_2BUTTON_PRESS
:
1590 event_type
= wxEVT_MIDDLE_DCLICK
;
1597 else if (gdk_event
->button
== 3)
1599 switch (gdk_event
->type
)
1601 case GDK_3BUTTON_PRESS
:
1602 case GDK_BUTTON_PRESS
:
1603 event_type
= wxEVT_RIGHT_DOWN
;
1606 case GDK_2BUTTON_PRESS
:
1607 event_type
= wxEVT_RIGHT_DCLICK
;
1614 else if (gdk_event
->button
== 4 || gdk_event
->button
== 5)
1616 if (gdk_event
->type
== GDK_BUTTON_PRESS
)
1618 event_type
= wxEVT_MOUSEWHEEL
;
1622 if ( event_type
== wxEVT_NULL
)
1624 // unknown mouse button or click type
1628 wxMouseEvent
event( event_type
);
1629 InitMouseEvent( win
, event
, gdk_event
);
1631 AdjustEventButtonState(event
);
1633 // wxListBox actually get mouse events from the item, so we need to give it
1634 // a chance to correct this
1635 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1637 // find the correct window to send the event too: it may be a different one
1638 // from the one which got it at GTK+ level because some control don't have
1639 // their own X window and thus cannot get any events.
1640 if ( !g_captureWindow
)
1641 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1643 gs_timeLastClick
= gdk_event
->time
;
1646 wxPrintf( wxT("2) OnButtonPress from ") );
1647 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1648 wxPrintf( win->GetClassInfo()->GetClassName() );
1649 wxPrintf( wxT(".\n") );
1653 if (event_type
== wxEVT_LEFT_DCLICK
)
1655 // GTK 1.2 crashes when intercepting double
1656 // click events from both wxSpinButton and
1658 if (GTK_IS_SPIN_BUTTON(win
->m_widget
))
1660 // Just disable this event for now.
1666 if (win
->GetEventHandler()->ProcessEvent( event
))
1668 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_press_event" );
1675 //-----------------------------------------------------------------------------
1676 // "button_release_event"
1677 //-----------------------------------------------------------------------------
1679 static gint
gtk_window_button_release_callback( GtkWidget
*widget
,
1680 GdkEventButton
*gdk_event
,
1686 wxapp_install_idle_handler();
1688 if (!win
->m_hasVMT
) return FALSE
;
1689 if (g_blockEventsOnDrag
) return FALSE
;
1690 if (g_blockEventsOnScroll
) return FALSE
;
1692 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1694 wxEventType event_type
= wxEVT_NULL
;
1696 switch (gdk_event
->button
)
1699 event_type
= wxEVT_LEFT_UP
;
1703 event_type
= wxEVT_MIDDLE_UP
;
1707 event_type
= wxEVT_RIGHT_UP
;
1711 // unknwon button, don't process
1715 wxMouseEvent
event( event_type
);
1716 InitMouseEvent( win
, event
, gdk_event
);
1718 AdjustEventButtonState(event
);
1720 // same wxListBox hack as above
1721 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1723 if ( event_type
== wxEVT_RIGHT_UP
)
1725 // generate a "context menu" event: this is similar to wxEVT_RIGHT_UP
1728 // (a) it's a command event and so is propagated to the parent
1729 // (b) under MSW it can be generated from kbd too
1730 // (c) it uses screen coords (because of (a))
1731 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
,
1733 win
->ClientToScreen(event
.GetPosition()));
1734 (void)win
->GetEventHandler()->ProcessEvent(evtCtx
);
1737 if ( !g_captureWindow
)
1738 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1740 if (win
->GetEventHandler()->ProcessEvent( event
))
1742 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_release_event" );
1749 //-----------------------------------------------------------------------------
1750 // "motion_notify_event"
1751 //-----------------------------------------------------------------------------
1753 static gint
gtk_window_motion_notify_callback( GtkWidget
*widget
,
1754 GdkEventMotion
*gdk_event
,
1760 wxapp_install_idle_handler();
1762 if (!win
->m_hasVMT
) return FALSE
;
1763 if (g_blockEventsOnDrag
) return FALSE
;
1764 if (g_blockEventsOnScroll
) return FALSE
;
1766 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1768 if (gdk_event
->is_hint
)
1772 GdkModifierType state
;
1773 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1779 printf( "OnMotion from " );
1780 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1781 printf( win->GetClassInfo()->GetClassName() );
1785 wxMouseEvent
event( wxEVT_MOTION
);
1786 InitMouseEvent(win
, event
, gdk_event
);
1788 if ( g_captureWindow
)
1790 // synthetize a mouse enter or leave event if needed
1791 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1792 // This seems to be necessary and actually been added to
1793 // GDK itself in version 2.0.X
1796 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1797 if ( hasMouse
!= g_captureWindowHasMouse
)
1799 // the mouse changed window
1800 g_captureWindowHasMouse
= hasMouse
;
1802 wxMouseEvent
event(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1803 : wxEVT_LEAVE_WINDOW
);
1804 InitMouseEvent(win
, event
, gdk_event
);
1805 event
.SetEventObject(win
);
1806 win
->GetEventHandler()->ProcessEvent(event
);
1811 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1814 if (win
->GetEventHandler()->ProcessEvent( event
))
1816 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "motion_notify_event" );
1824 //-----------------------------------------------------------------------------
1825 // "mouse_wheel_event"
1826 //-----------------------------------------------------------------------------
1828 static gint
gtk_window_wheel_callback (GtkWidget
* widget
,
1829 GdkEventScroll
* gdk_event
,
1835 wxapp_install_idle_handler();
1837 wxEventType event_type
= wxEVT_NULL
;
1838 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1839 event_type
= wxEVT_MOUSEWHEEL
;
1840 else if (gdk_event
->direction
== GDK_SCROLL_DOWN
)
1841 event_type
= wxEVT_MOUSEWHEEL
;
1845 wxMouseEvent
event( event_type
);
1846 // Can't use InitMouse macro because scroll events don't have button
1847 event
.SetTimestamp( gdk_event
->time
);
1848 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1849 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1850 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1851 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1852 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1853 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1854 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1855 event
.m_linesPerAction
= 3;
1856 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1857 event
.m_wheelRotation
= 120;
1859 event
.m_wheelRotation
= -120;
1861 wxPoint pt
= win
->GetClientAreaOrigin();
1862 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1863 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1865 event
.SetEventObject( win
);
1866 event
.SetId( win
->GetId() );
1867 event
.SetTimestamp( gdk_event
->time
);
1869 if (win
->GetEventHandler()->ProcessEvent( event
))
1871 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "scroll_event" );
1879 //-----------------------------------------------------------------------------
1881 //-----------------------------------------------------------------------------
1883 // send the wxChildFocusEvent and wxFocusEvent, common code of
1884 // gtk_window_focus_in_callback() and SetFocus()
1885 static bool DoSendFocusEvents(wxWindow
*win
)
1887 // Notify the parent keeping track of focus for the kbd navigation
1888 // purposes that we got it.
1889 wxChildFocusEvent
eventChildFocus(win
);
1890 (void)win
->GetEventHandler()->ProcessEvent(eventChildFocus
);
1892 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, win
->GetId());
1893 eventFocus
.SetEventObject(win
);
1895 return win
->GetEventHandler()->ProcessEvent(eventFocus
);
1898 static gint
gtk_window_focus_in_callback( GtkWidget
*widget
,
1899 GdkEvent
*WXUNUSED(event
),
1905 wxapp_install_idle_handler();
1907 if (!win
->m_hasVMT
) return FALSE
;
1908 if (g_blockEventsOnDrag
) return FALSE
;
1910 switch ( g_sendActivateEvent
)
1913 // we've got focus from outside, synthetize wxActivateEvent
1914 g_sendActivateEvent
= 1;
1918 // another our window just lost focus, it was already ours before
1919 // - don't send any wxActivateEvent
1920 g_sendActivateEvent
= -1;
1925 g_focusWindow
= win
;
1927 wxLogTrace(TRACE_FOCUS
,
1928 _T("%s: focus in"), win
->GetName().c_str());
1932 gdk_im_begin(win
->m_ic
, win
->m_wxwindow
->window
);
1936 // caret needs to be informed about focus change
1937 wxCaret
*caret
= win
->GetCaret();
1940 caret
->OnSetFocus();
1942 #endif // wxUSE_CARET
1944 g_activeFrameLostFocus
= FALSE
;
1946 wxWindowGTK
*active
= wxGetTopLevelParent(win
);
1947 if ( active
!= g_activeFrame
)
1949 if ( g_activeFrame
)
1951 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from focus_in)"), g_activeFrame
);
1952 wxActivateEvent
event(wxEVT_ACTIVATE
, FALSE
, g_activeFrame
->GetId());
1953 event
.SetEventObject(g_activeFrame
);
1954 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
1957 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), active
);
1958 g_activeFrame
= active
;
1959 wxActivateEvent
event(wxEVT_ACTIVATE
, TRUE
, g_activeFrame
->GetId());
1960 event
.SetEventObject(g_activeFrame
);
1961 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
1963 // Don't send focus events in addition to activate
1964 // if (win == g_activeFrame)
1968 // does the window itself think that it has the focus?
1969 if ( !win
->m_hasFocus
)
1971 // not yet, notify it
1972 win
->m_hasFocus
= TRUE
;
1974 if ( DoSendFocusEvents(win
) )
1976 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_in_event" );
1984 //-----------------------------------------------------------------------------
1985 // "focus_out_event"
1986 //-----------------------------------------------------------------------------
1988 static gint
gtk_window_focus_out_callback( GtkWidget
*widget
, GdkEventFocus
*gdk_event
, wxWindowGTK
*win
)
1993 wxapp_install_idle_handler();
1995 if (!win
->m_hasVMT
) return FALSE
;
1996 if (g_blockEventsOnDrag
) return FALSE
;
1998 wxLogTrace( TRACE_FOCUS
,
1999 _T("%s: focus out"), win
->GetName().c_str() );
2001 if ( !g_activeFrameLostFocus
&& g_activeFrame
)
2003 // VZ: commenting this out because it does happen (although not easy
2004 // to reproduce, I only see it when using wxMiniFrame and not
2005 // always) and makes using Mahogany quite annoying
2007 wxASSERT_MSG( wxGetTopLevelParent(win
) == g_activeFrame
,
2008 wxT("unfocusing window that hasn't gained focus properly") );
2011 g_activeFrameLostFocus
= TRUE
;
2014 // if the focus goes out of our app alltogether, OnIdle() will send
2015 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
2016 // g_sendActivateEvent to -1
2017 g_sendActivateEvent
= 0;
2019 wxWindowGTK
*winFocus
= wxFindFocusedChild(win
);
2023 g_focusWindow
= (wxWindowGTK
*)NULL
;
2031 // caret needs to be informed about focus change
2032 wxCaret
*caret
= win
->GetCaret();
2035 caret
->OnKillFocus();
2037 #endif // wxUSE_CARET
2039 // don't send the window a kill focus event if it thinks that it doesn't
2040 // have focus already
2041 if ( win
->m_hasFocus
)
2043 win
->m_hasFocus
= FALSE
;
2045 wxFocusEvent
event( wxEVT_KILL_FOCUS
, win
->GetId() );
2046 event
.SetEventObject( win
);
2048 if (win
->GetEventHandler()->ProcessEvent( event
))
2050 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_out_event" );
2058 //-----------------------------------------------------------------------------
2059 // "enter_notify_event"
2060 //-----------------------------------------------------------------------------
2063 gint
gtk_window_enter_callback( GtkWidget
*widget
,
2064 GdkEventCrossing
*gdk_event
,
2070 wxapp_install_idle_handler();
2072 if (!win
->m_hasVMT
) return FALSE
;
2073 if (g_blockEventsOnDrag
) return FALSE
;
2075 // Event was emitted after a grab
2076 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
2078 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
2082 GdkModifierType state
= (GdkModifierType
)0;
2084 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
2086 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
2087 InitMouseEvent(win
, event
, gdk_event
);
2088 wxPoint pt
= win
->GetClientAreaOrigin();
2089 event
.m_x
= x
+ pt
.x
;
2090 event
.m_y
= y
+ pt
.y
;
2092 if (win
->GetEventHandler()->ProcessEvent( event
))
2094 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "enter_notify_event" );
2101 //-----------------------------------------------------------------------------
2102 // "leave_notify_event"
2103 //-----------------------------------------------------------------------------
2105 static gint
gtk_window_leave_callback( GtkWidget
*widget
, GdkEventCrossing
*gdk_event
, wxWindowGTK
*win
)
2110 wxapp_install_idle_handler();
2112 if (!win
->m_hasVMT
) return FALSE
;
2113 if (g_blockEventsOnDrag
) return FALSE
;
2115 // Event was emitted after an ungrab
2116 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
2118 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
2120 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
2121 event
.SetTimestamp( gdk_event
->time
);
2122 event
.SetEventObject( win
);
2126 GdkModifierType state
= (GdkModifierType
)0;
2128 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
2130 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
) != 0;
2131 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
) != 0;
2132 event
.m_altDown
= (state
& GDK_MOD1_MASK
) != 0;
2133 event
.m_metaDown
= (state
& GDK_MOD2_MASK
) != 0;
2134 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
) != 0;
2135 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
) != 0;
2136 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
) != 0;
2138 wxPoint pt
= win
->GetClientAreaOrigin();
2139 event
.m_x
= x
+ pt
.x
;
2140 event
.m_y
= y
+ pt
.y
;
2142 if (win
->GetEventHandler()->ProcessEvent( event
))
2144 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "leave_notify_event" );
2151 //-----------------------------------------------------------------------------
2152 // "value_changed" from m_vAdjust
2153 //-----------------------------------------------------------------------------
2155 static void gtk_window_vscroll_callback( GtkAdjustment
*adjust
,
2162 wxapp_install_idle_handler();
2164 if (g_blockEventsOnDrag
) return;
2166 if (!win
->m_hasVMT
) return;
2168 float diff
= adjust
->value
- win
->m_oldVerticalPos
;
2169 if (fabs(diff
) < 0.2) return;
2171 win
->m_oldVerticalPos
= adjust
->value
;
2174 GtkScrolledWindow
*sw
= GTK_SCROLLED_WINDOW(win
->m_widget
);
2176 wxEventType command
= GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw
->vscrollbar
));
2178 int value
= (int)(adjust
->value
+0.5);
2180 wxScrollWinEvent
event( command
, value
, wxVERTICAL
);
2181 event
.SetEventObject( win
);
2182 win
->GetEventHandler()->ProcessEvent( event
);
2185 //-----------------------------------------------------------------------------
2186 // "value_changed" from m_hAdjust
2187 //-----------------------------------------------------------------------------
2189 static void gtk_window_hscroll_callback( GtkAdjustment
*adjust
,
2196 wxapp_install_idle_handler();
2198 if (g_blockEventsOnDrag
) return;
2199 if (!win
->m_hasVMT
) return;
2201 float diff
= adjust
->value
- win
->m_oldHorizontalPos
;
2202 if (fabs(diff
) < 0.2) return;
2205 GtkScrolledWindow
*sw
= GTK_SCROLLED_WINDOW(win
->m_widget
);
2207 wxEventType command
= GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw
->hscrollbar
));
2209 win
->m_oldHorizontalPos
= adjust
->value
;
2211 int value
= (int)(adjust
->value
+0.5);
2213 wxScrollWinEvent
event( command
, value
, wxHORIZONTAL
);
2214 event
.SetEventObject( win
);
2215 win
->GetEventHandler()->ProcessEvent( event
);
2218 //-----------------------------------------------------------------------------
2219 // "button_press_event" from scrollbar
2220 //-----------------------------------------------------------------------------
2222 static gint
gtk_scrollbar_button_press_callback( GtkRange
*widget
,
2223 GdkEventButton
*gdk_event
,
2229 wxapp_install_idle_handler();
2232 g_blockEventsOnScroll
= TRUE
;
2234 // FIXME: there is no 'slider' field in GTK+ 2.0 any more
2236 win
->m_isScrolling
= (gdk_event
->window
== widget
->slider
);
2242 //-----------------------------------------------------------------------------
2243 // "button_release_event" from scrollbar
2244 //-----------------------------------------------------------------------------
2246 static gint
gtk_scrollbar_button_release_callback( GtkRange
*widget
,
2247 GdkEventButton
*WXUNUSED(gdk_event
),
2252 // don't test here as we can release the mouse while being over
2253 // a different window than the slider
2255 // if (gdk_event->window != widget->slider) return FALSE;
2257 g_blockEventsOnScroll
= FALSE
;
2259 if (win
->m_isScrolling
)
2261 wxEventType command
= wxEVT_SCROLLWIN_THUMBRELEASE
;
2265 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(win
->m_widget
);
2266 if (widget
== GTK_RANGE(scrolledWindow
->hscrollbar
))
2268 value
= (int)(win
->m_hAdjust
->value
+0.5);
2271 if (widget
== GTK_RANGE(scrolledWindow
->vscrollbar
))
2273 value
= (int)(win
->m_vAdjust
->value
+0.5);
2277 wxScrollWinEvent
event( command
, value
, dir
);
2278 event
.SetEventObject( win
);
2279 win
->GetEventHandler()->ProcessEvent( event
);
2282 win
->m_isScrolling
= FALSE
;
2287 // ----------------------------------------------------------------------------
2288 // this wxWindowBase function is implemented here (in platform-specific file)
2289 // because it is static and so couldn't be made virtual
2290 // ----------------------------------------------------------------------------
2292 wxWindow
*wxWindowBase::FindFocus()
2294 // the cast is necessary when we compile in wxUniversal mode
2295 return (wxWindow
*)g_focusWindow
;
2299 //-----------------------------------------------------------------------------
2300 // "realize" from m_widget
2301 //-----------------------------------------------------------------------------
2303 /* We cannot set colours and fonts before the widget has
2304 been realized, so we do this directly after realization. */
2307 gtk_window_realized_callback( GtkWidget
*m_widget
, wxWindow
*win
)
2312 wxapp_install_idle_handler();
2315 if (win
->m_imContext
)
2317 GtkPizza
*pizza
= GTK_PIZZA( m_widget
);
2318 gtk_im_context_set_client_window( win
->m_imContext
, pizza
->bin_window
);
2322 wxWindowCreateEvent
event( win
);
2323 event
.SetEventObject( win
);
2324 win
->GetEventHandler()->ProcessEvent( event
);
2329 //-----------------------------------------------------------------------------
2331 //-----------------------------------------------------------------------------
2334 void gtk_window_size_callback( GtkWidget
*WXUNUSED(widget
),
2335 GtkAllocation
*WXUNUSED(alloc
),
2339 wxapp_install_idle_handler();
2341 if (!win
->m_hasScrolling
) return;
2343 int client_width
= 0;
2344 int client_height
= 0;
2345 win
->GetClientSize( &client_width
, &client_height
);
2346 if ((client_width
== win
->m_oldClientWidth
) && (client_height
== win
->m_oldClientHeight
))
2349 win
->m_oldClientWidth
= client_width
;
2350 win
->m_oldClientHeight
= client_height
;
2352 if (!win
->m_nativeSizeEvent
)
2354 wxSizeEvent
event( win
->GetSize(), win
->GetId() );
2355 event
.SetEventObject( win
);
2356 win
->GetEventHandler()->ProcessEvent( event
);
2362 #define WXUNUSED_UNLESS_XIM(param) param
2364 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2367 /* Resize XIM window */
2370 void gtk_wxwindow_size_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2371 GtkAllocation
* WXUNUSED_UNLESS_XIM(alloc
),
2372 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2375 wxapp_install_idle_handler();
2381 if (gdk_ic_get_style (win
->m_ic
) & GDK_IM_PREEDIT_POSITION
)
2385 gdk_window_get_size (widget
->window
, &width
, &height
);
2386 win
->m_icattr
->preedit_area
.width
= width
;
2387 win
->m_icattr
->preedit_area
.height
= height
;
2388 gdk_ic_set_attr (win
->m_ic
, win
->m_icattr
, GDK_IC_PREEDIT_AREA
);
2393 //-----------------------------------------------------------------------------
2394 // "realize" from m_wxwindow
2395 //-----------------------------------------------------------------------------
2397 /* Initialize XIM support */
2400 gtk_wxwindow_realized_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2401 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2404 wxapp_install_idle_handler();
2407 if (win
->m_ic
) return FALSE
;
2408 if (!widget
) return FALSE
;
2409 if (!gdk_im_ready()) return FALSE
;
2411 win
->m_icattr
= gdk_ic_attr_new();
2412 if (!win
->m_icattr
) return FALSE
;
2416 GdkColormap
*colormap
;
2417 GdkICAttr
*attr
= win
->m_icattr
;
2418 unsigned attrmask
= GDK_IC_ALL_REQ
;
2420 GdkIMStyle supported_style
= (GdkIMStyle
)
2421 (GDK_IM_PREEDIT_NONE
|
2422 GDK_IM_PREEDIT_NOTHING
|
2423 GDK_IM_PREEDIT_POSITION
|
2424 GDK_IM_STATUS_NONE
|
2425 GDK_IM_STATUS_NOTHING
);
2427 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2428 supported_style
= (GdkIMStyle
)(supported_style
& ~GDK_IM_PREEDIT_POSITION
);
2430 attr
->style
= style
= gdk_im_decide_style (supported_style
);
2431 attr
->client_window
= widget
->window
;
2433 if ((colormap
= gtk_widget_get_colormap (widget
)) !=
2434 gtk_widget_get_default_colormap ())
2436 attrmask
|= GDK_IC_PREEDIT_COLORMAP
;
2437 attr
->preedit_colormap
= colormap
;
2440 attrmask
|= GDK_IC_PREEDIT_FOREGROUND
;
2441 attrmask
|= GDK_IC_PREEDIT_BACKGROUND
;
2442 attr
->preedit_foreground
= widget
->style
->fg
[GTK_STATE_NORMAL
];
2443 attr
->preedit_background
= widget
->style
->base
[GTK_STATE_NORMAL
];
2445 switch (style
& GDK_IM_PREEDIT_MASK
)
2447 case GDK_IM_PREEDIT_POSITION
:
2448 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2450 g_warning ("over-the-spot style requires fontset");
2454 gdk_window_get_size (widget
->window
, &width
, &height
);
2456 attrmask
|= GDK_IC_PREEDIT_POSITION_REQ
;
2457 attr
->spot_location
.x
= 0;
2458 attr
->spot_location
.y
= height
;
2459 attr
->preedit_area
.x
= 0;
2460 attr
->preedit_area
.y
= 0;
2461 attr
->preedit_area
.width
= width
;
2462 attr
->preedit_area
.height
= height
;
2463 attr
->preedit_fontset
= widget
->style
->font
;
2468 win
->m_ic
= gdk_ic_new (attr
, (GdkICAttributesType
)attrmask
);
2470 if (win
->m_ic
== NULL
)
2471 g_warning ("Can't create input context.");
2474 mask
= gdk_window_get_events (widget
->window
);
2475 mask
= (GdkEventMask
)(mask
| gdk_ic_get_events (win
->m_ic
));
2476 gdk_window_set_events (widget
->window
, mask
);
2478 if (GTK_WIDGET_HAS_FOCUS(widget
))
2479 gdk_im_begin (win
->m_ic
, widget
->window
);
2486 //-----------------------------------------------------------------------------
2487 // InsertChild for wxWindowGTK.
2488 //-----------------------------------------------------------------------------
2490 /* Callback for wxWindowGTK. This very strange beast has to be used because
2491 * C++ has no virtual methods in a constructor. We have to emulate a
2492 * virtual function here as wxNotebook requires a different way to insert
2493 * a child in it. I had opted for creating a wxNotebookPage window class
2494 * which would have made this superfluous (such in the MDI window system),
2495 * but no-one was listening to me... */
2497 static void wxInsertChildInWindow( wxWindowGTK
* parent
, wxWindowGTK
* child
)
2499 /* the window might have been scrolled already, do we
2500 have to adapt the position */
2501 GtkPizza
*pizza
= GTK_PIZZA(parent
->m_wxwindow
);
2502 child
->m_x
+= pizza
->xoffset
;
2503 child
->m_y
+= pizza
->yoffset
;
2505 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
2506 GTK_WIDGET(child
->m_widget
),
2513 //-----------------------------------------------------------------------------
2515 //-----------------------------------------------------------------------------
2517 wxWindow
*wxGetActiveWindow()
2519 return wxWindow::FindFocus();
2522 //-----------------------------------------------------------------------------
2524 //-----------------------------------------------------------------------------
2526 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2528 #ifdef __WXUNIVERSAL__
2529 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2531 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
2532 #endif // __WXUNIVERSAL__/__WXGTK__
2534 void wxWindowGTK::Init()
2537 m_widget
= (GtkWidget
*) NULL
;
2538 m_wxwindow
= (GtkWidget
*) NULL
;
2539 m_focusWidget
= (GtkWidget
*) NULL
;
2549 m_needParent
= TRUE
;
2550 m_isBeingDeleted
= FALSE
;
2553 m_nativeSizeEvent
= FALSE
;
2555 m_hasScrolling
= FALSE
;
2556 m_isScrolling
= FALSE
;
2558 m_hAdjust
= (GtkAdjustment
*) NULL
;
2559 m_vAdjust
= (GtkAdjustment
*) NULL
;
2560 m_oldHorizontalPos
=
2561 m_oldVerticalPos
= 0.0;
2563 m_oldClientHeight
= 0;
2567 m_insertCallback
= (wxInsertChildFunction
) NULL
;
2569 m_acceptsFocus
= FALSE
;
2572 m_clipPaintRegion
= FALSE
;
2574 m_cursor
= *wxSTANDARD_CURSOR
;
2578 m_x11Context
= NULL
;
2581 m_ic
= (GdkIC
*) NULL
;
2582 m_icattr
= (GdkICAttr
*) NULL
;
2587 wxWindowGTK::wxWindowGTK()
2592 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2597 const wxString
&name
)
2601 Create( parent
, id
, pos
, size
, style
, name
);
2604 bool wxWindowGTK::Create( wxWindow
*parent
,
2609 const wxString
&name
)
2611 if (!PreCreation( parent
, pos
, size
) ||
2612 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2614 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2618 m_insertCallback
= wxInsertChildInWindow
;
2620 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
2621 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
2623 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2625 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2626 scroll_class
->scrollbar_spacing
= 0;
2628 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2630 m_hAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->hscrollbar
) );
2631 m_vAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->vscrollbar
) );
2633 m_wxwindow
= gtk_pizza_new();
2635 #ifndef __WXUNIVERSAL__
2636 GtkPizza
*pizza
= GTK_PIZZA(m_wxwindow
);
2638 if (HasFlag(wxRAISED_BORDER
))
2640 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_OUT
);
2642 else if (HasFlag(wxSUNKEN_BORDER
))
2644 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_IN
);
2646 else if (HasFlag(wxSIMPLE_BORDER
))
2648 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_THIN
);
2652 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_NONE
);
2654 #endif // __WXUNIVERSAL__
2656 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2658 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
2659 m_acceptsFocus
= TRUE
;
2661 // I _really_ don't want scrollbars in the beginning
2662 m_vAdjust
->lower
= 0.0;
2663 m_vAdjust
->upper
= 1.0;
2664 m_vAdjust
->value
= 0.0;
2665 m_vAdjust
->step_increment
= 1.0;
2666 m_vAdjust
->page_increment
= 1.0;
2667 m_vAdjust
->page_size
= 5.0;
2668 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
2669 m_hAdjust
->lower
= 0.0;
2670 m_hAdjust
->upper
= 1.0;
2671 m_hAdjust
->value
= 0.0;
2672 m_hAdjust
->step_increment
= 1.0;
2673 m_hAdjust
->page_increment
= 1.0;
2674 m_hAdjust
->page_size
= 5.0;
2675 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
2677 // these handlers block mouse events to any window during scrolling such as
2678 // motion events and prevent GTK and wxWidgets from fighting over where the
2681 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_press_event",
2682 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
2684 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_press_event",
2685 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
2687 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_release_event",
2688 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
2690 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_release_event",
2691 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
2693 // these handlers get notified when screen updates are required either when
2694 // scrolling or when the window size (and therefore scrollbar configuration)
2697 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
2698 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
2699 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
2700 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
2702 gtk_widget_show( m_wxwindow
);
2705 m_parent
->DoAddChild( this );
2707 m_focusWidget
= m_wxwindow
;
2714 wxWindowGTK::~wxWindowGTK()
2718 if (g_focusWindow
== this)
2719 g_focusWindow
= NULL
;
2721 if (g_activeFrame
== this)
2722 g_activeFrame
= NULL
;
2724 if ( g_delayedFocus
== this )
2725 g_delayedFocus
= NULL
;
2727 m_isBeingDeleted
= TRUE
;
2737 gdk_ic_destroy (m_ic
);
2739 gdk_ic_attr_destroy (m_icattr
);
2744 gtk_widget_destroy( m_wxwindow
);
2745 m_wxwindow
= (GtkWidget
*) NULL
;
2750 gtk_widget_destroy( m_widget
);
2751 m_widget
= (GtkWidget
*) NULL
;
2755 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2757 wxCHECK_MSG( !m_needParent
|| parent
, FALSE
, wxT("Need complete parent.") );
2759 // Use either the given size, or the default if -1 is given.
2760 // See wxWindowBase for these functions.
2761 m_width
= WidthDefault(size
.x
) ;
2762 m_height
= HeightDefault(size
.y
);
2770 void wxWindowGTK::PostCreation()
2772 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2778 // these get reported to wxWidgets -> wxPaintEvent
2780 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow
), TRUE
);
2782 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "expose_event",
2783 GTK_SIGNAL_FUNC(gtk_window_expose_callback
), (gpointer
)this );
2786 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "draw",
2787 GTK_SIGNAL_FUNC(gtk_window_draw_callback
), (gpointer
)this );
2789 if (!HasFlag(wxFULL_REPAINT_ON_RESIZE
))
2791 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "event",
2792 GTK_SIGNAL_FUNC(gtk_window_event_event_callback
), (gpointer
)this );
2795 // gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), !HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
2800 // Create input method handler
2801 m_imContext
= gtk_im_multicontext_new();
2803 // Cannot handle drawing preedited text yet
2804 gtk_im_context_set_use_preedit( m_imContext
, FALSE
);
2806 g_signal_connect (G_OBJECT (m_imContext
), "commit",
2807 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2810 // these are called when the "sunken" or "raised" borders are drawn
2811 gtk_signal_connect( GTK_OBJECT(m_widget
), "expose_event",
2812 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback
), (gpointer
)this );
2815 gtk_signal_connect( GTK_OBJECT(m_widget
), "draw",
2816 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback
), (gpointer
)this );
2822 if (m_focusWidget
== NULL
)
2823 m_focusWidget
= m_widget
;
2825 gtk_signal_connect( GTK_OBJECT(m_focusWidget
), "focus_in_event",
2826 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback
), (gpointer
)this );
2828 gtk_signal_connect( GTK_OBJECT(m_focusWidget
), "focus_out_event",
2829 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback
), (gpointer
)this );
2831 // connect to the various key and mouse handlers
2833 GtkWidget
*connect_widget
= GetConnectWidget();
2835 ConnectWidget( connect_widget
);
2837 /* We cannot set colours, fonts and cursors before the widget has
2838 been realized, so we do this directly after realization */
2839 gtk_signal_connect( GTK_OBJECT(connect_widget
), "realize",
2840 GTK_SIGNAL_FUNC(gtk_window_realized_callback
), (gpointer
) this );
2844 // Catch native resize events
2845 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "size_allocate",
2846 GTK_SIGNAL_FUNC(gtk_window_size_callback
), (gpointer
)this );
2848 // Initialize XIM support
2849 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "realize",
2850 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback
), (gpointer
) this );
2852 // And resize XIM window
2853 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "size_allocate",
2854 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback
), (gpointer
)this );
2857 if ( !GTK_IS_COMBO(m_widget
))
2859 // This is needed if we want to add our windows into native
2860 // GTK control, such as the toolbar. With this callback, the
2861 // toolbar gets to know the correct size (the one set by the
2862 // programmer). Sadly, it misbehaves for wxComboBox. FIXME
2863 // when moving to GTK 2.0.
2864 gtk_signal_connect( GTK_OBJECT(m_widget
), "size_request",
2865 GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback
),
2871 // unless the window was created initially hidden (i.e. Hide() had been
2872 // called before Create()), we should show it at GTK+ level as well
2874 gtk_widget_show( m_widget
);
2877 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2879 gtk_signal_connect( GTK_OBJECT(widget
), "key_press_event",
2880 GTK_SIGNAL_FUNC(gtk_window_key_press_callback
), (gpointer
)this );
2882 gtk_signal_connect( GTK_OBJECT(widget
), "key_release_event",
2883 GTK_SIGNAL_FUNC(gtk_window_key_release_callback
), (gpointer
)this );
2885 gtk_signal_connect( GTK_OBJECT(widget
), "button_press_event",
2886 GTK_SIGNAL_FUNC(gtk_window_button_press_callback
), (gpointer
)this );
2888 gtk_signal_connect( GTK_OBJECT(widget
), "button_release_event",
2889 GTK_SIGNAL_FUNC(gtk_window_button_release_callback
), (gpointer
)this );
2891 gtk_signal_connect( GTK_OBJECT(widget
), "motion_notify_event",
2892 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback
), (gpointer
)this );
2895 gtk_signal_connect( GTK_OBJECT(widget
), "scroll_event",
2896 GTK_SIGNAL_FUNC(gtk_window_wheel_callback
), (gpointer
)this );
2899 gtk_signal_connect( GTK_OBJECT(widget
), "enter_notify_event",
2900 GTK_SIGNAL_FUNC(gtk_window_enter_callback
), (gpointer
)this );
2902 gtk_signal_connect( GTK_OBJECT(widget
), "leave_notify_event",
2903 GTK_SIGNAL_FUNC(gtk_window_leave_callback
), (gpointer
)this );
2906 bool wxWindowGTK::Destroy()
2908 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2912 return wxWindowBase::Destroy();
2915 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2917 gtk_pizza_set_size( GTK_PIZZA(m_parent
->m_wxwindow
), m_widget
, x
, y
, width
, height
);
2920 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2922 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2923 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2926 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
2929 if (m_resizing
) return; /* I don't like recursions */
2932 int currentX
, currentY
;
2933 GetPosition(¤tX
, ¤tY
);
2934 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2936 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2938 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2940 if (m_parent
->m_wxwindow
== NULL
) /* i.e. wxNotebook */
2942 /* don't set the size for children of wxNotebook, just take the values. */
2950 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
2951 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
2953 if (x
!= -1) m_x
= x
+ pizza
->xoffset
;
2954 if (y
!= -1) m_y
= y
+ pizza
->yoffset
;
2958 m_x
= x
+ pizza
->xoffset
;
2959 m_y
= y
+ pizza
->yoffset
;
2962 // calculate the best size if we should auto size the window
2963 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
2964 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
2966 const wxSize sizeBest
= GetBestSize();
2967 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
2969 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
2970 height
= sizeBest
.y
;
2978 int minWidth
= GetMinWidth(),
2979 minHeight
= GetMinHeight(),
2980 maxWidth
= GetMaxWidth(),
2981 maxHeight
= GetMaxHeight();
2983 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
2984 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
2985 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
2986 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
2989 int bottom_border
= 0;
2992 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
2994 /* the default button has a border around it */
3000 DoMoveWindow( m_x
-border
,
3003 m_height
+border
+bottom_border
);
3008 /* Sometimes the client area changes size without the
3009 whole windows's size changing, but if the whole
3010 windows's size doesn't change, no wxSizeEvent will
3011 normally be sent. Here we add an extra test if
3012 the client test has been changed and this will
3014 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
3018 wxPrintf( "OnSize sent from " );
3019 if (GetClassInfo() && GetClassInfo()->GetClassName())
3020 wxPrintf( GetClassInfo()->GetClassName() );
3021 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
3024 if (!m_nativeSizeEvent
)
3026 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
3027 event
.SetEventObject( this );
3028 GetEventHandler()->ProcessEvent( event
);
3034 void wxWindowGTK::OnInternalIdle()
3036 // Update invalidated regions.
3039 // Synthetize activate events.
3040 if ( g_sendActivateEvent
!= -1 )
3042 bool activate
= g_sendActivateEvent
!= 0;
3045 g_sendActivateEvent
= -1;
3047 wxTheApp
->SetActive(activate
, (wxWindow
*)g_focusWindowLast
);
3050 if ( g_activeFrameLostFocus
)
3052 if ( g_activeFrame
)
3054 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame
);
3055 wxActivateEvent
event(wxEVT_ACTIVATE
, FALSE
, g_activeFrame
->GetId());
3056 event
.SetEventObject(g_activeFrame
);
3057 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
3058 g_activeFrame
= NULL
;
3060 g_activeFrameLostFocus
= FALSE
;
3063 wxCursor cursor
= m_cursor
;
3064 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
3068 /* I now set the cursor anew in every OnInternalIdle call
3069 as setting the cursor in a parent window also effects the
3070 windows above so that checking for the current cursor is
3075 GdkWindow
*window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3077 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3079 if (!g_globalCursor
.Ok())
3080 cursor
= *wxSTANDARD_CURSOR
;
3082 window
= m_widget
->window
;
3083 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
3084 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3090 GdkWindow
*window
= m_widget
->window
;
3091 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
3092 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3097 if (wxUpdateUIEvent::CanUpdate(this))
3098 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
3101 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
3103 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3105 if (width
) (*width
) = m_width
;
3106 if (height
) (*height
) = m_height
;
3109 void wxWindowGTK::DoSetClientSize( int width
, int height
)
3111 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3115 SetSize( width
, height
);
3122 #ifndef __WXUNIVERSAL__
3123 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
3125 /* when using GTK 1.2 we set the shadow border size to 2 */
3129 if (HasFlag(wxSIMPLE_BORDER
))
3131 /* when using GTK 1.2 we set the simple border size to 1 */
3135 #endif // __WXUNIVERSAL__
3139 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
3141 GtkRequisition vscroll_req
;
3142 vscroll_req
.width
= 2;
3143 vscroll_req
.height
= 2;
3144 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
3145 (scroll_window
->vscrollbar
, &vscroll_req
);
3147 GtkRequisition hscroll_req
;
3148 hscroll_req
.width
= 2;
3149 hscroll_req
.height
= 2;
3150 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
3151 (scroll_window
->hscrollbar
, &hscroll_req
);
3153 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
3155 if (scroll_window
->vscrollbar_visible
)
3157 dw
+= vscroll_req
.width
;
3158 dw
+= scroll_class
->scrollbar_spacing
;
3161 if (scroll_window
->hscrollbar_visible
)
3163 dh
+= hscroll_req
.height
;
3164 dh
+= scroll_class
->scrollbar_spacing
;
3168 SetSize( width
+dw
, height
+dh
);
3172 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
3174 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3178 if (width
) (*width
) = m_width
;
3179 if (height
) (*height
) = m_height
;
3186 #ifndef __WXUNIVERSAL__
3187 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
3189 /* when using GTK 1.2 we set the shadow border size to 2 */
3193 if (HasFlag(wxSIMPLE_BORDER
))
3195 /* when using GTK 1.2 we set the simple border size to 1 */
3199 #endif // __WXUNIVERSAL__
3203 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
3205 GtkRequisition vscroll_req
;
3206 vscroll_req
.width
= 2;
3207 vscroll_req
.height
= 2;
3208 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
3209 (scroll_window
->vscrollbar
, &vscroll_req
);
3211 GtkRequisition hscroll_req
;
3212 hscroll_req
.width
= 2;
3213 hscroll_req
.height
= 2;
3214 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
3215 (scroll_window
->hscrollbar
, &hscroll_req
);
3217 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
3219 if (scroll_window
->vscrollbar_visible
)
3221 dw
+= vscroll_req
.width
;
3222 dw
+= scroll_class
->scrollbar_spacing
;
3225 if (scroll_window
->hscrollbar_visible
)
3227 dh
+= hscroll_req
.height
;
3228 dh
+= scroll_class
->scrollbar_spacing
;
3232 if (width
) (*width
) = m_width
- dw
;
3233 if (height
) (*height
) = m_height
- dh
;
3237 printf( "GetClientSize, name %s ", GetName().c_str() );
3238 if (width) printf( " width = %d", (*width) );
3239 if (height) printf( " height = %d", (*height) );
3244 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
3246 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3250 if (m_parent
&& m_parent
->m_wxwindow
)
3252 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
3253 dx
= pizza
->xoffset
;
3254 dy
= pizza
->yoffset
;
3257 if (x
) (*x
) = m_x
- dx
;
3258 if (y
) (*y
) = m_y
- dy
;
3261 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
3263 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3265 if (!m_widget
->window
) return;
3267 GdkWindow
*source
= (GdkWindow
*) NULL
;
3269 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3271 source
= m_widget
->window
;
3275 gdk_window_get_origin( source
, &org_x
, &org_y
);
3279 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3281 org_x
+= m_widget
->allocation
.x
;
3282 org_y
+= m_widget
->allocation
.y
;
3290 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
3292 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3294 if (!m_widget
->window
) return;
3296 GdkWindow
*source
= (GdkWindow
*) NULL
;
3298 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3300 source
= m_widget
->window
;
3304 gdk_window_get_origin( source
, &org_x
, &org_y
);
3308 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3310 org_x
+= m_widget
->allocation
.x
;
3311 org_y
+= m_widget
->allocation
.y
;
3319 bool wxWindowGTK::Show( bool show
)
3321 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3323 if (!wxWindowBase::Show(show
))
3330 gtk_widget_show( m_widget
);
3332 gtk_widget_hide( m_widget
);
3334 wxShowEvent
eventShow(GetId(), show
);
3335 eventShow
.m_eventObject
= this;
3337 GetEventHandler()->ProcessEvent(eventShow
);
3342 static void wxWindowNotifyEnable(wxWindowGTK
* win
, bool enable
)
3344 win
->OnParentEnable(enable
);
3346 // Recurse, so that children have the opportunity to Do The Right Thing
3347 // and reset colours that have been messed up by a parent's (really ancestor's)
3349 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
3351 node
= node
->GetNext() )
3353 wxWindow
*child
= node
->GetData();
3354 if (!child
->IsKindOf(CLASSINFO(wxDialog
)) && !child
->IsKindOf(CLASSINFO(wxFrame
)))
3355 wxWindowNotifyEnable(child
, enable
);
3359 bool wxWindowGTK::Enable( bool enable
)
3361 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3363 if (!wxWindowBase::Enable(enable
))
3369 gtk_widget_set_sensitive( m_widget
, enable
);
3371 gtk_widget_set_sensitive( m_wxwindow
, enable
);
3373 wxWindowNotifyEnable(this, enable
);
3378 int wxWindowGTK::GetCharHeight() const
3380 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
3382 wxFont font
= GetFont();
3383 wxCHECK_MSG( font
.Ok(), 12, wxT("invalid font") );
3386 PangoContext
*context
= NULL
;
3388 context
= gtk_widget_get_pango_context( m_widget
);
3393 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3394 PangoLayout
*layout
= pango_layout_new(context
);
3395 pango_layout_set_font_description(layout
, desc
);
3396 pango_layout_set_text(layout
, "H", 1);
3397 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3399 PangoRectangle rect
;
3400 pango_layout_line_get_extents(line
, NULL
, &rect
);
3402 g_object_unref( G_OBJECT( layout
) );
3404 return (int) (rect
.height
/ PANGO_SCALE
);
3406 GdkFont
*gfont
= font
.GetInternalFont( 1.0 );
3408 return gfont
->ascent
+ gfont
->descent
;
3412 int wxWindowGTK::GetCharWidth() const
3414 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
3416 wxFont font
= GetFont();
3417 wxCHECK_MSG( font
.Ok(), 8, wxT("invalid font") );
3420 PangoContext
*context
= NULL
;
3422 context
= gtk_widget_get_pango_context( m_widget
);
3427 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3428 PangoLayout
*layout
= pango_layout_new(context
);
3429 pango_layout_set_font_description(layout
, desc
);
3430 pango_layout_set_text(layout
, "g", 1);
3431 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3433 PangoRectangle rect
;
3434 pango_layout_line_get_extents(line
, NULL
, &rect
);
3436 g_object_unref( G_OBJECT( layout
) );
3438 return (int) (rect
.width
/ PANGO_SCALE
);
3440 GdkFont
*gfont
= font
.GetInternalFont( 1.0 );
3442 return gdk_string_width( gfont
, "g" );
3446 void wxWindowGTK::GetTextExtent( const wxString
& string
,
3450 int *externalLeading
,
3451 const wxFont
*theFont
) const
3453 wxFont fontToUse
= theFont
? *theFont
: GetFont();
3455 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
3457 if (string
.IsEmpty())
3465 PangoContext
*context
= NULL
;
3467 context
= gtk_widget_get_pango_context( m_widget
);
3476 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3477 PangoLayout
*layout
= pango_layout_new(context
);
3478 pango_layout_set_font_description(layout
, desc
);
3481 const wxCharBuffer data
= wxConvUTF8
.cWC2MB( string
);
3482 pango_layout_set_text(layout
, (const char*) data
, strlen( (const char*) data
));
3484 const wxWCharBuffer wdata
= wxConvLocal
.cMB2WC( string
);
3485 const wxCharBuffer data
= wxConvUTF8
.cWC2MB( wdata
);
3486 pango_layout_set_text(layout
, (const char*) data
, strlen( (const char*) data
));
3489 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3491 PangoRectangle rect
;
3492 pango_layout_line_get_extents(line
, NULL
, &rect
);
3494 if (x
) (*x
) = (wxCoord
) (rect
.width
/ PANGO_SCALE
);
3495 if (y
) (*y
) = (wxCoord
) (rect
.height
/ PANGO_SCALE
);
3498 // Do something about metrics here
3501 if (externalLeading
) (*externalLeading
) = 0; // ??
3503 g_object_unref( G_OBJECT( layout
) );
3505 GdkFont
*font
= fontToUse
.GetInternalFont( 1.0 );
3506 if (x
) (*x
) = gdk_string_width( font
, wxGTK_CONV( string
) );
3507 if (y
) (*y
) = font
->ascent
+ font
->descent
;
3508 if (descent
) (*descent
) = font
->descent
;
3509 if (externalLeading
) (*externalLeading
) = 0; // ??
3513 void wxWindowGTK::SetFocus()
3515 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3519 // don't do anything if we already have focus
3525 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow
))
3527 gtk_widget_grab_focus (m_wxwindow
);
3532 if (GTK_WIDGET_CAN_FOCUS(m_widget
) && !GTK_WIDGET_HAS_FOCUS (m_widget
) )
3534 if (!GTK_WIDGET_REALIZED(m_widget
))
3536 // we can't set the focus to the widget now so we remember that
3537 // it should be focused and will do it later, during the idle
3538 // time, as soon as we can
3539 wxLogTrace(TRACE_FOCUS
,
3540 _T("Delaying setting focus to %s(%s)"),
3541 GetClassInfo()->GetClassName(), GetLabel().c_str());
3543 g_delayedFocus
= this;
3547 wxLogTrace(TRACE_FOCUS
,
3548 _T("Setting focus to %s(%s)"),
3549 GetClassInfo()->GetClassName(), GetLabel().c_str());
3551 gtk_widget_grab_focus (m_widget
);
3554 else if (GTK_IS_CONTAINER(m_widget
))
3556 SET_CONTAINER_FOCUS( m_widget
, GTK_DIR_TAB_FORWARD
);
3560 wxLogTrace(TRACE_FOCUS
,
3561 _T("Can't set focus to %s(%s)"),
3562 GetClassInfo()->GetClassName(), GetLabel().c_str());
3567 bool wxWindowGTK::AcceptsFocus() const
3569 return m_acceptsFocus
&& wxWindowBase::AcceptsFocus();
3572 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3574 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3576 wxWindowGTK
*oldParent
= m_parent
,
3577 *newParent
= (wxWindowGTK
*)newParentBase
;
3579 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3581 if ( !wxWindowBase::Reparent(newParent
) )
3584 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3586 /* prevent GTK from deleting the widget arbitrarily */
3587 gtk_widget_ref( m_widget
);
3591 gtk_container_remove( GTK_CONTAINER(m_widget
->parent
), m_widget
);
3594 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3598 /* insert GTK representation */
3599 (*(newParent
->m_insertCallback
))(newParent
, this);
3602 /* reverse: prevent GTK from deleting the widget arbitrarily */
3603 gtk_widget_unref( m_widget
);
3608 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3610 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3612 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3614 wxASSERT_MSG( (m_insertCallback
!= NULL
), wxT("invalid child insertion function") );
3619 /* insert GTK representation */
3620 (*m_insertCallback
)(this, child
);
3623 void wxWindowGTK::Raise()
3625 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3627 if (!m_widget
->window
) return;
3629 gdk_window_raise( m_widget
->window
);
3632 void wxWindowGTK::Lower()
3634 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3636 if (!m_widget
->window
) return;
3638 gdk_window_lower( m_widget
->window
);
3641 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3643 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3645 if (cursor
== m_cursor
)
3649 wxapp_install_idle_handler();
3651 if (cursor
== wxNullCursor
)
3652 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR
);
3654 return wxWindowBase::SetCursor( cursor
);
3657 void wxWindowGTK::WarpPointer( int x
, int y
)
3659 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3661 // We provide this function ourselves as it is
3662 // missing in GDK (top of this file).
3664 GdkWindow
*window
= (GdkWindow
*) NULL
;
3666 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3668 window
= GetConnectWidget()->window
;
3671 gdk_window_warp_pointer( window
, x
, y
);
3675 void wxWindowGTK::Refresh( bool eraseBackground
, const wxRect
*rect
)
3677 if (!m_widget
) return;
3678 if (!m_widget
->window
) return;
3682 wxapp_install_idle_handler();
3684 wxRect
myRect(0,0,0,0);
3685 if (m_wxwindow
&& rect
)
3687 myRect
.SetSize(wxSize( m_wxwindow
->allocation
.width
,
3688 m_wxwindow
->allocation
.height
));
3689 myRect
.Intersect(*rect
);
3690 if (!myRect
.width
|| !myRect
.height
)
3691 // nothing to do, rectangle is empty
3696 if (eraseBackground
&& m_wxwindow
&& m_wxwindow
->window
)
3700 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3701 m_clearRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3705 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3706 m_clearRegion
.Clear();
3707 m_clearRegion
.Union( 0, 0, m_wxwindow
->allocation
.width
, m_wxwindow
->allocation
.height
);
3715 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3716 m_updateRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3720 GdkRectangle gdk_rect
;
3721 gdk_rect
.x
= rect
->x
;
3722 gdk_rect
.y
= rect
->y
;
3723 gdk_rect
.width
= rect
->width
;
3724 gdk_rect
.height
= rect
->height
;
3725 gtk_widget_draw( m_widget
, &gdk_rect
);
3732 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3733 m_updateRegion
.Clear();
3734 m_updateRegion
.Union( 0, 0, m_wxwindow
->allocation
.width
, m_wxwindow
->allocation
.height
);
3738 gtk_widget_draw( m_widget
, (GdkRectangle
*) NULL
);
3746 GdkRectangle gdk_rect
;
3747 gdk_rect
.x
= rect
->x
;
3748 gdk_rect
.y
= rect
->y
;
3749 gdk_rect
.width
= rect
->width
;
3750 gdk_rect
.height
= rect
->height
;
3751 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, &gdk_rect
, TRUE
);
3755 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, NULL
, TRUE
);
3761 void wxWindowGTK::Update()
3766 void wxWindowGTK::GtkUpdate()
3769 if (m_wxwindow
&& GTK_PIZZA(m_wxwindow
)->bin_window
)
3770 gdk_window_process_updates( GTK_PIZZA(m_wxwindow
)->bin_window
, FALSE
);
3772 if (!m_updateRegion
.IsEmpty())
3773 GtkSendPaintEvents();
3777 void wxWindowGTK::GtkSendPaintEvents()
3782 m_clearRegion
.Clear();
3784 m_updateRegion
.Clear();
3788 // Clip to paint region in wxClientDC
3789 m_clipPaintRegion
= TRUE
;
3791 // widget to draw on
3792 GtkPizza
*pizza
= GTK_PIZZA (m_wxwindow
);
3794 if (GetThemeEnabled())
3796 // find ancestor from which to steal background
3797 wxWindow
*parent
= GetParent();
3798 while (parent
&& !parent
->IsTopLevel())
3799 parent
= parent
->GetParent();
3801 parent
= (wxWindow
*)this;
3803 wxRegionIterator
upd( m_updateRegion
);
3807 rect
.x
= upd
.GetX();
3808 rect
.y
= upd
.GetY();
3809 rect
.width
= upd
.GetWidth();
3810 rect
.height
= upd
.GetHeight();
3812 gtk_paint_flat_box( parent
->m_widget
->style
,
3814 (GtkStateType
)GTK_WIDGET_STATE(m_wxwindow
),
3828 wxWindowDC
dc( (wxWindow
*)this );
3829 dc
.SetClippingRegion( m_updateRegion
);
3831 wxEraseEvent
erase_event( GetId(), &dc
);
3832 erase_event
.SetEventObject( this );
3834 GetEventHandler()->ProcessEvent(erase_event
);
3837 // if (!m_clearRegion.IsEmpty()) // Always send an erase event under GTK 1.2
3839 wxWindowDC
dc( (wxWindow
*)this );
3840 if (m_clearRegion
.IsEmpty())
3841 dc
.SetClippingRegion( m_updateRegion
);
3843 dc
.SetClippingRegion( m_clearRegion
);
3845 wxEraseEvent
erase_event( GetId(), &dc
);
3846 erase_event
.SetEventObject( this );
3848 if (!GetEventHandler()->ProcessEvent(erase_event
))
3852 g_eraseGC
= gdk_gc_new( pizza
->bin_window
);
3853 gdk_gc_set_fill( g_eraseGC
, GDK_SOLID
);
3855 gdk_gc_set_foreground( g_eraseGC
, GetBackgroundColour().GetColor() );
3857 wxRegionIterator
upd( m_clearRegion
);
3860 gdk_draw_rectangle( pizza
->bin_window
, g_eraseGC
, 1,
3861 upd
.GetX(), upd
.GetY(), upd
.GetWidth(), upd
.GetHeight() );
3865 m_clearRegion
.Clear();
3869 wxNcPaintEvent
nc_paint_event( GetId() );
3870 nc_paint_event
.SetEventObject( this );
3871 GetEventHandler()->ProcessEvent( nc_paint_event
);
3873 wxPaintEvent
paint_event( GetId() );
3874 paint_event
.SetEventObject( this );
3875 GetEventHandler()->ProcessEvent( paint_event
);
3877 m_clipPaintRegion
= FALSE
;
3879 #ifndef __WXUNIVERSAL__
3881 // The following code will result in all window-less widgets
3882 // being redrawn because the wxWidgets class is allowed to
3883 // paint over the window-less widgets.
3885 GList
*children
= pizza
->children
;
3888 GtkPizzaChild
*child
= (GtkPizzaChild
*) children
->data
;
3889 children
= children
->next
;
3891 if (GTK_WIDGET_NO_WINDOW (child
->widget
) &&
3892 GTK_WIDGET_DRAWABLE (child
->widget
))
3894 // Get intersection of widget area and update region
3895 wxRegion
region( m_updateRegion
);
3897 GdkEventExpose gdk_event
;
3898 gdk_event
.type
= GDK_EXPOSE
;
3899 gdk_event
.window
= pizza
->bin_window
;
3900 gdk_event
.count
= 0;
3902 wxRegionIterator
upd( m_updateRegion
);
3906 rect
.x
= upd
.GetX();
3907 rect
.y
= upd
.GetY();
3908 rect
.width
= upd
.GetWidth();
3909 rect
.height
= upd
.GetHeight();
3911 if (gtk_widget_intersect (child
->widget
, &rect
, &gdk_event
.area
))
3913 gtk_widget_event (child
->widget
, (GdkEvent
*) &gdk_event
);
3923 m_updateRegion
.Clear();
3926 void wxWindowGTK::ClearBackground()
3928 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3931 if (m_wxwindow
&& m_wxwindow
->window
)
3933 m_clearRegion
.Clear();
3934 wxSize
size( GetClientSize() );
3935 m_clearRegion
.Union( 0,0,size
.x
,size
.y
);
3937 // Better do this in idle?
3944 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3946 wxWindowBase::DoSetToolTip(tip
);
3949 m_tooltip
->Apply( (wxWindow
*)this );
3952 void wxWindowGTK::ApplyToolTip( GtkTooltips
*tips
, const wxChar
*tip
)
3954 wxString
tmp( tip
);
3955 gtk_tooltips_set_tip( tips
, GetConnectWidget(), wxGTK_CONV(tmp
), (gchar
*) NULL
);
3957 #endif // wxUSE_TOOLTIPS
3959 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
3961 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
3963 if (!wxWindowBase::SetBackgroundColour(colour
))
3968 // We need the pixel value e.g. for background clearing.
3969 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3972 // apply style change (forceStyle=true so that new style is applied
3973 // even if the bg colour changed from valid to wxNullColour):
3974 ApplyWidgetStyle(true);
3979 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
3981 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
3983 if (!wxWindowBase::SetForegroundColour(colour
))
3990 // We need the pixel value e.g. for background clearing.
3991 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
3994 // apply style change (forceStyle=true so that new style is applied
3995 // even if the bg colour changed from valid to wxNullColour):
3996 ApplyWidgetStyle(true);
4002 PangoContext
*wxWindowGTK::GtkGetPangoDefaultContext()
4004 return gtk_widget_get_pango_context( m_widget
);
4007 PangoContext
*wxWindowGTK::GtkGetPangoX11Context()
4010 m_x11Context
= pango_x_get_context( gdk_display
);
4012 return m_x11Context
;
4016 GtkRcStyle
*wxWindowGTK::CreateWidgetStyle(bool forceStyle
)
4018 // do we need to apply any changes at all?
4021 !m_foregroundColour
.Ok() && !m_backgroundColour
.Ok() )
4026 GtkRcStyle
*style
= gtk_rc_style_new();
4032 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
4034 wxString xfontname
= m_font
.GetNativeFontInfo()->GetXFontName();
4035 style
->fontset_name
= g_strdup(xfontname
.c_str());
4039 if ( m_foregroundColour
.Ok() )
4041 GdkColor
*fg
= m_foregroundColour
.GetColor();
4043 style
->fg
[GTK_STATE_NORMAL
] = *fg
;
4044 style
->color_flags
[GTK_STATE_NORMAL
] = GTK_RC_FG
;
4046 style
->fg
[GTK_STATE_PRELIGHT
] = *fg
;
4047 style
->color_flags
[GTK_STATE_PRELIGHT
] = GTK_RC_FG
;
4049 style
->fg
[GTK_STATE_ACTIVE
] = *fg
;
4050 style
->color_flags
[GTK_STATE_ACTIVE
] = GTK_RC_FG
;
4053 if ( m_backgroundColour
.Ok() )
4055 GdkColor
*bg
= m_backgroundColour
.GetColor();
4057 style
->bg
[GTK_STATE_NORMAL
] = *bg
;
4058 style
->base
[GTK_STATE_NORMAL
] = *bg
;
4059 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)
4060 (style
->color_flags
[GTK_STATE_NORMAL
] | GTK_RC_BG
| GTK_RC_BASE
);
4062 style
->bg
[GTK_STATE_PRELIGHT
] = *bg
;
4063 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
4064 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)
4065 (style
->color_flags
[GTK_STATE_PRELIGHT
] | GTK_RC_BG
| GTK_RC_BASE
);
4067 style
->bg
[GTK_STATE_ACTIVE
] = *bg
;
4068 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
4069 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)
4070 (style
->color_flags
[GTK_STATE_ACTIVE
] | GTK_RC_BG
| GTK_RC_BASE
);
4072 style
->bg
[GTK_STATE_INSENSITIVE
] = *bg
;
4073 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
4074 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)
4075 (style
->color_flags
[GTK_STATE_INSENSITIVE
] | GTK_RC_BG
| GTK_RC_BASE
);
4081 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle
)
4083 GtkRcStyle
*style
= CreateWidgetStyle(forceStyle
);
4086 DoApplyWidgetStyle(style
);
4087 gtk_rc_style_unref(style
);
4091 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
4094 // should we also do m_widget in this case?
4095 gtk_widget_modify_style(m_wxwindow
, style
);
4097 gtk_widget_modify_style(m_widget
, style
);
4101 //-----------------------------------------------------------------------------
4102 // Pop-up menu stuff
4103 //-----------------------------------------------------------------------------
4105 #if wxUSE_MENUS_NATIVE
4108 void gtk_pop_hide_callback( GtkWidget
*WXUNUSED(widget
), bool* is_waiting
)
4110 *is_waiting
= FALSE
;
4113 static void SetInvokingWindow( wxMenu
*menu
, wxWindowGTK
*win
)
4115 menu
->SetInvokingWindow( win
);
4116 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
4119 wxMenuItem
*menuitem
= node
->GetData();
4120 if (menuitem
->IsSubMenu())
4122 SetInvokingWindow( menuitem
->GetSubMenu(), win
);
4125 node
= node
->GetNext();
4129 extern "C" void wxPopupMenuPositionCallback( GtkMenu
*menu
,
4132 gboolean
* WXUNUSED(whatever
),
4134 gpointer user_data
)
4136 // ensure that the menu appears entirely on screen
4138 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
4140 wxSize sizeScreen
= wxGetDisplaySize();
4141 wxPoint
*pos
= (wxPoint
*)user_data
;
4143 gint xmax
= sizeScreen
.x
- req
.width
,
4144 ymax
= sizeScreen
.y
- req
.height
;
4146 *x
= pos
->x
< xmax
? pos
->x
: xmax
;
4147 *y
= pos
->y
< ymax
? pos
->y
: ymax
;
4150 bool wxWindowGTK::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
4152 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4154 wxCHECK_MSG( menu
!= NULL
, false, wxT("invalid popup-menu") );
4156 SetInvokingWindow( menu
, this );
4160 bool is_waiting
= true;
4162 gtk_signal_connect( GTK_OBJECT(menu
->m_menu
),
4164 GTK_SIGNAL_FUNC(gtk_pop_hide_callback
),
4165 (gpointer
)&is_waiting
);
4169 GtkMenuPositionFunc posfunc
;
4170 if ( x
== -1 && y
== -1 )
4172 // use GTK's default positioning algorithm
4178 pos
= ClientToScreen(wxPoint(x
, y
));
4180 posfunc
= wxPopupMenuPositionCallback
;
4184 GTK_MENU(menu
->m_menu
),
4185 (GtkWidget
*) NULL
, // parent menu shell
4186 (GtkWidget
*) NULL
, // parent menu item
4187 posfunc
, // function to position it
4188 userdata
, // client data
4189 0, // button used to activate it
4191 gtk_get_current_event_time()
4193 gs_timeLastClick
// the time of activation
4199 gtk_main_iteration();
4205 #endif // wxUSE_MENUS_NATIVE
4207 #if wxUSE_DRAG_AND_DROP
4209 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4211 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4213 GtkWidget
*dnd_widget
= GetConnectWidget();
4215 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
4217 if (m_dropTarget
) delete m_dropTarget
;
4218 m_dropTarget
= dropTarget
;
4220 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
4223 #endif // wxUSE_DRAG_AND_DROP
4225 GtkWidget
* wxWindowGTK::GetConnectWidget()
4227 GtkWidget
*connect_widget
= m_widget
;
4228 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4230 return connect_widget
;
4233 bool wxWindowGTK::IsOwnGtkWindow( GdkWindow
*window
)
4236 return (window
== GTK_PIZZA(m_wxwindow
)->bin_window
);
4238 return (window
== m_widget
->window
);
4241 bool wxWindowGTK::SetFont( const wxFont
&font
)
4243 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
4245 if (!wxWindowBase::SetFont(font
))
4248 // apply style change (forceStyle=true so that new style is applied
4249 // even if the font changed from valid to wxNullFont):
4250 ApplyWidgetStyle(true);
4255 void wxWindowGTK::DoCaptureMouse()
4257 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4259 GdkWindow
*window
= (GdkWindow
*) NULL
;
4261 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4263 window
= GetConnectWidget()->window
;
4265 wxCHECK_RET( window
, _T("CaptureMouse() failed") );
4267 wxCursor
* cursor
= & m_cursor
;
4269 cursor
= wxSTANDARD_CURSOR
;
4271 gdk_pointer_grab( window
, FALSE
,
4273 (GDK_BUTTON_PRESS_MASK
|
4274 GDK_BUTTON_RELEASE_MASK
|
4275 GDK_POINTER_MOTION_HINT_MASK
|
4276 GDK_POINTER_MOTION_MASK
),
4278 cursor
->GetCursor(),
4279 (guint32
)GDK_CURRENT_TIME
);
4280 g_captureWindow
= this;
4281 g_captureWindowHasMouse
= TRUE
;
4284 void wxWindowGTK::DoReleaseMouse()
4286 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4288 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4290 g_captureWindow
= (wxWindowGTK
*) NULL
;
4292 GdkWindow
*window
= (GdkWindow
*) NULL
;
4294 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4296 window
= GetConnectWidget()->window
;
4301 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4305 wxWindow
*wxWindowBase::GetCapture()
4307 return (wxWindow
*)g_captureWindow
;
4310 bool wxWindowGTK::IsRetained() const
4315 void wxWindowGTK::SetScrollbar( int orient
, int pos
, int thumbVisible
,
4316 int range
, bool refresh
)
4318 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4320 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4322 m_hasScrolling
= TRUE
;
4324 if (orient
== wxHORIZONTAL
)
4326 float fpos
= (float)pos
;
4327 float frange
= (float)range
;
4328 float fthumb
= (float)thumbVisible
;
4329 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
4330 if (fpos
< 0.0) fpos
= 0.0;
4332 if ((fabs(frange
-m_hAdjust
->upper
) < 0.2) &&
4333 (fabs(fthumb
-m_hAdjust
->page_size
) < 0.2))
4335 SetScrollPos( orient
, pos
, refresh
);
4339 m_oldHorizontalPos
= fpos
;
4341 m_hAdjust
->lower
= 0.0;
4342 m_hAdjust
->upper
= frange
;
4343 m_hAdjust
->value
= fpos
;
4344 m_hAdjust
->step_increment
= 1.0;
4345 m_hAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
4346 m_hAdjust
->page_size
= fthumb
;
4350 float fpos
= (float)pos
;
4351 float frange
= (float)range
;
4352 float fthumb
= (float)thumbVisible
;
4353 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
4354 if (fpos
< 0.0) fpos
= 0.0;
4356 if ((fabs(frange
-m_vAdjust
->upper
) < 0.2) &&
4357 (fabs(fthumb
-m_vAdjust
->page_size
) < 0.2))
4359 SetScrollPos( orient
, pos
, refresh
);
4363 m_oldVerticalPos
= fpos
;
4365 m_vAdjust
->lower
= 0.0;
4366 m_vAdjust
->upper
= frange
;
4367 m_vAdjust
->value
= fpos
;
4368 m_vAdjust
->step_increment
= 1.0;
4369 m_vAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
4370 m_vAdjust
->page_size
= fthumb
;
4373 if (orient
== wxHORIZONTAL
)
4374 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
4376 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
4379 void wxWindowGTK::SetScrollPos( int orient
, int pos
, bool WXUNUSED(refresh
) )
4381 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4383 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4385 if (orient
== wxHORIZONTAL
)
4387 float fpos
= (float)pos
;
4388 if (fpos
> m_hAdjust
->upper
- m_hAdjust
->page_size
) fpos
= m_hAdjust
->upper
- m_hAdjust
->page_size
;
4389 if (fpos
< 0.0) fpos
= 0.0;
4390 m_oldHorizontalPos
= fpos
;
4392 if (fabs(fpos
-m_hAdjust
->value
) < 0.2) return;
4393 m_hAdjust
->value
= fpos
;
4397 float fpos
= (float)pos
;
4398 if (fpos
> m_vAdjust
->upper
- m_vAdjust
->page_size
) fpos
= m_vAdjust
->upper
- m_vAdjust
->page_size
;
4399 if (fpos
< 0.0) fpos
= 0.0;
4400 m_oldVerticalPos
= fpos
;
4402 if (fabs(fpos
-m_vAdjust
->value
) < 0.2) return;
4403 m_vAdjust
->value
= fpos
;
4406 if (m_wxwindow
->window
)
4408 if (orient
== wxHORIZONTAL
)
4410 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust
),
4411 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
4413 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "value_changed" );
4415 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
4416 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
4420 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust
),
4421 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
4423 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "value_changed" );
4425 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
4426 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
4431 int wxWindowGTK::GetScrollThumb( int orient
) const
4433 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4435 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4437 if (orient
== wxHORIZONTAL
)
4438 return (int)(m_hAdjust
->page_size
+0.5);
4440 return (int)(m_vAdjust
->page_size
+0.5);
4443 int wxWindowGTK::GetScrollPos( int orient
) const
4445 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4447 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4449 if (orient
== wxHORIZONTAL
)
4450 return (int)(m_hAdjust
->value
+0.5);
4452 return (int)(m_vAdjust
->value
+0.5);
4455 int wxWindowGTK::GetScrollRange( int orient
) const
4457 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4459 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4461 if (orient
== wxHORIZONTAL
)
4462 return (int)(m_hAdjust
->upper
+0.5);
4464 return (int)(m_vAdjust
->upper
+0.5);
4467 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4469 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4471 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4473 // No scrolling requested.
4474 if ((dx
== 0) && (dy
== 0)) return;
4477 if (!m_updateRegion
.IsEmpty())
4479 m_updateRegion
.Offset( dx
, dy
);
4483 GetClientSize( &cw
, &ch
);
4484 m_updateRegion
.Intersect( 0, 0, cw
, ch
);
4487 if (!m_clearRegion
.IsEmpty())
4489 m_clearRegion
.Offset( dx
, dy
);
4493 GetClientSize( &cw
, &ch
);
4494 m_clearRegion
.Intersect( 0, 0, cw
, ch
);
4498 m_clipPaintRegion
= TRUE
;
4500 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), -dx
, -dy
);
4502 m_clipPaintRegion
= FALSE
;
4506 // Find the wxWindow at the current mouse position, also returning the mouse
4508 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4510 pt
= wxGetMousePosition();
4511 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4515 // Get the current mouse position.
4516 wxPoint
wxGetMousePosition()
4518 /* This crashes when used within wxHelpContext,
4519 so we have to use the X-specific implementation below.
4521 GdkModifierType *mask;
4522 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4524 return wxPoint(x, y);
4528 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4530 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4531 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4532 Window rootReturn
, childReturn
;
4533 int rootX
, rootY
, winX
, winY
;
4534 unsigned int maskReturn
;
4536 XQueryPointer (display
,
4540 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4541 return wxPoint(rootX
, rootY
);
4545 // ----------------------------------------------------------------------------
4547 // ----------------------------------------------------------------------------
4549 class wxWinModule
: public wxModule
4556 DECLARE_DYNAMIC_CLASS(wxWinModule
)
4559 IMPLEMENT_DYNAMIC_CLASS(wxWinModule
, wxModule
)
4561 bool wxWinModule::OnInit()
4563 // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
4564 // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
4569 void wxWinModule::OnExit()
4572 gdk_gc_unref( g_eraseGC
);