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 wxWindows, 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 wxWindows 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 wxWindows 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 wxStatitText 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 wxWindows 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 wxWindows 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 wxWindows, 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 wxWindows 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 //-----------------------------------------------------------------------------
271 #define DISABLE_STYLE_IF_BROKEN_THEME 0
277 # define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
279 # define DEBUG_MAIN_THREAD
282 #define DEBUG_MAIN_THREAD
285 // the trace mask used for the focus debugging messages
286 #define TRACE_FOCUS _T("focus")
288 //-----------------------------------------------------------------------------
289 // missing gdk functions
290 //-----------------------------------------------------------------------------
293 gdk_window_warp_pointer (GdkWindow
*window
,
298 GdkWindowPrivate
*priv
;
302 window
= GDK_ROOT_PARENT();
305 if (!GDK_WINDOW_DESTROYED(window
))
307 XWarpPointer (GDK_WINDOW_XDISPLAY(window
),
308 None
, /* not source window -> move from anywhere */
309 GDK_WINDOW_XID(window
), /* dest window */
310 0, 0, 0, 0, /* not source window -> move from anywhere */
314 priv
= (GdkWindowPrivate
*) window
;
316 if (!priv
->destroyed
)
318 XWarpPointer (priv
->xdisplay
,
319 None
, /* not source window -> move from anywhere */
320 priv
->xwindow
, /* dest window */
321 0, 0, 0, 0, /* not source window -> move from anywhere */
327 //-----------------------------------------------------------------------------
329 //-----------------------------------------------------------------------------
331 extern void wxapp_install_idle_handler();
332 extern bool g_isIdle
;
334 //-----------------------------------------------------------------------------
335 // local code (see below)
336 //-----------------------------------------------------------------------------
338 // returns the child of win which currently has focus or NULL if not found
340 // Note: can't be static, needed by textctrl.cpp.
341 wxWindow
*wxFindFocusedChild(wxWindowGTK
*win
)
343 wxWindow
*winFocus
= wxWindowGTK::FindFocus();
345 return (wxWindow
*)NULL
;
347 if ( winFocus
== win
)
348 return (wxWindow
*)win
;
350 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
352 node
= node
->GetNext() )
354 wxWindow
*child
= wxFindFocusedChild(node
->GetData());
359 return (wxWindow
*)NULL
;
362 static void draw_frame( GtkWidget
*widget
, wxWindowGTK
*win
)
364 // wxUniversal widgets draw the borders and scrollbars themselves
365 #ifndef __WXUNIVERSAL__
372 if (win
->m_hasScrolling
)
374 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(widget
);
376 GtkRequisition vscroll_req
;
377 vscroll_req
.width
= 2;
378 vscroll_req
.height
= 2;
379 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
380 (scroll_window
->vscrollbar
, &vscroll_req
);
382 GtkRequisition hscroll_req
;
383 hscroll_req
.width
= 2;
384 hscroll_req
.height
= 2;
385 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
386 (scroll_window
->hscrollbar
, &hscroll_req
);
388 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(widget
) );
390 if (scroll_window
->vscrollbar_visible
)
392 dw
+= vscroll_req
.width
;
393 dw
+= scroll_class
->scrollbar_spacing
;
396 if (scroll_window
->hscrollbar_visible
)
398 dh
+= hscroll_req
.height
;
399 dh
+= scroll_class
->scrollbar_spacing
;
405 if (GTK_WIDGET_NO_WINDOW (widget
))
407 dx
+= widget
->allocation
.x
;
408 dy
+= widget
->allocation
.y
;
411 if (win
->HasFlag(wxRAISED_BORDER
))
413 gtk_draw_shadow( widget
->style
,
418 widget
->allocation
.width
-dw
, widget
->allocation
.height
-dh
);
422 if (win
->HasFlag(wxSUNKEN_BORDER
))
424 gtk_draw_shadow( widget
->style
,
429 widget
->allocation
.width
-dw
, widget
->allocation
.height
-dh
);
433 if (win
->HasFlag(wxSIMPLE_BORDER
))
436 gc
= gdk_gc_new( widget
->window
);
437 gdk_gc_set_foreground( gc
, &widget
->style
->black
);
438 gdk_draw_rectangle( widget
->window
, gc
, FALSE
,
440 widget
->allocation
.width
-dw
-1, widget
->allocation
.height
-dh
-1 );
444 #endif // __WXUNIVERSAL__
447 //-----------------------------------------------------------------------------
448 // "expose_event" of m_widget
449 //-----------------------------------------------------------------------------
451 gint
gtk_window_own_expose_callback( GtkWidget
*widget
, GdkEventExpose
*gdk_event
, wxWindowGTK
*win
)
453 if (gdk_event
->count
> 0) return FALSE
;
455 draw_frame( widget
, win
);
459 (* GTK_WIDGET_CLASS (pizza_parent_class
)->expose_event
) (widget
, gdk_event
);
465 //-----------------------------------------------------------------------------
466 // "draw" of m_widget
467 //-----------------------------------------------------------------------------
471 static void gtk_window_own_draw_callback( GtkWidget
*widget
, GdkRectangle
*WXUNUSED(rect
), wxWindowGTK
*win
)
473 draw_frame( widget
, win
);
478 //-----------------------------------------------------------------------------
479 // "size_request" of m_widget
480 //-----------------------------------------------------------------------------
482 // make it extern because wxStatitText needs to disconnect this one
484 void wxgtk_window_size_request_callback(GtkWidget
*widget
,
485 GtkRequisition
*requisition
,
489 win
->GetSize( &w
, &h
);
495 requisition
->height
= h
;
496 requisition
->width
= w
;
499 //-----------------------------------------------------------------------------
500 // "expose_event" of m_wxwindow
501 //-----------------------------------------------------------------------------
503 static int gtk_window_expose_callback( GtkWidget
*widget
,
504 GdkEventExpose
*gdk_event
,
510 wxapp_install_idle_handler();
513 // This callback gets called in drawing-idle time under
514 // GTK 2.0, so we don't need to defer anything to idle
517 GtkPizza
*pizza
= GTK_PIZZA( widget
);
518 if (gdk_event
->window
!= pizza
->bin_window
) return FALSE
;
523 wxPrintf( wxT("OnExpose from ") );
524 if (win
->GetClassInfo() && win
->GetClassInfo()->GetClassName())
525 wxPrintf( win
->GetClassInfo()->GetClassName() );
526 wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event
->area
.x
,
527 (int)gdk_event
->area
.y
,
528 (int)gdk_event
->area
.width
,
529 (int)gdk_event
->area
.height
);
534 win
->m_wxwindow
->style
,
538 (GdkRectangle
*) NULL
,
540 (char *)"button", // const_cast
545 win
->GetUpdateRegion() = wxRegion( gdk_event
->region
);
547 win
->GtkSendPaintEvents();
550 // Let parent window draw window less widgets
551 (* GTK_WIDGET_CLASS (pizza_parent_class
)->expose_event
) (widget
, gdk_event
);
553 // This gets called immediately after an expose event
554 // under GTK 1.2 so we collect the calls and wait for
555 // the idle handler to pick things up.
557 win
->GetUpdateRegion().Union( gdk_event
->area
.x
,
559 gdk_event
->area
.width
,
560 gdk_event
->area
.height
);
561 win
->m_clearRegion
.Union( gdk_event
->area
.x
,
563 gdk_event
->area
.width
,
564 gdk_event
->area
.height
);
566 // Actual redrawing takes place in idle time.
573 //-----------------------------------------------------------------------------
574 // "event" of m_wxwindow
575 //-----------------------------------------------------------------------------
577 // GTK thinks it is clever and filters out a certain amount of "unneeded"
578 // expose events. We need them, of course, so we override the main event
579 // procedure in GtkWidget by giving our own handler for all system events.
580 // There, we look for expose events ourselves whereas all other events are
583 gint
gtk_window_event_event_callback( GtkWidget
*widget
,
584 GdkEventExpose
*event
,
587 if (event
->type
== GDK_EXPOSE
)
589 gint ret
= gtk_window_expose_callback( widget
, event
, win
);
596 //-----------------------------------------------------------------------------
597 // "draw" of m_wxwindow
598 //-----------------------------------------------------------------------------
602 // This callback is a complete replacement of the gtk_pizza_draw() function,
603 // which is disabled.
605 static void gtk_window_draw_callback( GtkWidget
*widget
,
612 wxapp_install_idle_handler();
614 // if there are any children we must refresh everything
617 if ( !win
->HasFlag(wxFULL_REPAINT_ON_RESIZE
) &&
618 win
->GetChildren().IsEmpty() )
626 wxPrintf( wxT("OnDraw from ") );
627 if (win
->GetClassInfo() && win
->GetClassInfo()->GetClassName())
628 wxPrintf( win
->GetClassInfo()->GetClassName() );
629 wxPrintf( wxT(" %d %d %d %d\n"), (int)rect
->x
,
636 #ifndef __WXUNIVERSAL__
637 GtkPizza
*pizza
= GTK_PIZZA (widget
);
639 if (win
->GetThemeEnabled())
641 wxWindow
*parent
= win
->GetParent();
642 while (parent
&& !parent
->IsTopLevel())
643 parent
= parent
->GetParent();
647 gtk_paint_flat_box (parent
->m_widget
->style
,
658 win
->m_clearRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
659 win
->GetUpdateRegion().Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
661 // Update immediately, not in idle time.
664 #ifndef __WXUNIVERSAL__
665 // Redraw child widgets
666 GList
*children
= pizza
->children
;
669 GtkPizzaChild
*child
= (GtkPizzaChild
*) children
->data
;
670 children
= children
->next
;
672 GdkRectangle child_area
;
673 if (gtk_widget_intersect (child
->widget
, rect
, &child_area
))
675 gtk_widget_draw (child
->widget
, &child_area
/* (GdkRectangle*) NULL*/ );
683 //-----------------------------------------------------------------------------
684 // "key_press_event" from any window
685 //-----------------------------------------------------------------------------
687 // set WXTRACE to this to see the key event codes on the console
688 #define TRACE_KEYS _T("keyevent")
690 // translates an X key symbol to WXK_XXX value
692 // if isChar is true it means that the value returned will be used for EVT_CHAR
693 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
694 // for example, while if it is false it means that the value is going to be
695 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
697 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
703 // Shift, Control and Alt don't generate the CHAR events at all
706 key_code
= isChar
? 0 : WXK_SHIFT
;
710 key_code
= isChar
? 0 : WXK_CONTROL
;
718 key_code
= isChar
? 0 : WXK_ALT
;
721 // neither do the toggle modifies
722 case GDK_Scroll_Lock
:
723 key_code
= isChar
? 0 : WXK_SCROLL
;
727 key_code
= isChar
? 0 : WXK_CAPITAL
;
731 key_code
= isChar
? 0 : WXK_NUMLOCK
;
735 // various other special keys
748 case GDK_ISO_Left_Tab
:
755 key_code
= WXK_RETURN
;
759 key_code
= WXK_CLEAR
;
763 key_code
= WXK_PAUSE
;
767 key_code
= WXK_SELECT
;
771 key_code
= WXK_PRINT
;
775 key_code
= WXK_EXECUTE
;
779 key_code
= WXK_ESCAPE
;
782 // cursor and other extended keyboard keys
784 key_code
= WXK_DELETE
;
800 key_code
= WXK_RIGHT
;
807 case GDK_Prior
: // == GDK_Page_Up
808 key_code
= WXK_PRIOR
;
811 case GDK_Next
: // == GDK_Page_Down
824 key_code
= WXK_INSERT
;
839 key_code
= (isChar
? '0' : WXK_NUMPAD0
) + keysym
- GDK_KP_0
;
843 key_code
= isChar
? ' ' : WXK_NUMPAD_SPACE
;
847 key_code
= isChar
? WXK_TAB
: WXK_NUMPAD_TAB
;
851 key_code
= isChar
? WXK_RETURN
: WXK_NUMPAD_ENTER
;
855 key_code
= isChar
? WXK_F1
: WXK_NUMPAD_F1
;
859 key_code
= isChar
? WXK_F2
: WXK_NUMPAD_F2
;
863 key_code
= isChar
? WXK_F3
: WXK_NUMPAD_F3
;
867 key_code
= isChar
? WXK_F4
: WXK_NUMPAD_F4
;
871 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_HOME
;
875 key_code
= isChar
? WXK_LEFT
: WXK_NUMPAD_LEFT
;
879 key_code
= isChar
? WXK_UP
: WXK_NUMPAD_UP
;
883 key_code
= isChar
? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
887 key_code
= isChar
? WXK_DOWN
: WXK_NUMPAD_DOWN
;
890 case GDK_KP_Prior
: // == GDK_KP_Page_Up
891 key_code
= isChar
? WXK_PRIOR
: WXK_NUMPAD_PRIOR
;
894 case GDK_KP_Next
: // == GDK_KP_Page_Down
895 key_code
= isChar
? WXK_NEXT
: WXK_NUMPAD_NEXT
;
899 key_code
= isChar
? WXK_END
: WXK_NUMPAD_END
;
903 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_BEGIN
;
907 key_code
= isChar
? WXK_INSERT
: WXK_NUMPAD_INSERT
;
911 key_code
= isChar
? WXK_DELETE
: WXK_NUMPAD_DELETE
;
915 key_code
= isChar
? '=' : WXK_NUMPAD_EQUAL
;
918 case GDK_KP_Multiply
:
919 key_code
= isChar
? '*' : WXK_NUMPAD_MULTIPLY
;
923 key_code
= isChar
? '+' : WXK_NUMPAD_ADD
;
926 case GDK_KP_Separator
:
927 // FIXME: what is this?
928 key_code
= isChar
? '.' : WXK_NUMPAD_SEPARATOR
;
931 case GDK_KP_Subtract
:
932 key_code
= isChar
? '-' : WXK_NUMPAD_SUBTRACT
;
936 key_code
= isChar
? '.' : WXK_NUMPAD_DECIMAL
;
940 key_code
= isChar
? '/' : WXK_NUMPAD_DIVIDE
;
957 key_code
= WXK_F1
+ keysym
- GDK_F1
;
967 static inline bool wxIsAsciiKeysym(KeySym ks
)
973 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
975 GdkEventKey
*gdk_event
)
977 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
978 // but only event->keyval which is quite useless to us, so remember
979 // the last character from GDK_KEY_PRESS and reuse it as last resort
981 // NB: should be MT-safe as we're always called from the main thread only
986 } s_lastKeyPress
= { 0, 0 };
988 KeySym keysym
= gdk_event
->keyval
;
990 wxLogTrace(TRACE_KEYS
, _T("Key %s event: keysym = %ld"),
991 event
.GetEventType() == wxEVT_KEY_UP
? _T("release")
995 long key_code
= wxTranslateKeySymToWXKey(keysym
, FALSE
/* !isChar */);
999 // do we have the translation or is it a plain ASCII character?
1000 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
1002 // we should use keysym if it is ASCII as X does some translations
1003 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
1004 // which we don't want here (but which we do use for OnChar())
1005 if ( !wxIsAsciiKeysym(keysym
) )
1007 keysym
= (KeySym
)gdk_event
->string
[0];
1010 // we want to always get the same key code when the same key is
1011 // pressed regardless of the state of the modifies, i.e. on a
1012 // standard US keyboard pressing '5' or '%' ('5' key with
1013 // Shift) should result in the same key code in OnKeyDown():
1014 // '5' (although OnChar() will get either '5' or '%').
1016 // to do it we first translate keysym to keycode (== scan code)
1017 // and then back but always using the lower register
1018 Display
*dpy
= (Display
*)wxGetDisplay();
1019 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
1021 wxLogTrace(TRACE_KEYS
, _T("\t-> keycode %d"), keycode
);
1023 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
1025 // use the normalized, i.e. lower register, keysym if we've
1027 key_code
= keysymNormalized
? keysymNormalized
: keysym
;
1029 // as explained above, we want to have lower register key codes
1030 // normally but for the letter keys we want to have the upper ones
1032 // NB: don't use XConvertCase() here, we want to do it for letters
1034 key_code
= toupper(key_code
);
1036 else // non ASCII key, what to do?
1038 // by default, ignore it
1041 // but if we have cached information from the last KEY_PRESS
1042 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
1045 if ( keysym
== s_lastKeyPress
.keysym
)
1047 key_code
= s_lastKeyPress
.keycode
;
1052 if ( gdk_event
->type
== GDK_KEY_PRESS
)
1054 // remember it to be reused for KEY_UP event later
1055 s_lastKeyPress
.keysym
= keysym
;
1056 s_lastKeyPress
.keycode
= key_code
;
1060 wxLogTrace(TRACE_KEYS
, _T("\t-> wxKeyCode %ld"), key_code
);
1062 // sending unknown key events doesn't really make sense
1066 // now fill all the other fields
1069 GdkModifierType state
;
1070 if (gdk_event
->window
)
1071 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1073 event
.SetTimestamp( gdk_event
->time
);
1074 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
1075 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
1076 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
1077 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
) != 0;
1078 event
.m_keyCode
= key_code
;
1079 event
.m_scanCode
= gdk_event
->keyval
;
1080 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
1081 event
.m_rawFlags
= 0;
1084 event
.SetEventObject( win
);
1090 static gint
gtk_window_key_press_callback( GtkWidget
*widget
,
1091 GdkEventKey
*gdk_event
,
1097 wxapp_install_idle_handler();
1101 if (g_blockEventsOnDrag
)
1105 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1106 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1108 // unknown key pressed, ignore (the event would be useless anyhow)
1112 // Emit KEY_DOWN event
1113 bool ret
= win
->GetEventHandler()->ProcessEvent( event
);
1118 wxWindowGTK
*ancestor
= win
;
1121 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
1124 wxCommandEvent
command_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
1125 ret
= ancestor
->GetEventHandler()->ProcessEvent( command_event
);
1128 if (ancestor
->IsTopLevel())
1130 ancestor
= ancestor
->GetParent();
1133 #endif // wxUSE_ACCEL
1135 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1136 // will only be sent if it is not in an accelerator table.
1140 KeySym keysym
= gdk_event
->keyval
;
1142 // In GTK 2.0, we need to hand over the key event to an input method
1143 // and the IM will emit a "commit" event containing the actual utf8
1144 // character. In that case the EVT_CHAR events will be sent from
1145 // there. But only do it this way for non-KeySym keys.
1146 key_code
= wxTranslateKeySymToWXKey(gdk_event
->keyval
, FALSE
/* isChar */);
1147 if ( !key_code
&& win
->m_imContext
)
1149 gtk_im_context_filter_keypress ( (GtkIMContext
*) win
->m_imContext
, gdk_event
);
1155 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1156 key_code
= wxTranslateKeySymToWXKey(keysym
, TRUE
/* isChar */);
1159 if ( gdk_event
->length
== 1 )
1161 key_code
= (unsigned char)gdk_event
->string
[0];
1163 else if ( wxIsAsciiKeysym(keysym
) )
1166 key_code
= (unsigned char)keysym
;
1172 wxLogTrace(TRACE_KEYS
, _T("Char event: %ld"), key_code
);
1174 event
.m_keyCode
= key_code
;
1176 // Implement OnCharHook by checking ancesteror top level windows
1177 wxWindow
*parent
= win
;
1178 while (parent
&& !parent
->IsTopLevel())
1179 parent
= parent
->GetParent();
1182 event
.SetEventType( wxEVT_CHAR_HOOK
);
1183 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1188 event
.SetEventType(wxEVT_CHAR
);
1189 ret
= win
->GetEventHandler()->ProcessEvent( event
);
1195 // win is a control: tab can be propagated up
1197 ((gdk_event
->keyval
== GDK_Tab
) || (gdk_event
->keyval
== GDK_ISO_Left_Tab
)) &&
1198 // VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may
1199 // have this style, yet choose not to process this particular TAB in which
1200 // case TAB must still work as a navigational character
1202 !win
->HasFlag(wxTE_PROCESS_TAB
) &&
1204 win
->GetParent() && (win
->GetParent()->HasFlag( wxTAB_TRAVERSAL
)) )
1206 wxNavigationKeyEvent new_event
;
1207 new_event
.SetEventObject( win
->GetParent() );
1208 // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
1209 new_event
.SetDirection( (gdk_event
->keyval
== GDK_Tab
) );
1210 // CTRL-TAB changes the (parent) window, i.e. switch notebook page
1211 new_event
.SetWindowChange( (gdk_event
->state
& GDK_CONTROL_MASK
) );
1212 new_event
.SetCurrentFocus( win
);
1213 ret
= win
->GetParent()->GetEventHandler()->ProcessEvent( new_event
);
1216 // generate wxID_CANCEL if <esc> has been pressed (typically in dialogs)
1218 (gdk_event
->keyval
== GDK_Escape
) )
1220 // however only do it if we have a Cancel button in the dialog,
1221 // otherwise the user code may get confused by the events from a
1222 // non-existing button and, worse, a wxButton might get button event
1223 // from another button which is not really expected
1224 wxWindow
*winForCancel
= win
,
1226 while ( winForCancel
)
1228 btnCancel
= winForCancel
->FindWindow(wxID_CANCEL
);
1231 // found a cancel button
1235 if ( winForCancel
->IsTopLevel() )
1237 // no need to look further
1241 // maybe our parent has a cancel button?
1242 winForCancel
= winForCancel
->GetParent();
1247 wxCommandEvent
event(wxEVT_COMMAND_BUTTON_CLICKED
, wxID_CANCEL
);
1248 event
.SetEventObject(btnCancel
);
1249 ret
= btnCancel
->GetEventHandler()->ProcessEvent(event
);
1255 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_press_event" );
1263 static void gtk_wxwindow_commit_cb (GtkIMContext
*context
,
1269 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1272 event
.m_uniChar
= g_utf8_get_char( str
);
1274 // Backward compatible for ISO-8859
1275 if (event
.m_uniChar
< 256)
1276 event
.m_keyCode
= event
.m_uniChar
;
1278 gunichar uniChar
= g_utf8_get_char( str
);
1279 // We cannot handle Unicode in non-Unicode mode
1280 if (uniChar
> 255) return;
1282 event
.m_keyCode
= uniChar
;
1286 // TODO: We still need to set all the extra attributes of the
1287 // event, modifiers and such...
1290 // Implement OnCharHook by checking ancestor top level windows
1291 wxWindow
*parent
= window
;
1292 while (parent
&& !parent
->IsTopLevel())
1293 parent
= parent
->GetParent();
1296 event
.SetEventType( wxEVT_CHAR_HOOK
);
1297 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1302 event
.SetEventType(wxEVT_CHAR
);
1303 ret
= window
->GetEventHandler()->ProcessEvent( event
);
1309 //-----------------------------------------------------------------------------
1310 // "key_release_event" from any window
1311 //-----------------------------------------------------------------------------
1313 static gint
gtk_window_key_release_callback( GtkWidget
*widget
,
1314 GdkEventKey
*gdk_event
,
1320 wxapp_install_idle_handler();
1325 if (g_blockEventsOnDrag
)
1328 wxKeyEvent
event( wxEVT_KEY_UP
);
1329 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1331 // unknown key pressed, ignore (the event would be useless anyhow
1335 if ( !win
->GetEventHandler()->ProcessEvent( event
) )
1338 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_release_event" );
1342 // ============================================================================
1344 // ============================================================================
1346 // ----------------------------------------------------------------------------
1347 // mouse event processing helpers
1348 // ----------------------------------------------------------------------------
1350 // init wxMouseEvent with the info from gdk_event
1352 // NB: this has to be a macro as gdk_event type is different for different
1353 // events we're used with
1354 #define InitMouseEvent(/* wxWindowGTK * */ win, \
1355 /* wxMouseEvent& */ event, \
1356 /* GdkEventXXX * */ gdk_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.1.0 thing
1542 #if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 1, 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 wxWindows 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();
2314 if (win
->m_delayedBackgroundColour
&& !win
->GetThemeEnabled())
2315 win
->GtkSetBackgroundColour( win
->GetBackgroundColour() );
2317 if (win
->m_delayedForegroundColour
&& !win
->GetThemeEnabled())
2318 win
->GtkSetForegroundColour( win
->GetForegroundColour() );
2321 if (win
->m_imContext
)
2323 GtkPizza
*pizza
= GTK_PIZZA( m_widget
);
2324 gtk_im_context_set_client_window( (GtkIMContext
*) win
->m_imContext
, pizza
->bin_window
);
2328 wxWindowCreateEvent
event( win
);
2329 event
.SetEventObject( win
);
2330 win
->GetEventHandler()->ProcessEvent( event
);
2335 //-----------------------------------------------------------------------------
2337 //-----------------------------------------------------------------------------
2340 void gtk_window_size_callback( GtkWidget
*WXUNUSED(widget
),
2341 GtkAllocation
*WXUNUSED(alloc
),
2345 wxapp_install_idle_handler();
2347 if (!win
->m_hasScrolling
) return;
2349 int client_width
= 0;
2350 int client_height
= 0;
2351 win
->GetClientSize( &client_width
, &client_height
);
2352 if ((client_width
== win
->m_oldClientWidth
) && (client_height
== win
->m_oldClientHeight
))
2355 win
->m_oldClientWidth
= client_width
;
2356 win
->m_oldClientHeight
= client_height
;
2358 if (!win
->m_nativeSizeEvent
)
2360 wxSizeEvent
event( win
->GetSize(), win
->GetId() );
2361 event
.SetEventObject( win
);
2362 win
->GetEventHandler()->ProcessEvent( event
);
2368 #define WXUNUSED_UNLESS_XIM(param) param
2370 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2373 /* Resize XIM window */
2376 void gtk_wxwindow_size_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2377 GtkAllocation
* WXUNUSED_UNLESS_XIM(alloc
),
2378 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2381 wxapp_install_idle_handler();
2387 if (gdk_ic_get_style (win
->m_ic
) & GDK_IM_PREEDIT_POSITION
)
2391 gdk_window_get_size (widget
->window
, &width
, &height
);
2392 win
->m_icattr
->preedit_area
.width
= width
;
2393 win
->m_icattr
->preedit_area
.height
= height
;
2394 gdk_ic_set_attr (win
->m_ic
, win
->m_icattr
, GDK_IC_PREEDIT_AREA
);
2399 //-----------------------------------------------------------------------------
2400 // "realize" from m_wxwindow
2401 //-----------------------------------------------------------------------------
2403 /* Initialize XIM support */
2406 gtk_wxwindow_realized_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2407 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2410 wxapp_install_idle_handler();
2413 if (win
->m_ic
) return FALSE
;
2414 if (!widget
) return FALSE
;
2415 if (!gdk_im_ready()) return FALSE
;
2417 win
->m_icattr
= gdk_ic_attr_new();
2418 if (!win
->m_icattr
) return FALSE
;
2422 GdkColormap
*colormap
;
2423 GdkICAttr
*attr
= win
->m_icattr
;
2424 unsigned attrmask
= GDK_IC_ALL_REQ
;
2426 GdkIMStyle supported_style
= (GdkIMStyle
)
2427 (GDK_IM_PREEDIT_NONE
|
2428 GDK_IM_PREEDIT_NOTHING
|
2429 GDK_IM_PREEDIT_POSITION
|
2430 GDK_IM_STATUS_NONE
|
2431 GDK_IM_STATUS_NOTHING
);
2433 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2434 supported_style
= (GdkIMStyle
)(supported_style
& ~GDK_IM_PREEDIT_POSITION
);
2436 attr
->style
= style
= gdk_im_decide_style (supported_style
);
2437 attr
->client_window
= widget
->window
;
2439 if ((colormap
= gtk_widget_get_colormap (widget
)) !=
2440 gtk_widget_get_default_colormap ())
2442 attrmask
|= GDK_IC_PREEDIT_COLORMAP
;
2443 attr
->preedit_colormap
= colormap
;
2446 attrmask
|= GDK_IC_PREEDIT_FOREGROUND
;
2447 attrmask
|= GDK_IC_PREEDIT_BACKGROUND
;
2448 attr
->preedit_foreground
= widget
->style
->fg
[GTK_STATE_NORMAL
];
2449 attr
->preedit_background
= widget
->style
->base
[GTK_STATE_NORMAL
];
2451 switch (style
& GDK_IM_PREEDIT_MASK
)
2453 case GDK_IM_PREEDIT_POSITION
:
2454 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2456 g_warning ("over-the-spot style requires fontset");
2460 gdk_window_get_size (widget
->window
, &width
, &height
);
2462 attrmask
|= GDK_IC_PREEDIT_POSITION_REQ
;
2463 attr
->spot_location
.x
= 0;
2464 attr
->spot_location
.y
= height
;
2465 attr
->preedit_area
.x
= 0;
2466 attr
->preedit_area
.y
= 0;
2467 attr
->preedit_area
.width
= width
;
2468 attr
->preedit_area
.height
= height
;
2469 attr
->preedit_fontset
= widget
->style
->font
;
2474 win
->m_ic
= gdk_ic_new (attr
, (GdkICAttributesType
)attrmask
);
2476 if (win
->m_ic
== NULL
)
2477 g_warning ("Can't create input context.");
2480 mask
= gdk_window_get_events (widget
->window
);
2481 mask
= (GdkEventMask
)(mask
| gdk_ic_get_events (win
->m_ic
));
2482 gdk_window_set_events (widget
->window
, mask
);
2484 if (GTK_WIDGET_HAS_FOCUS(widget
))
2485 gdk_im_begin (win
->m_ic
, widget
->window
);
2492 //-----------------------------------------------------------------------------
2493 // InsertChild for wxWindowGTK.
2494 //-----------------------------------------------------------------------------
2496 /* Callback for wxWindowGTK. This very strange beast has to be used because
2497 * C++ has no virtual methods in a constructor. We have to emulate a
2498 * virtual function here as wxNotebook requires a different way to insert
2499 * a child in it. I had opted for creating a wxNotebookPage window class
2500 * which would have made this superfluous (such in the MDI window system),
2501 * but no-one was listening to me... */
2503 static void wxInsertChildInWindow( wxWindowGTK
* parent
, wxWindowGTK
* child
)
2505 /* the window might have been scrolled already, do we
2506 have to adapt the position */
2507 GtkPizza
*pizza
= GTK_PIZZA(parent
->m_wxwindow
);
2508 child
->m_x
+= pizza
->xoffset
;
2509 child
->m_y
+= pizza
->yoffset
;
2511 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
2512 GTK_WIDGET(child
->m_widget
),
2519 //-----------------------------------------------------------------------------
2521 //-----------------------------------------------------------------------------
2523 wxWindow
*wxGetActiveWindow()
2525 return wxWindow::FindFocus();
2528 //-----------------------------------------------------------------------------
2530 //-----------------------------------------------------------------------------
2532 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2534 #ifdef __WXUNIVERSAL__
2535 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2537 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
2538 #endif // __WXUNIVERSAL__/__WXGTK__
2540 void wxWindowGTK::Init()
2543 m_widget
= (GtkWidget
*) NULL
;
2544 m_wxwindow
= (GtkWidget
*) NULL
;
2545 m_focusWidget
= (GtkWidget
*) NULL
;
2555 m_needParent
= TRUE
;
2556 m_isBeingDeleted
= FALSE
;
2559 m_nativeSizeEvent
= FALSE
;
2561 m_hasScrolling
= FALSE
;
2562 m_isScrolling
= FALSE
;
2564 m_hAdjust
= (GtkAdjustment
*) NULL
;
2565 m_vAdjust
= (GtkAdjustment
*) NULL
;
2566 m_oldHorizontalPos
=
2567 m_oldVerticalPos
= 0.0;
2569 m_oldClientHeight
= 0;
2572 m_widgetStyle
= (GtkStyle
*) NULL
;
2574 m_insertCallback
= (wxInsertChildFunction
) NULL
;
2576 m_acceptsFocus
= FALSE
;
2579 m_clipPaintRegion
= FALSE
;
2581 m_cursor
= *wxSTANDARD_CURSOR
;
2583 m_delayedForegroundColour
= FALSE
;
2584 m_delayedBackgroundColour
= FALSE
;
2588 m_x11Context
= NULL
;
2591 m_ic
= (GdkIC
*) NULL
;
2592 m_icattr
= (GdkICAttr
*) NULL
;
2597 wxWindowGTK::wxWindowGTK()
2602 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2607 const wxString
&name
)
2611 Create( parent
, id
, pos
, size
, style
, name
);
2614 bool wxWindowGTK::Create( wxWindow
*parent
,
2619 const wxString
&name
)
2621 if (!PreCreation( parent
, pos
, size
) ||
2622 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2624 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2628 m_insertCallback
= wxInsertChildInWindow
;
2630 // always needed for background clearing
2631 m_delayedBackgroundColour
= TRUE
;
2633 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
2634 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
2636 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2638 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2639 scroll_class
->scrollbar_spacing
= 0;
2641 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2643 m_hAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->hscrollbar
) );
2644 m_vAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->vscrollbar
) );
2646 m_wxwindow
= gtk_pizza_new();
2648 #ifndef __WXUNIVERSAL__
2649 GtkPizza
*pizza
= GTK_PIZZA(m_wxwindow
);
2651 if (HasFlag(wxRAISED_BORDER
))
2653 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_OUT
);
2655 else if (HasFlag(wxSUNKEN_BORDER
))
2657 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_IN
);
2659 else if (HasFlag(wxSIMPLE_BORDER
))
2661 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_THIN
);
2665 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_NONE
);
2667 #endif // __WXUNIVERSAL__
2669 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2671 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
2672 m_acceptsFocus
= TRUE
;
2674 // I _really_ don't want scrollbars in the beginning
2675 m_vAdjust
->lower
= 0.0;
2676 m_vAdjust
->upper
= 1.0;
2677 m_vAdjust
->value
= 0.0;
2678 m_vAdjust
->step_increment
= 1.0;
2679 m_vAdjust
->page_increment
= 1.0;
2680 m_vAdjust
->page_size
= 5.0;
2681 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
2682 m_hAdjust
->lower
= 0.0;
2683 m_hAdjust
->upper
= 1.0;
2684 m_hAdjust
->value
= 0.0;
2685 m_hAdjust
->step_increment
= 1.0;
2686 m_hAdjust
->page_increment
= 1.0;
2687 m_hAdjust
->page_size
= 5.0;
2688 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
2690 // these handlers block mouse events to any window during scrolling such as
2691 // motion events and prevent GTK and wxWindows from fighting over where the
2694 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_press_event",
2695 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
2697 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_press_event",
2698 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
2700 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_release_event",
2701 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
2703 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_release_event",
2704 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
2706 // these handlers get notified when screen updates are required either when
2707 // scrolling or when the window size (and therefore scrollbar configuration)
2710 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
2711 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
2712 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
2713 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
2716 // Create input method handler
2717 m_imContext
= (GtkIMMulticontext
*) gtk_im_multicontext_new ();
2719 // Cannot handle drawing preedited text yet
2720 gtk_im_context_set_use_preedit( (GtkIMContext
*) m_imContext
, FALSE
);
2722 g_signal_connect (G_OBJECT (m_imContext
), "commit",
2723 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2726 gtk_widget_show( m_wxwindow
);
2729 m_parent
->DoAddChild( this );
2731 m_focusWidget
= m_wxwindow
;
2738 wxWindowGTK::~wxWindowGTK()
2742 if (g_focusWindow
== this)
2743 g_focusWindow
= NULL
;
2745 if (g_activeFrame
== this)
2746 g_activeFrame
= NULL
;
2748 if ( g_delayedFocus
== this )
2749 g_delayedFocus
= NULL
;
2751 m_isBeingDeleted
= TRUE
;
2761 gdk_ic_destroy (m_ic
);
2763 gdk_ic_attr_destroy (m_icattr
);
2768 #if DISABLE_STYLE_IF_BROKEN_THEME
2769 // don't delete if it's a pixmap theme style
2770 if (!m_widgetStyle
->engine_data
)
2771 gtk_style_unref( m_widgetStyle
);
2773 m_widgetStyle
= (GtkStyle
*) NULL
;
2778 gtk_widget_destroy( m_wxwindow
);
2779 m_wxwindow
= (GtkWidget
*) NULL
;
2784 gtk_widget_destroy( m_widget
);
2785 m_widget
= (GtkWidget
*) NULL
;
2789 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2791 wxCHECK_MSG( !m_needParent
|| parent
, FALSE
, wxT("Need complete parent.") );
2793 // Use either the given size, or the default if -1 is given.
2794 // See wxWindowBase for these functions.
2795 m_width
= WidthDefault(size
.x
) ;
2796 m_height
= HeightDefault(size
.y
);
2801 // some reasonable defaults
2806 m_x
= (gdk_screen_width () - m_width
) / 2;
2807 if (m_x
< 10) m_x
= 10;
2811 m_y
= (gdk_screen_height () - m_height
) / 2;
2812 if (m_y
< 10) m_y
= 10;
2819 void wxWindowGTK::PostCreation()
2821 wxCHECK_VALID_WIDGET_RET();
2827 // these get reported to wxWindows -> wxPaintEvent
2829 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow
), TRUE
);
2831 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "expose_event",
2832 GTK_SIGNAL_FUNC(gtk_window_expose_callback
), (gpointer
)this );
2835 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "draw",
2836 GTK_SIGNAL_FUNC(gtk_window_draw_callback
), (gpointer
)this );
2838 if (!HasFlag(wxFULL_REPAINT_ON_RESIZE
))
2840 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "event",
2841 GTK_SIGNAL_FUNC(gtk_window_event_event_callback
), (gpointer
)this );
2844 // gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), !HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
2848 // Create input method handler
2849 m_imContext
= (GtkIMMulticontext
*) gtk_im_multicontext_new ();
2851 // Cannot handle drawing preedited text yet
2852 gtk_im_context_set_use_preedit( (GtkIMContext
*) m_imContext
, FALSE
);
2854 g_signal_connect (G_OBJECT (m_imContext
), "commit",
2855 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2859 // these are called when the "sunken" or "raised" borders are drawn
2860 gtk_signal_connect( GTK_OBJECT(m_widget
), "expose_event",
2861 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback
), (gpointer
)this );
2864 gtk_signal_connect( GTK_OBJECT(m_widget
), "draw",
2865 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback
), (gpointer
)this );
2871 if (m_focusWidget
== NULL
)
2872 m_focusWidget
= m_widget
;
2874 gtk_signal_connect( GTK_OBJECT(m_focusWidget
), "focus_in_event",
2875 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback
), (gpointer
)this );
2877 gtk_signal_connect( GTK_OBJECT(m_focusWidget
), "focus_out_event",
2878 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback
), (gpointer
)this );
2880 // connect to the various key and mouse handlers
2882 GtkWidget
*connect_widget
= GetConnectWidget();
2884 ConnectWidget( connect_widget
);
2886 /* We cannot set colours, fonts and cursors before the widget has
2887 been realized, so we do this directly after realization */
2888 gtk_signal_connect( GTK_OBJECT(connect_widget
), "realize",
2889 GTK_SIGNAL_FUNC(gtk_window_realized_callback
), (gpointer
) this );
2893 // Catch native resize events
2894 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "size_allocate",
2895 GTK_SIGNAL_FUNC(gtk_window_size_callback
), (gpointer
)this );
2897 // Initialize XIM support
2898 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "realize",
2899 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback
), (gpointer
) this );
2901 // And resize XIM window
2902 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "size_allocate",
2903 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback
), (gpointer
)this );
2906 if ( !GTK_IS_COMBO(m_widget
))
2908 // This is needed if we want to add our windows into native
2909 // GTK control, such as the toolbar. With this callback, the
2910 // toolbar gets to know the correct size (the one set by the
2911 // programmer). Sadly, it misbehaves for wxComboBox. FIXME
2912 // when moving to GTK 2.0.
2913 gtk_signal_connect( GTK_OBJECT(m_widget
), "size_request",
2914 GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback
),
2920 // unless the window was created initially hidden (i.e. Hide() had been
2921 // called before Create()), we should show it at GTK+ level as well
2923 gtk_widget_show( m_widget
);
2926 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2928 gtk_signal_connect( GTK_OBJECT(widget
), "key_press_event",
2929 GTK_SIGNAL_FUNC(gtk_window_key_press_callback
), (gpointer
)this );
2931 gtk_signal_connect( GTK_OBJECT(widget
), "key_release_event",
2932 GTK_SIGNAL_FUNC(gtk_window_key_release_callback
), (gpointer
)this );
2934 gtk_signal_connect( GTK_OBJECT(widget
), "button_press_event",
2935 GTK_SIGNAL_FUNC(gtk_window_button_press_callback
), (gpointer
)this );
2937 gtk_signal_connect( GTK_OBJECT(widget
), "button_release_event",
2938 GTK_SIGNAL_FUNC(gtk_window_button_release_callback
), (gpointer
)this );
2940 gtk_signal_connect( GTK_OBJECT(widget
), "motion_notify_event",
2941 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback
), (gpointer
)this );
2944 gtk_signal_connect( GTK_OBJECT(widget
), "scroll_event",
2945 GTK_SIGNAL_FUNC(gtk_window_wheel_callback
), (gpointer
)this );
2948 gtk_signal_connect( GTK_OBJECT(widget
), "enter_notify_event",
2949 GTK_SIGNAL_FUNC(gtk_window_enter_callback
), (gpointer
)this );
2951 gtk_signal_connect( GTK_OBJECT(widget
), "leave_notify_event",
2952 GTK_SIGNAL_FUNC(gtk_window_leave_callback
), (gpointer
)this );
2955 bool wxWindowGTK::Destroy()
2957 wxCHECK_VALID_WIDGET(FALSE
);
2961 return wxWindowBase::Destroy();
2964 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2966 gtk_pizza_set_size( GTK_PIZZA(m_parent
->m_wxwindow
), m_widget
, x
, y
, width
, height
);
2969 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2971 wxCHECK_VALID_WIDGET_RET();
2972 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2975 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
2978 if (m_resizing
) return; /* I don't like recursions */
2981 int currentX
, currentY
;
2982 GetPosition(¤tX
, ¤tY
);
2983 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2985 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
2987 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2989 if (m_parent
->m_wxwindow
== NULL
) /* i.e. wxNotebook */
2991 /* don't set the size for children of wxNotebook, just take the values. */
2999 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
3000 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
3002 if (x
!= -1) m_x
= x
+ pizza
->xoffset
;
3003 if (y
!= -1) m_y
= y
+ pizza
->yoffset
;
3007 m_x
= x
+ pizza
->xoffset
;
3008 m_y
= y
+ pizza
->yoffset
;
3011 // calculate the best size if we should auto size the window
3012 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
3013 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
3015 const wxSize sizeBest
= GetBestSize();
3016 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
3018 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
3019 height
= sizeBest
.y
;
3027 int minWidth
= GetMinWidth(),
3028 minHeight
= GetMinHeight(),
3029 maxWidth
= GetMaxWidth(),
3030 maxHeight
= GetMaxHeight();
3032 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
3033 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
3034 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
3035 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
3038 int bottom_border
= 0;
3041 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
3043 /* the default button has a border around it */
3049 DoMoveWindow( m_x
-border
,
3052 m_height
+border
+bottom_border
);
3057 /* Sometimes the client area changes size without the
3058 whole windows's size changing, but if the whole
3059 windows's size doesn't change, no wxSizeEvent will
3060 normally be sent. Here we add an extra test if
3061 the client test has been changed and this will
3063 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
3067 wxPrintf( "OnSize sent from " );
3068 if (GetClassInfo() && GetClassInfo()->GetClassName())
3069 wxPrintf( GetClassInfo()->GetClassName() );
3070 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
3073 if (!m_nativeSizeEvent
)
3075 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
3076 event
.SetEventObject( this );
3077 GetEventHandler()->ProcessEvent( event
);
3083 void wxWindowGTK::OnInternalIdle()
3085 // Update invalidated regions.
3088 // Synthetize activate events.
3089 if ( g_sendActivateEvent
!= -1 )
3091 bool activate
= g_sendActivateEvent
!= 0;
3094 g_sendActivateEvent
= -1;
3096 wxTheApp
->SetActive(activate
, (wxWindow
*)g_focusWindowLast
);
3099 if ( g_activeFrameLostFocus
)
3101 if ( g_activeFrame
)
3103 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame
);
3104 wxActivateEvent
event(wxEVT_ACTIVATE
, FALSE
, g_activeFrame
->GetId());
3105 event
.SetEventObject(g_activeFrame
);
3106 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
3107 g_activeFrame
= NULL
;
3109 g_activeFrameLostFocus
= FALSE
;
3112 wxCursor cursor
= m_cursor
;
3113 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
3117 /* I now set the cursor anew in every OnInternalIdle call
3118 as setting the cursor in a parent window also effects the
3119 windows above so that checking for the current cursor is
3124 GdkWindow
*window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3126 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3128 if (!g_globalCursor
.Ok())
3129 cursor
= *wxSTANDARD_CURSOR
;
3131 window
= m_widget
->window
;
3132 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
3133 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3139 GdkWindow
*window
= m_widget
->window
;
3140 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
3141 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3146 if (wxUpdateUIEvent::CanUpdate(this))
3147 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
3150 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
3152 wxCHECK_VALID_WIDGET_RET();
3154 if (width
) (*width
) = m_width
;
3155 if (height
) (*height
) = m_height
;
3158 void wxWindowGTK::DoSetClientSize( int width
, int height
)
3160 wxCHECK_VALID_WIDGET_RET();
3164 SetSize( width
, height
);
3171 #ifndef __WXUNIVERSAL__
3172 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
3174 /* when using GTK 1.2 we set the shadow border size to 2 */
3178 if (HasFlag(wxSIMPLE_BORDER
))
3180 /* when using GTK 1.2 we set the simple border size to 1 */
3184 #endif // __WXUNIVERSAL__
3188 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
3190 GtkRequisition vscroll_req
;
3191 vscroll_req
.width
= 2;
3192 vscroll_req
.height
= 2;
3193 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
3194 (scroll_window
->vscrollbar
, &vscroll_req
);
3196 GtkRequisition hscroll_req
;
3197 hscroll_req
.width
= 2;
3198 hscroll_req
.height
= 2;
3199 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
3200 (scroll_window
->hscrollbar
, &hscroll_req
);
3202 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
3204 if (scroll_window
->vscrollbar_visible
)
3206 dw
+= vscroll_req
.width
;
3207 dw
+= scroll_class
->scrollbar_spacing
;
3210 if (scroll_window
->hscrollbar_visible
)
3212 dh
+= hscroll_req
.height
;
3213 dh
+= scroll_class
->scrollbar_spacing
;
3217 SetSize( width
+dw
, height
+dh
);
3221 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
3223 wxCHECK_VALID_WIDGET_RET();
3227 if (width
) (*width
) = m_width
;
3228 if (height
) (*height
) = m_height
;
3235 #ifndef __WXUNIVERSAL__
3236 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
3238 /* when using GTK 1.2 we set the shadow border size to 2 */
3242 if (HasFlag(wxSIMPLE_BORDER
))
3244 /* when using GTK 1.2 we set the simple border size to 1 */
3248 #endif // __WXUNIVERSAL__
3252 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
3254 GtkRequisition vscroll_req
;
3255 vscroll_req
.width
= 2;
3256 vscroll_req
.height
= 2;
3257 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
3258 (scroll_window
->vscrollbar
, &vscroll_req
);
3260 GtkRequisition hscroll_req
;
3261 hscroll_req
.width
= 2;
3262 hscroll_req
.height
= 2;
3263 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
3264 (scroll_window
->hscrollbar
, &hscroll_req
);
3266 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
3268 if (scroll_window
->vscrollbar_visible
)
3270 dw
+= vscroll_req
.width
;
3271 dw
+= scroll_class
->scrollbar_spacing
;
3274 if (scroll_window
->hscrollbar_visible
)
3276 dh
+= hscroll_req
.height
;
3277 dh
+= scroll_class
->scrollbar_spacing
;
3281 if (width
) (*width
) = m_width
- dw
;
3282 if (height
) (*height
) = m_height
- dh
;
3286 printf( "GetClientSize, name %s ", GetName().c_str() );
3287 if (width) printf( " width = %d", (*width) );
3288 if (height) printf( " height = %d", (*height) );
3293 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
3295 wxCHECK_VALID_WIDGET_RET();
3299 if (m_parent
&& m_parent
->m_wxwindow
)
3301 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
3302 dx
= pizza
->xoffset
;
3303 dy
= pizza
->yoffset
;
3306 if (x
) (*x
) = m_x
- dx
;
3307 if (y
) (*y
) = m_y
- dy
;
3310 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
3312 wxCHECK_VALID_WIDGET_RET();
3314 if (!m_widget
->window
) return;
3316 GdkWindow
*source
= (GdkWindow
*) NULL
;
3318 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3320 source
= m_widget
->window
;
3324 gdk_window_get_origin( source
, &org_x
, &org_y
);
3328 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3330 org_x
+= m_widget
->allocation
.x
;
3331 org_y
+= m_widget
->allocation
.y
;
3339 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
3341 wxCHECK_VALID_WIDGET_RET();
3343 if (!m_widget
->window
) return;
3345 GdkWindow
*source
= (GdkWindow
*) NULL
;
3347 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3349 source
= m_widget
->window
;
3353 gdk_window_get_origin( source
, &org_x
, &org_y
);
3357 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3359 org_x
+= m_widget
->allocation
.x
;
3360 org_y
+= m_widget
->allocation
.y
;
3368 bool wxWindowGTK::Show( bool show
)
3370 wxCHECK_VALID_WIDGET(FALSE
);
3372 if (!wxWindowBase::Show(show
))
3379 gtk_widget_show( m_widget
);
3381 gtk_widget_hide( m_widget
);
3383 wxShowEvent
eventShow(GetId(), show
);
3384 eventShow
.m_eventObject
= this;
3386 GetEventHandler()->ProcessEvent(eventShow
);
3391 static void wxWindowNotifyEnable(wxWindowGTK
* win
, bool enable
)
3393 win
->OnParentEnable(enable
);
3395 // Recurse, so that children have the opportunity to Do The Right Thing
3396 // and reset colours that have been messed up by a parent's (really ancestor's)
3398 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
3400 node
= node
->GetNext() )
3402 wxWindow
*child
= node
->GetData();
3403 if (!child
->IsKindOf(CLASSINFO(wxDialog
)) && !child
->IsKindOf(CLASSINFO(wxFrame
)))
3404 wxWindowNotifyEnable(child
, enable
);
3408 bool wxWindowGTK::Enable( bool enable
)
3410 wxCHECK_VALID_WIDGET(FALSE
);
3412 if (!wxWindowBase::Enable(enable
))
3418 gtk_widget_set_sensitive( m_widget
, enable
);
3420 gtk_widget_set_sensitive( m_wxwindow
, enable
);
3422 wxWindowNotifyEnable(this, enable
);
3427 int wxWindowGTK::GetCharHeight() const
3429 wxCHECK_VALID_WIDGET(12);
3431 wxFont font
= GetFont();
3432 wxCHECK_MSG( font
.Ok(), 12, wxT("invalid font") );
3435 PangoContext
*context
= NULL
;
3437 context
= gtk_widget_get_pango_context( m_widget
);
3442 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3443 PangoLayout
*layout
= pango_layout_new(context
);
3444 pango_layout_set_font_description(layout
, desc
);
3445 pango_layout_set_text(layout
, "H", 1);
3446 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3448 PangoRectangle rect
;
3449 pango_layout_line_get_extents(line
, NULL
, &rect
);
3451 g_object_unref( G_OBJECT( layout
) );
3453 return (int) (rect
.height
/ PANGO_SCALE
);
3455 GdkFont
*gfont
= font
.GetInternalFont( 1.0 );
3457 return gfont
->ascent
+ gfont
->descent
;
3461 int wxWindowGTK::GetCharWidth() const
3463 wxCHECK_VALID_WIDGET(8);
3465 wxFont font
= GetFont();
3466 wxCHECK_MSG( font
.Ok(), 8, wxT("invalid font") );
3469 PangoContext
*context
= NULL
;
3471 context
= gtk_widget_get_pango_context( m_widget
);
3476 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3477 PangoLayout
*layout
= pango_layout_new(context
);
3478 pango_layout_set_font_description(layout
, desc
);
3479 pango_layout_set_text(layout
, "g", 1);
3480 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3482 PangoRectangle rect
;
3483 pango_layout_line_get_extents(line
, NULL
, &rect
);
3485 g_object_unref( G_OBJECT( layout
) );
3487 return (int) (rect
.width
/ PANGO_SCALE
);
3489 GdkFont
*gfont
= font
.GetInternalFont( 1.0 );
3491 return gdk_string_width( gfont
, "g" );
3495 void wxWindowGTK::GetTextExtent( const wxString
& string
,
3499 int *externalLeading
,
3500 const wxFont
*theFont
) const
3502 wxFont fontToUse
= theFont
? *theFont
: GetFont();
3504 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
3506 if (string
.IsEmpty())
3514 PangoContext
*context
= NULL
;
3516 context
= gtk_widget_get_pango_context( m_widget
);
3525 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3526 PangoLayout
*layout
= pango_layout_new(context
);
3527 pango_layout_set_font_description(layout
, desc
);
3530 const wxCharBuffer data
= wxConvUTF8
.cWC2MB( string
);
3531 pango_layout_set_text(layout
, (const char*) data
, strlen( (const char*) data
));
3533 const wxWCharBuffer wdata
= wxConvLocal
.cMB2WC( string
);
3534 const wxCharBuffer data
= wxConvUTF8
.cWC2MB( wdata
);
3535 pango_layout_set_text(layout
, (const char*) data
, strlen( (const char*) data
));
3538 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3540 PangoRectangle rect
;
3541 pango_layout_line_get_extents(line
, NULL
, &rect
);
3543 if (x
) (*x
) = (wxCoord
) (rect
.width
/ PANGO_SCALE
);
3544 if (y
) (*y
) = (wxCoord
) (rect
.height
/ PANGO_SCALE
);
3547 // Do something about metrics here
3550 if (externalLeading
) (*externalLeading
) = 0; // ??
3552 g_object_unref( G_OBJECT( layout
) );
3554 GdkFont
*font
= fontToUse
.GetInternalFont( 1.0 );
3555 if (x
) (*x
) = gdk_string_width( font
, wxGTK_CONV( string
) );
3556 if (y
) (*y
) = font
->ascent
+ font
->descent
;
3557 if (descent
) (*descent
) = font
->descent
;
3558 if (externalLeading
) (*externalLeading
) = 0; // ??
3562 void wxWindowGTK::SetFocus()
3564 wxCHECK_VALID_WIDGET_RET();
3568 // don't do anything if we already have focus
3574 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow
))
3576 gtk_widget_grab_focus (m_wxwindow
);
3581 if (GTK_WIDGET_CAN_FOCUS(m_widget
) && !GTK_WIDGET_HAS_FOCUS (m_widget
) )
3583 if (!GTK_WIDGET_REALIZED(m_widget
))
3585 // we can't set the focus to the widget now so we remember that
3586 // it should be focused and will do it later, during the idle
3587 // time, as soon as we can
3588 wxLogTrace(TRACE_FOCUS
,
3589 _T("Delaying setting focus to %s(%s)"),
3590 GetClassInfo()->GetClassName(), GetLabel().c_str());
3592 g_delayedFocus
= this;
3596 wxLogTrace(TRACE_FOCUS
,
3597 _T("Setting focus to %s(%s)"),
3598 GetClassInfo()->GetClassName(), GetLabel().c_str());
3600 gtk_widget_grab_focus (m_widget
);
3603 else if (GTK_IS_CONTAINER(m_widget
))
3605 SET_CONTAINER_FOCUS( m_widget
, GTK_DIR_TAB_FORWARD
);
3609 wxLogTrace(TRACE_FOCUS
,
3610 _T("Can't set focus to %s(%s)"),
3611 GetClassInfo()->GetClassName(), GetLabel().c_str());
3616 bool wxWindowGTK::AcceptsFocus() const
3618 return m_acceptsFocus
&& wxWindowBase::AcceptsFocus();
3621 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3623 wxCHECK_VALID_WIDGET(FALSE
);
3625 wxWindowGTK
*oldParent
= m_parent
,
3626 *newParent
= (wxWindowGTK
*)newParentBase
;
3628 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3630 if ( !wxWindowBase::Reparent(newParent
) )
3633 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3635 /* prevent GTK from deleting the widget arbitrarily */
3636 gtk_widget_ref( m_widget
);
3640 gtk_container_remove( GTK_CONTAINER(m_widget
->parent
), m_widget
);
3643 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3647 /* insert GTK representation */
3648 (*(newParent
->m_insertCallback
))(newParent
, this);
3651 /* reverse: prevent GTK from deleting the widget arbitrarily */
3652 gtk_widget_unref( m_widget
);
3657 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3659 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3661 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3663 wxASSERT_MSG( (m_insertCallback
!= NULL
), wxT("invalid child insertion function") );
3668 /* insert GTK representation */
3669 (*m_insertCallback
)(this, child
);
3672 void wxWindowGTK::Raise()
3674 wxCHECK_VALID_WIDGET_RET();
3676 if (!m_widget
->window
) return;
3678 gdk_window_raise( m_widget
->window
);
3681 void wxWindowGTK::Lower()
3683 wxCHECK_VALID_WIDGET_RET();
3685 if (!m_widget
->window
) return;
3687 gdk_window_lower( m_widget
->window
);
3690 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3692 wxCHECK_VALID_WIDGET(FALSE
);
3694 if (cursor
== m_cursor
)
3698 wxapp_install_idle_handler();
3700 if (cursor
== wxNullCursor
)
3701 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR
);
3703 return wxWindowBase::SetCursor( cursor
);
3706 void wxWindowGTK::WarpPointer( int x
, int y
)
3708 wxCHECK_VALID_WIDGET_RET();
3710 // We provide this function ourselves as it is
3711 // missing in GDK (top of this file).
3713 GdkWindow
*window
= (GdkWindow
*) NULL
;
3715 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3717 window
= GetConnectWidget()->window
;
3720 gdk_window_warp_pointer( window
, x
, y
);
3724 void wxWindowGTK::Refresh( bool eraseBackground
, const wxRect
*rect
)
3726 if (!m_widget
) return;
3727 if (!m_widget
->window
) return;
3731 wxapp_install_idle_handler();
3733 wxRect
myRect(0,0,0,0);
3734 if (m_wxwindow
&& rect
)
3736 myRect
.SetSize(wxSize( m_wxwindow
->allocation
.width
,
3737 m_wxwindow
->allocation
.height
));
3738 myRect
.Intersect(*rect
);
3739 if (!myRect
.width
|| !myRect
.height
)
3740 // nothing to do, rectangle is empty
3745 if (eraseBackground
&& m_wxwindow
&& m_wxwindow
->window
)
3749 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3750 m_clearRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3754 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3755 m_clearRegion
.Clear();
3756 m_clearRegion
.Union( 0, 0, m_wxwindow
->allocation
.width
, m_wxwindow
->allocation
.height
);
3764 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3765 m_updateRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3769 GdkRectangle gdk_rect
;
3770 gdk_rect
.x
= rect
->x
;
3771 gdk_rect
.y
= rect
->y
;
3772 gdk_rect
.width
= rect
->width
;
3773 gdk_rect
.height
= rect
->height
;
3774 gtk_widget_draw( m_widget
, &gdk_rect
);
3781 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3782 m_updateRegion
.Clear();
3783 m_updateRegion
.Union( 0, 0, m_wxwindow
->allocation
.width
, m_wxwindow
->allocation
.height
);
3787 gtk_widget_draw( m_widget
, (GdkRectangle
*) NULL
);
3795 GdkRectangle gdk_rect
;
3796 gdk_rect
.x
= rect
->x
;
3797 gdk_rect
.y
= rect
->y
;
3798 gdk_rect
.width
= rect
->width
;
3799 gdk_rect
.height
= rect
->height
;
3800 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, &gdk_rect
, TRUE
);
3804 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, NULL
, TRUE
);
3810 void wxWindowGTK::Update()
3815 void wxWindowGTK::GtkUpdate()
3818 if (m_wxwindow
&& GTK_PIZZA(m_wxwindow
)->bin_window
)
3819 gdk_window_process_updates( GTK_PIZZA(m_wxwindow
)->bin_window
, FALSE
);
3821 if (!m_updateRegion
.IsEmpty())
3822 GtkSendPaintEvents();
3826 void wxWindowGTK::GtkSendPaintEvents()
3831 m_clearRegion
.Clear();
3833 m_updateRegion
.Clear();
3837 // Clip to paint region in wxClientDC
3838 m_clipPaintRegion
= TRUE
;
3841 // widget to draw on
3842 GtkPizza
*pizza
= GTK_PIZZA (m_wxwindow
);
3844 // later for GTK 2.0, too.
3845 if (GetThemeEnabled())
3847 // find ancestor from which to steal background
3848 wxWindow
*parent
= GetParent();
3849 while (parent
&& !parent
->IsTopLevel())
3850 parent
= parent
->GetParent();
3852 parent
= (wxWindow
*)this;
3854 wxRegionIterator
upd( m_updateRegion
);
3858 rect
.x
= upd
.GetX();
3859 rect
.y
= upd
.GetY();
3860 rect
.width
= upd
.GetWidth();
3861 rect
.height
= upd
.GetHeight();
3863 gtk_paint_flat_box( parent
->m_widget
->style
,
3880 wxWindowDC
dc( (wxWindow
*)this );
3881 dc
.SetClippingRegion( m_updateRegion
);
3883 wxEraseEvent
erase_event( GetId(), &dc
);
3884 erase_event
.SetEventObject( this );
3886 GetEventHandler()->ProcessEvent(erase_event
);
3889 // if (!m_clearRegion.IsEmpty()) // Always send an erase event under GTK 1.2
3891 wxWindowDC
dc( (wxWindow
*)this );
3892 if (m_clearRegion
.IsEmpty())
3893 dc
.SetClippingRegion( m_updateRegion
);
3895 dc
.SetClippingRegion( m_clearRegion
);
3897 wxEraseEvent
erase_event( GetId(), &dc
);
3898 erase_event
.SetEventObject( this );
3900 if (!GetEventHandler()->ProcessEvent(erase_event
))
3904 g_eraseGC
= gdk_gc_new( pizza
->bin_window
);
3905 gdk_gc_set_fill( g_eraseGC
, GDK_SOLID
);
3907 gdk_gc_set_foreground( g_eraseGC
, m_backgroundColour
.GetColor() );
3909 wxRegionIterator
upd( m_clearRegion
);
3912 gdk_draw_rectangle( pizza
->bin_window
, g_eraseGC
, 1,
3913 upd
.GetX(), upd
.GetY(), upd
.GetWidth(), upd
.GetHeight() );
3917 m_clearRegion
.Clear();
3921 wxNcPaintEvent
nc_paint_event( GetId() );
3922 nc_paint_event
.SetEventObject( this );
3923 GetEventHandler()->ProcessEvent( nc_paint_event
);
3925 wxPaintEvent
paint_event( GetId() );
3926 paint_event
.SetEventObject( this );
3927 GetEventHandler()->ProcessEvent( paint_event
);
3929 m_clipPaintRegion
= FALSE
;
3931 #ifndef __WXUNIVERSAL__
3933 // The following code will result in all window-less widgets
3934 // being redrawn because the wxWindows class is allowed to
3935 // paint over the window-less widgets.
3937 GList
*children
= pizza
->children
;
3940 GtkPizzaChild
*child
= (GtkPizzaChild
*) children
->data
;
3941 children
= children
->next
;
3943 if (GTK_WIDGET_NO_WINDOW (child
->widget
) &&
3944 GTK_WIDGET_DRAWABLE (child
->widget
))
3946 // Get intersection of widget area and update region
3947 wxRegion
region( m_updateRegion
);
3949 GdkEventExpose gdk_event
;
3950 gdk_event
.type
= GDK_EXPOSE
;
3951 gdk_event
.window
= pizza
->bin_window
;
3952 gdk_event
.count
= 0;
3954 wxRegionIterator
upd( m_updateRegion
);
3958 rect
.x
= upd
.GetX();
3959 rect
.y
= upd
.GetY();
3960 rect
.width
= upd
.GetWidth();
3961 rect
.height
= upd
.GetHeight();
3963 if (gtk_widget_intersect (child
->widget
, &rect
, &gdk_event
.area
))
3965 gtk_widget_event (child
->widget
, (GdkEvent
*) &gdk_event
);
3975 m_updateRegion
.Clear();
3978 void wxWindowGTK::ClearBackground()
3980 wxCHECK_VALID_WIDGET_RET();
3983 if (m_wxwindow
&& m_wxwindow
->window
)
3985 m_clearRegion
.Clear();
3986 wxSize
size( GetClientSize() );
3987 m_clearRegion
.Union( 0,0,size
.x
,size
.y
);
3989 // Better do this in idle?
3996 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3998 wxWindowBase::DoSetToolTip(tip
);
4001 m_tooltip
->Apply( (wxWindow
*)this );
4004 void wxWindowGTK::ApplyToolTip( GtkTooltips
*tips
, const wxChar
*tip
)
4006 wxString
tmp( tip
);
4007 gtk_tooltips_set_tip( tips
, GetConnectWidget(), wxGTK_CONV(tmp
), (gchar
*) NULL
);
4009 #endif // wxUSE_TOOLTIPS
4011 void wxWindowGTK::GtkSetBackgroundColour( const wxColour
&colour
)
4013 GdkWindow
*window
= (GdkWindow
*) NULL
;
4015 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4017 window
= GetConnectWidget()->window
;
4021 // We need the pixel value e.g. for background clearing.
4022 m_backgroundColour
.CalcPixel( gdk_window_get_colormap( window
) );
4026 // wxMSW doesn't clear the window here, either.
4027 gdk_window_set_background( window
, m_backgroundColour
.GetColor() );
4033 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
4035 wxCHECK_VALID_WIDGET(FALSE
);
4037 if (!wxWindowBase::SetBackgroundColour(colour
))
4040 GdkWindow
*window
= (GdkWindow
*) NULL
;
4042 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4044 window
= GetConnectWidget()->window
;
4048 // indicate that a new style has been set
4049 // but it couldn't get applied as the
4050 // widget hasn't been realized yet.
4051 m_delayedBackgroundColour
= TRUE
;
4056 GtkSetBackgroundColour( colour
);
4062 void wxWindowGTK::GtkSetForegroundColour( const wxColour
&colour
)
4064 GdkWindow
*window
= (GdkWindow
*) NULL
;
4066 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4068 window
= GetConnectWidget()->window
;
4075 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
4077 wxCHECK_VALID_WIDGET(FALSE
);
4079 if (!wxWindowBase::SetForegroundColour(colour
))
4081 // don't leave if the GTK widget has just
4083 if (!m_delayedForegroundColour
) return FALSE
;
4086 GdkWindow
*window
= (GdkWindow
*) NULL
;
4088 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4090 window
= GetConnectWidget()->window
;
4094 // indicate that a new style has been set
4095 // but it couldn't get applied as the
4096 // widget hasn't been realized yet.
4097 m_delayedForegroundColour
= TRUE
;
4101 GtkSetForegroundColour( colour
);
4108 PangoContext
*wxWindowGTK::GtkGetPangoDefaultContext()
4110 return gtk_widget_get_pango_context( m_widget
);
4113 PangoContext
*wxWindowGTK::GtkGetPangoX11Context()
4116 m_x11Context
= pango_x_get_context( gdk_display
);
4118 return m_x11Context
;
4122 GtkStyle
*wxWindowGTK::GetWidgetStyle()
4126 GtkStyle
*remake
= gtk_style_copy( m_widgetStyle
);
4128 // FIXME: no more klass in 2.0
4130 remake
->klass
= m_widgetStyle
->klass
;
4133 gtk_style_unref( m_widgetStyle
);
4134 m_widgetStyle
= remake
;
4138 GtkStyle
*def
= gtk_rc_get_style( m_widget
);
4141 def
= gtk_widget_get_default_style();
4143 m_widgetStyle
= gtk_style_copy( def
);
4145 // FIXME: no more klass in 2.0
4147 m_widgetStyle
->klass
= def
->klass
;
4151 return m_widgetStyle
;
4154 void wxWindowGTK::SetWidgetStyle()
4156 #if DISABLE_STYLE_IF_BROKEN_THEME
4157 if (m_widget
->style
->engine_data
)
4159 static bool s_warningPrinted
= FALSE
;
4160 if (!s_warningPrinted
)
4162 printf( "wxWindows warning: Widget styles disabled due to buggy GTK theme.\n" );
4163 s_warningPrinted
= TRUE
;
4165 m_widgetStyle
= m_widget
->style
;
4170 GtkStyle
*style
= GetWidgetStyle();
4175 pango_font_description_free( style
->font_desc
);
4176 style
->font_desc
= pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
4178 gdk_font_unref( style
->font
);
4179 style
->font
= gdk_font_ref( m_font
.GetInternalFont( 1.0 ) );
4185 m_foregroundColour
.CalcPixel( gtk_widget_get_colormap( m_widget
) );
4186 if (m_foregroundColour
!= wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT
))
4188 style
->fg
[GTK_STATE_NORMAL
] = *m_foregroundColour
.GetColor();
4189 style
->fg
[GTK_STATE_PRELIGHT
] = *m_foregroundColour
.GetColor();
4190 style
->fg
[GTK_STATE_ACTIVE
] = *m_foregroundColour
.GetColor();
4194 // Try to restore the gtk default style. This is still a little
4195 // oversimplified for what is probably really needed here for controls
4196 // other than buttons, but is better than not being able to (re)set a
4197 // control's foreground colour to *wxBLACK -- RL
4198 GtkStyle
*def
= gtk_rc_get_style( m_widget
);
4201 def
= gtk_widget_get_default_style();
4203 style
->fg
[GTK_STATE_NORMAL
] = def
->fg
[GTK_STATE_NORMAL
];
4204 style
->fg
[GTK_STATE_PRELIGHT
] = def
->fg
[GTK_STATE_PRELIGHT
];
4205 style
->fg
[GTK_STATE_ACTIVE
] = def
->fg
[GTK_STATE_ACTIVE
];
4209 if ( m_hasBgCol
&& m_backgroundColour
.Ok() )
4211 m_backgroundColour
.CalcPixel( gtk_widget_get_colormap( m_widget
) );
4212 if (m_backgroundColour
!= wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE
))
4214 style
->bg
[GTK_STATE_NORMAL
] = *m_backgroundColour
.GetColor();
4215 style
->base
[GTK_STATE_NORMAL
] = *m_backgroundColour
.GetColor();
4216 style
->bg
[GTK_STATE_PRELIGHT
] = *m_backgroundColour
.GetColor();
4217 style
->base
[GTK_STATE_PRELIGHT
] = *m_backgroundColour
.GetColor();
4218 style
->bg
[GTK_STATE_ACTIVE
] = *m_backgroundColour
.GetColor();
4219 style
->base
[GTK_STATE_ACTIVE
] = *m_backgroundColour
.GetColor();
4220 style
->bg
[GTK_STATE_INSENSITIVE
] = *m_backgroundColour
.GetColor();
4221 style
->base
[GTK_STATE_INSENSITIVE
] = *m_backgroundColour
.GetColor();
4225 // Try to restore the gtk default style. This is still a little
4226 // oversimplified for what is probably really needed here for controls
4227 // other than buttons, but is better than not being able to (re)set a
4228 // control's background colour to default grey and means resetting a
4229 // button to wxSYS_COLOUR_BTNFACE will restore its usual highlighting
4231 GtkStyle
*def
= gtk_rc_get_style( m_widget
);
4234 def
= gtk_widget_get_default_style();
4236 style
->bg
[GTK_STATE_NORMAL
] = def
->bg
[GTK_STATE_NORMAL
];
4237 style
->base
[GTK_STATE_NORMAL
] = def
->base
[GTK_STATE_NORMAL
];
4238 style
->bg
[GTK_STATE_PRELIGHT
] = def
->bg
[GTK_STATE_PRELIGHT
];
4239 style
->base
[GTK_STATE_PRELIGHT
] = def
->base
[GTK_STATE_PRELIGHT
];
4240 style
->bg
[GTK_STATE_ACTIVE
] = def
->bg
[GTK_STATE_ACTIVE
];
4241 style
->base
[GTK_STATE_ACTIVE
] = def
->base
[GTK_STATE_ACTIVE
];
4242 style
->bg
[GTK_STATE_INSENSITIVE
] = def
->bg
[GTK_STATE_INSENSITIVE
];
4243 style
->base
[GTK_STATE_INSENSITIVE
] = def
->base
[GTK_STATE_INSENSITIVE
];
4248 void wxWindowGTK::ApplyWidgetStyle()
4252 //-----------------------------------------------------------------------------
4253 // Pop-up menu stuff
4254 //-----------------------------------------------------------------------------
4256 #if wxUSE_MENUS_NATIVE
4259 void gtk_pop_hide_callback( GtkWidget
*WXUNUSED(widget
), bool* is_waiting
)
4261 *is_waiting
= FALSE
;
4264 static void SetInvokingWindow( wxMenu
*menu
, wxWindowGTK
*win
)
4266 menu
->SetInvokingWindow( win
);
4267 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
4270 wxMenuItem
*menuitem
= node
->GetData();
4271 if (menuitem
->IsSubMenu())
4273 SetInvokingWindow( menuitem
->GetSubMenu(), win
);
4276 node
= node
->GetNext();
4280 // used to pass the coordinates from wxWindowGTK::DoPopupMenu() to
4281 // wxPopupMenuPositionCallback()
4283 // should be safe even in the MT case as the user can hardly popup 2 menus
4284 // simultaneously, can he?
4285 static gint gs_pop_x
= 0;
4286 static gint gs_pop_y
= 0;
4288 extern "C" void wxPopupMenuPositionCallback( GtkMenu
*menu
,
4291 gboolean
* WXUNUSED(whatever
),
4293 gpointer
WXUNUSED(user_data
) )
4295 // ensure that the menu appears entirely on screen
4297 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
4299 wxSize sizeScreen
= wxGetDisplaySize();
4301 gint xmax
= sizeScreen
.x
- req
.width
,
4302 ymax
= sizeScreen
.y
- req
.height
;
4304 *x
= gs_pop_x
< xmax
? gs_pop_x
: xmax
;
4305 *y
= gs_pop_y
< ymax
? gs_pop_y
: ymax
;
4308 bool wxWindowGTK::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
4310 wxCHECK_VALID_WIDGET(FALSE
);
4312 wxCHECK_MSG( menu
!= NULL
, FALSE
, wxT("invalid popup-menu") );
4314 SetInvokingWindow( menu
, this );
4320 ClientToScreen( &gs_pop_x
, &gs_pop_y
);
4322 bool is_waiting
= TRUE
;
4324 gtk_signal_connect( GTK_OBJECT(menu
->m_menu
),
4326 GTK_SIGNAL_FUNC(gtk_pop_hide_callback
),
4327 (gpointer
)&is_waiting
);
4330 GTK_MENU(menu
->m_menu
),
4331 (GtkWidget
*) NULL
, // parent menu shell
4332 (GtkWidget
*) NULL
, // parent menu item
4333 wxPopupMenuPositionCallback
, // function to position it
4334 NULL
, // client data
4335 0, // button used to activate it
4337 gtk_get_current_event_time()
4339 gs_timeLastClick
// the time of activation
4345 gtk_main_iteration();
4351 #endif // wxUSE_MENUS_NATIVE
4353 #if wxUSE_DRAG_AND_DROP
4355 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4357 wxCHECK_VALID_WIDGET_RET();
4359 GtkWidget
*dnd_widget
= GetConnectWidget();
4361 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
4363 if (m_dropTarget
) delete m_dropTarget
;
4364 m_dropTarget
= dropTarget
;
4366 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
4369 #endif // wxUSE_DRAG_AND_DROP
4371 GtkWidget
* wxWindowGTK::GetConnectWidget()
4373 GtkWidget
*connect_widget
= m_widget
;
4374 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4376 return connect_widget
;
4379 bool wxWindowGTK::IsOwnGtkWindow( GdkWindow
*window
)
4382 return (window
== GTK_PIZZA(m_wxwindow
)->bin_window
);
4384 return (window
== m_widget
->window
);
4387 bool wxWindowGTK::SetFont( const wxFont
&font
)
4389 if (!wxWindowBase::SetFont(font
) || !m_widget
)
4394 wxColour sysbg
= wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE
);
4395 if ( sysbg
== m_backgroundColour
)
4397 m_backgroundColour
= wxNullColour
;
4399 m_backgroundColour
= sysbg
;
4409 void wxWindowGTK::DoCaptureMouse()
4411 wxCHECK_VALID_WIDGET_RET();
4413 GdkWindow
*window
= (GdkWindow
*) NULL
;
4415 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4417 window
= GetConnectWidget()->window
;
4419 wxCHECK_RET( window
, _T("CaptureMouse() failed") );
4421 wxCursor
* cursor
= & m_cursor
;
4423 cursor
= wxSTANDARD_CURSOR
;
4425 gdk_pointer_grab( window
, FALSE
,
4427 (GDK_BUTTON_PRESS_MASK
|
4428 GDK_BUTTON_RELEASE_MASK
|
4429 GDK_POINTER_MOTION_HINT_MASK
|
4430 GDK_POINTER_MOTION_MASK
),
4432 cursor
->GetCursor(),
4433 (guint32
)GDK_CURRENT_TIME
);
4434 g_captureWindow
= this;
4435 g_captureWindowHasMouse
= TRUE
;
4438 void wxWindowGTK::DoReleaseMouse()
4440 wxCHECK_VALID_WIDGET_RET();
4442 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4444 g_captureWindow
= (wxWindowGTK
*) NULL
;
4446 GdkWindow
*window
= (GdkWindow
*) NULL
;
4448 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4450 window
= GetConnectWidget()->window
;
4455 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4459 wxWindow
*wxWindowBase::GetCapture()
4461 return (wxWindow
*)g_captureWindow
;
4464 bool wxWindowGTK::IsRetained() const
4469 void wxWindowGTK::SetScrollbar( int orient
, int pos
, int thumbVisible
,
4470 int range
, bool refresh
)
4472 wxCHECK_VALID_WIDGET_RET();
4474 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4476 m_hasScrolling
= TRUE
;
4478 if (orient
== wxHORIZONTAL
)
4480 float fpos
= (float)pos
;
4481 float frange
= (float)range
;
4482 float fthumb
= (float)thumbVisible
;
4483 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
4484 if (fpos
< 0.0) fpos
= 0.0;
4486 if ((fabs(frange
-m_hAdjust
->upper
) < 0.2) &&
4487 (fabs(fthumb
-m_hAdjust
->page_size
) < 0.2))
4489 SetScrollPos( orient
, pos
, refresh
);
4493 m_oldHorizontalPos
= fpos
;
4495 m_hAdjust
->lower
= 0.0;
4496 m_hAdjust
->upper
= frange
;
4497 m_hAdjust
->value
= fpos
;
4498 m_hAdjust
->step_increment
= 1.0;
4499 m_hAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
4500 m_hAdjust
->page_size
= fthumb
;
4504 float fpos
= (float)pos
;
4505 float frange
= (float)range
;
4506 float fthumb
= (float)thumbVisible
;
4507 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
4508 if (fpos
< 0.0) fpos
= 0.0;
4510 if ((fabs(frange
-m_vAdjust
->upper
) < 0.2) &&
4511 (fabs(fthumb
-m_vAdjust
->page_size
) < 0.2))
4513 SetScrollPos( orient
, pos
, refresh
);
4517 m_oldVerticalPos
= fpos
;
4519 m_vAdjust
->lower
= 0.0;
4520 m_vAdjust
->upper
= frange
;
4521 m_vAdjust
->value
= fpos
;
4522 m_vAdjust
->step_increment
= 1.0;
4523 m_vAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
4524 m_vAdjust
->page_size
= fthumb
;
4527 if (orient
== wxHORIZONTAL
)
4528 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
4530 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
4533 void wxWindowGTK::SetScrollPos( int orient
, int pos
, bool WXUNUSED(refresh
) )
4535 wxCHECK_VALID_WIDGET_RET();
4537 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4539 if (orient
== wxHORIZONTAL
)
4541 float fpos
= (float)pos
;
4542 if (fpos
> m_hAdjust
->upper
- m_hAdjust
->page_size
) fpos
= m_hAdjust
->upper
- m_hAdjust
->page_size
;
4543 if (fpos
< 0.0) fpos
= 0.0;
4544 m_oldHorizontalPos
= fpos
;
4546 if (fabs(fpos
-m_hAdjust
->value
) < 0.2) return;
4547 m_hAdjust
->value
= fpos
;
4551 float fpos
= (float)pos
;
4552 if (fpos
> m_vAdjust
->upper
- m_vAdjust
->page_size
) fpos
= m_vAdjust
->upper
- m_vAdjust
->page_size
;
4553 if (fpos
< 0.0) fpos
= 0.0;
4554 m_oldVerticalPos
= fpos
;
4556 if (fabs(fpos
-m_vAdjust
->value
) < 0.2) return;
4557 m_vAdjust
->value
= fpos
;
4560 if (m_wxwindow
->window
)
4562 if (orient
== wxHORIZONTAL
)
4564 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust
),
4565 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
4567 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "value_changed" );
4569 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
4570 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
4574 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust
),
4575 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
4577 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "value_changed" );
4579 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
4580 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
4585 int wxWindowGTK::GetScrollThumb( int orient
) const
4587 wxCHECK_VALID_WIDGET(0);
4589 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4591 if (orient
== wxHORIZONTAL
)
4592 return (int)(m_hAdjust
->page_size
+0.5);
4594 return (int)(m_vAdjust
->page_size
+0.5);
4597 int wxWindowGTK::GetScrollPos( int orient
) const
4599 wxCHECK_VALID_WIDGET(0);
4601 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4603 if (orient
== wxHORIZONTAL
)
4604 return (int)(m_hAdjust
->value
+0.5);
4606 return (int)(m_vAdjust
->value
+0.5);
4609 int wxWindowGTK::GetScrollRange( int orient
) const
4611 wxCHECK_VALID_WIDGET(0);
4613 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4615 if (orient
== wxHORIZONTAL
)
4616 return (int)(m_hAdjust
->upper
+0.5);
4618 return (int)(m_vAdjust
->upper
+0.5);
4621 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4623 wxCHECK_VALID_WIDGET_RET();
4625 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4627 // No scrolling requested.
4628 if ((dx
== 0) && (dy
== 0)) return;
4631 if (!m_updateRegion
.IsEmpty())
4633 m_updateRegion
.Offset( dx
, dy
);
4637 GetClientSize( &cw
, &ch
);
4638 m_updateRegion
.Intersect( 0, 0, cw
, ch
);
4641 if (!m_clearRegion
.IsEmpty())
4643 m_clearRegion
.Offset( dx
, dy
);
4647 GetClientSize( &cw
, &ch
);
4648 m_clearRegion
.Intersect( 0, 0, cw
, ch
);
4652 m_clipPaintRegion
= TRUE
;
4654 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), -dx
, -dy
);
4656 m_clipPaintRegion
= FALSE
;
4660 // Find the wxWindow at the current mouse position, also returning the mouse
4662 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4664 pt
= wxGetMousePosition();
4665 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4669 // Get the current mouse position.
4670 wxPoint
wxGetMousePosition()
4672 /* This crashes when used within wxHelpContext,
4673 so we have to use the X-specific implementation below.
4675 GdkModifierType *mask;
4676 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4678 return wxPoint(x, y);
4682 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4684 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4685 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4686 Window rootReturn
, childReturn
;
4687 int rootX
, rootY
, winX
, winY
;
4688 unsigned int maskReturn
;
4690 XQueryPointer (display
,
4694 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4695 return wxPoint(rootX
, rootY
);
4699 // ----------------------------------------------------------------------------
4701 // ----------------------------------------------------------------------------
4703 class wxWinModule
: public wxModule
4710 DECLARE_DYNAMIC_CLASS(wxWinModule
)
4713 IMPLEMENT_DYNAMIC_CLASS(wxWinModule
, wxModule
)
4715 bool wxWinModule::OnInit()
4717 // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
4718 // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
4723 void wxWinModule::OnExit()
4726 gdk_gc_unref( g_eraseGC
);