1 /////////////////////////////////////////////////////////////////////////////
2 // Name: gtk/window.cpp
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling, Julian Smart
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
11 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
12 #pragma implementation "window.h"
15 // For compilers that support precompilation, includes "wx.h".
16 #include "wx/wxprec.h"
19 #define XWarpPointer XWARPPOINTER
22 #include "wx/window.h"
23 #include "wx/dcclient.h"
26 #include "wx/layout.h"
28 #include "wx/dialog.h"
29 #include "wx/msgdlg.h"
30 #include "wx/module.h"
32 #if wxUSE_DRAG_AND_DROP
37 #include "wx/tooltip.h"
45 #include "wx/textctrl.h"
49 #include "wx/statusbr.h"
51 #include "wx/settings.h"
53 #include "wx/fontutil.h"
56 #include "wx/thread.h"
62 #include "wx/gtk/private.h"
63 #include <gdk/gdkprivate.h>
64 #include <gdk/gdkkeysyms.h>
68 #include <gtk/gtkprivate.h>
70 #include "wx/gtk/win_gtk.h"
73 #include <pango/pangox.h>
84 extern GtkContainerClass
*pizza_parent_class
;
87 //-----------------------------------------------------------------------------
88 // documentation on internals
89 //-----------------------------------------------------------------------------
92 I have been asked several times about writing some documentation about
93 the GTK port of wxWidgets, especially its internal structures. Obviously,
94 you cannot understand wxGTK without knowing a little about the GTK, but
95 some more information about what the wxWindow, which is the base class
96 for all other window classes, does seems required as well.
100 What does wxWindow do? It contains the common interface for the following
101 jobs of its descendants:
103 1) Define the rudimentary behaviour common to all window classes, such as
104 resizing, intercepting user input (so as to make it possible to use these
105 events for special purposes in a derived class), window names etc.
107 2) Provide the possibility to contain and manage children, if the derived
108 class is allowed to contain children, which holds true for those window
109 classes which do not display a native GTK widget. To name them, these
110 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
111 work classes are a special case and are handled a bit differently from
112 the rest. The same holds true for the wxNotebook class.
114 3) Provide the possibility to draw into a client area of a window. This,
115 too, only holds true for classes that do not display a native GTK widget
118 4) Provide the entire mechanism for scrolling widgets. This actual inter-
119 face for this is usually in wxScrolledWindow, but the GTK implementation
122 5) A multitude of helper or extra methods for special purposes, such as
123 Drag'n'Drop, managing validators etc.
125 6) Display a border (sunken, raised, simple or none).
127 Normally one might expect, that one wxWidgets window would always correspond
128 to one GTK widget. Under GTK, there is no such allround widget that has all
129 the functionality. Moreover, the GTK defines a client area as a different
130 widget from the actual widget you are handling. Last but not least some
131 special classes (e.g. wxFrame) handle different categories of widgets and
132 still have the possibility to draw something in the client area.
133 It was therefore required to write a special purpose GTK widget, that would
134 represent a client area in the sense of wxWidgets capable to do the jobs
135 2), 3) and 4). I have written this class and it resides in win_gtk.c of
138 All windows must have a widget, with which they interact with other under-
139 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
140 thw wxWindow class has a member variable called m_widget which holds a
141 pointer to this widget. When the window class represents a GTK native widget,
142 this is (in most cases) the only GTK widget the class manages. E.g. the
143 wxStaticText class handles only a GtkLabel widget a pointer to which you
144 can find in m_widget (defined in wxWindow)
146 When the class has a client area for drawing into and for containing children
147 it has to handle the client area widget (of the type GtkPizza, defined in
148 win_gtk.c), but there could be any number of widgets, handled by a class
149 The common rule for all windows is only, that the widget that interacts with
150 the rest of GTK must be referenced in m_widget and all other widgets must be
151 children of this widget on the GTK level. The top-most widget, which also
152 represents the client area, must be in the m_wxwindow field and must be of
155 As I said, the window classes that display a GTK native widget only have
156 one widget, so in the case of e.g. the wxButton class m_widget holds a
157 pointer to a GtkButton widget. But windows with client areas (for drawing
158 and children) have a m_widget field that is a pointer to a GtkScrolled-
159 Window and a m_wxwindow field that is pointer to a GtkPizza and this
160 one is (in the GTK sense) a child of the GtkScrolledWindow.
162 If the m_wxwindow field is set, then all input to this widget is inter-
163 cepted and sent to the wxWidgets class. If not, all input to the widget
164 that gets pointed to by m_widget gets intercepted and sent to the class.
168 The design of scrolling in wxWidgets is markedly different from that offered
169 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
170 clicking on a scrollbar belonging to scrolled window will inevitably move
171 the window. In wxWidgets, the scrollbar will only emit an event, send this
172 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
173 which actually moves the window and its subchildren. Note that GtkPizza
174 memorizes how much it has been scrolled but that wxWidgets forgets this
175 so that the two coordinates systems have to be kept in synch. This is done
176 in various places using the pizza->xoffset and pizza->yoffset values.
180 Singularily the most broken code in GTK is the code that is supposes to
181 inform subwindows (child windows) about new positions. Very often, duplicate
182 events are sent without changes in size or position, equally often no
183 events are sent at all (All this is due to a bug in the GtkContainer code
184 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
185 GTK's own system and it simply waits for size events for toplevel windows
186 and then iterates down the respective size events to all window. This has
187 the disadvantage, that windows might get size events before the GTK widget
188 actually has the reported size. This doesn't normally pose any problem, but
189 the OpenGl drawing routines rely on correct behaviour. Therefore, I have
190 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
191 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
192 window that is used for OpenGl output really has that size (as reported by
197 If someone at some point of time feels the immense desire to have a look at,
198 change or attempt to optimse the Refresh() logic, this person will need an
199 intimate understanding of what a "draw" and what an "expose" events are and
200 what there are used for, in particular when used in connection with GTK's
201 own windowless widgets. Beware.
205 Cursors, too, have been a constant source of pleasure. The main difficulty
206 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
207 for the parent. To prevent this from doing too much harm, I use idle time
208 to set the cursor over and over again, starting from the toplevel windows
209 and ending with the youngest generation (speaking of parent and child windows).
210 Also don't forget that cursors (like much else) are connected to GdkWindows,
211 not GtkWidgets and that the "window" field of a GtkWidget might very well
212 point to the GdkWindow of the parent widget (-> "window less widget") and
213 that the two obviously have very different meanings.
217 //-----------------------------------------------------------------------------
219 //-----------------------------------------------------------------------------
221 extern wxList wxPendingDelete
;
222 extern bool g_blockEventsOnDrag
;
223 extern bool g_blockEventsOnScroll
;
224 extern wxCursor g_globalCursor
;
226 static GdkGC
*g_eraseGC
= NULL
;
228 // mouse capture state: the window which has it and if the mouse is currently
230 static wxWindowGTK
*g_captureWindow
= (wxWindowGTK
*) NULL
;
231 static bool g_captureWindowHasMouse
= FALSE
;
233 wxWindowGTK
*g_focusWindow
= (wxWindowGTK
*) NULL
;
235 // the last window which had the focus - this is normally never NULL (except
236 // if we never had focus at all) as even when g_focusWindow is NULL it still
237 // keeps its previous value
238 wxWindowGTK
*g_focusWindowLast
= (wxWindowGTK
*) NULL
;
240 // If a window get the focus set but has not been realized
241 // yet, defer setting the focus to idle time.
242 wxWindowGTK
*g_delayedFocus
= (wxWindowGTK
*) NULL
;
244 // hack: we need something to pass to gtk_menu_popup, so we store the time of
245 // the last click here
246 static guint32 gs_timeLastClick
= 0;
248 extern bool g_mainThreadLocked
;
250 //-----------------------------------------------------------------------------
252 //-----------------------------------------------------------------------------
257 # define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
259 # define DEBUG_MAIN_THREAD
262 #define DEBUG_MAIN_THREAD
265 // the trace mask used for the focus debugging messages
266 #define TRACE_FOCUS _T("focus")
268 //-----------------------------------------------------------------------------
269 // missing gdk functions
270 //-----------------------------------------------------------------------------
273 gdk_window_warp_pointer (GdkWindow
*window
,
278 GdkWindowPrivate
*priv
;
282 window
= GDK_ROOT_PARENT();
285 if (!GDK_WINDOW_DESTROYED(window
))
287 XWarpPointer (GDK_WINDOW_XDISPLAY(window
),
288 None
, /* not source window -> move from anywhere */
289 GDK_WINDOW_XID(window
), /* dest window */
290 0, 0, 0, 0, /* not source window -> move from anywhere */
294 priv
= (GdkWindowPrivate
*) window
;
296 if (!priv
->destroyed
)
298 XWarpPointer (priv
->xdisplay
,
299 None
, /* not source window -> move from anywhere */
300 priv
->xwindow
, /* dest window */
301 0, 0, 0, 0, /* not source window -> move from anywhere */
307 //-----------------------------------------------------------------------------
309 //-----------------------------------------------------------------------------
311 extern void wxapp_install_idle_handler();
312 extern bool g_isIdle
;
314 //-----------------------------------------------------------------------------
315 // local code (see below)
316 //-----------------------------------------------------------------------------
318 // returns the child of win which currently has focus or NULL if not found
320 // Note: can't be static, needed by textctrl.cpp.
321 wxWindow
*wxFindFocusedChild(wxWindowGTK
*win
)
323 wxWindow
*winFocus
= wxWindowGTK::FindFocus();
325 return (wxWindow
*)NULL
;
327 if ( winFocus
== win
)
328 return (wxWindow
*)win
;
330 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
332 node
= node
->GetNext() )
334 wxWindow
*child
= wxFindFocusedChild(node
->GetData());
339 return (wxWindow
*)NULL
;
342 static void draw_frame( GtkWidget
*widget
, wxWindowGTK
*win
)
344 // wxUniversal widgets draw the borders and scrollbars themselves
345 #ifndef __WXUNIVERSAL__
352 if (win
->m_hasScrolling
)
354 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(widget
);
356 GtkRequisition vscroll_req
;
357 vscroll_req
.width
= 2;
358 vscroll_req
.height
= 2;
359 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
360 (scroll_window
->vscrollbar
, &vscroll_req
);
362 GtkRequisition hscroll_req
;
363 hscroll_req
.width
= 2;
364 hscroll_req
.height
= 2;
365 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
366 (scroll_window
->hscrollbar
, &hscroll_req
);
368 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(widget
) );
370 if (scroll_window
->vscrollbar_visible
)
372 dw
+= vscroll_req
.width
;
373 dw
+= scroll_class
->scrollbar_spacing
;
376 if (scroll_window
->hscrollbar_visible
)
378 dh
+= hscroll_req
.height
;
379 dh
+= scroll_class
->scrollbar_spacing
;
385 if (GTK_WIDGET_NO_WINDOW (widget
))
387 dx
+= widget
->allocation
.x
;
388 dy
+= widget
->allocation
.y
;
391 if (win
->HasFlag(wxRAISED_BORDER
))
393 gtk_draw_shadow( widget
->style
,
398 widget
->allocation
.width
-dw
, widget
->allocation
.height
-dh
);
402 if (win
->HasFlag(wxSUNKEN_BORDER
))
404 gtk_draw_shadow( widget
->style
,
409 widget
->allocation
.width
-dw
, widget
->allocation
.height
-dh
);
413 if (win
->HasFlag(wxSIMPLE_BORDER
))
416 gc
= gdk_gc_new( widget
->window
);
417 gdk_gc_set_foreground( gc
, &widget
->style
->black
);
418 gdk_draw_rectangle( widget
->window
, gc
, FALSE
,
420 widget
->allocation
.width
-dw
-1, widget
->allocation
.height
-dh
-1 );
424 #endif // __WXUNIVERSAL__
427 //-----------------------------------------------------------------------------
428 // "expose_event" of m_widget
429 //-----------------------------------------------------------------------------
431 gint
gtk_window_own_expose_callback( GtkWidget
*widget
, GdkEventExpose
*gdk_event
, wxWindowGTK
*win
)
433 if (gdk_event
->count
> 0) return FALSE
;
435 draw_frame( widget
, win
);
439 (* GTK_WIDGET_CLASS (pizza_parent_class
)->expose_event
) (widget
, gdk_event
);
445 //-----------------------------------------------------------------------------
446 // "draw" of m_widget
447 //-----------------------------------------------------------------------------
451 static void gtk_window_own_draw_callback( GtkWidget
*widget
, GdkRectangle
*WXUNUSED(rect
), wxWindowGTK
*win
)
453 draw_frame( widget
, win
);
458 //-----------------------------------------------------------------------------
459 // "size_request" of m_widget
460 //-----------------------------------------------------------------------------
462 // make it extern because wxStatitText needs to disconnect this one
464 void wxgtk_window_size_request_callback(GtkWidget
*widget
,
465 GtkRequisition
*requisition
,
469 win
->GetSize( &w
, &h
);
475 requisition
->height
= h
;
476 requisition
->width
= w
;
479 //-----------------------------------------------------------------------------
480 // "expose_event" of m_wxwindow
481 //-----------------------------------------------------------------------------
483 static int gtk_window_expose_callback( GtkWidget
*widget
,
484 GdkEventExpose
*gdk_event
,
490 wxapp_install_idle_handler();
493 // This callback gets called in drawing-idle time under
494 // GTK 2.0, so we don't need to defer anything to idle
497 GtkPizza
*pizza
= GTK_PIZZA( widget
);
498 if (gdk_event
->window
!= pizza
->bin_window
) return FALSE
;
503 wxPrintf( wxT("OnExpose from ") );
504 if (win
->GetClassInfo() && win
->GetClassInfo()->GetClassName())
505 wxPrintf( win
->GetClassInfo()->GetClassName() );
506 wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event
->area
.x
,
507 (int)gdk_event
->area
.y
,
508 (int)gdk_event
->area
.width
,
509 (int)gdk_event
->area
.height
);
514 win
->m_wxwindow
->style
,
518 (GdkRectangle
*) NULL
,
520 (char *)"button", // const_cast
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 // if there are any children we must refresh everything
597 if ( !win
->HasFlag(wxFULL_REPAINT_ON_RESIZE
) &&
598 win
->GetChildren().IsEmpty() )
606 wxPrintf( wxT("OnDraw from ") );
607 if (win
->GetClassInfo() && win
->GetClassInfo()->GetClassName())
608 wxPrintf( win
->GetClassInfo()->GetClassName() );
609 wxPrintf( wxT(" %d %d %d %d\n"), (int)rect
->x
,
616 #ifndef __WXUNIVERSAL__
617 GtkPizza
*pizza
= GTK_PIZZA (widget
);
619 if (win
->GetThemeEnabled() && win
->GetBackgroundStyle() == wxBG_STYLE_SYSTEM
)
621 wxWindow
*parent
= win
->GetParent();
622 while (parent
&& !parent
->IsTopLevel())
623 parent
= parent
->GetParent();
627 gtk_paint_flat_box (parent
->m_widget
->style
,
638 win
->m_clearRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
639 win
->GetUpdateRegion().Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
641 // Update immediately, not in idle time.
644 #ifndef __WXUNIVERSAL__
645 // Redraw child widgets
646 GList
*children
= pizza
->children
;
649 GtkPizzaChild
*child
= (GtkPizzaChild
*) children
->data
;
650 children
= children
->next
;
652 GdkRectangle child_area
;
653 if (gtk_widget_intersect (child
->widget
, rect
, &child_area
))
655 gtk_widget_draw (child
->widget
, &child_area
/* (GdkRectangle*) NULL*/ );
663 //-----------------------------------------------------------------------------
664 // "key_press_event" from any window
665 //-----------------------------------------------------------------------------
667 // set WXTRACE to this to see the key event codes on the console
668 #define TRACE_KEYS _T("keyevent")
670 // translates an X key symbol to WXK_XXX value
672 // if isChar is true it means that the value returned will be used for EVT_CHAR
673 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
674 // for example, while if it is false it means that the value is going to be
675 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
677 static long wxTranslateKeySymToWXKey(KeySym keysym
, bool isChar
)
683 // Shift, Control and Alt don't generate the CHAR events at all
686 key_code
= isChar
? 0 : WXK_SHIFT
;
690 key_code
= isChar
? 0 : WXK_CONTROL
;
698 key_code
= isChar
? 0 : WXK_ALT
;
701 // neither do the toggle modifies
702 case GDK_Scroll_Lock
:
703 key_code
= isChar
? 0 : WXK_SCROLL
;
707 key_code
= isChar
? 0 : WXK_CAPITAL
;
711 key_code
= isChar
? 0 : WXK_NUMLOCK
;
715 // various other special keys
728 case GDK_ISO_Left_Tab
:
735 key_code
= WXK_RETURN
;
739 key_code
= WXK_CLEAR
;
743 key_code
= WXK_PAUSE
;
747 key_code
= WXK_SELECT
;
751 key_code
= WXK_PRINT
;
755 key_code
= WXK_EXECUTE
;
759 key_code
= WXK_ESCAPE
;
762 // cursor and other extended keyboard keys
764 key_code
= WXK_DELETE
;
780 key_code
= WXK_RIGHT
;
787 case GDK_Prior
: // == GDK_Page_Up
788 key_code
= WXK_PRIOR
;
791 case GDK_Next
: // == GDK_Page_Down
804 key_code
= WXK_INSERT
;
819 key_code
= (isChar
? '0' : WXK_NUMPAD0
) + keysym
- GDK_KP_0
;
823 key_code
= isChar
? ' ' : WXK_NUMPAD_SPACE
;
827 key_code
= isChar
? WXK_TAB
: WXK_NUMPAD_TAB
;
831 key_code
= isChar
? WXK_RETURN
: WXK_NUMPAD_ENTER
;
835 key_code
= isChar
? WXK_F1
: WXK_NUMPAD_F1
;
839 key_code
= isChar
? WXK_F2
: WXK_NUMPAD_F2
;
843 key_code
= isChar
? WXK_F3
: WXK_NUMPAD_F3
;
847 key_code
= isChar
? WXK_F4
: WXK_NUMPAD_F4
;
851 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_HOME
;
855 key_code
= isChar
? WXK_LEFT
: WXK_NUMPAD_LEFT
;
859 key_code
= isChar
? WXK_UP
: WXK_NUMPAD_UP
;
863 key_code
= isChar
? WXK_RIGHT
: WXK_NUMPAD_RIGHT
;
867 key_code
= isChar
? WXK_DOWN
: WXK_NUMPAD_DOWN
;
870 case GDK_KP_Prior
: // == GDK_KP_Page_Up
871 key_code
= isChar
? WXK_PRIOR
: WXK_NUMPAD_PRIOR
;
874 case GDK_KP_Next
: // == GDK_KP_Page_Down
875 key_code
= isChar
? WXK_NEXT
: WXK_NUMPAD_NEXT
;
879 key_code
= isChar
? WXK_END
: WXK_NUMPAD_END
;
883 key_code
= isChar
? WXK_HOME
: WXK_NUMPAD_BEGIN
;
887 key_code
= isChar
? WXK_INSERT
: WXK_NUMPAD_INSERT
;
891 key_code
= isChar
? WXK_DELETE
: WXK_NUMPAD_DELETE
;
895 key_code
= isChar
? '=' : WXK_NUMPAD_EQUAL
;
898 case GDK_KP_Multiply
:
899 key_code
= isChar
? '*' : WXK_NUMPAD_MULTIPLY
;
903 key_code
= isChar
? '+' : WXK_NUMPAD_ADD
;
906 case GDK_KP_Separator
:
907 // FIXME: what is this?
908 key_code
= isChar
? '.' : WXK_NUMPAD_SEPARATOR
;
911 case GDK_KP_Subtract
:
912 key_code
= isChar
? '-' : WXK_NUMPAD_SUBTRACT
;
916 key_code
= isChar
? '.' : WXK_NUMPAD_DECIMAL
;
920 key_code
= isChar
? '/' : WXK_NUMPAD_DIVIDE
;
937 key_code
= WXK_F1
+ keysym
- GDK_F1
;
947 static inline bool wxIsAsciiKeysym(KeySym ks
)
952 static void wxFillOtherKeyEventFields(wxKeyEvent
& event
,
954 GdkEventKey
*gdk_event
)
958 GdkModifierType state
;
959 if (gdk_event
->window
)
960 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
962 event
.SetTimestamp( gdk_event
->time
);
963 event
.SetId(win
->GetId());
964 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
) != 0;
965 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
) != 0;
966 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
) != 0;
967 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
) != 0;
968 event
.m_scanCode
= gdk_event
->keyval
;
969 event
.m_rawCode
= (wxUint32
) gdk_event
->keyval
;
970 event
.m_rawFlags
= 0;
972 event
.m_uniChar
= gdk_keyval_to_unicode(gdk_event
->keyval
);
976 event
.SetEventObject( win
);
981 wxTranslateGTKKeyEventToWx(wxKeyEvent
& event
,
983 GdkEventKey
*gdk_event
)
985 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
986 // but only event->keyval which is quite useless to us, so remember
987 // the last character from GDK_KEY_PRESS and reuse it as last resort
989 // NB: should be MT-safe as we're always called from the main thread only
994 } s_lastKeyPress
= { 0, 0 };
996 KeySym keysym
= gdk_event
->keyval
;
998 wxLogTrace(TRACE_KEYS
, _T("Key %s event: keysym = %ld"),
999 event
.GetEventType() == wxEVT_KEY_UP
? _T("release")
1003 long key_code
= wxTranslateKeySymToWXKey(keysym
, FALSE
/* !isChar */);
1007 // do we have the translation or is it a plain ASCII character?
1008 if ( (gdk_event
->length
== 1) || wxIsAsciiKeysym(keysym
) )
1010 // we should use keysym if it is ASCII as X does some translations
1011 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
1012 // which we don't want here (but which we do use for OnChar())
1013 if ( !wxIsAsciiKeysym(keysym
) )
1015 keysym
= (KeySym
)gdk_event
->string
[0];
1018 // we want to always get the same key code when the same key is
1019 // pressed regardless of the state of the modifies, i.e. on a
1020 // standard US keyboard pressing '5' or '%' ('5' key with
1021 // Shift) should result in the same key code in OnKeyDown():
1022 // '5' (although OnChar() will get either '5' or '%').
1024 // to do it we first translate keysym to keycode (== scan code)
1025 // and then back but always using the lower register
1026 Display
*dpy
= (Display
*)wxGetDisplay();
1027 KeyCode keycode
= XKeysymToKeycode(dpy
, keysym
);
1029 wxLogTrace(TRACE_KEYS
, _T("\t-> keycode %d"), keycode
);
1031 KeySym keysymNormalized
= XKeycodeToKeysym(dpy
, keycode
, 0);
1033 // use the normalized, i.e. lower register, keysym if we've
1035 key_code
= keysymNormalized
? keysymNormalized
: keysym
;
1037 // as explained above, we want to have lower register key codes
1038 // normally but for the letter keys we want to have the upper ones
1040 // NB: don't use XConvertCase() here, we want to do it for letters
1042 key_code
= toupper(key_code
);
1044 else // non ASCII key, what to do?
1046 // by default, ignore it
1049 // but if we have cached information from the last KEY_PRESS
1050 if ( gdk_event
->type
== GDK_KEY_RELEASE
)
1053 if ( keysym
== s_lastKeyPress
.keysym
)
1055 key_code
= s_lastKeyPress
.keycode
;
1060 if ( gdk_event
->type
== GDK_KEY_PRESS
)
1062 // remember it to be reused for KEY_UP event later
1063 s_lastKeyPress
.keysym
= keysym
;
1064 s_lastKeyPress
.keycode
= key_code
;
1068 wxLogTrace(TRACE_KEYS
, _T("\t-> wxKeyCode %ld"), key_code
);
1070 // sending unknown key events doesn't really make sense
1074 // now fill all the other fields
1075 wxFillOtherKeyEventFields(event
, win
, gdk_event
);
1077 event
.m_keyCode
= key_code
;
1086 GtkIMContext
*context
;
1087 GdkEventKey
*lastKeyEvent
;
1091 context
= gtk_im_multicontext_new();
1092 lastKeyEvent
= NULL
;
1096 g_object_unref(context
);
1101 static gint
gtk_window_key_press_callback( GtkWidget
*widget
,
1102 GdkEventKey
*gdk_event
,
1108 wxapp_install_idle_handler();
1112 if (g_blockEventsOnDrag
)
1117 // We have to pass key press events through GTK+'s Input Method context
1118 // object in order to get correct characters. By doing so, we lose the
1119 // ability to let other GTK+'s handlers (namely, widgets' default signal
1120 // handlers) handle the signal by returning false from this callback.
1121 // Because GTK+ sends the events to parent widgets as well, we can't
1122 // afford losing it, otherwise native widgets inserted into wxPanel
1123 // would break in subtle ways (e.g. spacebar would no longer toggle
1124 // wxCheckButton's state). Therefore, we only pass the event to IM if it
1125 // originated in this window's widget, which we detect by checking if we've
1126 // seen the same event before (no events from children are lost this way,
1127 // because gtk_window_key_press_callback is installed for native controls
1128 // as well and the wxKeyEvent it creates propagates upwards).
1129 static GdkEventKey s_lastEvent
;
1130 bool useIM
= (win
->m_imData
!= NULL
) &&
1131 memcmp(gdk_event
, &s_lastEvent
, sizeof(GdkEventKey
)) != 0;
1132 s_lastEvent
= *gdk_event
;
1134 // 2005.01.26 modified by Hong Jen Yee (hzysoft@sina.com.tw):
1135 // There is no need to store lastEvent. The original code makes GTK+ IM
1136 // dysfunction. When we get a key_press event here, it could be originate
1137 // from the current widget or its child widgets. However, only the widget
1138 // with the INPUT FOCUS can generate the INITIAL key_press event. That is,
1139 // if the CURRENT widget doesn't have the FOCUS at all, this event definitely
1140 // originated from its child widgets and shouldn't be passed to IM context.
1141 // In fact, what a GTK+ IM should do is filtering keyEvents and convert them
1142 // into text input ONLY WHEN THE WIDGET HAS INPUT FOCUS. Besides, when current
1143 // widgets has both IM context and input focus, the event should be filtered
1144 // by gtk_im_context_filter_keypress().
1145 // Then, we should, according to GTK+ 2.0 API doc, return whatever it returns.
1146 bool useIM
= (win
->m_imData
!= NULL
) && ( wxWindow::FindFocus() == win
);
1152 // 2005.01.26 modified by Hong Jen Yee (hzysoft@sina.com.tw):
1153 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
1154 // docs, if IM filter returns true, NO FURTHER PROCESSING SHOULD BE DONE for
1155 // this keystroke. Making wxWidgets unable to receive EVT_KEY_DOWN in this
1156 // situation is resonable. In reality, when IM is activated, wxWidgets should
1157 // receive EVT_CHAR instead.
1160 // it may be useful for the input method, though:
1161 bool ret
= gtk_im_context_filter_keypress(win
->m_imData
->context
, gdk_event
);
1162 win
->m_imData
->lastKeyEvent
= NULL
;
1165 wxLogTrace(TRACE_KEYS
, _T("Key event intercepted by IM"));
1171 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1174 // 2005.02.02 modified by Hong Jen Yee (hzysoft@sina.com.tw).
1175 // In GTK+ 1.2, strings sent by IMs are also regarded as key_press events whose
1176 // keyCodes cannot be recognized by wxWidgets. These MBCS strings, however, are
1177 // composed of more than one character, which means gdk_event->length will always
1178 // greater than one. When gtk_event->length == 1, this may be an ASCII character
1179 // and can be translated by wx. However, when MBCS characters are sent by IM,
1180 // gdk_event->length will >= 2. So neither should we pass it to accelerator table,
1181 // nor should we pass it to controls. The following explanation was excerpted
1182 // from GDK documentation.
1183 // gint length : the length of string.
1184 // gchar *string : a null-terminated multi-byte string containing the composed
1185 // characters resulting from the key press. When text is being input, in a GtkEntry
1186 // for example, it is these characters which should be added to the input buffer.
1187 // When using Input Methods to support internationalized text input, the composed
1188 // characters appear here after the pre-editing has been completed.
1190 #ifndef __WXGTK20__ // This is for GTK+ 1.2 only.
1191 if ( (gdk_event
->length
> 1) ) // If this event contains a pre-edited string from IM.
1193 // We should translate this key event into wxEVT_CHAR not wxEVT_KEY_DOWN.
1194 #if wxUSE_UNICODE // GTK+ 1.2 is not UTF-8 based.
1195 const wxWCharBuffer string
= wxConvLocal
.cMB2WC( gdk_event
->string
);
1196 if( !string
) return FALSE
;
1198 const char* string
= gdk_event
->string
;
1201 // Implement OnCharHook by checking ancesteror top level windows
1202 wxWindow
*parent
= window
;
1203 while (parent
&& !parent
->IsTopLevel())
1204 parent
= parent
->GetParent();
1206 for( wxChar
* pstr
= string
; *pstr
; pstr
++ )
1209 event
.m_uniChar
= *pstr
;
1210 // Backward compatible for ISO-8859-1
1211 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
1213 event
.m_keyCode
= *pstr
;
1217 event
.SetEventType( wxEVT_CHAR_HOOK
);
1218 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1222 event
.SetEventType(wxEVT_CHAR
);
1223 window
->GetEventHandler()->ProcessEvent( event
);
1228 // Only translate the key event when it's not sent with a pre-edited string.
1230 #endif // #ifndef __WXGTK20__
1231 if( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1233 // unknown key pressed, ignore (the event would be useless anyhow)
1236 else // This event doesn't contain a pre-edited string and is not an invalid key either.
1238 // Emit KEY_DOWN event
1239 ret
= win
->GetEventHandler()->ProcessEvent( event
);
1245 wxWindowGTK
*ancestor
= win
;
1248 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
1251 wxCommandEvent
command_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
1252 ret
= ancestor
->GetEventHandler()->ProcessEvent( command_event
);
1255 if (ancestor
->IsTopLevel())
1257 ancestor
= ancestor
->GetParent();
1260 #endif // wxUSE_ACCEL
1262 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1263 // will only be sent if it is not in an accelerator table.
1267 KeySym keysym
= gdk_event
->keyval
;
1268 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1269 key_code
= wxTranslateKeySymToWXKey(keysym
, TRUE
/* isChar */);
1272 if ( wxIsAsciiKeysym(keysym
) )
1275 key_code
= (unsigned char)keysym
;
1277 // gdk_event->string is actually deprecated
1278 else if ( gdk_event
->length
== 1 )
1280 key_code
= (unsigned char)gdk_event
->string
[0];
1286 wxLogTrace(TRACE_KEYS
, _T("Char event: %ld"), key_code
);
1288 event
.m_keyCode
= key_code
;
1290 // Implement OnCharHook by checking ancesteror top level windows
1291 wxWindow
*parent
= win
;
1292 while (parent
&& !parent
->IsTopLevel())
1293 parent
= parent
->GetParent();
1296 event
.SetEventType( wxEVT_CHAR_HOOK
);
1297 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1302 event
.SetEventType(wxEVT_CHAR
);
1303 ret
= win
->GetEventHandler()->ProcessEvent( event
);
1308 // win is a control: tab can be propagated up
1310 ((gdk_event
->keyval
== GDK_Tab
) || (gdk_event
->keyval
== GDK_ISO_Left_Tab
)) &&
1311 // VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may
1312 // have this style, yet choose not to process this particular TAB in which
1313 // case TAB must still work as a navigational character
1314 // JS: enabling again to make consistent with other platforms
1315 // (with wxTE_PROCESS_TAB you have to call Navigate to get default
1316 // navigation behaviour)
1318 (! (win
->HasFlag(wxTE_PROCESS_TAB
) && win
->IsKindOf(CLASSINFO(wxTextCtrl
)) )) &&
1320 win
->GetParent() && (win
->GetParent()->HasFlag( wxTAB_TRAVERSAL
)) )
1322 wxNavigationKeyEvent new_event
;
1323 new_event
.SetEventObject( win
->GetParent() );
1324 // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
1325 new_event
.SetDirection( (gdk_event
->keyval
== GDK_Tab
) );
1326 // CTRL-TAB changes the (parent) window, i.e. switch notebook page
1327 new_event
.SetWindowChange( (gdk_event
->state
& GDK_CONTROL_MASK
) );
1328 new_event
.SetCurrentFocus( win
);
1329 ret
= win
->GetParent()->GetEventHandler()->ProcessEvent( new_event
);
1332 // generate wxID_CANCEL if <esc> has been pressed (typically in dialogs)
1334 (gdk_event
->keyval
== GDK_Escape
) )
1336 // however only do it if we have a Cancel button in the dialog,
1337 // otherwise the user code may get confused by the events from a
1338 // non-existing button and, worse, a wxButton might get button event
1339 // from another button which is not really expected
1340 wxWindow
*winForCancel
= win
,
1342 while ( winForCancel
)
1344 btnCancel
= winForCancel
->FindWindow(wxID_CANCEL
);
1347 // found a cancel button
1351 if ( winForCancel
->IsTopLevel() )
1353 // no need to look further
1357 // maybe our parent has a cancel button?
1358 winForCancel
= winForCancel
->GetParent();
1363 wxCommandEvent
event(wxEVT_COMMAND_BUTTON_CLICKED
, wxID_CANCEL
);
1364 event
.SetEventObject(btnCancel
);
1365 ret
= btnCancel
->GetEventHandler()->ProcessEvent(event
);
1371 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_press_event" );
1379 static void gtk_wxwindow_commit_cb (GtkIMContext
*context
,
1383 wxKeyEvent
event( wxEVT_KEY_DOWN
);
1385 // take modifiers, cursor position, timestamp etc. from the last
1386 // key_press_event that was fed into Input Method:
1387 if (window
->m_imData
->lastKeyEvent
)
1389 wxFillOtherKeyEventFields(event
,
1390 window
, window
->m_imData
->lastKeyEvent
);
1394 const wxWCharBuffer data
= wxConvUTF8
.cMB2WC( (char*)str
);
1396 const wxWCharBuffer wdata
= wxConvUTF8
.cMB2WC( (char*)str
);
1397 const wxCharBuffer data
= wxConvLocal
.cWC2MB( wdata
);
1398 #endif // wxUSE_UNICODE
1399 if( !(const wxChar
*)data
)
1404 // Implement OnCharHook by checking ancestor top level windows
1405 wxWindow
*parent
= window
;
1406 while (parent
&& !parent
->IsTopLevel())
1407 parent
= parent
->GetParent();
1409 for( const wxChar
* pstr
= data
; *pstr
; pstr
++ )
1412 event
.m_uniChar
= *pstr
;
1413 // Backward compatible for ISO-8859-1
1414 event
.m_keyCode
= *pstr
< 256 ? event
.m_uniChar
: 0;
1415 wxLogTrace(TRACE_KEYS
, _T("IM sent character '%c'"), event
.m_uniChar
);
1417 event
.m_keyCode
= *pstr
;
1418 #endif // wxUSE_UNICODE
1421 event
.SetEventType( wxEVT_CHAR_HOOK
);
1422 ret
= parent
->GetEventHandler()->ProcessEvent( event
);
1427 event
.SetEventType(wxEVT_CHAR
);
1428 ret
= window
->GetEventHandler()->ProcessEvent( event
);
1435 //-----------------------------------------------------------------------------
1436 // "key_release_event" from any window
1437 //-----------------------------------------------------------------------------
1439 static gint
gtk_window_key_release_callback( GtkWidget
*widget
,
1440 GdkEventKey
*gdk_event
,
1446 wxapp_install_idle_handler();
1451 if (g_blockEventsOnDrag
)
1454 wxKeyEvent
event( wxEVT_KEY_UP
);
1455 if ( !wxTranslateGTKKeyEventToWx(event
, win
, gdk_event
) )
1457 // unknown key pressed, ignore (the event would be useless anyhow
1461 if ( !win
->GetEventHandler()->ProcessEvent( event
) )
1464 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_release_event" );
1468 // ============================================================================
1470 // ============================================================================
1472 // ----------------------------------------------------------------------------
1473 // mouse event processing helpers
1474 // ----------------------------------------------------------------------------
1476 // init wxMouseEvent with the info from GdkEventXXX struct
1477 template<typename T
> void InitMouseEvent(wxWindowGTK
*win
,
1478 wxMouseEvent
& event
,
1481 event
.SetTimestamp( gdk_event
->time
);
1482 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1483 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1484 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1485 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1486 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1487 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1488 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1489 if (event
.GetEventType() == wxEVT_MOUSEWHEEL
)
1491 event
.m_linesPerAction
= 3;
1492 event
.m_wheelDelta
= 120;
1493 if (((GdkEventButton
*)gdk_event
)->button
== 4)
1494 event
.m_wheelRotation
= 120;
1495 else if (((GdkEventButton
*)gdk_event
)->button
== 5)
1496 event
.m_wheelRotation
= -120;
1499 wxPoint pt
= win
->GetClientAreaOrigin();
1500 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1501 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1503 event
.SetEventObject( win
);
1504 event
.SetId( win
->GetId() );
1505 event
.SetTimestamp( gdk_event
->time
);
1508 static void AdjustEventButtonState(wxMouseEvent
& event
)
1510 // GDK reports the old state of the button for a button press event, but
1511 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1512 // for a LEFT_DOWN event, not FALSE, so we will invert
1513 // left/right/middleDown for the corresponding click events
1515 if ((event
.GetEventType() == wxEVT_LEFT_DOWN
) ||
1516 (event
.GetEventType() == wxEVT_LEFT_DCLICK
) ||
1517 (event
.GetEventType() == wxEVT_LEFT_UP
))
1519 event
.m_leftDown
= !event
.m_leftDown
;
1523 if ((event
.GetEventType() == wxEVT_MIDDLE_DOWN
) ||
1524 (event
.GetEventType() == wxEVT_MIDDLE_DCLICK
) ||
1525 (event
.GetEventType() == wxEVT_MIDDLE_UP
))
1527 event
.m_middleDown
= !event
.m_middleDown
;
1531 if ((event
.GetEventType() == wxEVT_RIGHT_DOWN
) ||
1532 (event
.GetEventType() == wxEVT_RIGHT_DCLICK
) ||
1533 (event
.GetEventType() == wxEVT_RIGHT_UP
))
1535 event
.m_rightDown
= !event
.m_rightDown
;
1540 // find the window to send the mouse event too
1542 wxWindowGTK
*FindWindowForMouseEvent(wxWindowGTK
*win
, wxCoord
& x
, wxCoord
& y
)
1547 if (win
->m_wxwindow
)
1549 GtkPizza
*pizza
= GTK_PIZZA(win
->m_wxwindow
);
1550 xx
+= pizza
->xoffset
;
1551 yy
+= pizza
->yoffset
;
1554 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
1557 wxWindowGTK
*child
= node
->GetData();
1559 node
= node
->GetNext();
1560 if (!child
->IsShown())
1563 if (child
->IsTransparentForMouse())
1565 // wxStaticBox is transparent in the box itself
1566 int xx1
= child
->m_x
;
1567 int yy1
= child
->m_y
;
1568 int xx2
= child
->m_x
+ child
->m_width
;
1569 int yy2
= child
->m_y
+ child
->m_height
;
1572 if (((xx
>= xx1
) && (xx
<= xx1
+10) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1574 ((xx
>= xx2
-10) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy2
)) ||
1576 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy1
) && (yy
<= yy1
+10)) ||
1578 ((xx
>= xx1
) && (xx
<= xx2
) && (yy
>= yy2
-1) && (yy
<= yy2
)))
1589 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1590 (child
->m_x
<= xx
) &&
1591 (child
->m_y
<= yy
) &&
1592 (child
->m_x
+child
->m_width
>= xx
) &&
1593 (child
->m_y
+child
->m_height
>= yy
))
1606 //-----------------------------------------------------------------------------
1607 // "button_press_event"
1608 //-----------------------------------------------------------------------------
1610 static gint
gtk_window_button_press_callback( GtkWidget
*widget
,
1611 GdkEventButton
*gdk_event
,
1617 wxapp_install_idle_handler();
1620 wxPrintf( wxT("1) OnButtonPress from ") );
1621 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1622 wxPrintf( win->GetClassInfo()->GetClassName() );
1623 wxPrintf( wxT(".\n") );
1625 if (!win
->m_hasVMT
) return FALSE
;
1626 if (g_blockEventsOnDrag
) return TRUE
;
1627 if (g_blockEventsOnScroll
) return TRUE
;
1629 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1631 if (win
->m_wxwindow
&& (g_focusWindow
!= win
) && win
->AcceptsFocus())
1633 gtk_widget_grab_focus( win
->m_wxwindow
);
1635 wxPrintf( wxT("GrabFocus from ") );
1636 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1637 wxPrintf( win->GetClassInfo()->GetClassName() );
1638 wxPrintf( wxT(".\n") );
1642 // GDK sends surplus button down event
1643 // before a double click event. We
1644 // need to filter these out.
1645 if (gdk_event
->type
== GDK_BUTTON_PRESS
)
1647 GdkEvent
*peek_event
= gdk_event_peek();
1650 if ((peek_event
->type
== GDK_2BUTTON_PRESS
) ||
1651 (peek_event
->type
== GDK_3BUTTON_PRESS
))
1653 gdk_event_free( peek_event
);
1658 gdk_event_free( peek_event
);
1663 wxEventType event_type
= wxEVT_NULL
;
1665 // GdkDisplay is a GTK+ 2.2.0 thing
1666 #if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0)
1667 if ( gdk_event
->type
== GDK_2BUTTON_PRESS
&&
1668 gdk_event
->button
>= 1 && gdk_event
->button
<= 3 )
1670 // Reset GDK internal timestamp variables in order to disable GDK
1671 // triple click events. GDK will then next time believe no button has
1672 // been clicked just before, and send a normal button click event.
1673 GdkDisplay
* display
= gtk_widget_get_display (widget
);
1674 display
->button_click_time
[1] = 0;
1675 display
->button_click_time
[0] = 0;
1679 if (gdk_event
->button
== 1)
1681 // note that GDK generates triple click events which are not supported
1682 // by wxWidgets but still have to be passed to the app as otherwise
1683 // clicks would simply go missing
1684 switch (gdk_event
->type
)
1686 // we shouldn't get triple clicks at all for GTK2 because we
1687 // suppress them artificially using the code above but we still
1688 // should map them to something for GTK1 and not just ignore them
1689 // as this would lose clicks
1690 case GDK_3BUTTON_PRESS
: // we could also map this to DCLICK...
1691 case GDK_BUTTON_PRESS
:
1692 event_type
= wxEVT_LEFT_DOWN
;
1695 case GDK_2BUTTON_PRESS
:
1696 event_type
= wxEVT_LEFT_DCLICK
;
1700 // just to silence gcc warnings
1704 else if (gdk_event
->button
== 2)
1706 switch (gdk_event
->type
)
1708 case GDK_3BUTTON_PRESS
:
1709 case GDK_BUTTON_PRESS
:
1710 event_type
= wxEVT_MIDDLE_DOWN
;
1713 case GDK_2BUTTON_PRESS
:
1714 event_type
= wxEVT_MIDDLE_DCLICK
;
1721 else if (gdk_event
->button
== 3)
1723 switch (gdk_event
->type
)
1725 case GDK_3BUTTON_PRESS
:
1726 case GDK_BUTTON_PRESS
:
1727 event_type
= wxEVT_RIGHT_DOWN
;
1730 case GDK_2BUTTON_PRESS
:
1731 event_type
= wxEVT_RIGHT_DCLICK
;
1738 else if (gdk_event
->button
== 4 || gdk_event
->button
== 5)
1740 if (gdk_event
->type
== GDK_BUTTON_PRESS
)
1742 event_type
= wxEVT_MOUSEWHEEL
;
1746 if ( event_type
== wxEVT_NULL
)
1748 // unknown mouse button or click type
1752 wxMouseEvent
event( event_type
);
1753 InitMouseEvent( win
, event
, gdk_event
);
1755 AdjustEventButtonState(event
);
1757 // wxListBox actually get mouse events from the item, so we need to give it
1758 // a chance to correct this
1759 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1761 // find the correct window to send the event too: it may be a different one
1762 // from the one which got it at GTK+ level because some control don't have
1763 // their own X window and thus cannot get any events.
1764 if ( !g_captureWindow
)
1765 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1767 gs_timeLastClick
= gdk_event
->time
;
1770 if (event_type
== wxEVT_LEFT_DCLICK
)
1772 // GTK 1.2 crashes when intercepting double
1773 // click events from both wxSpinButton and
1775 if (GTK_IS_SPIN_BUTTON(win
->m_widget
))
1777 // Just disable this event for now.
1783 if (win
->GetEventHandler()->ProcessEvent( event
))
1785 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_press_event" );
1789 if (event_type
== wxEVT_RIGHT_DOWN
)
1791 // generate a "context menu" event: this is similar to right mouse
1792 // click under many GUIs except that it is generated differently
1793 // (right up under MSW, ctrl-click under Mac, right down here) and
1795 // (a) it's a command event and so is propagated to the parent
1796 // (b) under some ports it can be generated from kbd too
1797 // (c) it uses screen coords (because of (a))
1798 wxContextMenuEvent
evtCtx(
1801 win
->ClientToScreen(event
.GetPosition()));
1802 evtCtx
.SetEventObject(win
);
1803 return win
->GetEventHandler()->ProcessEvent(evtCtx
);
1809 //-----------------------------------------------------------------------------
1810 // "button_release_event"
1811 //-----------------------------------------------------------------------------
1813 static gint
gtk_window_button_release_callback( GtkWidget
*widget
,
1814 GdkEventButton
*gdk_event
,
1820 wxapp_install_idle_handler();
1822 if (!win
->m_hasVMT
) return FALSE
;
1823 if (g_blockEventsOnDrag
) return FALSE
;
1824 if (g_blockEventsOnScroll
) return FALSE
;
1826 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1828 wxEventType event_type
= wxEVT_NULL
;
1830 switch (gdk_event
->button
)
1833 event_type
= wxEVT_LEFT_UP
;
1837 event_type
= wxEVT_MIDDLE_UP
;
1841 event_type
= wxEVT_RIGHT_UP
;
1845 // unknwon button, don't process
1849 wxMouseEvent
event( event_type
);
1850 InitMouseEvent( win
, event
, gdk_event
);
1852 AdjustEventButtonState(event
);
1854 // same wxListBox hack as above
1855 win
->FixUpMouseEvent(widget
, event
.m_x
, event
.m_y
);
1857 if ( !g_captureWindow
)
1858 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1860 if (win
->GetEventHandler()->ProcessEvent( event
))
1862 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_release_event" );
1869 //-----------------------------------------------------------------------------
1870 // "motion_notify_event"
1871 //-----------------------------------------------------------------------------
1873 static gint
gtk_window_motion_notify_callback( GtkWidget
*widget
,
1874 GdkEventMotion
*gdk_event
,
1880 wxapp_install_idle_handler();
1882 if (!win
->m_hasVMT
) return FALSE
;
1883 if (g_blockEventsOnDrag
) return FALSE
;
1884 if (g_blockEventsOnScroll
) return FALSE
;
1886 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1888 if (gdk_event
->is_hint
)
1892 GdkModifierType state
;
1893 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1899 printf( "OnMotion from " );
1900 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1901 printf( win->GetClassInfo()->GetClassName() );
1905 wxMouseEvent
event( wxEVT_MOTION
);
1906 InitMouseEvent(win
, event
, gdk_event
);
1908 if ( g_captureWindow
)
1910 // synthetize a mouse enter or leave event if needed
1911 GdkWindow
*winUnderMouse
= gdk_window_at_pointer(NULL
, NULL
);
1912 // This seems to be necessary and actually been added to
1913 // GDK itself in version 2.0.X
1916 bool hasMouse
= winUnderMouse
== gdk_event
->window
;
1917 if ( hasMouse
!= g_captureWindowHasMouse
)
1919 // the mouse changed window
1920 g_captureWindowHasMouse
= hasMouse
;
1922 wxMouseEvent
event(g_captureWindowHasMouse
? wxEVT_ENTER_WINDOW
1923 : wxEVT_LEAVE_WINDOW
);
1924 InitMouseEvent(win
, event
, gdk_event
);
1925 event
.SetEventObject(win
);
1926 win
->GetEventHandler()->ProcessEvent(event
);
1931 win
= FindWindowForMouseEvent(win
, event
.m_x
, event
.m_y
);
1934 if (win
->GetEventHandler()->ProcessEvent( event
))
1936 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "motion_notify_event" );
1944 //-----------------------------------------------------------------------------
1945 // "mouse_wheel_event"
1946 //-----------------------------------------------------------------------------
1948 static gint
gtk_window_wheel_callback (GtkWidget
* widget
,
1949 GdkEventScroll
* gdk_event
,
1955 wxapp_install_idle_handler();
1957 wxEventType event_type
= wxEVT_NULL
;
1958 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1959 event_type
= wxEVT_MOUSEWHEEL
;
1960 else if (gdk_event
->direction
== GDK_SCROLL_DOWN
)
1961 event_type
= wxEVT_MOUSEWHEEL
;
1965 wxMouseEvent
event( event_type
);
1966 // Can't use InitMouse macro because scroll events don't have button
1967 event
.SetTimestamp( gdk_event
->time
);
1968 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1969 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1970 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1971 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1972 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1973 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1974 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1975 event
.m_linesPerAction
= 3;
1976 event
.m_wheelDelta
= 120;
1977 if (gdk_event
->direction
== GDK_SCROLL_UP
)
1978 event
.m_wheelRotation
= 120;
1980 event
.m_wheelRotation
= -120;
1982 wxPoint pt
= win
->GetClientAreaOrigin();
1983 event
.m_x
= (wxCoord
)gdk_event
->x
- pt
.x
;
1984 event
.m_y
= (wxCoord
)gdk_event
->y
- pt
.y
;
1986 event
.SetEventObject( win
);
1987 event
.SetId( win
->GetId() );
1988 event
.SetTimestamp( gdk_event
->time
);
1990 if (win
->GetEventHandler()->ProcessEvent( event
))
1992 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "scroll_event" );
1999 //-----------------------------------------------------------------------------
2001 //-----------------------------------------------------------------------------
2002 static gboolean
wxgtk_window_popup_menu_callback(GtkWidget
*, wxWindowGTK
* win
)
2004 wxContextMenuEvent
event(
2008 event
.SetEventObject(win
);
2009 return win
->GetEventHandler()->ProcessEvent(event
);
2011 #endif // __WXGTK20__
2013 //-----------------------------------------------------------------------------
2015 //-----------------------------------------------------------------------------
2017 // send the wxChildFocusEvent and wxFocusEvent, common code of
2018 // gtk_window_focus_in_callback() and SetFocus()
2019 static bool DoSendFocusEvents(wxWindow
*win
)
2021 // Notify the parent keeping track of focus for the kbd navigation
2022 // purposes that we got it.
2023 wxChildFocusEvent
eventChildFocus(win
);
2024 (void)win
->GetEventHandler()->ProcessEvent(eventChildFocus
);
2026 wxFocusEvent
eventFocus(wxEVT_SET_FOCUS
, win
->GetId());
2027 eventFocus
.SetEventObject(win
);
2029 return win
->GetEventHandler()->ProcessEvent(eventFocus
);
2032 static gint
gtk_window_focus_in_callback( GtkWidget
*widget
,
2033 GdkEvent
*WXUNUSED(event
),
2039 wxapp_install_idle_handler();
2043 gtk_im_context_focus_in(win
->m_imData
->context
);
2047 g_focusWindow
= win
;
2049 wxLogTrace(TRACE_FOCUS
,
2050 _T("%s: focus in"), win
->GetName().c_str());
2054 gdk_im_begin(win
->m_ic
, win
->m_wxwindow
->window
);
2058 // caret needs to be informed about focus change
2059 wxCaret
*caret
= win
->GetCaret();
2062 caret
->OnSetFocus();
2064 #endif // wxUSE_CARET
2066 // does the window itself think that it has the focus?
2067 if ( !win
->m_hasFocus
)
2069 // not yet, notify it
2070 win
->m_hasFocus
= TRUE
;
2072 if ( DoSendFocusEvents(win
) )
2074 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_in_event" );
2082 //-----------------------------------------------------------------------------
2083 // "focus_out_event"
2084 //-----------------------------------------------------------------------------
2086 static gint
gtk_window_focus_out_callback( GtkWidget
*widget
, GdkEventFocus
*gdk_event
, wxWindowGTK
*win
)
2091 wxapp_install_idle_handler();
2095 gtk_im_context_focus_out(win
->m_imData
->context
);
2098 wxLogTrace( TRACE_FOCUS
,
2099 _T("%s: focus out"), win
->GetName().c_str() );
2102 wxWindowGTK
*winFocus
= wxFindFocusedChild(win
);
2106 g_focusWindow
= (wxWindowGTK
*)NULL
;
2114 // caret needs to be informed about focus change
2115 wxCaret
*caret
= win
->GetCaret();
2118 caret
->OnKillFocus();
2120 #endif // wxUSE_CARET
2122 // don't send the window a kill focus event if it thinks that it doesn't
2123 // have focus already
2124 if ( win
->m_hasFocus
)
2126 win
->m_hasFocus
= FALSE
;
2128 wxFocusEvent
event( wxEVT_KILL_FOCUS
, win
->GetId() );
2129 event
.SetEventObject( win
);
2131 // even if we did process the event in wx code, still let GTK itself
2132 // process it too as otherwise bad things happen, especially in GTK2
2133 // where the text control simply aborts the program if it doesn't get
2134 // the matching focus out event
2135 (void)win
->GetEventHandler()->ProcessEvent( event
);
2141 //-----------------------------------------------------------------------------
2142 // "enter_notify_event"
2143 //-----------------------------------------------------------------------------
2146 gint
gtk_window_enter_callback( GtkWidget
*widget
,
2147 GdkEventCrossing
*gdk_event
,
2153 wxapp_install_idle_handler();
2155 if (!win
->m_hasVMT
) return FALSE
;
2156 if (g_blockEventsOnDrag
) return FALSE
;
2158 // Event was emitted after a grab
2159 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
2161 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
2165 GdkModifierType state
= (GdkModifierType
)0;
2167 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
2169 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
2170 InitMouseEvent(win
, event
, gdk_event
);
2171 wxPoint pt
= win
->GetClientAreaOrigin();
2172 event
.m_x
= x
+ pt
.x
;
2173 event
.m_y
= y
+ pt
.y
;
2175 if (win
->GetEventHandler()->ProcessEvent( event
))
2177 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "enter_notify_event" );
2184 //-----------------------------------------------------------------------------
2185 // "leave_notify_event"
2186 //-----------------------------------------------------------------------------
2188 static gint
gtk_window_leave_callback( GtkWidget
*widget
, GdkEventCrossing
*gdk_event
, wxWindowGTK
*win
)
2193 wxapp_install_idle_handler();
2195 if (!win
->m_hasVMT
) return FALSE
;
2196 if (g_blockEventsOnDrag
) return FALSE
;
2198 // Event was emitted after an ungrab
2199 if (gdk_event
->mode
!= GDK_CROSSING_NORMAL
) return FALSE
;
2201 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
2203 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
2204 event
.SetTimestamp( gdk_event
->time
);
2205 event
.SetEventObject( win
);
2209 GdkModifierType state
= (GdkModifierType
)0;
2211 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
2213 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
) != 0;
2214 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
) != 0;
2215 event
.m_altDown
= (state
& GDK_MOD1_MASK
) != 0;
2216 event
.m_metaDown
= (state
& GDK_MOD2_MASK
) != 0;
2217 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
) != 0;
2218 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
) != 0;
2219 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
) != 0;
2221 wxPoint pt
= win
->GetClientAreaOrigin();
2222 event
.m_x
= x
+ pt
.x
;
2223 event
.m_y
= y
+ pt
.y
;
2225 if (win
->GetEventHandler()->ProcessEvent( event
))
2227 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "leave_notify_event" );
2234 //-----------------------------------------------------------------------------
2235 // "value_changed" from m_vAdjust
2236 //-----------------------------------------------------------------------------
2238 static void gtk_window_vscroll_callback( GtkAdjustment
*adjust
,
2245 wxapp_install_idle_handler();
2247 if (g_blockEventsOnDrag
) return;
2249 if (!win
->m_hasVMT
) return;
2251 float diff
= adjust
->value
- win
->m_oldVerticalPos
;
2252 if (fabs(diff
) < 0.2) return;
2254 win
->m_oldVerticalPos
= adjust
->value
;
2257 GtkScrolledWindow
*sw
= GTK_SCROLLED_WINDOW(win
->m_widget
);
2259 wxEventType command
= GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw
->vscrollbar
));
2261 int value
= (int)(adjust
->value
+0.5);
2263 wxScrollWinEvent
event( command
, value
, wxVERTICAL
);
2264 event
.SetEventObject( win
);
2265 win
->GetEventHandler()->ProcessEvent( event
);
2268 //-----------------------------------------------------------------------------
2269 // "value_changed" from m_hAdjust
2270 //-----------------------------------------------------------------------------
2272 static void gtk_window_hscroll_callback( GtkAdjustment
*adjust
,
2279 wxapp_install_idle_handler();
2281 if (g_blockEventsOnDrag
) return;
2282 if (!win
->m_hasVMT
) return;
2284 float diff
= adjust
->value
- win
->m_oldHorizontalPos
;
2285 if (fabs(diff
) < 0.2) return;
2288 GtkScrolledWindow
*sw
= GTK_SCROLLED_WINDOW(win
->m_widget
);
2290 wxEventType command
= GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw
->hscrollbar
));
2292 win
->m_oldHorizontalPos
= adjust
->value
;
2294 int value
= (int)(adjust
->value
+0.5);
2296 wxScrollWinEvent
event( command
, value
, wxHORIZONTAL
);
2297 event
.SetEventObject( win
);
2298 win
->GetEventHandler()->ProcessEvent( event
);
2301 //-----------------------------------------------------------------------------
2302 // "button_press_event" from scrollbar
2303 //-----------------------------------------------------------------------------
2305 static gint
gtk_scrollbar_button_press_callback( GtkRange
*widget
,
2306 GdkEventButton
*gdk_event
,
2312 wxapp_install_idle_handler();
2315 g_blockEventsOnScroll
= TRUE
;
2317 // FIXME: there is no 'slider' field in GTK+ 2.0 any more
2319 win
->m_isScrolling
= (gdk_event
->window
== widget
->slider
);
2325 //-----------------------------------------------------------------------------
2326 // "button_release_event" from scrollbar
2327 //-----------------------------------------------------------------------------
2329 static gint
gtk_scrollbar_button_release_callback( GtkRange
*widget
,
2330 GdkEventButton
*WXUNUSED(gdk_event
),
2335 // don't test here as we can release the mouse while being over
2336 // a different window than the slider
2338 // if (gdk_event->window != widget->slider) return FALSE;
2340 g_blockEventsOnScroll
= FALSE
;
2342 if (win
->m_isScrolling
)
2344 wxEventType command
= wxEVT_SCROLLWIN_THUMBRELEASE
;
2348 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(win
->m_widget
);
2349 if (widget
== GTK_RANGE(scrolledWindow
->hscrollbar
))
2351 value
= (int)(win
->m_hAdjust
->value
+0.5);
2354 if (widget
== GTK_RANGE(scrolledWindow
->vscrollbar
))
2356 value
= (int)(win
->m_vAdjust
->value
+0.5);
2360 wxScrollWinEvent
event( command
, value
, dir
);
2361 event
.SetEventObject( win
);
2362 win
->GetEventHandler()->ProcessEvent( event
);
2365 win
->m_isScrolling
= FALSE
;
2370 // ----------------------------------------------------------------------------
2371 // this wxWindowBase function is implemented here (in platform-specific file)
2372 // because it is static and so couldn't be made virtual
2373 // ----------------------------------------------------------------------------
2375 wxWindow
*wxWindowBase::DoFindFocus()
2377 // the cast is necessary when we compile in wxUniversal mode
2378 return (wxWindow
*)g_focusWindow
;
2382 //-----------------------------------------------------------------------------
2383 // "realize" from m_widget
2384 //-----------------------------------------------------------------------------
2386 /* We cannot set colours and fonts before the widget has
2387 been realized, so we do this directly after realization. */
2390 gtk_window_realized_callback( GtkWidget
*m_widget
, wxWindow
*win
)
2395 wxapp_install_idle_handler();
2400 GtkPizza
*pizza
= GTK_PIZZA( m_widget
);
2401 gtk_im_context_set_client_window( win
->m_imData
->context
,
2402 pizza
->bin_window
);
2406 wxWindowCreateEvent
event( win
);
2407 event
.SetEventObject( win
);
2408 win
->GetEventHandler()->ProcessEvent( event
);
2413 //-----------------------------------------------------------------------------
2415 //-----------------------------------------------------------------------------
2418 void gtk_window_size_callback( GtkWidget
*WXUNUSED(widget
),
2419 GtkAllocation
*WXUNUSED(alloc
),
2423 wxapp_install_idle_handler();
2425 if (!win
->m_hasScrolling
) return;
2427 int client_width
= 0;
2428 int client_height
= 0;
2429 win
->GetClientSize( &client_width
, &client_height
);
2430 if ((client_width
== win
->m_oldClientWidth
) && (client_height
== win
->m_oldClientHeight
))
2433 win
->m_oldClientWidth
= client_width
;
2434 win
->m_oldClientHeight
= client_height
;
2436 if (!win
->m_nativeSizeEvent
)
2438 wxSizeEvent
event( win
->GetSize(), win
->GetId() );
2439 event
.SetEventObject( win
);
2440 win
->GetEventHandler()->ProcessEvent( event
);
2446 #define WXUNUSED_UNLESS_XIM(param) param
2448 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2451 /* Resize XIM window */
2454 void gtk_wxwindow_size_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2455 GtkAllocation
* WXUNUSED_UNLESS_XIM(alloc
),
2456 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2459 wxapp_install_idle_handler();
2465 if (gdk_ic_get_style (win
->m_ic
) & GDK_IM_PREEDIT_POSITION
)
2469 gdk_window_get_size (widget
->window
, &width
, &height
);
2470 win
->m_icattr
->preedit_area
.width
= width
;
2471 win
->m_icattr
->preedit_area
.height
= height
;
2472 gdk_ic_set_attr (win
->m_ic
, win
->m_icattr
, GDK_IC_PREEDIT_AREA
);
2477 //-----------------------------------------------------------------------------
2478 // "realize" from m_wxwindow
2479 //-----------------------------------------------------------------------------
2481 /* Initialize XIM support */
2484 gtk_wxwindow_realized_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
2485 wxWindowGTK
* WXUNUSED_UNLESS_XIM(win
) )
2488 wxapp_install_idle_handler();
2491 if (win
->m_ic
) return FALSE
;
2492 if (!widget
) return FALSE
;
2493 if (!gdk_im_ready()) return FALSE
;
2495 win
->m_icattr
= gdk_ic_attr_new();
2496 if (!win
->m_icattr
) return FALSE
;
2500 GdkColormap
*colormap
;
2501 GdkICAttr
*attr
= win
->m_icattr
;
2502 unsigned attrmask
= GDK_IC_ALL_REQ
;
2504 GdkIMStyle supported_style
= (GdkIMStyle
)
2505 (GDK_IM_PREEDIT_NONE
|
2506 GDK_IM_PREEDIT_NOTHING
|
2507 GDK_IM_PREEDIT_POSITION
|
2508 GDK_IM_STATUS_NONE
|
2509 GDK_IM_STATUS_NOTHING
);
2511 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2512 supported_style
= (GdkIMStyle
)(supported_style
& ~GDK_IM_PREEDIT_POSITION
);
2514 attr
->style
= style
= gdk_im_decide_style (supported_style
);
2515 attr
->client_window
= widget
->window
;
2517 if ((colormap
= gtk_widget_get_colormap (widget
)) !=
2518 gtk_widget_get_default_colormap ())
2520 attrmask
|= GDK_IC_PREEDIT_COLORMAP
;
2521 attr
->preedit_colormap
= colormap
;
2524 attrmask
|= GDK_IC_PREEDIT_FOREGROUND
;
2525 attrmask
|= GDK_IC_PREEDIT_BACKGROUND
;
2526 attr
->preedit_foreground
= widget
->style
->fg
[GTK_STATE_NORMAL
];
2527 attr
->preedit_background
= widget
->style
->base
[GTK_STATE_NORMAL
];
2529 switch (style
& GDK_IM_PREEDIT_MASK
)
2531 case GDK_IM_PREEDIT_POSITION
:
2532 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
2534 g_warning ("over-the-spot style requires fontset");
2538 gdk_window_get_size (widget
->window
, &width
, &height
);
2540 attrmask
|= GDK_IC_PREEDIT_POSITION_REQ
;
2541 attr
->spot_location
.x
= 0;
2542 attr
->spot_location
.y
= height
;
2543 attr
->preedit_area
.x
= 0;
2544 attr
->preedit_area
.y
= 0;
2545 attr
->preedit_area
.width
= width
;
2546 attr
->preedit_area
.height
= height
;
2547 attr
->preedit_fontset
= widget
->style
->font
;
2552 win
->m_ic
= gdk_ic_new (attr
, (GdkICAttributesType
)attrmask
);
2554 if (win
->m_ic
== NULL
)
2555 g_warning ("Can't create input context.");
2558 mask
= gdk_window_get_events (widget
->window
);
2559 mask
= (GdkEventMask
)(mask
| gdk_ic_get_events (win
->m_ic
));
2560 gdk_window_set_events (widget
->window
, mask
);
2562 if (GTK_WIDGET_HAS_FOCUS(widget
))
2563 gdk_im_begin (win
->m_ic
, widget
->window
);
2570 //-----------------------------------------------------------------------------
2571 // InsertChild for wxWindowGTK.
2572 //-----------------------------------------------------------------------------
2574 /* Callback for wxWindowGTK. This very strange beast has to be used because
2575 * C++ has no virtual methods in a constructor. We have to emulate a
2576 * virtual function here as wxNotebook requires a different way to insert
2577 * a child in it. I had opted for creating a wxNotebookPage window class
2578 * which would have made this superfluous (such in the MDI window system),
2579 * but no-one was listening to me... */
2581 static void wxInsertChildInWindow( wxWindowGTK
* parent
, wxWindowGTK
* child
)
2583 /* the window might have been scrolled already, do we
2584 have to adapt the position */
2585 GtkPizza
*pizza
= GTK_PIZZA(parent
->m_wxwindow
);
2586 child
->m_x
+= pizza
->xoffset
;
2587 child
->m_y
+= pizza
->yoffset
;
2589 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
2590 GTK_WIDGET(child
->m_widget
),
2597 //-----------------------------------------------------------------------------
2599 //-----------------------------------------------------------------------------
2601 wxWindow
*wxGetActiveWindow()
2603 return wxWindow::FindFocus();
2606 //-----------------------------------------------------------------------------
2608 //-----------------------------------------------------------------------------
2610 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2612 #ifdef __WXUNIVERSAL__
2613 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK
, wxWindowBase
)
2615 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
2616 #endif // __WXUNIVERSAL__/__WXGTK__
2618 void wxWindowGTK::Init()
2621 m_widget
= (GtkWidget
*) NULL
;
2622 m_wxwindow
= (GtkWidget
*) NULL
;
2623 m_focusWidget
= (GtkWidget
*) NULL
;
2633 m_needParent
= TRUE
;
2634 m_isBeingDeleted
= FALSE
;
2637 m_nativeSizeEvent
= FALSE
;
2639 m_hasScrolling
= FALSE
;
2640 m_isScrolling
= FALSE
;
2642 m_hAdjust
= (GtkAdjustment
*) NULL
;
2643 m_vAdjust
= (GtkAdjustment
*) NULL
;
2644 m_oldHorizontalPos
=
2645 m_oldVerticalPos
= 0.0;
2647 m_oldClientHeight
= 0;
2651 m_insertCallback
= (wxInsertChildFunction
) NULL
;
2653 m_acceptsFocus
= FALSE
;
2656 m_clipPaintRegion
= FALSE
;
2658 m_needsStyleChange
= false;
2660 m_cursor
= *wxSTANDARD_CURSOR
;
2664 m_x11Context
= NULL
;
2665 m_dirtyTabOrder
= false;
2668 m_ic
= (GdkIC
*) NULL
;
2669 m_icattr
= (GdkICAttr
*) NULL
;
2674 wxWindowGTK::wxWindowGTK()
2679 wxWindowGTK::wxWindowGTK( wxWindow
*parent
,
2684 const wxString
&name
)
2688 Create( parent
, id
, pos
, size
, style
, name
);
2691 bool wxWindowGTK::Create( wxWindow
*parent
,
2696 const wxString
&name
)
2698 if (!PreCreation( parent
, pos
, size
) ||
2699 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
2701 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2705 m_insertCallback
= wxInsertChildInWindow
;
2707 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
2708 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
2710 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
2712 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
2713 scroll_class
->scrollbar_spacing
= 0;
2715 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2717 m_hAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->hscrollbar
) );
2718 m_vAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->vscrollbar
) );
2720 m_wxwindow
= gtk_pizza_new();
2722 #ifndef __WXUNIVERSAL__
2723 GtkPizza
*pizza
= GTK_PIZZA(m_wxwindow
);
2725 if (HasFlag(wxRAISED_BORDER
))
2727 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_OUT
);
2729 else if (HasFlag(wxSUNKEN_BORDER
))
2731 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_IN
);
2733 else if (HasFlag(wxSIMPLE_BORDER
))
2735 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_THIN
);
2739 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_NONE
);
2741 #endif // __WXUNIVERSAL__
2743 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
2745 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
2746 m_acceptsFocus
= TRUE
;
2748 // I _really_ don't want scrollbars in the beginning
2749 m_vAdjust
->lower
= 0.0;
2750 m_vAdjust
->upper
= 1.0;
2751 m_vAdjust
->value
= 0.0;
2752 m_vAdjust
->step_increment
= 1.0;
2753 m_vAdjust
->page_increment
= 1.0;
2754 m_vAdjust
->page_size
= 5.0;
2755 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
2756 m_hAdjust
->lower
= 0.0;
2757 m_hAdjust
->upper
= 1.0;
2758 m_hAdjust
->value
= 0.0;
2759 m_hAdjust
->step_increment
= 1.0;
2760 m_hAdjust
->page_increment
= 1.0;
2761 m_hAdjust
->page_size
= 5.0;
2762 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
2764 // these handlers block mouse events to any window during scrolling such as
2765 // motion events and prevent GTK and wxWidgets from fighting over where the
2768 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_press_event",
2769 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
2771 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_press_event",
2772 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
2774 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_release_event",
2775 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
2777 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_release_event",
2778 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
2780 // these handlers get notified when screen updates are required either when
2781 // scrolling or when the window size (and therefore scrollbar configuration)
2784 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
2785 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
2786 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
2787 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
2789 gtk_widget_show( m_wxwindow
);
2792 m_parent
->DoAddChild( this );
2794 m_focusWidget
= m_wxwindow
;
2801 wxWindowGTK::~wxWindowGTK()
2805 if (g_focusWindow
== this)
2806 g_focusWindow
= NULL
;
2808 if ( g_delayedFocus
== this )
2809 g_delayedFocus
= NULL
;
2811 m_isBeingDeleted
= TRUE
;
2821 gdk_ic_destroy (m_ic
);
2823 gdk_ic_attr_destroy (m_icattr
);
2828 gtk_widget_destroy( m_wxwindow
);
2829 m_wxwindow
= (GtkWidget
*) NULL
;
2834 gtk_widget_destroy( m_widget
);
2835 m_widget
= (GtkWidget
*) NULL
;
2843 bool wxWindowGTK::PreCreation( wxWindowGTK
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2845 wxCHECK_MSG( !m_needParent
|| parent
, FALSE
, wxT("Need complete parent.") );
2847 // Use either the given size, or the default if -1 is given.
2848 // See wxWindowBase for these functions.
2849 m_width
= WidthDefault(size
.x
) ;
2850 m_height
= HeightDefault(size
.y
);
2858 void wxWindowGTK::PostCreation()
2860 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2866 // these get reported to wxWidgets -> wxPaintEvent
2868 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow
), TRUE
);
2870 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "expose_event",
2871 GTK_SIGNAL_FUNC(gtk_window_expose_callback
), (gpointer
)this );
2874 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "draw",
2875 GTK_SIGNAL_FUNC(gtk_window_draw_callback
), (gpointer
)this );
2877 if (!HasFlag(wxFULL_REPAINT_ON_RESIZE
))
2879 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "event",
2880 GTK_SIGNAL_FUNC(gtk_window_event_event_callback
), (gpointer
)this );
2883 // gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), !HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
2888 // Create input method handler
2889 m_imData
= new wxGtkIMData
;
2891 // Cannot handle drawing preedited text yet
2892 gtk_im_context_set_use_preedit( m_imData
->context
, FALSE
);
2894 g_signal_connect (G_OBJECT (m_imData
->context
), "commit",
2895 G_CALLBACK (gtk_wxwindow_commit_cb
), this);
2898 // these are called when the "sunken" or "raised" borders are drawn
2899 gtk_signal_connect( GTK_OBJECT(m_widget
), "expose_event",
2900 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback
), (gpointer
)this );
2903 gtk_signal_connect( GTK_OBJECT(m_widget
), "draw",
2904 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback
), (gpointer
)this );
2910 if (!GTK_IS_WINDOW(m_widget
))
2912 if (m_focusWidget
== NULL
)
2913 m_focusWidget
= m_widget
;
2915 gtk_signal_connect( GTK_OBJECT(m_focusWidget
), "focus_in_event",
2916 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback
), (gpointer
)this );
2918 gtk_signal_connect_after( GTK_OBJECT(m_focusWidget
), "focus_out_event",
2919 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback
), (gpointer
)this );
2922 // connect to the various key and mouse handlers
2924 GtkWidget
*connect_widget
= GetConnectWidget();
2926 ConnectWidget( connect_widget
);
2928 /* We cannot set colours, fonts and cursors before the widget has
2929 been realized, so we do this directly after realization */
2930 gtk_signal_connect( GTK_OBJECT(connect_widget
), "realize",
2931 GTK_SIGNAL_FUNC(gtk_window_realized_callback
), (gpointer
) this );
2935 // Catch native resize events
2936 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "size_allocate",
2937 GTK_SIGNAL_FUNC(gtk_window_size_callback
), (gpointer
)this );
2939 // Initialize XIM support
2940 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "realize",
2941 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback
), (gpointer
) this );
2943 // And resize XIM window
2944 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "size_allocate",
2945 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback
), (gpointer
)this );
2948 if ( !GTK_IS_COMBO(m_widget
))
2950 // This is needed if we want to add our windows into native
2951 // GTK control, such as the toolbar. With this callback, the
2952 // toolbar gets to know the correct size (the one set by the
2953 // programmer). Sadly, it misbehaves for wxComboBox. FIXME
2954 // when moving to GTK 2.0.
2955 gtk_signal_connect( GTK_OBJECT(m_widget
), "size_request",
2956 GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback
),
2960 InheritAttributes();
2964 // unless the window was created initially hidden (i.e. Hide() had been
2965 // called before Create()), we should show it at GTK+ level as well
2967 gtk_widget_show( m_widget
);
2970 void wxWindowGTK::ConnectWidget( GtkWidget
*widget
)
2972 gtk_signal_connect( GTK_OBJECT(widget
), "key_press_event",
2973 GTK_SIGNAL_FUNC(gtk_window_key_press_callback
), (gpointer
)this );
2975 gtk_signal_connect( GTK_OBJECT(widget
), "key_release_event",
2976 GTK_SIGNAL_FUNC(gtk_window_key_release_callback
), (gpointer
)this );
2978 gtk_signal_connect( GTK_OBJECT(widget
), "button_press_event",
2979 GTK_SIGNAL_FUNC(gtk_window_button_press_callback
), (gpointer
)this );
2981 gtk_signal_connect( GTK_OBJECT(widget
), "button_release_event",
2982 GTK_SIGNAL_FUNC(gtk_window_button_release_callback
), (gpointer
)this );
2984 gtk_signal_connect( GTK_OBJECT(widget
), "motion_notify_event",
2985 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback
), (gpointer
)this );
2988 gtk_signal_connect( GTK_OBJECT(widget
), "scroll_event",
2989 GTK_SIGNAL_FUNC(gtk_window_wheel_callback
), (gpointer
)this );
2990 g_signal_connect(widget
, "popup_menu",
2991 G_CALLBACK(wxgtk_window_popup_menu_callback
), this);
2994 gtk_signal_connect( GTK_OBJECT(widget
), "enter_notify_event",
2995 GTK_SIGNAL_FUNC(gtk_window_enter_callback
), (gpointer
)this );
2997 gtk_signal_connect( GTK_OBJECT(widget
), "leave_notify_event",
2998 GTK_SIGNAL_FUNC(gtk_window_leave_callback
), (gpointer
)this );
3001 bool wxWindowGTK::Destroy()
3003 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3007 return wxWindowBase::Destroy();
3010 void wxWindowGTK::DoMoveWindow(int x
, int y
, int width
, int height
)
3012 gtk_pizza_set_size( GTK_PIZZA(m_parent
->m_wxwindow
), m_widget
, x
, y
, width
, height
);
3015 void wxWindowGTK::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
3017 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3018 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindowGTK::SetSize requires parent.\n") );
3021 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
3024 if (m_resizing
) return; /* I don't like recursions */
3027 int currentX
, currentY
;
3028 GetPosition(¤tX
, ¤tY
);
3029 if (x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
3031 if (y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
))
3033 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
3035 if (m_parent
->m_wxwindow
== NULL
) /* i.e. wxNotebook */
3037 /* don't set the size for children of wxNotebook, just take the values. */
3045 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
3046 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
3048 if (x
!= -1) m_x
= x
+ pizza
->xoffset
;
3049 if (y
!= -1) m_y
= y
+ pizza
->yoffset
;
3053 m_x
= x
+ pizza
->xoffset
;
3054 m_y
= y
+ pizza
->yoffset
;
3057 // calculate the best size if we should auto size the window
3058 if ( ((sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1) ||
3059 ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1) )
3061 const wxSize sizeBest
= GetBestSize();
3062 if ( (sizeFlags
& wxSIZE_AUTO_WIDTH
) && width
== -1 )
3064 if ( (sizeFlags
& wxSIZE_AUTO_HEIGHT
) && height
== -1 )
3065 height
= sizeBest
.y
;
3073 int minWidth
= GetMinWidth(),
3074 minHeight
= GetMinHeight(),
3075 maxWidth
= GetMaxWidth(),
3076 maxHeight
= GetMaxHeight();
3078 if ((minWidth
!= -1) && (m_width
< minWidth
)) m_width
= minWidth
;
3079 if ((minHeight
!= -1) && (m_height
< minHeight
)) m_height
= minHeight
;
3080 if ((maxWidth
!= -1) && (m_width
> maxWidth
)) m_width
= maxWidth
;
3081 if ((maxHeight
!= -1) && (m_height
> maxHeight
)) m_height
= maxHeight
;
3084 int bottom_border
= 0;
3087 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
3089 /* the default button has a border around it */
3095 DoMoveWindow( m_x
-border
,
3098 m_height
+border
+bottom_border
);
3103 /* Sometimes the client area changes size without the
3104 whole windows's size changing, but if the whole
3105 windows's size doesn't change, no wxSizeEvent will
3106 normally be sent. Here we add an extra test if
3107 the client test has been changed and this will
3109 GetClientSize( &m_oldClientWidth
, &m_oldClientHeight
);
3113 wxPrintf( "OnSize sent from " );
3114 if (GetClassInfo() && GetClassInfo()->GetClassName())
3115 wxPrintf( GetClassInfo()->GetClassName() );
3116 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
3119 if (!m_nativeSizeEvent
)
3121 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
3122 event
.SetEventObject( this );
3123 GetEventHandler()->ProcessEvent( event
);
3129 void wxWindowGTK::OnInternalIdle()
3132 if ( m_dirtyTabOrder
)
3135 // Update style if the window was not yet realized
3136 // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
3137 if (m_needsStyleChange
)
3139 SetBackgroundStyle(GetBackgroundStyle());
3140 m_needsStyleChange
= false;
3143 // Update invalidated regions.
3146 wxCursor cursor
= m_cursor
;
3147 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
3151 /* I now set the cursor anew in every OnInternalIdle call
3152 as setting the cursor in a parent window also effects the
3153 windows above so that checking for the current cursor is
3158 GdkWindow
*window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3160 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3162 if (!g_globalCursor
.Ok())
3163 cursor
= *wxSTANDARD_CURSOR
;
3165 window
= m_widget
->window
;
3166 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
3167 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3173 GdkWindow
*window
= m_widget
->window
;
3174 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
3175 gdk_window_set_cursor( window
, cursor
.GetCursor() );
3180 if (wxUpdateUIEvent::CanUpdate(this))
3181 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
3184 void wxWindowGTK::DoGetSize( int *width
, int *height
) const
3186 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3188 if (width
) (*width
) = m_width
;
3189 if (height
) (*height
) = m_height
;
3192 void wxWindowGTK::DoSetClientSize( int width
, int height
)
3194 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3198 SetSize( width
, height
);
3205 #ifndef __WXUNIVERSAL__
3206 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
3208 /* when using GTK 1.2 we set the shadow border size to 2 */
3212 if (HasFlag(wxSIMPLE_BORDER
))
3214 /* when using GTK 1.2 we set the simple border size to 1 */
3218 #endif // __WXUNIVERSAL__
3222 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
3224 GtkRequisition vscroll_req
;
3225 vscroll_req
.width
= 2;
3226 vscroll_req
.height
= 2;
3227 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
3228 (scroll_window
->vscrollbar
, &vscroll_req
);
3230 GtkRequisition hscroll_req
;
3231 hscroll_req
.width
= 2;
3232 hscroll_req
.height
= 2;
3233 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
3234 (scroll_window
->hscrollbar
, &hscroll_req
);
3236 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
3238 if (scroll_window
->vscrollbar_visible
)
3240 dw
+= vscroll_req
.width
;
3241 dw
+= scroll_class
->scrollbar_spacing
;
3244 if (scroll_window
->hscrollbar_visible
)
3246 dh
+= hscroll_req
.height
;
3247 dh
+= scroll_class
->scrollbar_spacing
;
3251 SetSize( width
+dw
, height
+dh
);
3255 void wxWindowGTK::DoGetClientSize( int *width
, int *height
) const
3257 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3261 if (width
) (*width
) = m_width
;
3262 if (height
) (*height
) = m_height
;
3269 #ifndef __WXUNIVERSAL__
3270 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
3272 /* when using GTK 1.2 we set the shadow border size to 2 */
3276 if (HasFlag(wxSIMPLE_BORDER
))
3278 /* when using GTK 1.2 we set the simple border size to 1 */
3282 #endif // __WXUNIVERSAL__
3286 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
3288 GtkRequisition vscroll_req
;
3289 vscroll_req
.width
= 2;
3290 vscroll_req
.height
= 2;
3291 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->vscrollbar
) )->size_request
)
3292 (scroll_window
->vscrollbar
, &vscroll_req
);
3294 GtkRequisition hscroll_req
;
3295 hscroll_req
.width
= 2;
3296 hscroll_req
.height
= 2;
3297 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window
->hscrollbar
) )->size_request
)
3298 (scroll_window
->hscrollbar
, &hscroll_req
);
3300 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
3302 if (scroll_window
->vscrollbar_visible
)
3304 dw
+= vscroll_req
.width
;
3305 dw
+= scroll_class
->scrollbar_spacing
;
3308 if (scroll_window
->hscrollbar_visible
)
3310 dh
+= hscroll_req
.height
;
3311 dh
+= scroll_class
->scrollbar_spacing
;
3315 if (width
) (*width
) = m_width
- dw
;
3316 if (height
) (*height
) = m_height
- dh
;
3320 printf( "GetClientSize, name %s ", GetName().c_str() );
3321 if (width) printf( " width = %d", (*width) );
3322 if (height) printf( " height = %d", (*height) );
3327 void wxWindowGTK::DoGetPosition( int *x
, int *y
) const
3329 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3333 if (m_parent
&& m_parent
->m_wxwindow
)
3335 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
3336 dx
= pizza
->xoffset
;
3337 dy
= pizza
->yoffset
;
3340 if (x
) (*x
) = m_x
- dx
;
3341 if (y
) (*y
) = m_y
- dy
;
3344 void wxWindowGTK::DoClientToScreen( int *x
, int *y
) const
3346 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3348 if (!m_widget
->window
) return;
3350 GdkWindow
*source
= (GdkWindow
*) NULL
;
3352 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3354 source
= m_widget
->window
;
3358 gdk_window_get_origin( source
, &org_x
, &org_y
);
3362 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3364 org_x
+= m_widget
->allocation
.x
;
3365 org_y
+= m_widget
->allocation
.y
;
3373 void wxWindowGTK::DoScreenToClient( int *x
, int *y
) const
3375 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3377 if (!m_widget
->window
) return;
3379 GdkWindow
*source
= (GdkWindow
*) NULL
;
3381 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3383 source
= m_widget
->window
;
3387 gdk_window_get_origin( source
, &org_x
, &org_y
);
3391 if (GTK_WIDGET_NO_WINDOW (m_widget
))
3393 org_x
+= m_widget
->allocation
.x
;
3394 org_y
+= m_widget
->allocation
.y
;
3402 bool wxWindowGTK::Show( bool show
)
3404 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3406 if (!wxWindowBase::Show(show
))
3413 gtk_widget_show( m_widget
);
3415 gtk_widget_hide( m_widget
);
3417 wxShowEvent
eventShow(GetId(), show
);
3418 eventShow
.SetEventObject(this);
3420 GetEventHandler()->ProcessEvent(eventShow
);
3425 static void wxWindowNotifyEnable(wxWindowGTK
* win
, bool enable
)
3427 win
->OnParentEnable(enable
);
3429 // Recurse, so that children have the opportunity to Do The Right Thing
3430 // and reset colours that have been messed up by a parent's (really ancestor's)
3432 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
3434 node
= node
->GetNext() )
3436 wxWindow
*child
= node
->GetData();
3437 if (!child
->IsKindOf(CLASSINFO(wxDialog
)) && !child
->IsKindOf(CLASSINFO(wxFrame
)))
3438 wxWindowNotifyEnable(child
, enable
);
3442 bool wxWindowGTK::Enable( bool enable
)
3444 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3446 if (!wxWindowBase::Enable(enable
))
3452 gtk_widget_set_sensitive( m_widget
, enable
);
3454 gtk_widget_set_sensitive( m_wxwindow
, enable
);
3456 wxWindowNotifyEnable(this, enable
);
3461 int wxWindowGTK::GetCharHeight() const
3463 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
3465 wxFont font
= GetFont();
3466 wxCHECK_MSG( font
.Ok(), 12, wxT("invalid font") );
3469 PangoContext
*context
= NULL
;
3471 context
= gtk_widget_get_pango_context( m_widget
);
3476 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3477 PangoLayout
*layout
= pango_layout_new(context
);
3478 pango_layout_set_font_description(layout
, desc
);
3479 pango_layout_set_text(layout
, "H", 1);
3480 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3482 PangoRectangle rect
;
3483 pango_layout_line_get_extents(line
, NULL
, &rect
);
3485 g_object_unref( G_OBJECT( layout
) );
3487 return (int) PANGO_PIXELS(rect
.height
);
3489 GdkFont
*gfont
= font
.GetInternalFont( 1.0 );
3491 return gfont
->ascent
+ gfont
->descent
;
3495 int wxWindowGTK::GetCharWidth() const
3497 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
3499 wxFont font
= GetFont();
3500 wxCHECK_MSG( font
.Ok(), 8, wxT("invalid font") );
3503 PangoContext
*context
= NULL
;
3505 context
= gtk_widget_get_pango_context( m_widget
);
3510 PangoFontDescription
*desc
= font
.GetNativeFontInfo()->description
;
3511 PangoLayout
*layout
= pango_layout_new(context
);
3512 pango_layout_set_font_description(layout
, desc
);
3513 pango_layout_set_text(layout
, "g", 1);
3514 PangoLayoutLine
*line
= (PangoLayoutLine
*)pango_layout_get_lines(layout
)->data
;
3516 PangoRectangle rect
;
3517 pango_layout_line_get_extents(line
, NULL
, &rect
);
3519 g_object_unref( G_OBJECT( layout
) );
3521 return (int) PANGO_PIXELS(rect
.width
);
3523 GdkFont
*gfont
= font
.GetInternalFont( 1.0 );
3525 return gdk_string_width( gfont
, "g" );
3529 void wxWindowGTK::GetTextExtent( const wxString
& string
,
3533 int *externalLeading
,
3534 const wxFont
*theFont
) const
3536 wxFont fontToUse
= theFont
? *theFont
: GetFont();
3538 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
3540 if (string
.IsEmpty())
3548 PangoContext
*context
= NULL
;
3550 context
= gtk_widget_get_pango_context( m_widget
);
3559 PangoFontDescription
*desc
= fontToUse
.GetNativeFontInfo()->description
;
3560 PangoLayout
*layout
= pango_layout_new(context
);
3561 pango_layout_set_font_description(layout
, desc
);
3564 const wxCharBuffer data
= wxConvUTF8
.cWC2MB( string
);
3565 pango_layout_set_text(layout
, (const char*) data
, strlen( (const char*) data
));
3567 const wxWCharBuffer wdata
= wxConvLocal
.cMB2WC( string
);
3568 const wxCharBuffer data
= wxConvUTF8
.cWC2MB( wdata
);
3569 pango_layout_set_text(layout
, (const char*) data
, strlen( (const char*) data
));
3573 PangoRectangle rect
;
3574 pango_layout_get_extents(layout
, NULL
, &rect
);
3576 if (x
) (*x
) = (wxCoord
) PANGO_PIXELS(rect
.width
);
3577 if (y
) (*y
) = (wxCoord
) PANGO_PIXELS(rect
.height
);
3580 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
3581 int baseline
= pango_layout_iter_get_baseline(iter
);
3582 pango_layout_iter_free(iter
);
3583 *descent
= *y
- PANGO_PIXELS(baseline
);
3585 if (externalLeading
) (*externalLeading
) = 0; // ??
3587 g_object_unref( G_OBJECT( layout
) );
3589 GdkFont
*font
= fontToUse
.GetInternalFont( 1.0 );
3590 if (x
) (*x
) = gdk_string_width( font
, wxGTK_CONV( string
) );
3591 if (y
) (*y
) = font
->ascent
+ font
->descent
;
3592 if (descent
) (*descent
) = font
->descent
;
3593 if (externalLeading
) (*externalLeading
) = 0; // ??
3597 void wxWindowGTK::SetFocus()
3599 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3602 // don't do anything if we already have focus
3608 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow
))
3610 gtk_widget_grab_focus (m_wxwindow
);
3616 if (GTK_IS_CONTAINER(m_widget
))
3618 gtk_widget_child_focus( m_widget
, GTK_DIR_TAB_FORWARD
);
3622 if (GTK_WIDGET_CAN_FOCUS(m_widget
) && !GTK_WIDGET_HAS_FOCUS (m_widget
) )
3625 if (!GTK_WIDGET_REALIZED(m_widget
))
3627 // we can't set the focus to the widget now so we remember that
3628 // it should be focused and will do it later, during the idle
3629 // time, as soon as we can
3630 wxLogTrace(TRACE_FOCUS
,
3631 _T("Delaying setting focus to %s(%s)"),
3632 GetClassInfo()->GetClassName(), GetLabel().c_str());
3634 g_delayedFocus
= this;
3638 wxLogTrace(TRACE_FOCUS
,
3639 _T("Setting focus to %s(%s)"),
3640 GetClassInfo()->GetClassName(), GetLabel().c_str());
3642 gtk_widget_grab_focus (m_widget
);
3647 if (GTK_IS_CONTAINER(m_widget
))
3649 gtk_container_focus( GTK_CONTAINER(m_widget
), GTK_DIR_TAB_FORWARD
);
3654 wxLogTrace(TRACE_FOCUS
,
3655 _T("Can't set focus to %s(%s)"),
3656 GetClassInfo()->GetClassName(), GetLabel().c_str());
3661 bool wxWindowGTK::AcceptsFocus() const
3663 return m_acceptsFocus
&& wxWindowBase::AcceptsFocus();
3666 bool wxWindowGTK::Reparent( wxWindowBase
*newParentBase
)
3668 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3670 wxWindowGTK
*oldParent
= m_parent
,
3671 *newParent
= (wxWindowGTK
*)newParentBase
;
3673 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3675 if ( !wxWindowBase::Reparent(newParent
) )
3678 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3680 /* prevent GTK from deleting the widget arbitrarily */
3681 gtk_widget_ref( m_widget
);
3685 gtk_container_remove( GTK_CONTAINER(m_widget
->parent
), m_widget
);
3688 wxASSERT( GTK_IS_WIDGET(m_widget
) );
3692 /* insert GTK representation */
3693 (*(newParent
->m_insertCallback
))(newParent
, this);
3696 /* reverse: prevent GTK from deleting the widget arbitrarily */
3697 gtk_widget_unref( m_widget
);
3702 void wxWindowGTK::DoAddChild(wxWindowGTK
*child
)
3704 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
3706 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
3708 wxASSERT_MSG( (m_insertCallback
!= NULL
), wxT("invalid child insertion function") );
3713 /* insert GTK representation */
3714 (*m_insertCallback
)(this, child
);
3719 void wxWindowGTK::AddChild(wxWindowBase
*child
)
3721 wxWindowBase::AddChild(child
);
3722 m_dirtyTabOrder
= true;
3724 wxapp_install_idle_handler();
3727 void wxWindowGTK::RemoveChild(wxWindowBase
*child
)
3729 wxWindowBase::RemoveChild(child
);
3730 m_dirtyTabOrder
= true;
3732 wxapp_install_idle_handler();
3735 void wxWindowGTK::DoMoveInTabOrder(wxWindow
*win
, MoveKind move
)
3737 wxWindowBase::DoMoveInTabOrder(win
, move
);
3738 m_dirtyTabOrder
= true;
3740 wxapp_install_idle_handler();
3743 void wxWindowGTK::RealizeTabOrder()
3747 if (m_children
.size() > 0)
3749 GList
*chain
= NULL
;
3751 for (wxWindowList::const_iterator i
= m_children
.begin();
3752 i
!= m_children
.end(); ++i
)
3754 chain
= g_list_prepend(chain
, (*i
)->m_widget
);
3757 chain
= g_list_reverse(chain
);
3759 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow
), chain
);
3764 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow
));
3768 m_dirtyTabOrder
= false;
3771 #endif // __WXGTK20__
3773 void wxWindowGTK::Raise()
3775 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3777 if (m_wxwindow
&& m_wxwindow
->window
)
3779 gdk_window_raise( m_wxwindow
->window
);
3781 else if (m_widget
->window
)
3783 gdk_window_raise( m_widget
->window
);
3787 void wxWindowGTK::Lower()
3789 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3791 if (m_wxwindow
&& m_wxwindow
->window
)
3793 gdk_window_lower( m_wxwindow
->window
);
3795 else if (m_widget
->window
)
3797 gdk_window_lower( m_widget
->window
);
3801 bool wxWindowGTK::SetCursor( const wxCursor
&cursor
)
3803 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
3805 if (cursor
== m_cursor
)
3809 wxapp_install_idle_handler();
3811 if (cursor
== wxNullCursor
)
3812 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR
);
3814 return wxWindowBase::SetCursor( cursor
);
3817 void wxWindowGTK::WarpPointer( int x
, int y
)
3819 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
3821 // We provide this function ourselves as it is
3822 // missing in GDK (top of this file).
3824 GdkWindow
*window
= (GdkWindow
*) NULL
;
3826 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3828 window
= GetConnectWidget()->window
;
3831 gdk_window_warp_pointer( window
, x
, y
);
3835 void wxWindowGTK::Refresh( bool eraseBackground
, const wxRect
*rect
)
3837 if (!m_widget
) return;
3838 if (!m_widget
->window
) return;
3842 wxapp_install_idle_handler();
3844 wxRect
myRect(0,0,0,0);
3845 if (m_wxwindow
&& rect
)
3847 myRect
.SetSize(wxSize( m_wxwindow
->allocation
.width
,
3848 m_wxwindow
->allocation
.height
));
3849 myRect
.Intersect(*rect
);
3850 if (!myRect
.width
|| !myRect
.height
)
3851 // nothing to do, rectangle is empty
3856 if (eraseBackground
&& m_wxwindow
&& m_wxwindow
->window
)
3860 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3861 m_clearRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3865 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3866 m_clearRegion
.Clear();
3867 m_clearRegion
.Union( 0, 0, m_wxwindow
->allocation
.width
, m_wxwindow
->allocation
.height
);
3875 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3876 m_updateRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
3880 GdkRectangle gdk_rect
;
3881 gdk_rect
.x
= rect
->x
;
3882 gdk_rect
.y
= rect
->y
;
3883 gdk_rect
.width
= rect
->width
;
3884 gdk_rect
.height
= rect
->height
;
3885 gtk_widget_draw( m_widget
, &gdk_rect
);
3892 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3893 m_updateRegion
.Clear();
3894 m_updateRegion
.Union( 0, 0, m_wxwindow
->allocation
.width
, m_wxwindow
->allocation
.height
);
3898 gtk_widget_draw( m_widget
, (GdkRectangle
*) NULL
);
3906 GdkRectangle gdk_rect
;
3907 gdk_rect
.x
= rect
->x
;
3908 gdk_rect
.y
= rect
->y
;
3909 gdk_rect
.width
= rect
->width
;
3910 gdk_rect
.height
= rect
->height
;
3911 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, &gdk_rect
, TRUE
);
3915 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow
)->bin_window
, NULL
, TRUE
);
3921 void wxWindowGTK::Update()
3926 void wxWindowGTK::GtkUpdate()
3929 if (m_wxwindow
&& GTK_PIZZA(m_wxwindow
)->bin_window
)
3930 gdk_window_process_updates( GTK_PIZZA(m_wxwindow
)->bin_window
, FALSE
);
3932 if (!m_updateRegion
.IsEmpty())
3933 GtkSendPaintEvents();
3937 void wxWindowGTK::GtkSendPaintEvents()
3942 m_clearRegion
.Clear();
3944 m_updateRegion
.Clear();
3948 // Clip to paint region in wxClientDC
3949 m_clipPaintRegion
= TRUE
;
3951 // widget to draw on
3952 GtkPizza
*pizza
= GTK_PIZZA (m_wxwindow
);
3954 if (GetThemeEnabled() && GetBackgroundStyle() == wxBG_STYLE_SYSTEM
)
3956 // find ancestor from which to steal background
3957 wxWindow
*parent
= GetParent();
3958 while (parent
&& !parent
->IsTopLevel())
3959 parent
= parent
->GetParent();
3961 parent
= (wxWindow
*)this;
3963 if (GTK_WIDGET_MAPPED(parent
->m_widget
))
3965 wxRegionIterator
upd( m_updateRegion
);
3969 rect
.x
= upd
.GetX();
3970 rect
.y
= upd
.GetY();
3971 rect
.width
= upd
.GetWidth();
3972 rect
.height
= upd
.GetHeight();
3974 gtk_paint_flat_box( parent
->m_widget
->style
,
3976 (GtkStateType
)GTK_WIDGET_STATE(m_wxwindow
),
3991 wxWindowDC
dc( (wxWindow
*)this );
3992 dc
.SetClippingRegion( m_updateRegion
);
3994 wxEraseEvent
erase_event( GetId(), &dc
);
3995 erase_event
.SetEventObject( this );
3997 GetEventHandler()->ProcessEvent(erase_event
);
4000 // if (!m_clearRegion.IsEmpty()) // Always send an erase event under GTK 1.2
4002 wxWindowDC
dc( (wxWindow
*)this );
4003 if (m_clearRegion
.IsEmpty())
4004 dc
.SetClippingRegion( m_updateRegion
);
4006 dc
.SetClippingRegion( m_clearRegion
);
4008 wxEraseEvent
erase_event( GetId(), &dc
);
4009 erase_event
.SetEventObject( this );
4011 if (!GetEventHandler()->ProcessEvent(erase_event
) && GetBackgroundStyle() != wxBG_STYLE_CUSTOM
)
4015 g_eraseGC
= gdk_gc_new( pizza
->bin_window
);
4016 gdk_gc_set_fill( g_eraseGC
, GDK_SOLID
);
4018 gdk_gc_set_foreground( g_eraseGC
, GetBackgroundColour().GetColor() );
4020 wxRegionIterator
upd( m_clearRegion
);
4023 gdk_draw_rectangle( pizza
->bin_window
, g_eraseGC
, 1,
4024 upd
.GetX(), upd
.GetY(), upd
.GetWidth(), upd
.GetHeight() );
4028 m_clearRegion
.Clear();
4032 wxNcPaintEvent
nc_paint_event( GetId() );
4033 nc_paint_event
.SetEventObject( this );
4034 GetEventHandler()->ProcessEvent( nc_paint_event
);
4036 wxPaintEvent
paint_event( GetId() );
4037 paint_event
.SetEventObject( this );
4038 GetEventHandler()->ProcessEvent( paint_event
);
4040 m_clipPaintRegion
= FALSE
;
4042 #ifndef __WXUNIVERSAL__
4044 // The following code will result in all window-less widgets
4045 // being redrawn because the wxWidgets class is allowed to
4046 // paint over the window-less widgets.
4048 GList
*children
= pizza
->children
;
4051 GtkPizzaChild
*child
= (GtkPizzaChild
*) children
->data
;
4052 children
= children
->next
;
4054 if (GTK_WIDGET_NO_WINDOW (child
->widget
) &&
4055 GTK_WIDGET_DRAWABLE (child
->widget
))
4057 // Get intersection of widget area and update region
4058 wxRegion
region( m_updateRegion
);
4060 GdkEventExpose gdk_event
;
4061 gdk_event
.type
= GDK_EXPOSE
;
4062 gdk_event
.window
= pizza
->bin_window
;
4063 gdk_event
.count
= 0;
4065 wxRegionIterator
upd( m_updateRegion
);
4069 rect
.x
= upd
.GetX();
4070 rect
.y
= upd
.GetY();
4071 rect
.width
= upd
.GetWidth();
4072 rect
.height
= upd
.GetHeight();
4074 if (gtk_widget_intersect (child
->widget
, &rect
, &gdk_event
.area
))
4076 gtk_widget_event (child
->widget
, (GdkEvent
*) &gdk_event
);
4086 m_updateRegion
.Clear();
4089 void wxWindowGTK::ClearBackground()
4091 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4094 if (m_wxwindow
&& m_wxwindow
->window
)
4096 m_clearRegion
.Clear();
4097 wxSize
size( GetClientSize() );
4098 m_clearRegion
.Union( 0,0,size
.x
,size
.y
);
4100 // Better do this in idle?
4107 void wxWindowGTK::DoSetToolTip( wxToolTip
*tip
)
4109 wxWindowBase::DoSetToolTip(tip
);
4112 m_tooltip
->Apply( (wxWindow
*)this );
4115 void wxWindowGTK::ApplyToolTip( GtkTooltips
*tips
, const wxChar
*tip
)
4117 wxString
tmp( tip
);
4118 gtk_tooltips_set_tip( tips
, GetConnectWidget(), wxGTK_CONV(tmp
), (gchar
*) NULL
);
4120 #endif // wxUSE_TOOLTIPS
4122 bool wxWindowGTK::SetBackgroundColour( const wxColour
&colour
)
4124 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
4126 if (!wxWindowBase::SetBackgroundColour(colour
))
4131 // We need the pixel value e.g. for background clearing.
4132 m_backgroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
4135 // apply style change (forceStyle=true so that new style is applied
4136 // even if the bg colour changed from valid to wxNullColour)
4137 if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM
)
4138 ApplyWidgetStyle(true);
4143 bool wxWindowGTK::SetForegroundColour( const wxColour
&colour
)
4145 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
4147 if (!wxWindowBase::SetForegroundColour(colour
))
4154 // We need the pixel value e.g. for background clearing.
4155 m_foregroundColour
.CalcPixel(gtk_widget_get_colormap(m_widget
));
4158 // apply style change (forceStyle=true so that new style is applied
4159 // even if the bg colour changed from valid to wxNullColour):
4160 ApplyWidgetStyle(true);
4166 PangoContext
*wxWindowGTK::GtkGetPangoDefaultContext()
4168 return gtk_widget_get_pango_context( m_widget
);
4171 PangoContext
*wxWindowGTK::GtkGetPangoX11Context()
4174 m_x11Context
= pango_x_get_context( gdk_display
);
4176 return m_x11Context
;
4180 GtkRcStyle
*wxWindowGTK::CreateWidgetStyle(bool forceStyle
)
4182 // do we need to apply any changes at all?
4185 !m_foregroundColour
.Ok() && !m_backgroundColour
.Ok() )
4190 GtkRcStyle
*style
= gtk_rc_style_new();
4196 pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
4198 wxString xfontname
= m_font
.GetNativeFontInfo()->GetXFontName();
4199 style
->fontset_name
= g_strdup(xfontname
.c_str());
4203 if ( m_foregroundColour
.Ok() )
4205 GdkColor
*fg
= m_foregroundColour
.GetColor();
4207 style
->fg
[GTK_STATE_NORMAL
] = *fg
;
4208 style
->color_flags
[GTK_STATE_NORMAL
] = GTK_RC_FG
;
4210 style
->fg
[GTK_STATE_PRELIGHT
] = *fg
;
4211 style
->color_flags
[GTK_STATE_PRELIGHT
] = GTK_RC_FG
;
4213 style
->fg
[GTK_STATE_ACTIVE
] = *fg
;
4214 style
->color_flags
[GTK_STATE_ACTIVE
] = GTK_RC_FG
;
4217 if ( m_backgroundColour
.Ok() )
4219 GdkColor
*bg
= m_backgroundColour
.GetColor();
4221 style
->bg
[GTK_STATE_NORMAL
] = *bg
;
4222 style
->base
[GTK_STATE_NORMAL
] = *bg
;
4223 style
->color_flags
[GTK_STATE_NORMAL
] = (GtkRcFlags
)
4224 (style
->color_flags
[GTK_STATE_NORMAL
] | GTK_RC_BG
| GTK_RC_BASE
);
4226 style
->bg
[GTK_STATE_PRELIGHT
] = *bg
;
4227 style
->base
[GTK_STATE_PRELIGHT
] = *bg
;
4228 style
->color_flags
[GTK_STATE_PRELIGHT
] = (GtkRcFlags
)
4229 (style
->color_flags
[GTK_STATE_PRELIGHT
] | GTK_RC_BG
| GTK_RC_BASE
);
4231 style
->bg
[GTK_STATE_ACTIVE
] = *bg
;
4232 style
->base
[GTK_STATE_ACTIVE
] = *bg
;
4233 style
->color_flags
[GTK_STATE_ACTIVE
] = (GtkRcFlags
)
4234 (style
->color_flags
[GTK_STATE_ACTIVE
] | GTK_RC_BG
| GTK_RC_BASE
);
4236 style
->bg
[GTK_STATE_INSENSITIVE
] = *bg
;
4237 style
->base
[GTK_STATE_INSENSITIVE
] = *bg
;
4238 style
->color_flags
[GTK_STATE_INSENSITIVE
] = (GtkRcFlags
)
4239 (style
->color_flags
[GTK_STATE_INSENSITIVE
] | GTK_RC_BG
| GTK_RC_BASE
);
4245 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle
)
4247 GtkRcStyle
*style
= CreateWidgetStyle(forceStyle
);
4250 DoApplyWidgetStyle(style
);
4251 gtk_rc_style_unref(style
);
4254 // Style change may affect GTK+'s size calculation:
4255 InvalidateBestSize();
4258 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle
*style
)
4261 gtk_widget_modify_style(m_wxwindow
, style
);
4262 gtk_widget_modify_style(m_widget
, style
);
4265 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style
)
4267 wxWindowBase::SetBackgroundStyle(style
);
4269 if (style
== wxBG_STYLE_CUSTOM
)
4271 GdkWindow
*window
= (GdkWindow
*) NULL
;
4273 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4275 window
= GetConnectWidget()->window
;
4279 // Make sure GDK/X11 doesn't refresh the window
4281 gdk_window_set_back_pixmap( window
, None
, False
);
4283 Display
* display
= GDK_WINDOW_DISPLAY(window
);
4286 m_needsStyleChange
= false;
4289 // Do in OnIdle, because the window is not yet available
4290 m_needsStyleChange
= true;
4292 // Don't apply widget style, or we get a grey background
4296 // apply style change (forceStyle=true so that new style is applied
4297 // even if the bg colour changed from valid to wxNullColour):
4298 ApplyWidgetStyle(true);
4303 //-----------------------------------------------------------------------------
4304 // Pop-up menu stuff
4305 //-----------------------------------------------------------------------------
4307 #if wxUSE_MENUS_NATIVE
4310 void gtk_pop_hide_callback( GtkWidget
*WXUNUSED(widget
), bool* is_waiting
)
4312 *is_waiting
= FALSE
;
4315 void SetInvokingWindow( wxMenu
*menu
, wxWindow
* win
)
4317 menu
->SetInvokingWindow( win
);
4319 wxMenuItemList::compatibility_iterator node
= menu
->GetMenuItems().GetFirst();
4322 wxMenuItem
*menuitem
= node
->GetData();
4323 if (menuitem
->IsSubMenu())
4325 SetInvokingWindow( menuitem
->GetSubMenu(), win
);
4328 node
= node
->GetNext();
4332 extern "C" void wxPopupMenuPositionCallback( GtkMenu
*menu
,
4335 gboolean
* WXUNUSED(whatever
),
4337 gpointer user_data
)
4339 // ensure that the menu appears entirely on screen
4341 gtk_widget_get_child_requisition(GTK_WIDGET(menu
), &req
);
4343 wxSize sizeScreen
= wxGetDisplaySize();
4344 wxPoint
*pos
= (wxPoint
*)user_data
;
4346 gint xmax
= sizeScreen
.x
- req
.width
,
4347 ymax
= sizeScreen
.y
- req
.height
;
4349 *x
= pos
->x
< xmax
? pos
->x
: xmax
;
4350 *y
= pos
->y
< ymax
? pos
->y
: ymax
;
4353 bool wxWindowGTK::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
4355 wxCHECK_MSG( m_widget
!= NULL
, false, wxT("invalid window") );
4357 wxCHECK_MSG( menu
!= NULL
, false, wxT("invalid popup-menu") );
4359 // NOTE: if you change this code, you need to update
4360 // the same code in taskbar.cpp as well. This
4361 // is ugly code duplication, I know,
4363 SetInvokingWindow( menu
, this );
4367 bool is_waiting
= true;
4369 gulong handler
= gtk_signal_connect( GTK_OBJECT(menu
->m_menu
),
4371 GTK_SIGNAL_FUNC(gtk_pop_hide_callback
),
4372 (gpointer
)&is_waiting
);
4376 GtkMenuPositionFunc posfunc
;
4377 if ( x
== -1 && y
== -1 )
4379 // use GTK's default positioning algorithm
4385 pos
= ClientToScreen(wxPoint(x
, y
));
4387 posfunc
= wxPopupMenuPositionCallback
;
4391 GTK_MENU(menu
->m_menu
),
4392 (GtkWidget
*) NULL
, // parent menu shell
4393 (GtkWidget
*) NULL
, // parent menu item
4394 posfunc
, // function to position it
4395 userdata
, // client data
4396 0, // button used to activate it
4398 gtk_get_current_event_time()
4400 gs_timeLastClick
// the time of activation
4406 gtk_main_iteration();
4409 gtk_signal_disconnect(GTK_OBJECT(menu
->m_menu
), handler
);
4414 #endif // wxUSE_MENUS_NATIVE
4416 #if wxUSE_DRAG_AND_DROP
4418 void wxWindowGTK::SetDropTarget( wxDropTarget
*dropTarget
)
4420 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4422 GtkWidget
*dnd_widget
= GetConnectWidget();
4424 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
4426 if (m_dropTarget
) delete m_dropTarget
;
4427 m_dropTarget
= dropTarget
;
4429 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
4432 #endif // wxUSE_DRAG_AND_DROP
4434 GtkWidget
* wxWindowGTK::GetConnectWidget()
4436 GtkWidget
*connect_widget
= m_widget
;
4437 if (m_wxwindow
) connect_widget
= m_wxwindow
;
4439 return connect_widget
;
4442 bool wxWindowGTK::IsOwnGtkWindow( GdkWindow
*window
)
4445 return (window
== GTK_PIZZA(m_wxwindow
)->bin_window
);
4447 return (window
== m_widget
->window
);
4450 bool wxWindowGTK::SetFont( const wxFont
&font
)
4452 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
4454 if (!wxWindowBase::SetFont(font
))
4457 // apply style change (forceStyle=true so that new style is applied
4458 // even if the font changed from valid to wxNullFont):
4459 ApplyWidgetStyle(true);
4464 void wxWindowGTK::DoCaptureMouse()
4466 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4468 GdkWindow
*window
= (GdkWindow
*) NULL
;
4470 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4472 window
= GetConnectWidget()->window
;
4474 wxCHECK_RET( window
, _T("CaptureMouse() failed") );
4476 wxCursor
* cursor
= & m_cursor
;
4478 cursor
= wxSTANDARD_CURSOR
;
4480 gdk_pointer_grab( window
, FALSE
,
4482 (GDK_BUTTON_PRESS_MASK
|
4483 GDK_BUTTON_RELEASE_MASK
|
4484 GDK_POINTER_MOTION_HINT_MASK
|
4485 GDK_POINTER_MOTION_MASK
),
4487 cursor
->GetCursor(),
4488 (guint32
)GDK_CURRENT_TIME
);
4489 g_captureWindow
= this;
4490 g_captureWindowHasMouse
= TRUE
;
4493 void wxWindowGTK::DoReleaseMouse()
4495 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4497 wxCHECK_RET( g_captureWindow
, wxT("can't release mouse - not captured") );
4499 g_captureWindow
= (wxWindowGTK
*) NULL
;
4501 GdkWindow
*window
= (GdkWindow
*) NULL
;
4503 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
4505 window
= GetConnectWidget()->window
;
4510 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
4514 wxWindow
*wxWindowBase::GetCapture()
4516 return (wxWindow
*)g_captureWindow
;
4519 bool wxWindowGTK::IsRetained() const
4524 void wxWindowGTK::SetScrollbar( int orient
, int pos
, int thumbVisible
,
4525 int range
, bool refresh
)
4527 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4529 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4531 m_hasScrolling
= TRUE
;
4533 if (orient
== wxHORIZONTAL
)
4535 float fpos
= (float)pos
;
4536 float frange
= (float)range
;
4537 float fthumb
= (float)thumbVisible
;
4538 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
4539 if (fpos
< 0.0) fpos
= 0.0;
4541 if ((fabs(frange
-m_hAdjust
->upper
) < 0.2) &&
4542 (fabs(fthumb
-m_hAdjust
->page_size
) < 0.2))
4544 SetScrollPos( orient
, pos
, refresh
);
4548 m_oldHorizontalPos
= fpos
;
4550 m_hAdjust
->lower
= 0.0;
4551 m_hAdjust
->upper
= frange
;
4552 m_hAdjust
->value
= fpos
;
4553 m_hAdjust
->step_increment
= 1.0;
4554 m_hAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
4555 m_hAdjust
->page_size
= fthumb
;
4559 float fpos
= (float)pos
;
4560 float frange
= (float)range
;
4561 float fthumb
= (float)thumbVisible
;
4562 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
4563 if (fpos
< 0.0) fpos
= 0.0;
4565 if ((fabs(frange
-m_vAdjust
->upper
) < 0.2) &&
4566 (fabs(fthumb
-m_vAdjust
->page_size
) < 0.2))
4568 SetScrollPos( orient
, pos
, refresh
);
4572 m_oldVerticalPos
= fpos
;
4574 m_vAdjust
->lower
= 0.0;
4575 m_vAdjust
->upper
= frange
;
4576 m_vAdjust
->value
= fpos
;
4577 m_vAdjust
->step_increment
= 1.0;
4578 m_vAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
4579 m_vAdjust
->page_size
= fthumb
;
4582 if (orient
== wxHORIZONTAL
)
4583 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
4585 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
4588 void wxWindowGTK::SetScrollPos( int orient
, int pos
, bool WXUNUSED(refresh
) )
4590 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4592 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4594 if (orient
== wxHORIZONTAL
)
4596 float fpos
= (float)pos
;
4597 if (fpos
> m_hAdjust
->upper
- m_hAdjust
->page_size
) fpos
= m_hAdjust
->upper
- m_hAdjust
->page_size
;
4598 if (fpos
< 0.0) fpos
= 0.0;
4599 m_oldHorizontalPos
= fpos
;
4601 if (fabs(fpos
-m_hAdjust
->value
) < 0.2) return;
4602 m_hAdjust
->value
= fpos
;
4606 float fpos
= (float)pos
;
4607 if (fpos
> m_vAdjust
->upper
- m_vAdjust
->page_size
) fpos
= m_vAdjust
->upper
- m_vAdjust
->page_size
;
4608 if (fpos
< 0.0) fpos
= 0.0;
4609 m_oldVerticalPos
= fpos
;
4611 if (fabs(fpos
-m_vAdjust
->value
) < 0.2) return;
4612 m_vAdjust
->value
= fpos
;
4615 if (m_wxwindow
->window
)
4617 if (orient
== wxHORIZONTAL
)
4619 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust
),
4620 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
4622 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "value_changed" );
4624 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
4625 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
4629 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust
),
4630 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
4632 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "value_changed" );
4634 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
4635 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
4640 int wxWindowGTK::GetScrollThumb( int orient
) const
4642 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4644 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4646 if (orient
== wxHORIZONTAL
)
4647 return (int)(m_hAdjust
->page_size
+0.5);
4649 return (int)(m_vAdjust
->page_size
+0.5);
4652 int wxWindowGTK::GetScrollPos( int orient
) const
4654 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4656 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4658 if (orient
== wxHORIZONTAL
)
4659 return (int)(m_hAdjust
->value
+0.5);
4661 return (int)(m_vAdjust
->value
+0.5);
4664 int wxWindowGTK::GetScrollRange( int orient
) const
4666 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
4668 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
4670 if (orient
== wxHORIZONTAL
)
4671 return (int)(m_hAdjust
->upper
+0.5);
4673 return (int)(m_vAdjust
->upper
+0.5);
4676 void wxWindowGTK::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
4678 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
4680 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
4682 // No scrolling requested.
4683 if ((dx
== 0) && (dy
== 0)) return;
4686 if (!m_updateRegion
.IsEmpty())
4688 m_updateRegion
.Offset( dx
, dy
);
4692 GetClientSize( &cw
, &ch
);
4693 m_updateRegion
.Intersect( 0, 0, cw
, ch
);
4696 if (!m_clearRegion
.IsEmpty())
4698 m_clearRegion
.Offset( dx
, dy
);
4702 GetClientSize( &cw
, &ch
);
4703 m_clearRegion
.Intersect( 0, 0, cw
, ch
);
4707 m_clipPaintRegion
= TRUE
;
4709 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), -dx
, -dy
);
4711 m_clipPaintRegion
= FALSE
;
4715 // Find the wxWindow at the current mouse position, also returning the mouse
4717 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
4719 pt
= wxGetMousePosition();
4720 wxWindow
* found
= wxFindWindowAtPoint(pt
);
4724 // Get the current mouse position.
4725 wxPoint
wxGetMousePosition()
4727 /* This crashes when used within wxHelpContext,
4728 so we have to use the X-specific implementation below.
4730 GdkModifierType *mask;
4731 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4733 return wxPoint(x, y);
4737 GdkWindow
* windowAtPtr
= gdk_window_at_pointer(& x
, & y
);
4739 Display
*display
= windowAtPtr
? GDK_WINDOW_XDISPLAY(windowAtPtr
) : GDK_DISPLAY();
4740 Window rootWindow
= RootWindowOfScreen (DefaultScreenOfDisplay(display
));
4741 Window rootReturn
, childReturn
;
4742 int rootX
, rootY
, winX
, winY
;
4743 unsigned int maskReturn
;
4745 XQueryPointer (display
,
4749 &rootX
, &rootY
, &winX
, &winY
, &maskReturn
);
4750 return wxPoint(rootX
, rootY
);
4754 // ----------------------------------------------------------------------------
4756 // ----------------------------------------------------------------------------
4758 class wxWinModule
: public wxModule
4765 DECLARE_DYNAMIC_CLASS(wxWinModule
)
4768 IMPLEMENT_DYNAMIC_CLASS(wxWinModule
, wxModule
)
4770 bool wxWinModule::OnInit()
4772 // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
4773 // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
4778 void wxWinModule::OnExit()
4781 gdk_gc_unref( g_eraseGC
);