1 /////////////////////////////////////////////////////////////////////////////
2 // Name: gtk/window.cpp
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling, Julian Smart
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
12 #pragma implementation "window.h"
16 #define XWarpPointer XWARPPOINTER
20 #include "wx/window.h"
21 #include "wx/dcclient.h"
24 #include "wx/layout.h"
26 #include "wx/dialog.h"
27 #include "wx/msgdlg.h"
28 #include "wx/module.h"
30 #if wxUSE_DRAG_AND_DROP
35 #include "wx/tooltip.h"
43 #include "wx/textctrl.h"
47 #include "wx/statusbr.h"
49 #include "wx/settings.h"
51 #include "wx/fontutil.h"
54 #include "wx/thread.h"
60 #include "wx/gtk/private.h"
61 #include <gdk/gdkprivate.h>
62 #include <gdk/gdkkeysyms.h>
66 #include <gtk/gtkprivate.h>
68 #include "wx/gtk/win_gtk.h"
71 #include <pango/pangox.h>
75 #define SET_CONTAINER_FOCUS(w, d) gtk_widget_child_focus((w), (d))
77 #define SET_CONTAINER_FOCUS(w, d) gtk_container_focus(GTK_CONTAINER(w), (d))
87 extern GtkContainerClass
*pizza_parent_class
;
90 //-----------------------------------------------------------------------------
91 // documentation on internals
92 //-----------------------------------------------------------------------------
95 I have been asked several times about writing some documentation about
96 the GTK port of wxWindows, especially its internal structures. Obviously,
97 you cannot understand wxGTK without knowing a little about the GTK, but
98 some more information about what the wxWindow, which is the base class
99 for all other window classes, does seems required as well.
103 What does wxWindow do? It contains the common interface for the following
104 jobs of its descendants:
106 1) Define the rudimentary behaviour common to all window classes, such as
107 resizing, intercepting user input (so as to make it possible to use these
108 events for special purposes in a derived class), window names etc.
110 2) Provide the possibility to contain and manage children, if the derived
111 class is allowed to contain children, which holds true for those window
112 classes which do not display a native GTK widget. To name them, these
113 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
114 work classes are a special case and are handled a bit differently from
115 the rest. The same holds true for the wxNotebook class.
117 3) Provide the possibility to draw into a client area of a window. This,
118 too, only holds true for classes that do not display a native GTK widget
121 4) Provide the entire mechanism for scrolling widgets. This actual inter-
122 face for this is usually in wxScrolledWindow, but the GTK implementation
125 5) A multitude of helper or extra methods for special purposes, such as
126 Drag'n'Drop, managing validators etc.
128 6) Display a border (sunken, raised, simple or none).
130 Normally one might expect, that one wxWindows window would always correspond
131 to one GTK widget. Under GTK, there is no such allround widget that has all
132 the functionality. Moreover, the GTK defines a client area as a different
133 widget from the actual widget you are handling. Last but not least some
134 special classes (e.g. wxFrame) handle different categories of widgets and
135 still have the possibility to draw something in the client area.
136 It was therefore required to write a special purpose GTK widget, that would
137 represent a client area in the sense of wxWindows capable to do the jobs
138 2), 3) and 4). I have written this class and it resides in win_gtk.c of
141 All windows must have a widget, with which they interact with other under-
142 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
143 thw wxWindow class has a member variable called m_widget which holds a
144 pointer to this widget. When the window class represents a GTK native widget,
145 this is (in most cases) the only GTK widget the class manages. E.g. the
146 wxStatitText class handles only a GtkLabel widget a pointer to which you
147 can find in m_widget (defined in wxWindow)
149 When the class has a client area for drawing into and for containing children
150 it has to handle the client area widget (of the type GtkPizza, defined in
151 win_gtk.c), but there could be any number of widgets, handled by a class
152 The common rule for all windows is only, that the widget that interacts with
153 the rest of GTK must be referenced in m_widget and all other widgets must be
154 children of this widget on the GTK level. The top-most widget, which also
155 represents the client area, must be in the m_wxwindow field and must be of
158 As I said, the window classes that display a GTK native widget only have
159 one widget, so in the case of e.g. the wxButton class m_widget holds a
160 pointer to a GtkButton widget. But windows with client areas (for drawing
161 and children) have a m_widget field that is a pointer to a GtkScrolled-
162 Window and a m_wxwindow field that is pointer to a GtkPizza and this
163 one is (in the GTK sense) a child of the GtkScrolledWindow.
165 If the m_wxwindow field is set, then all input to this widget is inter-
166 cepted and sent to the wxWindows class. If not, all input to the widget
167 that gets pointed to by m_widget gets intercepted and sent to the class.
171 The design of scrolling in wxWindows is markedly different from that offered
172 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
173 clicking on a scrollbar belonging to scrolled window will inevitably move
174 the window. In wxWindows, the scrollbar will only emit an event, send this
175 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
176 which actually moves the window and its subchildren. Note that GtkPizza
177 memorizes how much it has been scrolled but that wxWindows forgets this
178 so that the two coordinates systems have to be kept in synch. This is done
179 in various places using the pizza->xoffset and pizza->yoffset values.
183 Singularily the most broken code in GTK is the code that is supposes to
184 inform subwindows (child windows) about new positions. Very often, duplicate
185 events are sent without changes in size or position, equally often no
186 events are sent at all (All this is due to a bug in the GtkContainer code
187 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
188 GTK's own system and it simply waits for size events for toplevel windows
189 and then iterates down the respective size events to all window. This has
190 the disadvantage, that windows might get size events before the GTK widget
191 actually has the reported size. This doesn't normally pose any problem, but
192 the OpenGl drawing routines rely on correct behaviour. Therefore, I have
193 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
194 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
195 window that is used for OpenGl output really has that size (as reported by
200 If someone at some point of time feels the immense desire to have a look at,
201 change or attempt to optimse the Refresh() logic, this person will need an
202 intimate understanding of what a "draw" and what an "expose" events are and
203 what there are used for, in particular when used in connection with GTK's
204 own windowless widgets. Beware.
208 Cursors, too, have been a constant source of pleasure. The main difficulty
209 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
210 for the parent. To prevent this from doing too much harm, I use idle time
211 to set the cursor over and over again, starting from the toplevel windows
212 and ending with the youngest generation (speaking of parent and child windows).
213 Also don't forget that cursors (like much else) are connected to GdkWindows,
214 not GtkWidgets and that the "window" field of a GtkWidget might very well
215 point to the GdkWindow of the parent widget (-> "window less widget") and
216 that the two obviously have very different meanings.
220 //-----------------------------------------------------------------------------
222 //-----------------------------------------------------------------------------
224 extern wxList wxPendingDelete
;
225 extern bool g_blockEventsOnDrag
;
226 extern bool g_blockEventsOnScroll
;
227 extern wxCursor g_globalCursor
;
229 static GdkGC
*g_eraseGC
= NULL
;
231 // mouse capture state: the window which has it and if the mouse is currently
233 static wxWindowGTK
*g_captureWindow
= (wxWindowGTK
*) NULL
;
234 static bool g_captureWindowHasMouse
= FALSE
;
236 /* extern */ wxWindowGTK
*g_focusWindow
= (wxWindowGTK
*) NULL
;
238 // the last window which had the focus - this is normally never NULL (except
239 // if we never had focus at all) as even when g_focusWindow is NULL it still
240 // keeps its previous value
241 static wxWindowGTK
*g_focusWindowLast
= (wxWindowGTK
*) NULL
;
243 // the frame that is currently active (i.e. its child has focus). It is
244 // used to generate wxActivateEvents
245 static wxWindowGTK
*g_activeFrame
= (wxWindowGTK
*) NULL
;
246 static bool g_activeFrameLostFocus
= FALSE
;
248 // If a window get the focus set but has not been realized
249 // yet, defer setting the focus to idle time.
250 wxWindowGTK
*g_delayedFocus
= (wxWindowGTK
*) NULL
;
252 // if we detect that the app has got/lost the focus, we set this variable to
253 // either TRUE or FALSE and an activate event will be sent during the next
254 // OnIdle() call and it is reset to -1: this value means that we shouldn't
255 // send any activate events at all
256 static int g_sendActivateEvent
= -1;
258 /* hack: we need something to pass to gtk_menu_popup, so we store the time of
259 the last click here */
260 static guint32 gs_timeLastClick
= 0;
262 extern bool g_mainThreadLocked
;
264 //-----------------------------------------------------------------------------
266 //-----------------------------------------------------------------------------
269 #define DISABLE_STYLE_IF_BROKEN_THEME 0
275 # define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
277 # define DEBUG_MAIN_THREAD
280 #define DEBUG_MAIN_THREAD
283 // the trace mask used for the focus debugging messages
284 #define TRACE_FOCUS _T("focus")
286 //-----------------------------------------------------------------------------
287 // missing gdk functions
288 //-----------------------------------------------------------------------------
291 gdk_window_warp_pointer (GdkWindow
*window
,
296 GdkWindowPrivate
*priv
;
300 window
= GDK_ROOT_PARENT();
303 if (!GDK_WINDOW_DESTROYED(window
))
305 XWarpPointer (GDK_WINDOW_XDISPLAY(window
),
306 None
, /* not source window -> move from anywhere */
307 GDK_WINDOW_XID(window
), /* dest window */
308 0, 0, 0, 0, /* not source window -> move from anywhere */
312 priv
= (GdkWindowPrivate
*) window
;
314 if (!priv
->destroyed
)
316 XWarpPointer (priv
->xdisplay
,
317 None
, /* not source window -> move from anywhere */
318 priv
->xwindow
, /* dest window */
319 0, 0, 0, 0, /* not source window -> move from anywhere */
325 //-----------------------------------------------------------------------------
327 //-----------------------------------------------------------------------------
329 extern void wxapp_install_idle_handler();
330 extern bool g_isIdle
;
332 //-----------------------------------------------------------------------------
333 // local code (see below)
334 //-----------------------------------------------------------------------------
336 // returns the child of win which currently has focus or NULL if not found
338 // Note: can't be static, needed by textctrl.cpp.
339 wxWindow
*wxFindFocusedChild(wxWindowGTK
*win
)
341 wxWindow
*winFocus
= wxWindowGTK::FindFocus();
343 return (wxWindow
*)NULL
;
345 if ( winFocus
== win
)
346 return (wxWindow
*)win
;
348 for ( wxWindowList::Node
*node
= win
->GetChildren().GetFirst();
350 node
= node
->GetNext() )
352 wxWindow
*child
= wxFindFocusedChild(node
->GetData());
357 return (wxWindow
*)NULL
;
360 static void draw_frame( GtkWidget
*widget
, wxWindowGTK
*win
)
362 // wxUniversal widgets draw the borders and scrollbars themselves
363 #ifndef __WXUNIVERSAL__
370 if (win
->m_hasScrolling
)
372 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(widget
);
374 GtkRequisition vscroll_req
;
375 vscroll_req
.width
= 2;
376 vscroll_req
.height
= 2;
377 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
378 (scroll_window
->vscrollbar
, &vscroll_req
);
380 GtkRequisition hscroll_req
;
381 hscroll_req
.width
= 2;
382 hscroll_req
.height
= 2;
383 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
384 (scroll_window
->hscrollbar
, &hscroll_req
);
386 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(widget
) );
388 if (scroll_window
->vscrollbar_visible
)
390 dw
+= vscroll_req
.width
;
391 dw
+= scroll_class
->scrollbar_spacing
;
394 if (scroll_window
->hscrollbar_visible
)
396 dh
+= hscroll_req
.height
;
397 dh
+= scroll_class
->scrollbar_spacing
;
403 if (GTK_WIDGET_NO_WINDOW (widget
))
405 dx
+= widget
->allocation
.x
;
406 dy
+= widget
->allocation
.y
;
409 if (win
->HasFlag(wxRAISED_BORDER
))
411 gtk_draw_shadow( widget
->style
,
416 widget
->allocation
.width
-dw
, widget
->allocation
.height
-dh
);
420 if (win
->HasFlag(wxSUNKEN_BORDER
))
422 gtk_draw_shadow( widget
->style
,
427 widget
->allocation
.width
-dw
, widget
->allocation
.height
-dh
);
431 if (win
->HasFlag(wxSIMPLE_BORDER
))
434 gc
= gdk_gc_new( widget
->window
);
435 gdk_gc_set_foreground( gc
, &widget
->style
->black
);
436 gdk_draw_rectangle( widget
->window
, gc
, FALSE
,
438 widget
->allocation
.width
-dw
-1, widget
->allocation
.height
-dh
-1 );
442 #endif // __WXUNIVERSAL__
445 //-----------------------------------------------------------------------------
446 // "expose_event" of m_widget
447 //-----------------------------------------------------------------------------
449 gint
gtk_window_own_expose_callback( GtkWidget
*widget
, GdkEventExpose
*gdk_event
, wxWindowGTK
*win
)
451 if (gdk_event
->count
> 0) return FALSE
;
453 draw_frame( widget
, win
);
457 (* GTK_WIDGET_CLASS (pizza_parent_class
)->expose_event
) (widget
, gdk_event
);
463 //-----------------------------------------------------------------------------
464 // "draw" of m_widget
465 //-----------------------------------------------------------------------------
469 static void gtk_window_own_draw_callback( GtkWidget
*widget
, GdkRectangle
*WXUNUSED(rect
), wxWindowGTK
*win
)
471 draw_frame( widget
, win
);
476 //-----------------------------------------------------------------------------
477 // "size_request" of m_widget
478 //-----------------------------------------------------------------------------
480 static void gtk_window_size_request_callback( GtkWidget
*widget
, GtkRequisition
*requisition
, wxWindow
*win
)
483 win
->GetSize( &w
, &h
);
487 requisition
->height
= h
;
488 requisition
->width
= w
;
491 //-----------------------------------------------------------------------------
492 // "expose_event" of m_wxwindow
493 //-----------------------------------------------------------------------------
495 static int gtk_window_expose_callback( GtkWidget
*widget
,
496 GdkEventExpose
*gdk_event
,
502 wxapp_install_idle_handler();
505 // This callback gets called in drawing-idle time under
506 // GTK 2.0, so we don't need to defer anything to idle
509 GtkPizza
*pizza
= GTK_PIZZA( widget
);
510 if (gdk_event
->window
!= pizza
->bin_window
) return FALSE
;
515 wxPrintf( wxT("OnExpose from ") );
516 if (win
->GetClassInfo() && win
->GetClassInfo()->GetClassName())
517 wxPrintf( win
->GetClassInfo()->GetClassName() );
518 wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event
->area
.x
,
519 (int)gdk_event
->area
.y
,
520 (int)gdk_event
->area
.width
,
521 (int)gdk_event
->area
.height
);
525 win
->GetUpdateRegion() = wxRegion( gdk_event
->region
);
527 win
->GtkSendPaintEvents();
530 // Let parent window draw window less widgets
531 (* GTK_WIDGET_CLASS (pizza_parent_class
)->expose_event
) (widget
, gdk_event
);
533 // This gets called immediately after an expose event
534 // under GTK 1.2 so we collect the calls and wait for
535 // the idle handler to pick things up.
537 win
->GetUpdateRegion().Union( gdk_event
->area
.x
,
539 gdk_event
->area
.width
,
540 gdk_event
->area
.height
);
541 win
->m_clearRegion
.Union( gdk_event
->area
.x
,
543 gdk_event
->area
.width
,
544 gdk_event
->area
.height
);
546 // Actual redrawing takes place in idle time.
553 //-----------------------------------------------------------------------------
554 // "event" of m_wxwindow
555 //-----------------------------------------------------------------------------
557 // GTK thinks it is clever and filters out a certain amount of "unneeded"
558 // expose events. We need them, of course, so we override the main event
559 // procedure in GtkWidget by giving our own handler for all system events.
560 // There, we look for expose events ourselves whereas all other events are
563 gint
gtk_window_event_event_callback( GtkWidget
*widget
,
564 GdkEventExpose
*event
,
567 if (event
->type
== GDK_EXPOSE
)
569 gint ret
= gtk_window_expose_callback( widget
, event
, win
);
576 //-----------------------------------------------------------------------------
577 // "draw" of m_wxwindow
578 //-----------------------------------------------------------------------------
582 // This callback is a complete replacement of the gtk_pizza_draw() function,
583 // which is disabled.
585 static void gtk_window_draw_callback( GtkWidget
*widget
,
592 wxapp_install_idle_handler();
594 // The wxNO_FULL_REPAINT_ON_RESIZE flag only works if
595 // there are no child windows.
596 if ((win
->HasFlag(wxNO_FULL_REPAINT_ON_RESIZE
)) &&
597 (win
->GetChildren().GetCount() == 0))
605 wxPrintf( wxT("OnDraw from ") );
606 if (win
->GetClassInfo() && win
->GetClassInfo()->GetClassName())
607 wxPrintf( win
->GetClassInfo()->GetClassName() );
608 wxPrintf( wxT(" %d %d %d %d\n"), (int)rect
->x
,
615 #ifndef __WXUNIVERSAL__
616 GtkPizza
*pizza
= GTK_PIZZA (widget
);
618 if (win
->GetThemeEnabled())
620 wxWindow
*parent
= win
->GetParent();
621 while (parent
&& !parent
->IsTopLevel())
622 parent
= parent
->GetParent();
626 gtk_paint_flat_box (parent
->m_widget
->style
,
637 win
->m_clearRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
638 win
->GetUpdateRegion().Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
640 // Update immediately, not in idle time.
643 #ifndef __WXUNIVERSAL__
644 // Redraw child widgets
645 GList
*children
= pizza
->children
;
648 GtkPizzaChild
*child
= (GtkPizzaChild
*) children
->data
;
649 children
= children
->next
;
651 GdkRectangle child_area
;
652 if (gtk_widget_intersect (child
->widget
, rect
, &child_area
))
654 gtk_widget_draw (child
->widget
, &child_area
/* (GdkRectangle*) NULL*/ );
662 //-----------------------------------------------------------------------------
663 // "key_press_event" from any window
664 //-----------------------------------------------------------------------------
666 // set WXTRACE to this to see the key event codes on the console
667 #define TRACE_KEYS _T("keyevent")
669 // translates an X key symbol to WXK_XXX value
671 // if isChar is true it means that the value returned will be used for EVT_CHAR
672 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
673 // for example, while if it is false it means that the value is going to be
674 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
676 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
682 // Shift, Control and Alt don't generate the CHAR events at all
685 key_code
= isChar
? 0 : WXK_SHIFT
;
689 key_code
= isChar
? 0 : WXK_CONTROL
;
697 key_code
= isChar
? 0 : WXK_ALT
;
700 // neither do the toggle modifies
701 case GDK_Scroll_Lock
:
702 key_code
= isChar
? 0 : WXK_SCROLL
;
706 key_code
= isChar
? 0 : WXK_CAPITAL
;
710 key_code
= isChar
? 0 : WXK_NUMLOCK
;
714 // various other special keys
727 case GDK_ISO_Left_Tab
:
734 key_code
= WXK_RETURN
;
738 key_code
= WXK_CLEAR
;
742 key_code
= WXK_PAUSE
;
746 key_code
= WXK_SELECT
;
750 key_code
= WXK_PRINT
;
754 key_code
= WXK_EXECUTE
;
758 key_code
= WXK_ESCAPE
;
761 // cursor and other extended keyboard keys
763 key_code
= WXK_DELETE
;
779 key_code
= WXK_RIGHT
;
786 case GDK_Prior
: // == GDK_Page_Up
787 key_code
= WXK_PRIOR
;
790 case GDK_Next
: // == GDK_Page_Down
803 key_code
= WXK_INSERT
;
818 key_code
= (isChar
? '0' : WXK_NUMPAD0
) + keysym
- GDK_KP_0
;
822 key_code
= isChar
? ' ' : WXK_NUMPAD_SPACE
;
826 key_code
= isChar
? WXK_TAB
: WXK_NUMPAD_TAB
;
830 key_code
= isChar
? WXK_RETURN
: WXK_NUMPAD_ENTER
;
834 key_code
= isChar
? WXK_F1
: WXK_NUMPAD_F1
;
838 key_code
= isChar
? WXK_F2
: WXK_NUMPAD_F2
;
842 key_code
= isChar
? WXK_F3
: WXK_NUMPAD_F3
;
846 key_code
= isChar
? WXK_F4
: WXK_NUMPAD_F4
;
850 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_HOME
;
854 key_code
= isChar
? WXK_LEFT
: WXK_NUMPAD_LEFT
;
858 key_code
= isChar
? WXK_UP
: WXK_NUMPAD_UP
;
862 key_code
= isChar
? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
866 key_code
= isChar
? WXK_DOWN
: WXK_NUMPAD_DOWN
;
869 case GDK_KP_Prior
: // == GDK_KP_Page_Up
870 key_code
= isChar
? WXK_PRIOR
: WXK_NUMPAD_PRIOR
;
873 case GDK_KP_Next
: // == GDK_KP_Page_Down
874 key_code
= isChar
? WXK_NEXT
: WXK_NUMPAD_NEXT
;
878 key_code
= isChar
? WXK_END
: WXK_NUMPAD_END
;
882 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_BEGIN
;
886 key_code
= isChar
? WXK_INSERT
: WXK_NUMPAD_INSERT
;
890 key_code
= isChar
? WXK_DELETE
: WXK_NUMPAD_DELETE
;
894 key_code
= isChar
? '=' : WXK_NUMPAD_EQUAL
;
897 case GDK_KP_Multiply
:
898 key_code
= isChar
? '*' : WXK_NUMPAD_MULTIPLY
;
902 key_code
= isChar
? '+' : WXK_NUMPAD_ADD
;
905 case GDK_KP_Separator
:
906 // FIXME: what is this?
907 key_code
= isChar
? '.' : WXK_NUMPAD_SEPARATOR
;
910 case GDK_KP_Subtract
:
911 key_code
= isChar
? '-' : WXK_NUMPAD_SUBTRACT
;
915 key_code
= isChar
? '.' : WXK_NUMPAD_DECIMAL
;
919 key_code
= isChar
? '/' : WXK_NUMPAD_DIVIDE
;
936 key_code
= WXK_F1
+ keysym
- GDK_F1
;
946 static inline bool wxIsAsciiKeysym(KeySym ks
)
952 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
954 GdkEventKey
*gdk_event
)
956 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
957 // but only event->keyval which is quite useless to us, so remember
958 // the last character from GDK_KEY_PRESS and reuse it as last resort
960 // NB: should be MT-safe as we're always called from the main thread only
965 } s_lastKeyPress
= { 0, 0 };
967 KeySym keysym
= gdk_event
->keyval
;
969 wxLogTrace(TRACE_KEYS
, _T("Key %s event: keysym = %ld"),
970 event
.GetEventType() == wxEVT_KEY_UP
? _T("release")
974 long key_code
= wxTranslateKeySymToWXKey(keysym
, FALSE
/* !isChar */);
978 // do we have the translation or is it a plain ASCII character?
979 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
981 // we should use keysym if it is ASCII as X does some translations
982 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
983 // which we don't want here (but which we do use for OnChar())
984 if ( !wxIsAsciiKeysym(keysym
) )
986 keysym
= (KeySym
)gdk_event
->string
[0];
989 // we want to always get the same key code when the same key is
990 // pressed regardless of the state of the modifies, i.e. on a
991 // standard US keyboard pressing '5' or '%' ('5' key with
992 // Shift) should result in the same key code in OnKeyDown():
993 // '5' (although OnChar() will get either '5' or '%').
995 // to do it we first translate keysym to keycode (== scan code)
996 // and then back but always using the lower register
997 Display
*dpy
= (Display
*)wxGetDisplay();
998 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
1000 wxLogTrace(TRACE_KEYS
, _T("\t-> keycode %d"), keycode
);
1002 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
1004 // use the normalized, i.e. lower register, keysym if we've
1006 key_code
= keysymNormalized
? keysymNormalized
: keysym
;
1008 // as explained above, we want to have lower register key codes
1009 // normally but for the letter keys we want to have the upper ones
1011 // NB: don't use XConvertCase() here, we want to do it for letters
1013 key_code
= toupper(key_code
);
1015 else // non ASCII key, what to do?
1017 // by default, ignore it
1020 // but if we have cached information from the last KEY_PRESS
1021 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
1024 if ( keysym
== s_lastKeyPress
.keysym
)
1026 key_code
= s_lastKeyPress
.keycode
;
1031 if ( gdk_event
->type
== GDK_KEY_PRESS
)
1033 // remember it to be reused for KEY_UP event later
1034 s_lastKeyPress
.keysym
= keysym
;
1035 s_lastKeyPress
.keycode
= key_code
;
1039 wxLogTrace(TRACE_KEYS
, _T("\t-> wxKeyCode %ld"), key_code
);
1041 // sending unknown key events doesn't really make sense
1045 // now fill all the other fields
1048 GdkModifierType state
;
1049 if (gdk_event
->window
)
1050 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1052 event
.SetTimestamp( gdk_event
->time
);
1053 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
1054 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
1055 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
1056 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
) != 0;
1057 event
.m_keyCode
= key_code
;
1058 event
.m_scanCode
= gdk_event
->keyval
;
1059 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
1060 event
.m_rawFlags
= 0;
1063 event
.SetEventObject( win
);
1069 static gint
gtk_window_key_press_callback( GtkWidget
*widget
,
1070 GdkEventKey
*gdk_event
,
1076 wxapp_install_idle_handler();
1080 if (g_blockEventsOnDrag
)
1084 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1085 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1087 // unknown key pressed, ignore (the event would be useless anyhow)
1091 // Emit KEY_DOWN event
1092 bool ret
= win
->GetEventHandler()->ProcessEvent( event
);
1097 wxWindowGTK
*ancestor
= win
;
1100 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
1103 wxCommandEvent
command_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
1104 ret
= ancestor
->GetEventHandler()->ProcessEvent( command_event
);
1107 if (ancestor
->IsTopLevel())
1109 ancestor
= ancestor
->GetParent();
1112 #endif // wxUSE_ACCEL
1114 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1115 // will only be sent if it is not in an accelerator table.
1119 KeySym keysym
= gdk_event
->keyval
;
1121 // In GTK 2.0, we need to hand over the key event to an input method
1122 // and the IM will emit a "commit" event containing the actual utf8
1123 // character. In that case the EVT_CHAR events will be sent from
1124 // there. But only do it this way for non-KeySym keys.
1125 key_code
= wxTranslateKeySymToWXKey(gdk_event
->keyval
, FALSE
/* isChar */);
1126 if ( !key_code
&& win
->m_imContext
)
1128 gtk_im_context_filter_keypress ( (GtkIMContext
*) win
->m_imContext
, gdk_event
);
1134 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1135 key_code
= wxTranslateKeySymToWXKey(keysym
, TRUE
/* isChar */);
1138 if ( gdk_event
->length
== 1 )
1140 key_code
= (unsigned char)gdk_event
->string
[0];
1142 else if ( wxIsAsciiKeysym(keysym
) )
1145 key_code
= (unsigned char)keysym
;
1151 wxLogTrace(TRACE_KEYS
, _T("Char event: %ld"), key_code
);
1153 event
.m_keyCode
= key_code
;
1155 // Implement OnCharHook by checking ancesteror top level windows
1156 wxWindow
*parent
= win
;
1157 while (parent
&& !parent
->IsTopLevel())
1158 parent
= parent
->GetParent();
1161 event
.SetEventType( wxEVT_CHAR_HOOK
);
1162 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1167 event
.SetEventType(wxEVT_CHAR
);
1168 ret
= win
->GetEventHandler()->ProcessEvent( event
);
1174 // win is a control: tab can be propagated up
1176 ((gdk_event
->keyval
== GDK_Tab
) || (gdk_event
->keyval
== GDK_ISO_Left_Tab
)) &&
1177 // VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may
1178 // have this style, yet choose not to process this particular TAB in which
1179 // case TAB must still work as a navigational character
1181 !win
->HasFlag(wxTE_PROCESS_TAB
) &&
1183 win
->GetParent() && (win
->GetParent()->HasFlag( wxTAB_TRAVERSAL
)) )
1185 wxNavigationKeyEvent new_event
;
1186 new_event
.SetEventObject( win
->GetParent() );
1187 // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
1188 new_event
.SetDirection( (gdk_event
->keyval
== GDK_Tab
) );
1189 // CTRL-TAB changes the (parent) window, i.e. switch notebook page
1190 new_event
.SetWindowChange( (gdk_event
->state
& GDK_CONTROL_MASK
) );
1191 new_event
.SetCurrentFocus( win
);
1192 ret
= win
->GetParent()->GetEventHandler()->ProcessEvent( new_event
);
1195 // generate wxID_CANCEL if <esc> has been pressed (typically in dialogs)
1197 (gdk_event
->keyval
== GDK_Escape
) )
1199 // however only do it if we have a Cancel button in the dialog,
1200 // otherwise the user code may get confused by the events from a
1201 // non-existing button and, worse, a wxButton might get button event
1202 // from another button which is not really expected
1203 wxWindow
*winForCancel
= win
,
1205 while ( winForCancel
)
1207 btnCancel
= winForCancel
->FindWindow(wxID_CANCEL
);
1210 // found a cancel button
1214 if ( winForCancel
->IsTopLevel() )
1216 // no need to look further
1220 // maybe our parent has a cancel button?
1221 winForCancel
= winForCancel
->GetParent();
1226 wxCommandEvent
event(wxEVT_COMMAND_BUTTON_CLICKED
, wxID_CANCEL
);
1227 event
.SetEventObject(btnCancel
);
1228 ret
= btnCancel
->GetEventHandler()->ProcessEvent(event
);
1234 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_press_event" );
1242 static void gtk_wxwindow_commit_cb (GtkIMContext
*context
,
1248 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1251 event
.m_uniChar
= g_utf8_get_char( str
);
1253 // Backward compatible for ISO-8859
1254 if (event
.m_uniChar
< 256)
1255 event
.m_keyCode
= event
.m_uniChar
;
1257 gunichar uniChar
= g_utf8_get_char( str
);
1258 // We cannot handle Unicode in non-Unicode mode
1259 if (uniChar
> 255) return;
1261 event
.m_keyCode
= uniChar
;
1265 // TODO: We still need to set all the extra attributes of the
1266 // event, modifiers and such...
1269 // Implement OnCharHook by checking ancestor top level windows
1270 wxWindow
*parent
= window
;
1271 while (parent
&& !parent
->IsTopLevel())
1272 parent
= parent
->GetParent();
1275 event
.SetEventType( wxEVT_CHAR_HOOK
);
1276 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1281 event
.SetEventType(wxEVT_CHAR
);
1282 ret
= window
->GetEventHandler()->ProcessEvent( event
);
1288 //-----------------------------------------------------------------------------
1289 // "key_release_event" from any window
1290 //-----------------------------------------------------------------------------
1292 static gint
gtk_window_key_release_callback( GtkWidget
*widget
,
1293 GdkEventKey
*gdk_event
,
1299 wxapp_install_idle_handler();
1304 if (g_blockEventsOnDrag
)
1307 wxKeyEvent
event( wxEVT_KEY_UP
);
1308 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1310 // unknown key pressed, ignore (the event would be useless anyhow
1314 if ( !win
->GetEventHandler()->ProcessEvent( event
) )
1317 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_release_event" );
1321 // ============================================================================
1323 // ============================================================================
1325 // ----------------------------------------------------------------------------
1326 // mouse event processing helpers
1327 // ----------------------------------------------------------------------------
1329 // init wxMouseEvent with the info from gdk_event
1331 // NB: this has to be a macro as gdk_event type is different for different
1332 // events we're used with
1333 #define InitMouseEvent(/* wxWindowGTK * */ win, \
1334 /* wxMouseEvent& */ event, \
1335 /* GdkEventXXX * */ gdk_event) \
1337 event.SetTimestamp( gdk_event->time ); \
1338 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK); \
1339 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK); \
1340 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK); \
1341 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK); \
1342 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK); \
1343 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK); \
1344 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK); \
1345 if (event.GetEventType()==wxEVT_MOUSEWHEEL) \
1347 if (((GdkEventButton*)gdk_event)->button == 4) \
1348 event.m_wheelRotation = 120; \
1349 else if (((GdkEventButton*)gdk_event)->button == 5) \
1350 event.m_wheelRotation = -120; \
1353 wxPoint pt = win->GetClientAreaOrigin(); \
1354 event.m_x = (wxCoord)gdk_event->x - pt.x; \
1355 event.m_y = (wxCoord)gdk_event->y - pt.y; \
1357 event.SetEventObject( win ); \
1358 event.SetId( win->GetId() ); \
1359 event.SetTimestamp( gdk_event->time ); \
1362 static void AdjustEventButtonState(wxMouseEvent& event)
1364 // GDK reports the old state of the button for a button press event, but
1365 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1366 // for a LEFT_DOWN event, not FALSE, so we will invert
1367 // left/right/middleDown for the corresponding click events
1369 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1370 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1371 (event
.GetEventType() == wxEVT_LEFT_UP
))
1373 event
.m_leftDown
= !event
.m_leftDown
;
1377 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1378 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1379 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1381 event
.m_middleDown
= !event
.m_middleDown
;
1385 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1386 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1387 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1389 event
.m_rightDown
= !event
.m_rightDown
;
1394 // find the window to send the mouse event too
1396 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1401 if (win
->m_wxwindow
)
1403 GtkPizza
*pizza
= GTK_PIZZA(win
->m_wxwindow
);
1404 xx
+= pizza
->xoffset
;
1405 yy
+= pizza
->yoffset
;
1408 wxWindowList::Node
*node
= win
->GetChildren().GetFirst();
1411 wxWindowGTK
*child
= node
->GetData();
1413 node
= node
->GetNext();
1414 if (!child
->IsShown())
1417 if (child
->IsTransparentForMouse())
1419 // wxStaticBox is transparent in the box itself
1420 int xx1
= child
->m_x
;
1421 int yy1
= child
->m_y
;
1422 int xx2
= child
->m_x
+ child
->m_width
;
1423 int yy2
= child
->m_y
+ child
->m_height
;
1426 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1428 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1430 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1432 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1443 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1444 (child
->m_x
<= xx
) &&
1445 (child
->m_y
<= yy
) &&
1446 (child
->m_x
+child
->m_width
>= xx
) &&
1447 (child
->m_y
+child
->m_height
>= yy
))
1460 //-----------------------------------------------------------------------------
1461 // "button_press_event"
1462 //-----------------------------------------------------------------------------
1464 static gint
gtk_window_button_press_callback( GtkWidget
*widget
,
1465 GdkEventButton
*gdk_event
,
1471 wxapp_install_idle_handler();
1474 wxPrintf( wxT("1) OnButtonPress from ") );
1475 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1476 wxPrintf( win->GetClassInfo()->GetClassName() );
1477 wxPrintf( wxT(".\n") );
1479 if (!win
->m_hasVMT
) return FALSE
;
1480 if (g_blockEventsOnDrag
) return TRUE
;
1481 if (g_blockEventsOnScroll
) return TRUE
;
1483 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1485 if (win
->m_wxwindow
&& (g_focusWindow
!= win
) && win
->AcceptsFocus())
1487 gtk_widget_grab_focus( win
->m_wxwindow
);
1489 wxPrintf( wxT("GrabFocus from ") );
1490 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1491 wxPrintf( win->GetClassInfo()->GetClassName() );
1492 wxPrintf( wxT(".\n") );
1496 // GDK sends surplus button down event
1497 // before a double click event. We
1498 // need to filter these out.
1499 if (gdk_event
->type
== GDK_BUTTON_PRESS
)
1501 GdkEvent
*peek_event
= gdk_event_peek();
1504 if (peek_event
->type
== GDK_2BUTTON_PRESS
)
1506 gdk_event_free( peek_event
);
1511 gdk_event_free( peek_event
);
1516 wxEventType event_type
= wxEVT_NULL
;
1518 if (gdk_event
->button
== 1)
1520 switch (gdk_event
->type
)
1522 case GDK_BUTTON_PRESS
: event_type
= wxEVT_LEFT_DOWN
; break;
1523 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_LEFT_DCLICK
; break;
1527 else if (gdk_event
->button
== 2)
1529 switch (gdk_event
->type
)
1531 case GDK_BUTTON_PRESS
: event_type
= wxEVT_MIDDLE_DOWN
; break;
1532 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_MIDDLE_DCLICK
; break;
1536 else if (gdk_event
->button
== 3)
1538 switch (gdk_event
->type
)
1540 case GDK_BUTTON_PRESS
: event_type
= wxEVT_RIGHT_DOWN
; break;
1541 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_RIGHT_DCLICK
; break;
1545 else if (gdk_event
->button
== 4)
1547 switch (gdk_event
->type
)
1549 case GDK_BUTTON_PRESS
: event_type
= wxEVT_MOUSEWHEEL
; break;
1553 else if (gdk_event
->button
== 5)
1555 switch (gdk_event
->type
)
1557 case GDK_BUTTON_PRESS
: event_type
= wxEVT_MOUSEWHEEL
; break;
1562 if ( event_type
== wxEVT_NULL
)
1564 // unknown mouse button or click type
1568 wxMouseEvent
event( event_type
);
1569 InitMouseEvent( win
, event
, gdk_event
);
1571 AdjustEventButtonState(event
);
1573 // wxListBox actually get mouse events from the item, so we need to give it
1574 // a chance to correct this
1575 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1577 // find the correct window to send the event too: it may be a different one
1578 // from the one which got it at GTK+ level because some control don't have
1579 // their own X window and thus cannot get any events.
1580 if ( !g_captureWindow
)
1581 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1583 gs_timeLastClick
= gdk_event
->time
;
1586 wxPrintf( wxT("2) OnButtonPress from ") );
1587 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1588 wxPrintf( win->GetClassInfo()->GetClassName() );
1589 wxPrintf( wxT(".\n") );
1593 if (event_type
== wxEVT_LEFT_DCLICK
)
1595 // GTK 1.2 crashes when intercepting double
1596 // click events from both wxSpinButton and
1598 if (GTK_IS_SPIN_BUTTON(win
->m_widget
))
1600 // Just disable this event for now.
1606 if (win
->GetEventHandler()->ProcessEvent( event
))
1608 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_press_event" );
1615 //-----------------------------------------------------------------------------
1616 // "button_release_event"
1617 //-----------------------------------------------------------------------------
1619 static gint
gtk_window_button_release_callback( GtkWidget
*widget
,
1620 GdkEventButton
*gdk_event
,
1626 wxapp_install_idle_handler();
1628 if (!win
->m_hasVMT
) return FALSE
;
1629 if (g_blockEventsOnDrag
) return FALSE
;
1630 if (g_blockEventsOnScroll
) return FALSE
;
1632 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1634 wxEventType event_type
= wxEVT_NULL
;
1636 switch (gdk_event
->button
)
1639 event_type
= wxEVT_LEFT_UP
;
1643 event_type
= wxEVT_MIDDLE_UP
;
1647 event_type
= wxEVT_RIGHT_UP
;
1651 // unknwon button, don't process
1655 wxMouseEvent
event( event_type
);
1656 InitMouseEvent( win
, event
, gdk_event
);
1658 AdjustEventButtonState(event
);
1660 // same wxListBox hack as above
1661 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1663 if ( event_type
== wxEVT_RIGHT_UP
)
1665 // generate a "context menu" event: this is similar to wxEVT_RIGHT_UP
1668 // (a) it's a command event and so is propagated to the parent
1669 // (b) under MSW it can be generated from kbd too
1670 // (c) it uses screen coords (because of (a))
1671 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
,
1673 win
->ClientToScreen(event
.GetPosition()));
1674 (void)win
->GetEventHandler()->ProcessEvent(evtCtx
);
1677 if ( !g_captureWindow
)
1678 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1680 if (win
->GetEventHandler()->ProcessEvent( event
))
1682 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_release_event" );
1689 //-----------------------------------------------------------------------------
1690 // "motion_notify_event"
1691 //-----------------------------------------------------------------------------
1693 static gint
gtk_window_motion_notify_callback( GtkWidget
*widget
,
1694 GdkEventMotion
*gdk_event
,
1700 wxapp_install_idle_handler();
1702 if (!win
->m_hasVMT
) return FALSE
;
1703 if (g_blockEventsOnDrag
) return FALSE
;
1704 if (g_blockEventsOnScroll
) return FALSE
;
1706 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1708 if (gdk_event
->is_hint
)
1712 GdkModifierType state
;
1713 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1719 printf( "OnMotion from " );
1720 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1721 printf( win->GetClassInfo()->GetClassName() );
1725 wxMouseEvent
event( wxEVT_MOTION
);
1726 InitMouseEvent(win
, event
, gdk_event
);
1728 if ( g_captureWindow
)
1730 // synthetize a mouse enter or leave event if needed
1731 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1732 // This seems to be necessary and actually been added to
1733 // GDK itself in version 2.0.X
1736 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1737 if ( hasMouse
!= g_captureWindowHasMouse
)
1739 // the mouse changed window
1740 g_captureWindowHasMouse
= hasMouse
;
1742 wxMouseEvent
event(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1743 : wxEVT_LEAVE_WINDOW
);
1744 InitMouseEvent(win
, event
, gdk_event
);
1745 event
.SetEventObject(win
);
1746 win
->GetEventHandler()->ProcessEvent(event
);
1751 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1754 if (win
->GetEventHandler()->ProcessEvent( event
))
1756 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "motion_notify_event" );
1763 //-----------------------------------------------------------------------------
1765 //-----------------------------------------------------------------------------
1767 // send the wxChildFocusEvent and wxFocusEvent, common code of
1768 // gtk_window_focus_in_callback() and SetFocus()
1769 static bool DoSendFocusEvents(wxWindow
*win
)
1771 // Notify the parent keeping track of focus for the kbd navigation
1772 // purposes that we got it.
1773 wxChildFocusEvent
eventChildFocus(win
);
1774 (void)win
->GetEventHandler()->ProcessEvent(eventChildFocus
);
1776 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, win
->GetId());
1777 eventFocus
.SetEventObject(win
);
1779 return win
->GetEventHandler()->ProcessEvent(eventFocus
);
1782 static gint
gtk_window_focus_in_callback( GtkWidget
*widget
,
1783 GdkEvent
*WXUNUSED(event
),
1789 wxapp_install_idle_handler();
1791 if (!win
->m_hasVMT
) return FALSE
;
1792 if (g_blockEventsOnDrag
) return FALSE
;
1794 switch ( g_sendActivateEvent
)
1797 // we've got focus from outside, synthetize wxActivateEvent
1798 g_sendActivateEvent
= 1;
1802 // another our window just lost focus, it was already ours before
1803 // - don't send any wxActivateEvent
1804 g_sendActivateEvent
= -1;
1809 g_focusWindow
= win
;
1811 wxLogTrace(TRACE_FOCUS
,
1812 _T("%s: focus in"), win
->GetName().c_str());
1816 gdk_im_begin(win
->m_ic
, win
->m_wxwindow
->window
);
1820 // caret needs to be informed about focus change
1821 wxCaret
*caret
= win
->GetCaret();
1824 caret
->OnSetFocus();
1826 #endif // wxUSE_CARET
1828 g_activeFrameLostFocus
= FALSE
;
1830 wxWindowGTK
*active
= wxGetTopLevelParent(win
);
1831 if ( active
!= g_activeFrame
)
1833 if ( g_activeFrame
)
1835 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from focus_in)"), g_activeFrame
);
1836 wxActivateEvent
event(wxEVT_ACTIVATE
, FALSE
, g_activeFrame
->GetId());
1837 event
.SetEventObject(g_activeFrame
);
1838 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
1841 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), active
);
1842 g_activeFrame
= active
;
1843 wxActivateEvent
event(wxEVT_ACTIVATE
, TRUE
, g_activeFrame
->GetId());
1844 event
.SetEventObject(g_activeFrame
);
1845 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
1847 // Don't send focus events in addition to activate
1848 // if (win == g_activeFrame)
1852 // does the window itself think that it has the focus?
1853 if ( !win
->m_hasFocus
)
1855 // not yet, notify it
1856 win
->m_hasFocus
= TRUE
;
1858 if ( DoSendFocusEvents(win
) )
1860 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_in_event" );
1868 //-----------------------------------------------------------------------------
1869 // "focus_out_event"
1870 //-----------------------------------------------------------------------------
1872 static gint
gtk_window_focus_out_callback( GtkWidget
*widget
, GdkEventFocus
*gdk_event
, wxWindowGTK
*win
)
1877 wxapp_install_idle_handler();
1879 if (!win
->m_hasVMT
) return FALSE
;
1880 if (g_blockEventsOnDrag
) return FALSE
;
1882 wxLogTrace( TRACE_FOCUS
,
1883 _T("%s: focus out"), win
->GetName().c_str() );
1885 if ( !g_activeFrameLostFocus
&& g_activeFrame
)
1887 // VZ: commenting this out because it does happen (although not easy
1888 // to reproduce, I only see it when using wxMiniFrame and not
1889 // always) and makes using Mahogany quite annoying
1891 wxASSERT_MSG( wxGetTopLevelParent(win
) == g_activeFrame
,
1892 wxT("unfocusing window that hasn't gained focus properly") );
1895 g_activeFrameLostFocus
= TRUE
;
1898 // if the focus goes out of our app alltogether, OnIdle() will send
1899 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
1900 // g_sendActivateEvent to -1
1901 g_sendActivateEvent
= 0;
1903 wxWindowGTK
*winFocus
= wxFindFocusedChild(win
);
1907 g_focusWindow
= (wxWindowGTK
*)NULL
;
1915 // caret needs to be informed about focus change
1916 wxCaret
*caret
= win
->GetCaret();
1919 caret
->OnKillFocus();
1921 #endif // wxUSE_CARET
1923 // don't send the window a kill focus event if it thinks that it doesn't
1924 // have focus already
1925 if ( win
->m_hasFocus
)
1927 win
->m_hasFocus
= FALSE
;
1929 wxFocusEvent
event( wxEVT_KILL_FOCUS
, win
->GetId() );
1930 event
.SetEventObject( win
);
1932 if (win
->GetEventHandler()->ProcessEvent( event
))
1934 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_out_event" );
1942 //-----------------------------------------------------------------------------
1943 // "enter_notify_event"
1944 //-----------------------------------------------------------------------------
1947 gint
gtk_window_enter_callback( GtkWidget
*widget
,
1948 GdkEventCrossing
*gdk_event
,
1954 wxapp_install_idle_handler();
1956 if (!win
->m_hasVMT
) return FALSE
;
1957 if (g_blockEventsOnDrag
) return FALSE
;
1959 // Event was emitted after a grab
1960 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
1962 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1966 GdkModifierType state
= (GdkModifierType
)0;
1968 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1970 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1971 InitMouseEvent(win
, event
, gdk_event
);
1972 wxPoint pt
= win
->GetClientAreaOrigin();
1973 event
.m_x
= x
+ pt
.x
;
1974 event
.m_y
= y
+ pt
.y
;
1976 if (win
->GetEventHandler()->ProcessEvent( event
))
1978 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "enter_notify_event" );
1985 //-----------------------------------------------------------------------------
1986 // "leave_notify_event"
1987 //-----------------------------------------------------------------------------
1989 static gint
gtk_window_leave_callback( GtkWidget
*widget
, GdkEventCrossing
*gdk_event
, wxWindowGTK
*win
)
1994 wxapp_install_idle_handler();
1996 if (!win
->m_hasVMT
) return FALSE
;
1997 if (g_blockEventsOnDrag
) return FALSE
;
1999 // Event was emitted after an ungrab
2000 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
2002 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
2004 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
2005 event
.SetTimestamp( gdk_event
->time
);
2006 event
.SetEventObject( win
);
2010 GdkModifierType state
= (GdkModifierType
)0;
2012 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
2014 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
) != 0;
2015 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
) != 0;
2016 event
.m_altDown
= (state
& GDK_MOD1_MASK
) != 0;
2017 event
.m_metaDown
= (state
& GDK_MOD2_MASK
) != 0;
2018 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
) != 0;
2019 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
) != 0;
2020 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
) != 0;
2022 wxPoint pt
= win
->GetClientAreaOrigin();
2023 event
.m_x
= x
+ pt
.x
;
2024 event
.m_y
= y
+ pt
.y
;
2026 if (win
->GetEventHandler()->ProcessEvent( event
))
2028 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "leave_notify_event" );
2035 //-----------------------------------------------------------------------------
2036 // "value_changed" from m_vAdjust
2037 //-----------------------------------------------------------------------------
2039 static void gtk_window_vscroll_callback( GtkAdjustment
*adjust
,
2046 wxapp_install_idle_handler();
2048 if (g_blockEventsOnDrag
) return;
2050 if (!win
->m_hasVMT
) return;
2052 float diff
= adjust
->value
- win
->m_oldVerticalPos
;
2053 if (fabs(diff
) < 0.2) return;
2055 win
->m_oldVerticalPos
= adjust
->value
;
2058 GtkScrolledWindow
*sw
= GTK_SCROLLED_WINDOW(win
->m_widget
);
2060 wxEventType command
= GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw
->vscrollbar
));
2062 int value
= (int)(adjust
->value
+0.5);
2064 wxScrollWinEvent
event( command
, value
, wxVERTICAL
);
2065 event
.SetEventObject( win
);
2066 win
->GetEventHandler()->ProcessEvent( event
);
2069 //-----------------------------------------------------------------------------
2070 // "value_changed" from m_hAdjust
2071 //-----------------------------------------------------------------------------
2073 static void gtk_window_hscroll_callback( GtkAdjustment
*adjust
,
2080 wxapp_install_idle_handler();
2082 if (g_blockEventsOnDrag
) return;
2083 if (!win
->m_hasVMT
) return;
2085 float diff
= adjust
->value
- win
->m_oldHorizontalPos
;
2086 if (fabs(diff
) < 0.2) return;
2089 GtkScrolledWindow
*sw
= GTK_SCROLLED_WINDOW(win
->m_widget
);
2091 wxEventType command
= GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw
->hscrollbar
));
2093 win
->m_oldHorizontalPos
= adjust
->value
;
2095 int value
= (int)(adjust
->value
+0.5);
2097 wxScrollWinEvent
event( command
, value
, wxHORIZONTAL
);
2098 event
.SetEventObject( win
);
2099 win
->GetEventHandler()->ProcessEvent( event
);
2102 //-----------------------------------------------------------------------------
2103 // "button_press_event" from scrollbar
2104 //-----------------------------------------------------------------------------
2106 static gint
gtk_scrollbar_button_press_callback( GtkRange
*widget
,
2107 GdkEventButton
*gdk_event
,
2113 wxapp_install_idle_handler();
2116 g_blockEventsOnScroll
= TRUE
;
2118 // FIXME: there is no 'slider' field in GTK+ 2.0 any more
2120 win
->m_isScrolling
= (gdk_event
->window
== widget
->slider
);
2126 //-----------------------------------------------------------------------------
2127 // "button_release_event" from scrollbar
2128 //-----------------------------------------------------------------------------
2130 static gint
gtk_scrollbar_button_release_callback( GtkRange
*widget
,
2131 GdkEventButton
*WXUNUSED(gdk_event
),
2136 // don't test here as we can release the mouse while being over
2137 // a different window than the slider
2139 // if (gdk_event->window != widget->slider) return FALSE;
2141 g_blockEventsOnScroll
= FALSE
;
2143 if (win
->m_isScrolling
)
2145 wxEventType command
= wxEVT_SCROLLWIN_THUMBRELEASE
;
2149 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(win
->m_widget
);
2150 if (widget
== GTK_RANGE(scrolledWindow
->hscrollbar
))
2152 value
= (int)(win
->m_hAdjust
->value
+0.5);
2155 if (widget
== GTK_RANGE(scrolledWindow
->vscrollbar
))
2157 value
= (int)(win
->m_vAdjust
->value
+0.5);
2161 wxScrollWinEvent
event( command
, value
, dir
);
2162 event
.SetEventObject( win
);
2163 win
->GetEventHandler()->ProcessEvent( event
);
2166 win
->m_isScrolling
= FALSE
;
2171 // ----------------------------------------------------------------------------
2172 // this wxWindowBase function is implemented here (in platform-specific file)
2173 // because it is static and so couldn't be made virtual
2174 // ----------------------------------------------------------------------------
2176 wxWindow
*wxWindowBase::FindFocus()
2178 // the cast is necessary when we compile in wxUniversal mode
2179 return (wxWindow
*)g_focusWindow
;
2183 //-----------------------------------------------------------------------------
2184 // "realize" from m_widget
2185 //-----------------------------------------------------------------------------
2187 /* We cannot set colours and fonts before the widget has
2188 been realized, so we do this directly after realization. */
2191 gtk_window_realized_callback( GtkWidget
*m_widget
, wxWindow
*win
)
2196 wxapp_install_idle_handler();
2198 if (win
->m_delayedBackgroundColour
)
2199 win
->GtkSetBackgroundColour( win
->GetBackgroundColour() );
2201 if (win
->m_delayedForegroundColour
)
2202 win
->GtkSetForegroundColour( win
->GetForegroundColour() );
2205 if (win
->m_imContext
)
2207 GtkPizza
*pizza
= GTK_PIZZA( m_widget
);
2208 gtk_im_context_set_client_window( (GtkIMContext
*) win
->m_imContext
, pizza
->bin_window
);
2212 wxWindowCreateEvent
event( win
);
2213 event
.SetEventObject( win
);
2214 win
->GetEventHandler()->ProcessEvent( event
);
2219 //-----------------------------------------------------------------------------
2221 //-----------------------------------------------------------------------------
2224 void gtk_window_size_callback( GtkWidget
*WXUNUSED(widget
),
2225 GtkAllocation
*WXUNUSED(alloc
),
2229 wxapp_install_idle_handler();
2231 if (!win
->m_hasScrolling
) return;
2233 int client_width
= 0;
2234 int client_height
= 0;
2235 win
->GetClientSize( &client_width
, &client_height
);
2236 if ((client_width
== win
->m_oldClientWidth
) && (client_height
== win
->m_oldClientHeight
))
2239 win
->m_oldClientWidth
= client_width
;
2240 win
->m_oldClientHeight
= client_height
;
2242 if (!win
->m_nativeSizeEvent
)
2244 wxSizeEvent
event( win
->GetSize(), win
->GetId() );
2245 event
.SetEventObject( win
);
2246 win
->GetEventHandler()->ProcessEvent( event
);
2252 #define WXUNUSED_UNLESS_XIM(param) param
2254 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2257 /* Resize XIM window */
2260 void gtk_wxwindow_size_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2261 GtkAllocation
* WXUNUSED_UNLESS_XIM(alloc
),
2262 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2265 wxapp_install_idle_handler();
2271 if (gdk_ic_get_style (win
->m_ic
) & GDK_IM_PREEDIT_POSITION
)
2275 gdk_window_get_size (widget
->window
, &width
, &height
);
2276 win
->m_icattr
->preedit_area
.width
= width
;
2277 win
->m_icattr
->preedit_area
.height
= height
;
2278 gdk_ic_set_attr (win
->m_ic
, win
->m_icattr
, GDK_IC_PREEDIT_AREA
);
2283 //-----------------------------------------------------------------------------
2284 // "realize" from m_wxwindow
2285 //-----------------------------------------------------------------------------
2287 /* Initialize XIM support */
2290 gtk_wxwindow_realized_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2291 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2294 wxapp_install_idle_handler();
2297 if (win
->m_ic
) return FALSE
;
2298 if (!widget
) return FALSE
;
2299 if (!gdk_im_ready()) return FALSE
;
2301 win
->m_icattr
= gdk_ic_attr_new();
2302 if (!win
->m_icattr
) return FALSE
;
2306 GdkColormap
*colormap
;
2307 GdkICAttr
*attr
= win
->m_icattr
;
2308 unsigned attrmask
= GDK_IC_ALL_REQ
;
2310 GdkIMStyle supported_style
= (GdkIMStyle
)
2311 (GDK_IM_PREEDIT_NONE
|
2312 GDK_IM_PREEDIT_NOTHING
|
2313 GDK_IM_PREEDIT_POSITION
|
2314 GDK_IM_STATUS_NONE
|
2315 GDK_IM_STATUS_NOTHING
);
2317 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2318 supported_style
= (GdkIMStyle
)(supported_style
& ~GDK_IM_PREEDIT_POSITION
);
2320 attr
->style
= style
= gdk_im_decide_style (supported_style
);
2321 attr
->client_window
= widget
->window
;
2323 if ((colormap
= gtk_widget_get_colormap (widget
)) !=
2324 gtk_widget_get_default_colormap ())
2326 attrmask
|= GDK_IC_PREEDIT_COLORMAP
;
2327 attr
->preedit_colormap
= colormap
;
2330 attrmask
|= GDK_IC_PREEDIT_FOREGROUND
;
2331 attrmask
|= GDK_IC_PREEDIT_BACKGROUND
;
2332 attr
->preedit_foreground
= widget
->style
->fg
[GTK_STATE_NORMAL
];
2333 attr
->preedit_background
= widget
->style
->base
[GTK_STATE_NORMAL
];
2335 switch (style
& GDK_IM_PREEDIT_MASK
)
2337 case GDK_IM_PREEDIT_POSITION
:
2338 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2340 g_warning ("over-the-spot style requires fontset");
2344 gdk_window_get_size (widget
->window
, &width
, &height
);
2346 attrmask
|= GDK_IC_PREEDIT_POSITION_REQ
;
2347 attr
->spot_location
.x
= 0;
2348 attr
->spot_location
.y
= height
;
2349 attr
->preedit_area
.x
= 0;
2350 attr
->preedit_area
.y
= 0;
2351 attr
->preedit_area
.width
= width
;
2352 attr
->preedit_area
.height
= height
;
2353 attr
->preedit_fontset
= widget
->style
->font
;
2358 win
->m_ic
= gdk_ic_new (attr
, (GdkICAttributesType
)attrmask
);
2360 if (win
->m_ic
== NULL
)
2361 g_warning ("Can't create input context.");
2364 mask
= gdk_window_get_events (widget
->window
);
2365 mask
= (GdkEventMask
)(mask
| gdk_ic_get_events (win
->m_ic
));
2366 gdk_window_set_events (widget
->window
, mask
);
2368 if (GTK_WIDGET_HAS_FOCUS(widget
))
2369 gdk_im_begin (win
->m_ic
, widget
->window
);
2376 //-----------------------------------------------------------------------------
2377 // InsertChild for wxWindowGTK.
2378 //-----------------------------------------------------------------------------
2380 /* Callback for wxWindowGTK. This very strange beast has to be used because
2381 * C++ has no virtual methods in a constructor. We have to emulate a
2382 * virtual function here as wxNotebook requires a different way to insert
2383 * a child in it. I had opted for creating a wxNotebookPage window class
2384 * which would have made this superfluous (such in the MDI window system),
2385 * but no-one was listening to me... */
2387 static void wxInsertChildInWindow( wxWindowGTK
* parent
, wxWindowGTK
* child
)
2389 /* the window might have been scrolled already, do we
2390 have to adapt the position */
2391 GtkPizza
*pizza
= GTK_PIZZA(parent
->m_wxwindow
);
2392 child
->m_x
+= pizza
->xoffset
;
2393 child
->m_y
+= pizza
->yoffset
;
2395 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
2396 GTK_WIDGET(child
->m_widget
),
2403 //-----------------------------------------------------------------------------
2405 //-----------------------------------------------------------------------------
2407 wxWindow
*wxGetActiveWindow()
2409 return wxWindow::FindFocus();
2412 //-----------------------------------------------------------------------------
2414 //-----------------------------------------------------------------------------
2416 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2418 #ifdef __WXUNIVERSAL__
2419 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2421 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
2422 #endif // __WXUNIVERSAL__/__WXGTK__
2424 void wxWindowGTK::Init()
2430 m_widget
= (GtkWidget
*) NULL
;
2431 m_wxwindow
= (GtkWidget
*) NULL
;
2432 m_focusWidget
= (GtkWidget
*) NULL
;
2442 m_needParent
= TRUE
;
2443 m_isBeingDeleted
= FALSE
;
2446 m_nativeSizeEvent
= FALSE
;
2448 m_hasScrolling
= FALSE
;
2449 m_isScrolling
= FALSE
;
2451 m_hAdjust
= (GtkAdjustment
*) NULL
;
2452 m_vAdjust
= (GtkAdjustment
*) NULL
;
2453 m_oldHorizontalPos
= 0.0;
2454 m_oldVerticalPos
= 0.0;
2457 m_widgetStyle
= (GtkStyle
*) NULL
;
2459 m_insertCallback
= (wxInsertChildFunction
) NULL
;
2461 m_acceptsFocus
= FALSE
;
2464 m_clipPaintRegion
= FALSE
;
2466 m_cursor
= *wxSTANDARD_CURSOR
;
2468 m_delayedForegroundColour
= FALSE
;
2469 m_delayedBackgroundColour
= FALSE
;
2473 m_x11Context
= NULL
;
2476 m_ic
= (GdkIC
*) NULL
;
2477 m_icattr
= (GdkICAttr
*) NULL
;
2482 wxWindowGTK::wxWindowGTK()
2487 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2492 const wxString
&name
)
2496 Create( parent
, id
, pos
, size
, style
, name
);
2499 bool wxWindowGTK::Create( wxWindow
*parent
,
2504 const wxString
&name
)
2506 if (!PreCreation( parent
, pos
, size
) ||
2507 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2509 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2513 m_insertCallback
= wxInsertChildInWindow
;
2515 // always needed for background clearing
2516 m_delayedBackgroundColour
= TRUE
;
2518 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
2519 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
2521 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2523 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2524 scroll_class
->scrollbar_spacing
= 0;
2526 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2528 m_hAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->hscrollbar
) );
2529 m_vAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->vscrollbar
) );
2531 m_wxwindow
= gtk_pizza_new();
2533 #ifndef __WXUNIVERSAL__
2534 GtkPizza
*pizza
= GTK_PIZZA(m_wxwindow
);
2536 if (HasFlag(wxRAISED_BORDER
))
2538 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_OUT
);
2540 else if (HasFlag(wxSUNKEN_BORDER
))
2542 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_IN
);
2544 else if (HasFlag(wxSIMPLE_BORDER
))
2546 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_THIN
);
2550 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_NONE
);
2552 #endif // __WXUNIVERSAL__
2554 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2556 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
2557 m_acceptsFocus
= TRUE
;
2559 // I _really_ don't want scrollbars in the beginning
2560 m_vAdjust
->lower
= 0.0;
2561 m_vAdjust
->upper
= 1.0;
2562 m_vAdjust
->value
= 0.0;
2563 m_vAdjust
->step_increment
= 1.0;
2564 m_vAdjust
->page_increment
= 1.0;
2565 m_vAdjust
->page_size
= 5.0;
2566 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
2567 m_hAdjust
->lower
= 0.0;
2568 m_hAdjust
->upper
= 1.0;
2569 m_hAdjust
->value
= 0.0;
2570 m_hAdjust
->step_increment
= 1.0;
2571 m_hAdjust
->page_increment
= 1.0;
2572 m_hAdjust
->page_size
= 5.0;
2573 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
2575 // these handlers block mouse events to any window during scrolling such as
2576 // motion events and prevent GTK and wxWindows from fighting over where the
2579 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_press_event",
2580 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
2582 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_press_event",
2583 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
2585 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_release_event",
2586 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
2588 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_release_event",
2589 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
2591 // these handlers get notified when screen updates are required either when
2592 // scrolling or when the window size (and therefore scrollbar configuration)
2595 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
2596 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
2597 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
2598 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
2601 // Create input method handler
2602 m_imContext
= (GtkIMMulticontext
*) gtk_im_multicontext_new ();
2604 // Cannot handle drawing preedited text yet
2605 gtk_im_context_set_use_preedit( (GtkIMContext
*) m_imContext
, FALSE
);
2607 g_signal_connect (G_OBJECT (m_imContext
), "commit",
2608 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2611 gtk_widget_show( m_wxwindow
);
2614 m_parent
->DoAddChild( this );
2616 m_focusWidget
= m_wxwindow
;
2625 wxWindowGTK::~wxWindowGTK()
2629 if (g_focusWindow
== this)
2630 g_focusWindow
= NULL
;
2632 if (g_activeFrame
== this)
2633 g_activeFrame
= NULL
;
2635 if ( g_delayedFocus
== this )
2636 g_delayedFocus
= NULL
;
2638 m_isBeingDeleted
= TRUE
;
2647 m_parent
->RemoveChild( this );
2651 gdk_ic_destroy (m_ic
);
2653 gdk_ic_attr_destroy (m_icattr
);
2658 #if DISABLE_STYLE_IF_BROKEN_THEME
2659 // don't delete if it's a pixmap theme style
2660 if (!m_widgetStyle
->engine_data
)
2661 gtk_style_unref( m_widgetStyle
);
2663 m_widgetStyle
= (GtkStyle
*) NULL
;
2668 gtk_widget_destroy( m_wxwindow
);
2669 m_wxwindow
= (GtkWidget
*) NULL
;
2674 gtk_widget_destroy( m_widget
);
2675 m_widget
= (GtkWidget
*) NULL
;
2679 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2681 wxCHECK_MSG( !m_needParent
|| parent
, FALSE
, wxT("Need complete parent.") );
2683 // This turns -1 into 30 so that a minimal window is
2684 // visible even although -1,-1 has been given as the
2685 // size of the window. the same trick is used in other
2686 // ports and should make debugging easier.
2687 m_width
= WidthDefault(size
.x
) ;
2688 m_height
= HeightDefault(size
.y
);
2693 // some reasonable defaults
2698 m_x
= (gdk_screen_width () - m_width
) / 2;
2699 if (m_x
< 10) m_x
= 10;
2703 m_y
= (gdk_screen_height () - m_height
) / 2;
2704 if (m_y
< 10) m_y
= 10;
2711 void wxWindowGTK::PostCreation()
2713 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2719 // these get reported to wxWindows -> wxPaintEvent
2721 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow
), TRUE
);
2723 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "expose_event",
2724 GTK_SIGNAL_FUNC(gtk_window_expose_callback
), (gpointer
)this );
2727 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "draw",
2728 GTK_SIGNAL_FUNC(gtk_window_draw_callback
), (gpointer
)this );
2730 if (HasFlag(wxNO_FULL_REPAINT_ON_RESIZE
))
2732 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "event",
2733 GTK_SIGNAL_FUNC(gtk_window_event_event_callback
), (gpointer
)this );
2736 // gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), HasFlag( wxNO_FULL_REPAINT_ON_RESIZE ) );
2740 // Create input method handler
2741 m_imContext
= (GtkIMMulticontext
*) gtk_im_multicontext_new ();
2743 // Cannot handle drawing preedited text yet
2744 gtk_im_context_set_use_preedit( (GtkIMContext
*) m_imContext
, FALSE
);
2746 g_signal_connect (G_OBJECT (m_imContext
), "commit",
2747 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2751 // these are called when the "sunken" or "raised" borders are drawn
2752 gtk_signal_connect( GTK_OBJECT(m_widget
), "expose_event",
2753 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback
), (gpointer
)this );
2756 gtk_signal_connect( GTK_OBJECT(m_widget
), "draw",
2757 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback
), (gpointer
)this );
2763 if (m_focusWidget
== NULL
)
2764 m_focusWidget
= m_widget
;
2766 gtk_signal_connect( GTK_OBJECT(m_focusWidget
), "focus_in_event",
2767 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback
), (gpointer
)this );
2769 gtk_signal_connect( GTK_OBJECT(m_focusWidget
), "focus_out_event",
2770 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback
), (gpointer
)this );
2772 // connect to the various key and mouse handlers
2774 GtkWidget
*connect_widget
= GetConnectWidget();
2776 ConnectWidget( connect_widget
);
2778 /* We cannot set colours, fonts and cursors before the widget has
2779 been realized, so we do this directly after realization */
2780 gtk_signal_connect( GTK_OBJECT(connect_widget
), "realize",
2781 GTK_SIGNAL_FUNC(gtk_window_realized_callback
), (gpointer
) this );
2785 // Catch native resize events
2786 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "size_allocate",
2787 GTK_SIGNAL_FUNC(gtk_window_size_callback
), (gpointer
)this );
2789 // Initialize XIM support
2790 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "realize",
2791 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback
), (gpointer
) this );
2793 // And resize XIM window
2794 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "size_allocate",
2795 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback
), (gpointer
)this );
2798 if (!GTK_IS_COMBO(m_widget
))
2800 // This is needed if we want to add our windows into native
2801 // GTK control, such as the toolbar. With this callback, the
2802 // toolbar gets to know the correct size (the one set by the
2803 // programmer). Sadly, it misbehaves for wxComboBox. FIXME
2804 // when moving to GTK 2.0.
2805 gtk_signal_connect( GTK_OBJECT(m_widget
), "size_request",
2806 GTK_SIGNAL_FUNC(gtk_window_size_request_callback
), (gpointer
) this );
2812 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2814 gtk_signal_connect( GTK_OBJECT(widget
), "key_press_event",
2815 GTK_SIGNAL_FUNC(gtk_window_key_press_callback
), (gpointer
)this );
2817 gtk_signal_connect( GTK_OBJECT(widget
), "key_release_event",
2818 GTK_SIGNAL_FUNC(gtk_window_key_release_callback
), (gpointer
)this );
2820 gtk_signal_connect( GTK_OBJECT(widget
), "button_press_event",
2821 GTK_SIGNAL_FUNC(gtk_window_button_press_callback
), (gpointer
)this );
2823 gtk_signal_connect( GTK_OBJECT(widget
), "button_release_event",
2824 GTK_SIGNAL_FUNC(gtk_window_button_release_callback
), (gpointer
)this );
2826 gtk_signal_connect( GTK_OBJECT(widget
), "motion_notify_event",
2827 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback
), (gpointer
)this );
2829 gtk_signal_connect( GTK_OBJECT(widget
), "enter_notify_event",
2830 GTK_SIGNAL_FUNC(gtk_window_enter_callback
), (gpointer
)this );
2832 gtk_signal_connect( GTK_OBJECT(widget
), "leave_notify_event",
2833 GTK_SIGNAL_FUNC(gtk_window_leave_callback
), (gpointer
)this );
2836 bool wxWindowGTK::Destroy()
2838 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2842 return wxWindowBase::Destroy();
2845 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
2847 gtk_pizza_set_size( GTK_PIZZA(m_parent
->m_wxwindow
), m_widget
, x
, y
, width
, height
);
2850 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2852 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2853 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
2856 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
2859 if (m_resizing
) return; /* I don't like recursions */
2862 int currentX
, currentY
;
2863 GetPosition(¤tX
, ¤tY
);
2868 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2870 if (m_parent
->m_wxwindow
== NULL
) /* i.e. wxNotebook */
2872 /* don't set the size for children of wxNotebook, just take the values. */
2880 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
2881 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
2883 if (x
!= -1) m_x
= x
+ pizza
->xoffset
;
2884 if (y
!= -1) m_y
= y
+ pizza
->yoffset
;
2888 m_x
= x
+ pizza
->xoffset
;
2889 m_y
= y
+ pizza
->yoffset
;
2891 if (width
!= -1) m_width
= width
;
2892 if (height
!= -1) m_height
= height
;
2894 if ((sizeFlags
& wxSIZE_AUTO_WIDTH
) == wxSIZE_AUTO_WIDTH
)
2896 if (width
== -1) m_width
= 80;
2899 if ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) == wxSIZE_AUTO_HEIGHT
)
2901 if (height
== -1) m_height
= 26;
2904 int minWidth
= GetMinWidth(),
2905 minHeight
= GetMinHeight(),
2906 maxWidth
= GetMaxWidth(),
2907 maxHeight
= GetMaxHeight();
2909 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
2910 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
2911 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
2912 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
2915 int bottom_border
= 0;
2918 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
2920 /* the default button has a border around it */
2926 DoMoveWindow( m_x
-border
,
2929 m_height
+border
+bottom_border
);
2934 /* Sometimes the client area changes size without the
2935 whole windows's size changing, but if the whole
2936 windows's size doesn't change, no wxSizeEvent will
2937 normally be sent. Here we add an extra test if
2938 the client test has been changed and this will
2940 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
2944 wxPrintf( "OnSize sent from " );
2945 if (GetClassInfo() && GetClassInfo()->GetClassName())
2946 wxPrintf( GetClassInfo()->GetClassName() );
2947 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2950 if (!m_nativeSizeEvent
)
2952 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2953 event
.SetEventObject( this );
2954 GetEventHandler()->ProcessEvent( event
);
2960 void wxWindowGTK::OnInternalIdle()
2962 // Update invalidated regions.
2965 // Synthetize activate events.
2966 if ( g_sendActivateEvent
!= -1 )
2968 bool activate
= g_sendActivateEvent
!= 0;
2971 g_sendActivateEvent
= -1;
2973 wxTheApp
->SetActive(activate
, (wxWindow
*)g_focusWindowLast
);
2976 if ( g_activeFrameLostFocus
)
2978 if ( g_activeFrame
)
2980 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame
);
2981 wxActivateEvent
event(wxEVT_ACTIVATE
, FALSE
, g_activeFrame
->GetId());
2982 event
.SetEventObject(g_activeFrame
);
2983 g_activeFrame
->GetEventHandler()->ProcessEvent(event
);
2984 g_activeFrame
= NULL
;
2986 g_activeFrameLostFocus
= FALSE
;
2989 wxCursor cursor
= m_cursor
;
2990 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
2994 /* I now set the cursor anew in every OnInternalIdle call
2995 as setting the cursor in a parent window also effects the
2996 windows above so that checking for the current cursor is
3001 GdkWindow
*window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3003 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3005 if (!g_globalCursor
.Ok())
3006 cursor
= *wxSTANDARD_CURSOR
;
3008 window
= m_widget
->window
;
3009 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
3010 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3016 GdkWindow
*window
= m_widget
->window
;
3017 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
3018 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3026 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
3028 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3030 if (width
) (*width
) = m_width
;
3031 if (height
) (*height
) = m_height
;
3034 void wxWindowGTK::DoSetClientSize( int width
, int height
)
3036 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3040 SetSize( width
, height
);
3047 #ifndef __WXUNIVERSAL__
3048 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
3050 /* when using GTK 1.2 we set the shadow border size to 2 */
3054 if (HasFlag(wxSIMPLE_BORDER
))
3056 /* when using GTK 1.2 we set the simple border size to 1 */
3060 #endif // __WXUNIVERSAL__
3064 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
3066 GtkRequisition vscroll_req
;
3067 vscroll_req
.width
= 2;
3068 vscroll_req
.height
= 2;
3069 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
3070 (scroll_window
->vscrollbar
, &vscroll_req
);
3072 GtkRequisition hscroll_req
;
3073 hscroll_req
.width
= 2;
3074 hscroll_req
.height
= 2;
3075 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
3076 (scroll_window
->hscrollbar
, &hscroll_req
);
3078 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
3080 if (scroll_window
->vscrollbar_visible
)
3082 dw
+= vscroll_req
.width
;
3083 dw
+= scroll_class
->scrollbar_spacing
;
3086 if (scroll_window
->hscrollbar_visible
)
3088 dh
+= hscroll_req
.height
;
3089 dh
+= scroll_class
->scrollbar_spacing
;
3093 SetSize( width
+dw
, height
+dh
);
3097 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
3099 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3103 if (width
) (*width
) = m_width
;
3104 if (height
) (*height
) = m_height
;
3111 #ifndef __WXUNIVERSAL__
3112 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
3114 /* when using GTK 1.2 we set the shadow border size to 2 */
3118 if (HasFlag(wxSIMPLE_BORDER
))
3120 /* when using GTK 1.2 we set the simple border size to 1 */
3124 #endif // __WXUNIVERSAL__
3128 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
3130 GtkRequisition vscroll_req
;
3131 vscroll_req
.width
= 2;
3132 vscroll_req
.height
= 2;
3133 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
3134 (scroll_window
->vscrollbar
, &vscroll_req
);
3136 GtkRequisition hscroll_req
;
3137 hscroll_req
.width
= 2;
3138 hscroll_req
.height
= 2;
3139 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
3140 (scroll_window
->hscrollbar
, &hscroll_req
);
3142 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
3144 if (scroll_window
->vscrollbar_visible
)
3146 dw
+= vscroll_req
.width
;
3147 dw
+= scroll_class
->scrollbar_spacing
;
3150 if (scroll_window
->hscrollbar_visible
)
3152 dh
+= hscroll_req
.height
;
3153 dh
+= scroll_class
->scrollbar_spacing
;
3157 if (width
) (*width
) = m_width
- dw
;
3158 if (height
) (*height
) = m_height
- dh
;
3162 printf( "GetClientSize, name %s ", GetName().c_str() );
3163 if (width) printf( " width = %d", (*width) );
3164 if (height) printf( " height = %d", (*height) );
3169 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
3171 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3175 if (m_parent
&& m_parent
->m_wxwindow
)
3177 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
3178 dx
= pizza
->xoffset
;
3179 dy
= pizza
->yoffset
;
3182 if (x
) (*x
) = m_x
- dx
;
3183 if (y
) (*y
) = m_y
- dy
;
3186 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
3188 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3190 if (!m_widget
->window
) return;
3192 GdkWindow
*source
= (GdkWindow
*) NULL
;
3194 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3196 source
= m_widget
->window
;
3200 gdk_window_get_origin( source
, &org_x
, &org_y
);
3204 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3206 org_x
+= m_widget
->allocation
.x
;
3207 org_y
+= m_widget
->allocation
.y
;
3215 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
3217 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3219 if (!m_widget
->window
) return;
3221 GdkWindow
*source
= (GdkWindow
*) NULL
;
3223 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3225 source
= m_widget
->window
;
3229 gdk_window_get_origin( source
, &org_x
, &org_y
);
3233 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3235 org_x
+= m_widget
->allocation
.x
;
3236 org_y
+= m_widget
->allocation
.y
;
3244 bool wxWindowGTK::Show( bool show
)
3246 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3248 if (!wxWindowBase::Show(show
))
3255 gtk_widget_show( m_widget
);
3257 gtk_widget_hide( m_widget
);
3259 wxShowEvent
eventShow(GetId(), show
);
3260 eventShow
.m_eventObject
= this;
3262 GetEventHandler()->ProcessEvent(eventShow
);
3267 static void wxWindowNotifyEnable(wxWindowGTK
* win
, bool enable
)
3269 win
->OnParentEnable(enable
);
3271 // Recurse, so that children have the opportunity to Do The Right Thing
3272 // and reset colours that have been messed up by a parent's (really ancestor's)
3274 for ( wxWindowList::Node
*node
= win
->GetChildren().GetFirst();
3276 node
= node
->GetNext() )
3278 wxWindow
*child
= node
->GetData();
3279 if (!child
->IsKindOf(CLASSINFO(wxDialog
)) && !child
->IsKindOf(CLASSINFO(wxFrame
)))
3280 wxWindowNotifyEnable(child
, enable
);
3284 bool wxWindowGTK::Enable( bool enable
)
3286 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3288 if (!wxWindowBase::Enable(enable
))
3294 gtk_widget_set_sensitive( m_widget
, enable
);
3296 gtk_widget_set_sensitive( m_wxwindow
, enable
);
3298 wxWindowNotifyEnable(this, enable
);
3303 int wxWindowGTK::GetCharHeight() const
3305 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
3307 wxCHECK_MSG( m_font
.Ok(), 12, wxT("invalid font") );
3310 PangoContext
*context
= NULL
;
3312 context
= gtk_widget_get_pango_context( m_widget
);
3317 PangoFontDescription
*desc
= m_font
.GetNativeFontInfo()->description
;
3318 PangoLayout
*layout
= pango_layout_new(context
);
3319 pango_layout_set_font_description(layout
, desc
);
3320 pango_layout_set_text(layout
, "H", 1);
3321 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3323 PangoRectangle rect
;
3324 pango_layout_line_get_extents(line
, NULL
, &rect
);
3326 g_object_unref( G_OBJECT( layout
) );
3328 return (int) (rect
.height
/ PANGO_SCALE
);
3330 GdkFont
*font
= m_font
.GetInternalFont( 1.0 );
3332 return font
->ascent
+ font
->descent
;
3336 int wxWindowGTK::GetCharWidth() const
3338 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
3340 wxCHECK_MSG( m_font
.Ok(), 8, wxT("invalid font") );
3343 PangoContext
*context
= NULL
;
3345 context
= gtk_widget_get_pango_context( m_widget
);
3350 PangoFontDescription
*desc
= m_font
.GetNativeFontInfo()->description
;
3351 PangoLayout
*layout
= pango_layout_new(context
);
3352 pango_layout_set_font_description(layout
, desc
);
3353 pango_layout_set_text(layout
, "H", 1);
3354 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3356 PangoRectangle rect
;
3357 pango_layout_line_get_extents(line
, NULL
, &rect
);
3359 g_object_unref( G_OBJECT( layout
) );
3361 return (int) (rect
.width
/ PANGO_SCALE
);
3363 GdkFont
*font
= m_font
.GetInternalFont( 1.0 );
3365 return gdk_string_width( font
, "H" );
3369 void wxWindowGTK::GetTextExtent( const wxString
& string
,
3373 int *externalLeading
,
3374 const wxFont
*theFont
) const
3376 wxFont fontToUse
= m_font
;
3377 if (theFont
) fontToUse
= *theFont
;
3379 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
3381 if (string
.IsEmpty())
3389 PangoContext
*context
= NULL
;
3391 context
= gtk_widget_get_pango_context( m_widget
);
3400 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3401 PangoLayout
*layout
= pango_layout_new(context
);
3402 pango_layout_set_font_description(layout
, desc
);
3405 const wxCharBuffer data
= wxConvUTF8
.cWC2MB( string
);
3406 pango_layout_set_text(layout
, (const char*) data
, strlen( (const char*) data
));
3408 const wxWCharBuffer wdata
= wxConvLocal
.cMB2WC( string
);
3409 const wxCharBuffer data
= wxConvUTF8
.cWC2MB( wdata
);
3410 pango_layout_set_text(layout
, (const char*) data
, strlen( (const char*) data
));
3413 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3415 PangoRectangle rect
;
3416 pango_layout_line_get_extents(line
, NULL
, &rect
);
3418 if (x
) (*x
) = (wxCoord
) (rect
.width
/ PANGO_SCALE
);
3419 if (y
) (*y
) = (wxCoord
) (rect
.height
/ PANGO_SCALE
);
3422 // Do something about metrics here
3425 if (externalLeading
) (*externalLeading
) = 0; // ??
3427 g_object_unref( G_OBJECT( layout
) );
3429 GdkFont
*font
= fontToUse
.GetInternalFont( 1.0 );
3430 if (x
) (*x
) = gdk_string_width( font
, wxGTK_CONV( string
) );
3431 if (y
) (*y
) = font
->ascent
+ font
->descent
;
3432 if (descent
) (*descent
) = font
->descent
;
3433 if (externalLeading
) (*externalLeading
) = 0; // ??
3437 void wxWindowGTK::SetFocus()
3439 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3443 // don't do anything if we already have focus
3449 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow
))
3451 gtk_widget_grab_focus (m_wxwindow
);
3456 if (GTK_WIDGET_CAN_FOCUS(m_widget
) && !GTK_WIDGET_HAS_FOCUS (m_widget
) )
3458 if (!GTK_WIDGET_REALIZED(m_widget
))
3460 // we can't set the focus to the widget now so we remember that
3461 // it should be focused and will do it later, during the idle
3462 // time, as soon as we can
3463 wxLogTrace(TRACE_FOCUS
,
3464 _T("Delaying setting focus to %s(%s)"),
3465 GetClassInfo()->GetClassName(), GetLabel().c_str());
3467 g_delayedFocus
= this;
3471 wxLogTrace(TRACE_FOCUS
,
3472 _T("Setting focus to %s(%s)"),
3473 GetClassInfo()->GetClassName(), GetLabel().c_str());
3475 gtk_widget_grab_focus (m_widget
);
3478 else if (GTK_IS_CONTAINER(m_widget
))
3480 SET_CONTAINER_FOCUS( m_widget
, GTK_DIR_TAB_FORWARD
);
3484 wxLogTrace(TRACE_FOCUS
,
3485 _T("Can't set focus to %s(%s)"),
3486 GetClassInfo()->GetClassName(), GetLabel().c_str());
3491 bool wxWindowGTK::AcceptsFocus() const
3493 return m_acceptsFocus
&& wxWindowBase::AcceptsFocus();
3496 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3498 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3500 wxWindowGTK
*oldParent
= m_parent
,
3501 *newParent
= (wxWindowGTK
*)newParentBase
;
3503 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3505 if ( !wxWindowBase::Reparent(newParent
) )
3508 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3510 /* prevent GTK from deleting the widget arbitrarily */
3511 gtk_widget_ref( m_widget
);
3515 gtk_container_remove( GTK_CONTAINER(m_widget
->parent
), m_widget
);
3518 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3522 /* insert GTK representation */
3523 (*(newParent
->m_insertCallback
))(newParent
, this);
3526 /* reverse: prevent GTK from deleting the widget arbitrarily */
3527 gtk_widget_unref( m_widget
);
3532 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3534 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3536 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3538 wxASSERT_MSG( (m_insertCallback
!= NULL
), wxT("invalid child insertion function") );
3543 /* insert GTK representation */
3544 (*m_insertCallback
)(this, child
);
3547 void wxWindowGTK::Raise()
3549 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3551 if (!m_widget
->window
) return;
3553 gdk_window_raise( m_widget
->window
);
3556 void wxWindowGTK::Lower()
3558 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3560 if (!m_widget
->window
) return;
3562 gdk_window_lower( m_widget
->window
);
3565 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3567 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3569 if (cursor
== m_cursor
)
3573 wxapp_install_idle_handler();
3575 if (cursor
== wxNullCursor
)
3576 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR
);
3578 return wxWindowBase::SetCursor( cursor
);
3581 void wxWindowGTK::WarpPointer( int x
, int y
)
3583 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3585 // We provide this function ourselves as it is
3586 // missing in GDK (top of this file).
3588 GdkWindow
*window
= (GdkWindow
*) NULL
;
3590 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3592 window
= GetConnectWidget()->window
;
3595 gdk_window_warp_pointer( window
, x
, y
);
3599 void wxWindowGTK::Refresh( bool eraseBackground
, const wxRect
*rect
)
3601 if (!m_widget
) return;
3602 if (!m_widget
->window
) return;
3606 wxapp_install_idle_handler();
3608 wxRect
myRect(0,0,0,0);
3609 if (m_wxwindow
&& rect
)
3611 myRect
.SetSize(wxSize( m_wxwindow
->allocation
.width
,
3612 m_wxwindow
->allocation
.height
));
3613 myRect
.Intersect(*rect
);
3614 if (!myRect
.width
|| !myRect
.height
)
3615 // nothing to do, rectangle is empty
3620 if (eraseBackground
&& m_wxwindow
&& m_wxwindow
->window
)
3624 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3625 m_clearRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3629 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3630 m_clearRegion
.Clear();
3631 m_clearRegion
.Union( 0, 0, m_wxwindow
->allocation
.width
, m_wxwindow
->allocation
.height
);
3639 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3640 m_updateRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3644 GdkRectangle gdk_rect
;
3645 gdk_rect
.x
= rect
->x
;
3646 gdk_rect
.y
= rect
->y
;
3647 gdk_rect
.width
= rect
->width
;
3648 gdk_rect
.height
= rect
->height
;
3649 gtk_widget_draw( m_widget
, &gdk_rect
);
3656 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3657 m_updateRegion
.Clear();
3658 m_updateRegion
.Union( 0, 0, m_wxwindow
->allocation
.width
, m_wxwindow
->allocation
.height
);
3662 gtk_widget_draw( m_widget
, (GdkRectangle
*) NULL
);
3670 GdkRectangle gdk_rect
;
3671 gdk_rect
.x
= rect
->x
;
3672 gdk_rect
.y
= rect
->y
;
3673 gdk_rect
.width
= rect
->width
;
3674 gdk_rect
.height
= rect
->height
;
3675 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, &gdk_rect
, TRUE
);
3679 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, NULL
, TRUE
);
3685 void wxWindowGTK::Update()
3690 void wxWindowGTK::GtkUpdate()
3693 if (m_wxwindow
&& GTK_PIZZA(m_wxwindow
)->bin_window
)
3694 gdk_window_process_updates( GTK_PIZZA(m_wxwindow
)->bin_window
, FALSE
);
3696 if (!m_updateRegion
.IsEmpty())
3697 GtkSendPaintEvents();
3701 void wxWindowGTK::GtkSendPaintEvents()
3706 m_clearRegion
.Clear();
3708 m_updateRegion
.Clear();
3712 // Clip to paint region in wxClientDC
3713 m_clipPaintRegion
= TRUE
;
3716 // widget to draw on
3717 GtkPizza
*pizza
= GTK_PIZZA (m_wxwindow
);
3719 // later for GTK 2.0, too.
3720 if (GetThemeEnabled())
3722 // find ancestor from which to steal background
3723 wxWindow
*parent
= GetParent();
3724 while (parent
&& !parent
->IsTopLevel())
3725 parent
= parent
->GetParent();
3727 parent
= (wxWindow
*)this;
3729 wxRegionIterator
upd( m_updateRegion
);
3733 rect
.x
= upd
.GetX();
3734 rect
.y
= upd
.GetY();
3735 rect
.width
= upd
.GetWidth();
3736 rect
.height
= upd
.GetHeight();
3738 gtk_paint_flat_box( parent
->m_widget
->style
,
3755 wxWindowDC
dc( (wxWindow
*)this );
3756 dc
.SetClippingRegion( m_updateRegion
);
3758 wxEraseEvent
erase_event( GetId(), &dc
);
3759 erase_event
.SetEventObject( this );
3761 GetEventHandler()->ProcessEvent(erase_event
);
3764 // if (!m_clearRegion.IsEmpty()) // Always send an erase event under GTK 1.2
3766 wxWindowDC
dc( (wxWindow
*)this );
3767 if (m_clearRegion
.IsEmpty())
3768 dc
.SetClippingRegion( m_updateRegion
);
3770 dc
.SetClippingRegion( m_clearRegion
);
3772 wxEraseEvent
erase_event( GetId(), &dc
);
3773 erase_event
.SetEventObject( this );
3775 if (!GetEventHandler()->ProcessEvent(erase_event
))
3779 g_eraseGC
= gdk_gc_new( pizza
->bin_window
);
3780 gdk_gc_set_fill( g_eraseGC
, GDK_SOLID
);
3782 gdk_gc_set_foreground( g_eraseGC
, m_backgroundColour
.GetColor() );
3784 wxRegionIterator
upd( m_clearRegion
);
3787 gdk_draw_rectangle( pizza
->bin_window
, g_eraseGC
, 1,
3788 upd
.GetX(), upd
.GetY(), upd
.GetWidth(), upd
.GetHeight() );
3792 m_clearRegion
.Clear();
3796 wxNcPaintEvent
nc_paint_event( GetId() );
3797 nc_paint_event
.SetEventObject( this );
3798 GetEventHandler()->ProcessEvent( nc_paint_event
);
3800 wxPaintEvent
paint_event( GetId() );
3801 paint_event
.SetEventObject( this );
3802 GetEventHandler()->ProcessEvent( paint_event
);
3804 m_clipPaintRegion
= FALSE
;
3806 #ifndef __WXUNIVERSAL__
3808 // The following code will result in all window-less widgets
3809 // being redrawn because the wxWindows class is allowed to
3810 // paint over the window-less widgets.
3812 GList
*children
= pizza
->children
;
3815 GtkPizzaChild
*child
= (GtkPizzaChild
*) children
->data
;
3816 children
= children
->next
;
3818 if (GTK_WIDGET_NO_WINDOW (child
->widget
) &&
3819 GTK_WIDGET_DRAWABLE (child
->widget
))
3821 // Get intersection of widget area and update region
3822 wxRegion
region( m_updateRegion
);
3824 GdkEventExpose gdk_event
;
3825 gdk_event
.type
= GDK_EXPOSE
;
3826 gdk_event
.window
= pizza
->bin_window
;
3827 gdk_event
.count
= 0;
3829 wxRegionIterator
upd( m_updateRegion
);
3833 rect
.x
= upd
.GetX();
3834 rect
.y
= upd
.GetY();
3835 rect
.width
= upd
.GetWidth();
3836 rect
.height
= upd
.GetHeight();
3838 if (gtk_widget_intersect (child
->widget
, &rect
, &gdk_event
.area
))
3840 gtk_widget_event (child
->widget
, (GdkEvent
*) &gdk_event
);
3850 m_updateRegion
.Clear();
3853 void wxWindowGTK::Clear()
3855 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3858 if (m_wxwindow
&& m_wxwindow
->window
)
3860 m_clearRegion
.Clear();
3861 wxSize
size( GetClientSize() );
3862 m_clearRegion
.Union( 0,0,size
.x
,size
.y
);
3864 // Better do this in idle?
3871 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
3873 wxWindowBase::DoSetToolTip(tip
);
3876 m_tooltip
->Apply( (wxWindow
*)this );
3879 void wxWindowGTK::ApplyToolTip( GtkTooltips
*tips
, const wxChar
*tip
)
3881 gtk_tooltips_set_tip( tips
, GetConnectWidget(), wxConvCurrent
->cWX2MB(tip
), (gchar
*) NULL
);
3883 #endif // wxUSE_TOOLTIPS
3885 void wxWindowGTK::GtkSetBackgroundColour( const wxColour
&colour
)
3887 GdkWindow
*window
= (GdkWindow
*) NULL
;
3889 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3891 window
= GetConnectWidget()->window
;
3895 // We need the pixel value e.g. for background clearing.
3896 m_backgroundColour
.CalcPixel( gdk_window_get_colormap( window
) );
3900 // wxMSW doesn't clear the window here, either.
3901 gdk_window_set_background( window
, m_backgroundColour
.GetColor() );
3907 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
3909 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
3911 if (!wxWindowBase::SetBackgroundColour(colour
))
3914 GdkWindow
*window
= (GdkWindow
*) NULL
;
3916 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3918 window
= GetConnectWidget()->window
;
3922 // indicate that a new style has been set
3923 // but it couldn't get applied as the
3924 // widget hasn't been realized yet.
3925 m_delayedBackgroundColour
= TRUE
;
3930 GtkSetBackgroundColour( colour
);
3936 void wxWindowGTK::GtkSetForegroundColour( const wxColour
&colour
)
3938 GdkWindow
*window
= (GdkWindow
*) NULL
;
3940 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3942 window
= GetConnectWidget()->window
;
3949 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
3951 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
3953 if (!wxWindowBase::SetForegroundColour(colour
))
3955 // don't leave if the GTK widget has just
3957 if (!m_delayedForegroundColour
) return FALSE
;
3960 GdkWindow
*window
= (GdkWindow
*) NULL
;
3962 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3964 window
= GetConnectWidget()->window
;
3968 // indicate that a new style has been set
3969 // but it couldn't get applied as the
3970 // widget hasn't been realized yet.
3971 m_delayedForegroundColour
= TRUE
;
3975 GtkSetForegroundColour( colour
);
3982 PangoContext
*wxWindowGTK::GtkGetPangoDefaultContext()
3984 return gtk_widget_get_pango_context( m_widget
);
3987 PangoContext
*wxWindowGTK::GtkGetPangoX11Context()
3990 m_x11Context
= pango_x_get_context( gdk_display
);
3992 return m_x11Context
;
3996 GtkStyle
*wxWindowGTK::GetWidgetStyle()
4000 GtkStyle
*remake
= gtk_style_copy( m_widgetStyle
);
4002 // FIXME: no more klass in 2.0
4004 remake
->klass
= m_widgetStyle
->klass
;
4007 gtk_style_unref( m_widgetStyle
);
4008 m_widgetStyle
= remake
;
4012 GtkStyle
*def
= gtk_rc_get_style( m_widget
);
4015 def
= gtk_widget_get_default_style();
4017 m_widgetStyle
= gtk_style_copy( def
);
4019 // FIXME: no more klass in 2.0
4021 m_widgetStyle
->klass
= def
->klass
;
4025 return m_widgetStyle
;
4028 void wxWindowGTK::SetWidgetStyle()
4030 #if DISABLE_STYLE_IF_BROKEN_THEME
4031 if (m_widget
->style
->engine_data
)
4033 static bool s_warningPrinted
= FALSE
;
4034 if (!s_warningPrinted
)
4036 printf( "wxWindows warning: Widget styles disabled due to buggy GTK theme.\n" );
4037 s_warningPrinted
= TRUE
;
4039 m_widgetStyle
= m_widget
->style
;
4044 GtkStyle
*style
= GetWidgetStyle();
4046 if (m_font
!= wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT
))
4049 pango_font_description_free( style
->font_desc
);
4050 style
->font_desc
= pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
4052 gdk_font_unref( style
->font
);
4053 style
->font
= gdk_font_ref( m_font
.GetInternalFont( 1.0 ) );
4057 if (m_foregroundColour
.Ok())
4059 m_foregroundColour
.CalcPixel( gtk_widget_get_colormap( m_widget
) );
4060 if (m_foregroundColour
!= wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT
))
4062 style
->fg
[GTK_STATE_NORMAL
] = *m_foregroundColour
.GetColor();
4063 style
->fg
[GTK_STATE_PRELIGHT
] = *m_foregroundColour
.GetColor();
4064 style
->fg
[GTK_STATE_ACTIVE
] = *m_foregroundColour
.GetColor();
4068 // Try to restore the gtk default style. This is still a little
4069 // oversimplified for what is probably really needed here for controls
4070 // other than buttons, but is better than not being able to (re)set a
4071 // control's foreground colour to *wxBLACK -- RL
4072 GtkStyle
*def
= gtk_rc_get_style( m_widget
);
4075 def
= gtk_widget_get_default_style();
4077 style
->fg
[GTK_STATE_NORMAL
] = def
->fg
[GTK_STATE_NORMAL
];
4078 style
->fg
[GTK_STATE_PRELIGHT
] = def
->fg
[GTK_STATE_PRELIGHT
];
4079 style
->fg
[GTK_STATE_ACTIVE
] = def
->fg
[GTK_STATE_ACTIVE
];
4083 if (m_backgroundColour
.Ok())
4085 m_backgroundColour
.CalcPixel( gtk_widget_get_colormap( m_widget
) );
4086 if (m_backgroundColour
!= wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE
))
4088 style
->bg
[GTK_STATE_NORMAL
] = *m_backgroundColour
.GetColor();
4089 style
->base
[GTK_STATE_NORMAL
] = *m_backgroundColour
.GetColor();
4090 style
->bg
[GTK_STATE_PRELIGHT
] = *m_backgroundColour
.GetColor();
4091 style
->base
[GTK_STATE_PRELIGHT
] = *m_backgroundColour
.GetColor();
4092 style
->bg
[GTK_STATE_ACTIVE
] = *m_backgroundColour
.GetColor();
4093 style
->base
[GTK_STATE_ACTIVE
] = *m_backgroundColour
.GetColor();
4094 style
->bg
[GTK_STATE_INSENSITIVE
] = *m_backgroundColour
.GetColor();
4095 style
->base
[GTK_STATE_INSENSITIVE
] = *m_backgroundColour
.GetColor();
4099 // Try to restore the gtk default style. This is still a little
4100 // oversimplified for what is probably really needed here for controls
4101 // other than buttons, but is better than not being able to (re)set a
4102 // control's background colour to default grey and means resetting a
4103 // button to wxSYS_COLOUR_BTNFACE will restore its usual highlighting
4105 GtkStyle
*def
= gtk_rc_get_style( m_widget
);
4108 def
= gtk_widget_get_default_style();
4110 style
->bg
[GTK_STATE_NORMAL
] = def
->bg
[GTK_STATE_NORMAL
];
4111 style
->base
[GTK_STATE_NORMAL
] = def
->base
[GTK_STATE_NORMAL
];
4112 style
->bg
[GTK_STATE_PRELIGHT
] = def
->bg
[GTK_STATE_PRELIGHT
];
4113 style
->base
[GTK_STATE_PRELIGHT
] = def
->base
[GTK_STATE_PRELIGHT
];
4114 style
->bg
[GTK_STATE_ACTIVE
] = def
->bg
[GTK_STATE_ACTIVE
];
4115 style
->base
[GTK_STATE_ACTIVE
] = def
->base
[GTK_STATE_ACTIVE
];
4116 style
->bg
[GTK_STATE_INSENSITIVE
] = def
->bg
[GTK_STATE_INSENSITIVE
];
4117 style
->base
[GTK_STATE_INSENSITIVE
] = def
->base
[GTK_STATE_INSENSITIVE
];
4122 void wxWindowGTK::ApplyWidgetStyle()
4126 //-----------------------------------------------------------------------------
4127 // Pop-up menu stuff
4128 //-----------------------------------------------------------------------------
4130 #if wxUSE_MENUS_NATIVE
4133 void gtk_pop_hide_callback( GtkWidget
*WXUNUSED(widget
), bool* is_waiting
)
4135 *is_waiting
= FALSE
;
4138 static void SetInvokingWindow( wxMenu
*menu
, wxWindowGTK
*win
)
4140 menu
->SetInvokingWindow( win
);
4141 wxMenuItemList::Node
*node
= menu
->GetMenuItems().GetFirst();
4144 wxMenuItem
*menuitem
= node
->GetData();
4145 if (menuitem
->IsSubMenu())
4147 SetInvokingWindow( menuitem
->GetSubMenu(), win
);
4150 node
= node
->GetNext();
4154 // used to pass the coordinates from wxWindowGTK::DoPopupMenu() to
4155 // wxPopupMenuPositionCallback()
4157 // should be safe even in the MT case as the user can hardly popup 2 menus
4158 // simultaneously, can he?
4159 static gint gs_pop_x
= 0;
4160 static gint gs_pop_y
= 0;
4162 extern "C" void wxPopupMenuPositionCallback( GtkMenu
*menu
,
4165 gboolean
* WXUNUSED(whatever
),
4167 gpointer
WXUNUSED(user_data
) )
4169 // ensure that the menu appears entirely on screen
4171 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
4173 wxSize sizeScreen
= wxGetDisplaySize();
4175 gint xmax
= sizeScreen
.x
- req
.width
,
4176 ymax
= sizeScreen
.y
- req
.height
;
4178 *x
= gs_pop_x
< xmax
? gs_pop_x
: xmax
;
4179 *y
= gs_pop_y
< ymax
? gs_pop_y
: ymax
;
4182 bool wxWindowGTK::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
4184 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
4186 wxCHECK_MSG( menu
!= NULL
, FALSE
, wxT("invalid popup-menu") );
4188 SetInvokingWindow( menu
, this );
4194 ClientToScreen( &gs_pop_x
, &gs_pop_y
);
4196 bool is_waiting
= TRUE
;
4198 gtk_signal_connect( GTK_OBJECT(menu
->m_menu
),
4200 GTK_SIGNAL_FUNC(gtk_pop_hide_callback
),
4201 (gpointer
)&is_waiting
);
4204 GTK_MENU(menu
->m_menu
),
4205 (GtkWidget
*) NULL
, // parent menu shell
4206 (GtkWidget
*) NULL
, // parent menu item
4207 wxPopupMenuPositionCallback
, // function to position it
4208 NULL
, // client data
4209 0, // button used to activate it
4210 gs_timeLastClick
// the time of activation
4215 while (gtk_events_pending())
4216 gtk_main_iteration();
4222 #endif // wxUSE_MENUS_NATIVE
4224 #if wxUSE_DRAG_AND_DROP
4226 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4228 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4230 GtkWidget
*dnd_widget
= GetConnectWidget();
4232 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
4234 if (m_dropTarget
) delete m_dropTarget
;
4235 m_dropTarget
= dropTarget
;
4237 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
4240 #endif // wxUSE_DRAG_AND_DROP
4242 GtkWidget
* wxWindowGTK::GetConnectWidget()
4244 GtkWidget
*connect_widget
= m_widget
;
4245 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4247 return connect_widget
;
4250 bool wxWindowGTK::IsOwnGtkWindow( GdkWindow
*window
)
4253 return (window
== GTK_PIZZA(m_wxwindow
)->bin_window
);
4255 return (window
== m_widget
->window
);
4258 bool wxWindowGTK::SetFont( const wxFont
&font
)
4260 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
4262 if (!wxWindowBase::SetFont(font
))
4267 wxColour sysbg
= wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE
);
4268 if ( sysbg
== m_backgroundColour
)
4270 m_backgroundColour
= wxNullColour
;
4272 m_backgroundColour
= sysbg
;
4282 void wxWindowGTK::DoCaptureMouse()
4284 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4286 GdkWindow
*window
= (GdkWindow
*) NULL
;
4288 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4290 window
= GetConnectWidget()->window
;
4292 wxCHECK_RET( window
, _T("CaptureMouse() failed") );
4294 wxCursor
* cursor
= & m_cursor
;
4296 cursor
= wxSTANDARD_CURSOR
;
4298 gdk_pointer_grab( window
, FALSE
,
4300 (GDK_BUTTON_PRESS_MASK
|
4301 GDK_BUTTON_RELEASE_MASK
|
4302 GDK_POINTER_MOTION_HINT_MASK
|
4303 GDK_POINTER_MOTION_MASK
),
4305 cursor
->GetCursor(),
4306 (guint32
)GDK_CURRENT_TIME
);
4307 g_captureWindow
= this;
4308 g_captureWindowHasMouse
= TRUE
;
4311 void wxWindowGTK::DoReleaseMouse()
4313 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4315 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4317 g_captureWindow
= (wxWindowGTK
*) NULL
;
4319 GdkWindow
*window
= (GdkWindow
*) NULL
;
4321 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4323 window
= GetConnectWidget()->window
;
4328 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4332 wxWindow
*wxWindowBase::GetCapture()
4334 return (wxWindow
*)g_captureWindow
;
4337 bool wxWindowGTK::IsRetained() const
4342 void wxWindowGTK::SetScrollbar( int orient
, int pos
, int thumbVisible
,
4343 int range
, bool refresh
)
4345 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4347 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4349 m_hasScrolling
= TRUE
;
4351 if (orient
== wxHORIZONTAL
)
4353 float fpos
= (float)pos
;
4354 float frange
= (float)range
;
4355 float fthumb
= (float)thumbVisible
;
4356 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
4357 if (fpos
< 0.0) fpos
= 0.0;
4359 if ((fabs(frange
-m_hAdjust
->upper
) < 0.2) &&
4360 (fabs(fthumb
-m_hAdjust
->page_size
) < 0.2))
4362 SetScrollPos( orient
, pos
, refresh
);
4366 m_oldHorizontalPos
= fpos
;
4368 m_hAdjust
->lower
= 0.0;
4369 m_hAdjust
->upper
= frange
;
4370 m_hAdjust
->value
= fpos
;
4371 m_hAdjust
->step_increment
= 1.0;
4372 m_hAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
4373 m_hAdjust
->page_size
= fthumb
;
4377 float fpos
= (float)pos
;
4378 float frange
= (float)range
;
4379 float fthumb
= (float)thumbVisible
;
4380 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
4381 if (fpos
< 0.0) fpos
= 0.0;
4383 if ((fabs(frange
-m_vAdjust
->upper
) < 0.2) &&
4384 (fabs(fthumb
-m_vAdjust
->page_size
) < 0.2))
4386 SetScrollPos( orient
, pos
, refresh
);
4390 m_oldVerticalPos
= fpos
;
4392 m_vAdjust
->lower
= 0.0;
4393 m_vAdjust
->upper
= frange
;
4394 m_vAdjust
->value
= fpos
;
4395 m_vAdjust
->step_increment
= 1.0;
4396 m_vAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
4397 m_vAdjust
->page_size
= fthumb
;
4400 if (orient
== wxHORIZONTAL
)
4401 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
4403 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
4406 void wxWindowGTK::SetScrollPos( int orient
, int pos
, bool WXUNUSED(refresh
) )
4408 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4410 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4412 if (orient
== wxHORIZONTAL
)
4414 float fpos
= (float)pos
;
4415 if (fpos
> m_hAdjust
->upper
- m_hAdjust
->page_size
) fpos
= m_hAdjust
->upper
- m_hAdjust
->page_size
;
4416 if (fpos
< 0.0) fpos
= 0.0;
4417 m_oldHorizontalPos
= fpos
;
4419 if (fabs(fpos
-m_hAdjust
->value
) < 0.2) return;
4420 m_hAdjust
->value
= fpos
;
4424 float fpos
= (float)pos
;
4425 if (fpos
> m_vAdjust
->upper
- m_vAdjust
->page_size
) fpos
= m_vAdjust
->upper
- m_vAdjust
->page_size
;
4426 if (fpos
< 0.0) fpos
= 0.0;
4427 m_oldVerticalPos
= fpos
;
4429 if (fabs(fpos
-m_vAdjust
->value
) < 0.2) return;
4430 m_vAdjust
->value
= fpos
;
4433 if (m_wxwindow
->window
)
4435 if (orient
== wxHORIZONTAL
)
4437 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust
),
4438 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
4440 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "value_changed" );
4442 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
4443 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
4447 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust
),
4448 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
4450 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "value_changed" );
4452 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
4453 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
4458 int wxWindowGTK::GetScrollThumb( int orient
) const
4460 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4462 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4464 if (orient
== wxHORIZONTAL
)
4465 return (int)(m_hAdjust
->page_size
+0.5);
4467 return (int)(m_vAdjust
->page_size
+0.5);
4470 int wxWindowGTK::GetScrollPos( int orient
) const
4472 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4474 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4476 if (orient
== wxHORIZONTAL
)
4477 return (int)(m_hAdjust
->value
+0.5);
4479 return (int)(m_vAdjust
->value
+0.5);
4482 int wxWindowGTK::GetScrollRange( int orient
) const
4484 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4486 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4488 if (orient
== wxHORIZONTAL
)
4489 return (int)(m_hAdjust
->upper
+0.5);
4491 return (int)(m_vAdjust
->upper
+0.5);
4494 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4496 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4498 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4500 // No scrolling requested.
4501 if ((dx
== 0) && (dy
== 0)) return;
4504 if (!m_updateRegion
.IsEmpty())
4506 m_updateRegion
.Offset( dx
, dy
);
4510 GetClientSize( &cw
, &ch
);
4511 m_updateRegion
.Intersect( 0, 0, cw
, ch
);
4514 if (!m_clearRegion
.IsEmpty())
4516 m_clearRegion
.Offset( dx
, dy
);
4520 GetClientSize( &cw
, &ch
);
4521 m_clearRegion
.Intersect( 0, 0, cw
, ch
);
4525 m_clipPaintRegion
= TRUE
;
4527 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), -dx
, -dy
);
4529 m_clipPaintRegion
= FALSE
;
4533 // Find the wxWindow at the current mouse position, also returning the mouse
4535 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4537 pt
= wxGetMousePosition();
4538 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4542 // Get the current mouse position.
4543 wxPoint
wxGetMousePosition()
4545 /* This crashes when used within wxHelpContext,
4546 so we have to use the X-specific implementation below.
4548 GdkModifierType *mask;
4549 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4551 return wxPoint(x, y);
4555 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4557 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4558 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4559 Window rootReturn
, childReturn
;
4560 int rootX
, rootY
, winX
, winY
;
4561 unsigned int maskReturn
;
4563 XQueryPointer (display
,
4567 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4568 return wxPoint(rootX
, rootY
);
4572 // ----------------------------------------------------------------------------
4574 // ----------------------------------------------------------------------------
4576 class wxWinModule
: public wxModule
4583 DECLARE_DYNAMIC_CLASS(wxWinModule
)
4586 IMPLEMENT_DYNAMIC_CLASS(wxWinModule
, wxModule
)
4588 bool wxWinModule::OnInit()
4590 // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
4591 // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
4596 void wxWinModule::OnExit()
4599 gdk_gc_unref( g_eraseGC
);