X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/6256849fdf400639670877f1ea628be706029251..70544c1e6c2c52722a8215ed12724a75a284be08:/src/gtk/window.cpp diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp index 7b24565135..82a20f8a58 100644 --- a/src/gtk/window.cpp +++ b/src/gtk/window.cpp @@ -1,6 +1,6 @@ ///////////////////////////////////////////////////////////////////////////// // Name: src/gtk/window.cpp -// Purpose: +// Purpose: wxWindowGTK implementation // Author: Robert Roebling // Id: $Id$ // Copyright: (c) 1998 Robert Roebling, Julian Smart @@ -19,16 +19,11 @@ #ifndef WX_PRECOMP #include "wx/log.h" #include "wx/app.h" - #include "wx/frame.h" + #include "wx/toplevel.h" #include "wx/dcclient.h" #include "wx/menu.h" #include "wx/settings.h" #include "wx/msgdlg.h" - #include "wx/textctrl.h" - #include "wx/radiobut.h" - #include "wx/toolbar.h" - #include "wx/combobox.h" - #include "wx/layout.h" #include "wx/math.h" #endif @@ -36,26 +31,43 @@ #include "wx/tooltip.h" #include "wx/caret.h" #include "wx/fontutil.h" - -#ifdef __WXDEBUG__ - #include "wx/thread.h" -#endif +#include "wx/sysopt.h" #include -// FIXME: Due to a hack we use GtkCombo in here, which is deprecated since gtk2.3.0 -#include -#if defined(GTK_DISABLE_DEPRECATED) && GTK_CHECK_VERSION(2,3,0) - #undef GTK_DISABLE_DEPRECATED - #include - #define GTK_DISABLE_DEPRECATED -#endif - #include "wx/gtk/private.h" -#include "wx/gtk/win_gtk.h" -#include +#include "wx/gtk/private/win_gtk.h" + #include +#include +#if GTK_CHECK_VERSION(3,0,0) +#include +#endif + +#if !GTK_CHECK_VERSION(2,10,0) + // GTK+ can reliably detect Meta key state only since 2.10 when + // GDK_META_MASK was introduced -- there wasn't any way to detect it + // in older versions. wxGTK used GDK_MOD2_MASK for this purpose, but + // GDK_MOD2_MASK is documented as: + // + // the fifth modifier key (it depends on the modifier mapping of the X + // server which key is interpreted as this modifier) + // + // In other words, it isn't guaranteed to map to Meta. This is a real + // problem: it is common to map NumLock to it (in fact, it's an exception + // if the X server _doesn't_ use it for NumLock). So the old code caused + // wxKeyEvent::MetaDown() to always return true as long as NumLock was on + // on many systems, which broke all applications using + // wxKeyEvent::GetModifiers() to check modifiers state (see e.g. here: + // http://tinyurl.com/56lsk2). + // + // Because of this, it's better to not detect Meta key state at all than + // to detect it incorrectly. Hence the following #define, which causes + // m_metaDown to be always set to false. + #define GDK_META_MASK 0 +#endif + //----------------------------------------------------------------------------- // documentation on internals //----------------------------------------------------------------------------- @@ -116,19 +128,19 @@ can find in m_widget (defined in wxWindow) When the class has a client area for drawing into and for containing children - it has to handle the client area widget (of the type GtkPizza, defined in - win_gtk.c), but there could be any number of widgets, handled by a class + it has to handle the client area widget (of the type wxPizza, defined in + win_gtk.cpp), but there could be any number of widgets, handled by a class. The common rule for all windows is only, that the widget that interacts with the rest of GTK must be referenced in m_widget and all other widgets must be children of this widget on the GTK level. The top-most widget, which also represents the client area, must be in the m_wxwindow field and must be of - the type GtkPizza. + the type wxPizza. As I said, the window classes that display a GTK native widget only have one widget, so in the case of e.g. the wxButton class m_widget holds a pointer to a GtkButton widget. But windows with client areas (for drawing and children) have a m_widget field that is a pointer to a GtkScrolled- - Window and a m_wxwindow field that is pointer to a GtkPizza and this + Window and a m_wxwindow field that is pointer to a wxPizza and this one is (in the GTK sense) a child of the GtkScrolledWindow. If the m_wxwindow field is set, then all input to this widget is inter- @@ -142,10 +154,10 @@ clicking on a scrollbar belonging to scrolled window will inevitably move the window. In wxWidgets, the scrollbar will only emit an event, send this to (normally) a wxScrolledWindow and that class will call ScrollWindow() - which actually moves the window and its sub-windows. Note that GtkPizza + which actually moves the window and its sub-windows. Note that wxPizza memorizes how much it has been scrolled but that wxWidgets forgets this so that the two coordinates systems have to be kept in synch. This is done - in various places using the pizza->xoffset and pizza->yoffset values. + in various places using the pizza->m_scroll_x and pizza->m_scroll_y values. III) @@ -176,14 +188,12 @@ Cursors, too, have been a constant source of pleasure. The main difficulty is that a GdkWindow inherits a cursor if the programmer sets a new cursor - for the parent. To prevent this from doing too much harm, I use idle time - to set the cursor over and over again, starting from the toplevel windows - and ending with the youngest generation (speaking of parent and child windows). + for the parent. To prevent this from doing too much harm, SetCursor calls + GTKUpdateCursor, which will recursively re-set the cursors of all child windows. Also don't forget that cursors (like much else) are connected to GdkWindows, not GtkWidgets and that the "window" field of a GtkWidget might very well point to the GdkWindow of the parent widget (-> "window-less widget") and that the two obviously have very different meanings. - */ //----------------------------------------------------------------------------- @@ -198,44 +208,30 @@ extern wxCursor g_globalCursor; // mouse capture state: the window which has it and if the mouse is currently // inside it -static wxWindowGTK *g_captureWindow = (wxWindowGTK*) NULL; +static wxWindowGTK *g_captureWindow = NULL; static bool g_captureWindowHasMouse = false; -wxWindowGTK *g_focusWindow = (wxWindowGTK*) NULL; - -// the last window which had the focus - this is normally never NULL (except -// if we never had focus at all) as even when g_focusWindow is NULL it still -// keeps its previous value -wxWindowGTK *g_focusWindowLast = (wxWindowGTK*) NULL; +// The window that currently has focus: +static wxWindowGTK *gs_currentFocus = NULL; +// The window that is scheduled to get focus in the next event loop iteration +// or NULL if there's no pending focus change: +static wxWindowGTK *gs_pendingFocus = NULL; -// If a window get the focus set but has not been realized -// yet, defer setting the focus to idle time. -wxWindowGTK *g_delayedFocus = (wxWindowGTK*) NULL; +// the window that has deferred focus-out event pending, if any (see +// GTKAddDeferredFocusOut() for details) +static wxWindowGTK *gs_deferredFocusOut = NULL; // global variables because GTK+ DnD want to have the // mouse event that caused it -GdkEvent *g_lastMouseEvent = (GdkEvent*) NULL; +GdkEvent *g_lastMouseEvent = NULL; int g_lastButtonNumber = 0; -extern bool g_mainThreadLocked; - //----------------------------------------------------------------------------- // debug //----------------------------------------------------------------------------- -#ifdef __WXDEBUG__ - -#if wxUSE_THREADS -# define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance"); -#else -# define DEBUG_MAIN_THREAD -#endif -#else -#define DEBUG_MAIN_THREAD -#endif // Debug - // the trace mask used for the focus debugging messages -#define TRACE_FOCUS _T("focus") +#define TRACE_FOCUS wxT("focus") //----------------------------------------------------------------------------- // missing gdk functions @@ -259,158 +255,16 @@ gdk_window_warp_pointer (GdkWindow *window, } } -//----------------------------------------------------------------------------- -// local code (see below) -//----------------------------------------------------------------------------- - -// returns the child of win which currently has focus or NULL if not found -// -// Note: can't be static, needed by textctrl.cpp. -wxWindow *wxFindFocusedChild(wxWindowGTK *win) -{ - wxWindow *winFocus = wxWindowGTK::FindFocus(); - if ( !winFocus ) - return (wxWindow *)NULL; - - if ( winFocus == win ) - return (wxWindow *)win; - - for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst(); - node; - node = node->GetNext() ) - { - wxWindow *child = wxFindFocusedChild(node->GetData()); - if ( child ) - return child; - } - - return (wxWindow *)NULL; -} - -static void GetScrollbarWidth(GtkWidget* widget, int& w, int& h) -{ - GtkScrolledWindow* scroll_window = GTK_SCROLLED_WINDOW(widget); - GtkScrolledWindowClass* scroll_class = GTK_SCROLLED_WINDOW_CLASS(GTK_OBJECT_GET_CLASS(scroll_window)); - GtkRequisition scroll_req; - - w = 0; - if (scroll_window->vscrollbar_visible) - { - scroll_req.width = 2; - scroll_req.height = 2; - (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request ) - (scroll_window->vscrollbar, &scroll_req ); - w = scroll_req.width + - scroll_class->scrollbar_spacing; - } - - h = 0; - if (scroll_window->hscrollbar_visible) - { - scroll_req.width = 2; - scroll_req.height = 2; - (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request ) - (scroll_window->hscrollbar, &scroll_req ); - h = scroll_req.height + - scroll_class->scrollbar_spacing; - } -} - -static void draw_frame( GtkWidget *widget, wxWindowGTK *win ) -{ - // wxUniversal widgets draw the borders and scrollbars themselves -#ifndef __WXUNIVERSAL__ - if (!win->m_hasVMT) - return; - - int dx = 0; - int dy = 0; - if (GTK_WIDGET_NO_WINDOW (widget)) - { - dx += widget->allocation.x; - dy += widget->allocation.y; - } - - int x = dx; - int y = dy; - - int dw = 0; - int dh = 0; - if (win->m_hasScrolling) - { - GetScrollbarWidth(widget, dw, dh); - - if (win->GetLayoutDirection() == wxLayout_RightToLeft) - { - // This is actually wrong for old GTK+ version - // which do not display the scrollbar on the - // left side in RTL - x += dw; - } - } - - int w = widget->allocation.width-dw; - int h = widget->allocation.height-dh; - - if (win->HasFlag(wxRAISED_BORDER)) - { - gtk_paint_shadow (widget->style, - widget->window, - GTK_STATE_NORMAL, - GTK_SHADOW_OUT, - NULL, NULL, NULL, // FIXME: No clipping? - x, y, w, h ); - return; - } - - if (win->HasFlag(wxSUNKEN_BORDER)) - { - gtk_paint_shadow (widget->style, - widget->window, - GTK_STATE_NORMAL, - GTK_SHADOW_IN, - NULL, NULL, NULL, // FIXME: No clipping? - x, y, w, h ); - return; - } - - if (win->HasFlag(wxSIMPLE_BORDER)) - { - GdkGC *gc; - gc = gdk_gc_new( widget->window ); - gdk_gc_set_foreground( gc, &widget->style->black ); - gdk_draw_rectangle( widget->window, gc, FALSE, x, y, w-1, h-1 ); - g_object_unref (gc); - return; - } -#endif // __WXUNIVERSAL__ -} - -//----------------------------------------------------------------------------- -// "expose_event" of m_widget -//----------------------------------------------------------------------------- - -extern "C" { -static gboolean -gtk_window_own_expose_callback( GtkWidget *widget, - GdkEventExpose *gdk_event, - wxWindowGTK *win ) -{ - if (gdk_event->count == 0) - draw_frame(widget, win); - return false; -} -} //----------------------------------------------------------------------------- // "size_request" of m_widget //----------------------------------------------------------------------------- -// make it extern because wxStaticText needs to disconnect this one extern "C" { -void wxgtk_window_size_request_callback(GtkWidget *widget, - GtkRequisition *requisition, - wxWindow *win) +static void +wxgtk_window_size_request_callback(GtkWidget * WXUNUSED(widget), + GtkRequisition *requisition, + wxWindow * win) { int w, h; win->GetSize( &w, &h ); @@ -424,99 +278,104 @@ void wxgtk_window_size_request_callback(GtkWidget *widget, } } +//----------------------------------------------------------------------------- +// "expose_event" of m_wxwindow +//----------------------------------------------------------------------------- + extern "C" { -static -void wxgtk_combo_size_request_callback(GtkWidget *widget, - GtkRequisition *requisition, - wxComboBox *win) +static gboolean +gtk_window_expose_callback( GtkWidget*, + GdkEventExpose *gdk_event, + wxWindow *win ) { - // This callback is actually hooked into the text entry - // of the combo box, not the GtkHBox. - - int w, h; - win->GetSize( &w, &h ); - if (w < 2) - w = 2; - if (h < 2) - h = 2; - - GtkCombo *gcombo = GTK_COMBO(win->m_widget); - - GtkRequisition entry_req; - entry_req.width = 2; - entry_req.height = 2; - (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo->entry) )->size_request ) - (gcombo->entry, &entry_req ); - - GtkRequisition button_req; - button_req.width = 2; - button_req.height = 2; - (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo->button) )->size_request ) - (gcombo->button, &button_req ); - - requisition->width = w - button_req.width; - requisition->height = entry_req.height; + if (gdk_event->window == win->GTKGetDrawingWindow()) + { + win->GetUpdateRegion() = wxRegion( gdk_event->region ); + win->GtkSendPaintEvents(); + } + // Let parent window draw window-less widgets + return FALSE; } } +#ifndef __WXUNIVERSAL__ //----------------------------------------------------------------------------- -// "expose_event" of m_wxwindow +// "expose_event" from m_wxwindow->parent, for drawing border //----------------------------------------------------------------------------- extern "C" { static gboolean -gtk_window_expose_callback( GtkWidget *widget, - GdkEventExpose *gdk_event, - wxWindow *win ) +expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win) { - DEBUG_MAIN_THREAD + if (gdk_event->window != gtk_widget_get_parent_window(win->m_wxwindow)) + return false; - // This callback gets called in drawing-idle time under - // GTK 2.0, so we don't need to defer anything to idle - // time anymore. + if (!win->IsShown()) + return false; - GtkPizza *pizza = GTK_PIZZA( widget ); - if (gdk_event->window != pizza->bin_window) - { - // block expose events on GTK_WIDGET(pizza)->window, - // all drawing is done on pizza->bin_window - return true; - } + GtkAllocation alloc; + gtk_widget_get_allocation(win->m_wxwindow, &alloc); + const int x = alloc.x; + const int y = alloc.y; + const int w = alloc.width; + const int h = alloc.height; + if (w <= 0 || h <= 0) + return false; -#if 0 - if (win->GetName()) + if (win->HasFlag(wxBORDER_SIMPLE)) { - wxPrintf( wxT("OnExpose from ") ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - wxPrintf( win->GetClassInfo()->GetClassName() ); - wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event->area.x, - (int)gdk_event->area.y, - (int)gdk_event->area.width, - (int)gdk_event->area.height ); + gdk_draw_rectangle(gdk_event->window, + gtk_widget_get_style(widget)->black_gc, false, x, y, w - 1, h - 1); } + else + { + GtkShadowType shadow = GTK_SHADOW_IN; + if (win->HasFlag(wxBORDER_RAISED)) + shadow = GTK_SHADOW_OUT; - gtk_paint_box - ( - win->m_wxwindow->style, - pizza->bin_window, - GTK_STATE_NORMAL, - GTK_SHADOW_OUT, - (GdkRectangle*) NULL, - win->m_wxwindow, - (char *)"button", // const_cast - 20,20,24,24 - ); -#endif + // Style detail to use + const char* detail; + if (win->m_widget == win->m_wxwindow) + // for non-scrollable wxWindows + detail = "entry"; + else + // for scrollable ones + detail = "viewport"; - win->GetUpdateRegion() = wxRegion( gdk_event->region ); + // clip rect is required to avoid painting background + // over upper left (w,h) of parent window + GdkRectangle clipRect = { x, y, w, h }; + gtk_paint_shadow( + gtk_widget_get_style(win->m_wxwindow), gdk_event->window, GTK_STATE_NORMAL, + shadow, &clipRect, wxGTKPrivate::GetEntryWidget(), detail, x, y, w, h); + } + return false; +} +} - win->GtkSendPaintEvents(); +//----------------------------------------------------------------------------- +// "parent_set" from m_wxwindow +//----------------------------------------------------------------------------- - // Let parent window draw window-less widgets - return FALSE; +extern "C" { +static void +parent_set(GtkWidget* widget, GtkObject* old_parent, wxWindow* win) +{ + if (old_parent) + { + g_signal_handlers_disconnect_by_func( + old_parent, (void*)expose_event_border, win); + } + GtkWidget* parent = gtk_widget_get_parent(widget); + if (parent) + { + g_signal_connect_after(parent, "expose_event", + G_CALLBACK(expose_event_border), win); + } } } +#endif // !__WXUNIVERSAL__ //----------------------------------------------------------------------------- // "key_press_event" from any window @@ -535,7 +394,7 @@ inline bool wxIsUpperChar(int code) // set WXTRACE to this to see the key event codes on the console -#define TRACE_KEYS _T("keyevent") +#define TRACE_KEYS wxT("keyevent") // translates an X key symbol to WXK_XXX value // @@ -686,11 +545,11 @@ static long wxTranslateKeySymToWXKey(KeySym keysym, bool isChar) case GDK_KP_7: case GDK_KP_8: case GDK_KP_9: - key_code = (isChar ? '0' : WXK_NUMPAD0) + keysym - GDK_KP_0; + key_code = (isChar ? '0' : int(WXK_NUMPAD0)) + keysym - GDK_KP_0; break; case GDK_KP_Space: - key_code = isChar ? ' ' : WXK_NUMPAD_SPACE; + key_code = isChar ? ' ' : int(WXK_NUMPAD_SPACE); break; case GDK_KP_Tab: @@ -762,32 +621,32 @@ static long wxTranslateKeySymToWXKey(KeySym keysym, bool isChar) break; case GDK_KP_Equal: - key_code = isChar ? '=' : WXK_NUMPAD_EQUAL; + key_code = isChar ? '=' : int(WXK_NUMPAD_EQUAL); break; case GDK_KP_Multiply: - key_code = isChar ? '*' : WXK_NUMPAD_MULTIPLY; + key_code = isChar ? '*' : int(WXK_NUMPAD_MULTIPLY); break; case GDK_KP_Add: - key_code = isChar ? '+' : WXK_NUMPAD_ADD; + key_code = isChar ? '+' : int(WXK_NUMPAD_ADD); break; case GDK_KP_Separator: // FIXME: what is this? - key_code = isChar ? '.' : WXK_NUMPAD_SEPARATOR; + key_code = isChar ? '.' : int(WXK_NUMPAD_SEPARATOR); break; case GDK_KP_Subtract: - key_code = isChar ? '-' : WXK_NUMPAD_SUBTRACT; + key_code = isChar ? '-' : int(WXK_NUMPAD_SUBTRACT); break; case GDK_KP_Decimal: - key_code = isChar ? '.' : WXK_NUMPAD_DECIMAL; + key_code = isChar ? '.' : int(WXK_NUMPAD_DECIMAL); break; case GDK_KP_Divide: - key_code = isChar ? '/' : WXK_NUMPAD_DIVIDE; + key_code = isChar ? '/' : int(WXK_NUMPAD_DIVIDE); break; @@ -831,16 +690,57 @@ static void wxFillOtherKeyEventFields(wxKeyEvent& event, event.SetTimestamp( gdk_event->time ); event.SetId(win->GetId()); + event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0; event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0; event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0; - event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK) != 0; - event.m_scanCode = gdk_event->keyval; + event.m_metaDown = (gdk_event->state & GDK_META_MASK) != 0; + + // Normally we take the state of modifiers directly from the low level GDK + // event but unfortunately GDK uses a different convention from MSW for the + // key events corresponding to the modifier keys themselves: in it, when + // e.g. Shift key is pressed, GDK_SHIFT_MASK is not set while it is set + // when Shift is released. Under MSW the situation is exactly reversed and + // the modifier corresponding to the key is set when it is pressed and + // unset when it is released. To ensure consistent behaviour between + // platforms (and because it seems to make slightly more sense, although + // arguably both behaviours are reasonable) we follow MSW here. + // + // Final notice: we set the flags to the desired value instead of just + // inverting them because they are not set correctly (i.e. in the same way + // as for the real events generated by the user) for wxUIActionSimulator- + // produced events and it seems better to keep that class code the same + // among all platforms and fix the discrepancy here instead of adding + // wxGTK-specific code to wxUIActionSimulator. + const bool isPress = gdk_event->type == GDK_KEY_PRESS; + switch ( gdk_event->keyval ) + { + case GDK_Shift_L: + case GDK_Shift_R: + event.m_shiftDown = isPress; + break; + + case GDK_Control_L: + case GDK_Control_R: + event.m_controlDown = isPress; + break; + + case GDK_Alt_L: + case GDK_Alt_R: + event.m_altDown = isPress; + break; + + case GDK_Meta_L: + case GDK_Meta_R: + case GDK_Super_L: + case GDK_Super_R: + event.m_metaDown = isPress; + break; + } + event.m_rawCode = (wxUint32) gdk_event->keyval; - event.m_rawFlags = 0; -#if wxUSE_UNICODE - event.m_uniChar = gdk_keyval_to_unicode(gdk_event->keyval); -#endif + event.m_rawFlags = gdk_event->hardware_keycode; + wxGetMousePosition( &x, &y ); win->ScreenToClient( &x, &y ); event.m_x = x; @@ -867,9 +767,9 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event, KeySym keysym = gdk_event->keyval; - wxLogTrace(TRACE_KEYS, _T("Key %s event: keysym = %ld"), - event.GetEventType() == wxEVT_KEY_UP ? _T("release") - : _T("press"), + wxLogTrace(TRACE_KEYS, wxT("Key %s event: keysym = %ld"), + event.GetEventType() == wxEVT_KEY_UP ? wxT("release") + : wxT("press"), keysym); long key_code = wxTranslateKeySymToWXKey(keysym, false /* !isChar */); @@ -898,7 +798,7 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event, Display *dpy = (Display *)wxGetDisplay(); KeyCode keycode = XKeysymToKeycode(dpy, keysym); - wxLogTrace(TRACE_KEYS, _T("\t-> keycode %d"), keycode); + wxLogTrace(TRACE_KEYS, wxT("\t-> keycode %d"), keycode); KeySym keysymNormalized = XKeycodeToKeysym(dpy, keycode, 0); @@ -937,22 +837,27 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event, } } - wxLogTrace(TRACE_KEYS, _T("\t-> wxKeyCode %ld"), key_code); + wxLogTrace(TRACE_KEYS, wxT("\t-> wxKeyCode %ld"), key_code); // sending unknown key events doesn't really make sense if ( !key_code ) return false; - // now fill all the other fields - wxFillOtherKeyEventFields(event, win, gdk_event); - event.m_keyCode = key_code; + #if wxUSE_UNICODE - if ( gdk_event->type == GDK_KEY_PRESS || gdk_event->type == GDK_KEY_RELEASE ) + event.m_uniChar = gdk_keyval_to_unicode(key_code ? key_code : keysym); + if ( !event.m_uniChar && event.m_keyCode <= WXK_DELETE ) { - event.m_uniChar = key_code; + // Set Unicode key code to the ASCII equivalent for compatibility. E.g. + // let RETURN generate the key event with both key and Unicode key + // codes of 13. + event.m_uniChar = event.m_keyCode; } -#endif +#endif // wxUSE_UNICODE + + // now fill all the other fields + wxFillOtherKeyEventFields(event, win, gdk_event); return true; } @@ -974,20 +879,52 @@ struct wxGtkIMData } }; +namespace +{ + +// Send wxEVT_CHAR_HOOK event to the parent of the window and if it wasn't +// processed, send wxEVT_CHAR to the window itself. Return true if either of +// them was handled. +bool +SendCharHookAndCharEvents(const wxKeyEvent& event, wxWindow *win) +{ + // wxEVT_CHAR_HOOK must be sent to the top level parent window to allow it + // to handle key events in all of its children unless the mouse is captured + // in which case we consider that the keyboard should be "captured" too. + if ( !g_captureWindow ) + { + wxWindow * const parent = wxGetTopLevelParent(win); + if ( parent ) + { + // We need to make a copy of the event object because it is + // modified while it's handled, notably its WasProcessed() flag + // is set after it had been processed once. + wxKeyEvent eventCharHook(event); + eventCharHook.SetEventType(wxEVT_CHAR_HOOK); + if ( parent->HandleWindowEvent(eventCharHook) ) + return true; + } + } + + // As above, make a copy of the event first. + wxKeyEvent eventChar(event); + eventChar.SetEventType(wxEVT_CHAR); + return win->HandleWindowEvent(eventChar); +} + +} // anonymous namespace + extern "C" { static gboolean -gtk_window_key_press_callback( GtkWidget *widget, +gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget), GdkEventKey *gdk_event, wxWindow *win ) { - DEBUG_MAIN_THREAD - if (!win->m_hasVMT) return FALSE; if (g_blockEventsOnDrag) return FALSE; - wxKeyEvent event( wxEVT_KEY_DOWN ); bool ret = false; bool return_after_IM = false; @@ -995,7 +932,7 @@ gtk_window_key_press_callback( GtkWidget *widget, if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) ) { // Emit KEY_DOWN event - ret = win->GetEventHandler()->ProcessEvent( event ); + ret = win->HandleWindowEvent( event ); } else { @@ -1004,19 +941,10 @@ gtk_window_key_press_callback( GtkWidget *widget, return_after_IM = true; } - // 2005.01.26 modified by Hong Jen Yee (hzysoft@sina.com.tw): - // When we get a key_press event here, it could be originate - // from the current widget or its child widgets. However, only the widget - // with the INPUT FOCUS can generate the INITIAL key_press event. That is, - // if the CURRENT widget doesn't have the FOCUS at all, this event definitely - // originated from its child widgets and shouldn't be passed to IM context. - // In fact, what a GTK+ IM should do is filtering keyEvents and convert them - // into text input ONLY WHEN THE WIDGET HAS INPUT FOCUS. Besides, when current - // widgets has both IM context and input focus, the event should be filtered - // by gtk_im_context_filter_keypress(). - // Then, we should, according to GTK+ 2.0 API doc, return whatever it returns. - if ((!ret) && (win->m_imData != NULL) && ( wxWindow::FindFocus() == win )) + if (!ret && win->m_imData) { + win->m_imData->lastKeyEvent = gdk_event; + // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API // docs, if IM filter returns true, no further processing should be done. // we should send the key_down event anyway. @@ -1024,7 +952,7 @@ gtk_window_key_press_callback( GtkWidget *widget, win->m_imData->lastKeyEvent = NULL; if (intercepted_by_IM) { - wxLogTrace(TRACE_KEYS, _T("Key event intercepted by IM")); + wxLogTrace(TRACE_KEYS, wxT("Key event intercepted by IM")); return TRUE; } } @@ -1041,8 +969,18 @@ gtk_window_key_press_callback( GtkWidget *widget, int command = ancestor->GetAcceleratorTable()->GetCommand( event ); if (command != -1) { - wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command ); - ret = ancestor->GetEventHandler()->ProcessEvent( command_event ); + wxCommandEvent menu_event( wxEVT_COMMAND_MENU_SELECTED, command ); + ret = ancestor->HandleWindowEvent( menu_event ); + + if ( !ret ) + { + // if the accelerator wasn't handled as menu event, try + // it as button click (for compatibility with other + // platforms): + wxCommandEvent button_event( wxEVT_COMMAND_BUTTON_CLICKED, command ); + ret = ancestor->HandleWindowEvent( button_event ); + } + break; } if (ancestor->IsTopLevel()) @@ -1076,7 +1014,7 @@ gtk_window_key_press_callback( GtkWidget *widget, if ( key_code ) { - wxLogTrace(TRACE_KEYS, _T("Char event: %ld"), key_code); + wxLogTrace(TRACE_KEYS, wxT("Char event: %ld"), key_code); event.m_keyCode = key_code; @@ -1094,21 +1032,7 @@ gtk_window_key_press_callback( GtkWidget *widget, #endif } - // Implement OnCharHook by checking ancestor top level windows - wxWindow *parent = win; - while (parent && !parent->IsTopLevel()) - parent = parent->GetParent(); - if (parent) - { - event.SetEventType( wxEVT_CHAR_HOOK ); - ret = parent->GetEventHandler()->ProcessEvent( event ); - } - - if (!ret) - { - event.SetEventType(wxEVT_CHAR); - ret = win->GetEventHandler()->ProcessEvent( event ); - } + ret = SendCharHookAndCharEvents(event, win); } } @@ -1118,7 +1042,7 @@ gtk_window_key_press_callback( GtkWidget *widget, extern "C" { static void -gtk_wxwindow_commit_cb (GtkIMContext *context, +gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context), const gchar *str, wxWindow *window) { @@ -1140,20 +1064,13 @@ gtk_wxwindow_commit_cb (GtkIMContext *context, if( data.empty() ) return; - bool ret = false; - - // Implement OnCharHook by checking ancestor top level windows - wxWindow *parent = window; - while (parent && !parent->IsTopLevel()) - parent = parent->GetParent(); - for( wxString::const_iterator pstr = data.begin(); pstr != data.end(); ++pstr ) { #if wxUSE_UNICODE event.m_uniChar = *pstr; // Backward compatible for ISO-8859-1 event.m_keyCode = *pstr < 256 ? event.m_uniChar : 0; - wxLogTrace(TRACE_KEYS, _T("IM sent character '%c'"), event.m_uniChar); + wxLogTrace(TRACE_KEYS, wxT("IM sent character '%c'"), event.m_uniChar); #else event.m_keyCode = (char)*pstr; #endif // wxUSE_UNICODE @@ -1174,17 +1091,7 @@ gtk_wxwindow_commit_cb (GtkIMContext *context, #endif } - if (parent) - { - event.SetEventType( wxEVT_CHAR_HOOK ); - ret = parent->GetEventHandler()->ProcessEvent( event ); - } - - if (!ret) - { - event.SetEventType(wxEVT_CHAR); - ret = window->GetEventHandler()->ProcessEvent( event ); - } + SendCharHookAndCharEvents(event, window); } } } @@ -1196,12 +1103,10 @@ gtk_wxwindow_commit_cb (GtkIMContext *context, extern "C" { static gboolean -gtk_window_key_release_callback( GtkWidget *widget, +gtk_window_key_release_callback( GtkWidget * WXUNUSED(widget), GdkEventKey *gdk_event, wxWindowGTK *win ) { - DEBUG_MAIN_THREAD - if (!win->m_hasVMT) return FALSE; @@ -1233,22 +1138,19 @@ template void InitMouseEvent(wxWindowGTK *win, T *gdk_event) { event.SetTimestamp( gdk_event->time ); - event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK); - event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK); - event.m_altDown = (gdk_event->state & GDK_MOD1_MASK); - event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK); - event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK); - event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK); - event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK); - if (event.GetEventType() == wxEVT_MOUSEWHEEL) - { - event.m_linesPerAction = 3; - event.m_wheelDelta = 120; - if (((GdkEventButton*)gdk_event)->button == 4) - event.m_wheelRotation = 120; - else if (((GdkEventButton*)gdk_event)->button == 5) - event.m_wheelRotation = -120; - } + event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0; + event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0; + event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0; + event.m_metaDown = (gdk_event->state & GDK_META_MASK) != 0; + event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK) != 0; + event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK) != 0; + event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK) != 0; + + // In gdk/win32 VK_XBUTTON1 is translated to GDK_BUTTON4_MASK + // and VK_XBUTTON2 to GDK_BUTTON5_MASK. In x11/gdk buttons 4/5 + // are wheel rotation and buttons 8/9 don't change the state. + event.m_aux1Down = (gdk_event->state & GDK_BUTTON4_MASK) != 0; + event.m_aux2Down = (gdk_event->state & GDK_BUTTON5_MASK) != 0; wxPoint pt = win->GetClientAreaOrigin(); event.m_x = (wxCoord)gdk_event->x - pt.x; @@ -1257,7 +1159,9 @@ template void InitMouseEvent(wxWindowGTK *win, if ((win->m_wxwindow) && (win->GetLayoutDirection() == wxLayout_RightToLeft)) { // origin in the upper right corner - int window_width = gtk_pizza_get_rtl_offset( GTK_PIZZA(win->m_wxwindow) ); + GtkAllocation a; + gtk_widget_get_allocation(win->m_wxwindow, &a); + int window_width = a.width; event.m_x = window_width - event.m_x; } @@ -1296,6 +1200,20 @@ static void AdjustEventButtonState(wxMouseEvent& event) event.m_rightDown = !event.m_rightDown; return; } + + if ((event.GetEventType() == wxEVT_AUX1_DOWN) || + (event.GetEventType() == wxEVT_AUX1_DCLICK)) + { + event.m_aux1Down = true; + return; + } + + if ((event.GetEventType() == wxEVT_AUX2_DOWN) || + (event.GetEventType() == wxEVT_AUX2_DCLICK)) + { + event.m_aux2Down = true; + return; + } } // find the window to send the mouse event too @@ -1307,9 +1225,9 @@ wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y) if (win->m_wxwindow) { - GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow); - xx += gtk_pizza_get_xoffset( pizza ); - yy += gtk_pizza_get_yoffset( pizza ); + wxPizza* pizza = WX_PIZZA(win->m_wxwindow); + xx += pizza->m_scroll_x; + yy += pizza->m_scroll_y; } wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst(); @@ -1321,7 +1239,7 @@ wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y) if (!child->IsShown()) continue; - if (child->IsTransparentForMouse()) + if (child->GTKIsTransparentForMouse()) { // wxStaticBox is transparent in the box itself int xx1 = child->m_x; @@ -1347,7 +1265,7 @@ wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y) } else { - if ((child->m_wxwindow == (GtkWidget*) NULL) && + if ((child->m_wxwindow == NULL) && (child->m_x <= xx) && (child->m_y <= yy) && (child->m_x+child->m_width >= xx) && @@ -1371,13 +1289,16 @@ wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y) bool wxWindowGTK::GTKProcessEvent(wxEvent& event) const { // nothing special at this level - return GetEventHandler()->ProcessEvent(event); + return HandleWindowEvent(event); } -int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const +bool wxWindowGTK::GTKShouldIgnoreEvent() const { - DEBUG_MAIN_THREAD + return !m_hasVMT || g_blockEventsOnDrag; +} +int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const +{ if (!m_hasVMT) return FALSE; if (g_blockEventsOnDrag) @@ -1411,21 +1332,6 @@ wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing) if ( rc != -1 ) \ return rc -// send the wxChildFocusEvent and wxFocusEvent, common code of -// gtk_window_focus_in_callback() and SetFocus() -static bool DoSendFocusEvents(wxWindow *win) -{ - // Notify the parent keeping track of focus for the kbd navigation - // purposes that we got it. - wxChildFocusEvent eventChildFocus(win); - (void)win->GetEventHandler()->ProcessEvent(eventChildFocus); - - wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId()); - eventFocus.SetEventObject(win); - - return win->GetEventHandler()->ProcessEvent(eventFocus); -} - // all event handlers must have C linkage as they're called from GTK+ C code extern "C" { @@ -1443,11 +1349,6 @@ gtk_window_button_press_callback( GtkWidget *widget, g_lastButtonNumber = gdk_event->button; - if (win->m_wxwindow && (g_focusWindow != win) && win->CanAcceptFocus()) - { - gtk_widget_grab_focus( win->m_wxwindow ); - } - // GDK sends surplus button down events // before a double click event. We // need to filter these out. @@ -1471,10 +1372,7 @@ gtk_window_button_press_callback( GtkWidget *widget, wxEventType event_type = wxEVT_NULL; - // GdkDisplay is a GTK+ 2.2.0 thing -#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0) if ( gdk_event->type == GDK_2BUTTON_PRESS && - !gtk_check_version(2,2,0) && gdk_event->button >= 1 && gdk_event->button <= 3 ) { // Reset GDK internal timestamp variables in order to disable GDK @@ -1484,7 +1382,6 @@ gtk_window_button_press_callback( GtkWidget *widget, display->button_click_time[1] = 0; display->button_click_time[0] = 0; } -#endif // GTK 2+ if (gdk_event->button == 1) { @@ -1545,31 +1442,56 @@ gtk_window_button_press_callback( GtkWidget *widget, ; } } - else if (gdk_event->button == 4 || gdk_event->button == 5) + + else if (gdk_event->button == 8) { - if (gdk_event->type == GDK_BUTTON_PRESS ) + switch (gdk_event->type) { - event_type = wxEVT_MOUSEWHEEL; + case GDK_3BUTTON_PRESS: + case GDK_BUTTON_PRESS: + event_type = wxEVT_AUX1_DOWN; + break; + + case GDK_2BUTTON_PRESS: + event_type = wxEVT_AUX1_DCLICK; + break; + + default: + ; } } - if ( event_type == wxEVT_NULL ) + else if (gdk_event->button == 9) { - // unknown mouse button or click type - return FALSE; - } - - g_lastMouseEvent = (GdkEvent*) gdk_event; + switch (gdk_event->type) + { + case GDK_3BUTTON_PRESS: + case GDK_BUTTON_PRESS: + event_type = wxEVT_AUX2_DOWN; + break; + + case GDK_2BUTTON_PRESS: + event_type = wxEVT_AUX2_DCLICK; + break; + + default: + ; + } + } + + if ( event_type == wxEVT_NULL ) + { + // unknown mouse button or click type + return FALSE; + } + + g_lastMouseEvent = (GdkEvent*) gdk_event; wxMouseEvent event( event_type ); InitMouseEvent( win, event, gdk_event ); AdjustEventButtonState(event); - // wxListBox actually gets mouse events from the item, so we need to give it - // a chance to correct this - win->FixUpMouseEvent(widget, event.m_x, event.m_y); - // find the correct window to send the event to: it may be a different one // from the one which got it at GTK+ level because some controls don't have // their own X window and thus cannot get any events. @@ -1585,10 +1507,10 @@ gtk_window_button_press_callback( GtkWidget *widget, if ( ret ) return TRUE; - if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() && - (g_focusWindow != win) && win->CanAcceptFocus()) + if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() && + (gs_currentFocus != win) /* && win->IsFocusable() */) { - gtk_widget_grab_focus( win->m_wxwindow ); + win->SetFocus(); } if (event_type == wxEVT_RIGHT_DOWN) @@ -1616,7 +1538,7 @@ gtk_window_button_press_callback( GtkWidget *widget, //----------------------------------------------------------------------------- static gboolean -gtk_window_button_release_callback( GtkWidget *widget, +gtk_window_button_release_callback( GtkWidget *WXUNUSED(widget), GdkEventButton *gdk_event, wxWindowGTK *win ) { @@ -1640,6 +1562,14 @@ gtk_window_button_release_callback( GtkWidget *widget, event_type = wxEVT_RIGHT_UP; break; + case 8: + event_type = wxEVT_AUX1_UP; + break; + + case 9: + event_type = wxEVT_AUX2_UP; + break; + default: // unknown button, don't process return FALSE; @@ -1652,9 +1582,6 @@ gtk_window_button_release_callback( GtkWidget *widget, AdjustEventButtonState(event); - // same wxListBox hack as above - win->FixUpMouseEvent(widget, event.m_x, event.m_y); - if ( !g_captureWindow ) win = FindWindowForMouseEvent(win, event.m_x, event.m_y); @@ -1674,7 +1601,7 @@ gtk_window_button_release_callback( GtkWidget *widget, //----------------------------------------------------------------------------- static gboolean -gtk_window_motion_notify_callback( GtkWidget *widget, +gtk_window_motion_notify_callback( GtkWidget * WXUNUSED(widget), GdkEventMotion *gdk_event, wxWindowGTK *win ) { @@ -1742,14 +1669,38 @@ gtk_window_motion_notify_callback( GtkWidget *widget, } //----------------------------------------------------------------------------- -// "scroll_event", (mouse wheel event) +// "scroll_event" (mouse wheel event) //----------------------------------------------------------------------------- static gboolean -window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win) +window_scroll_event_hscrollbar(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win) { - DEBUG_MAIN_THREAD + if (gdk_event->direction != GDK_SCROLL_LEFT && + gdk_event->direction != GDK_SCROLL_RIGHT) + { + return false; + } + + GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Horz]; + + if (range && gtk_widget_get_visible(GTK_WIDGET(range))) + { + GtkAdjustment* adj = gtk_range_get_adjustment(range); + double delta = gtk_adjustment_get_step_increment(adj) * 3; + if (gdk_event->direction == GDK_SCROLL_LEFT) + delta = -delta; + + gtk_range_set_value(range, gtk_adjustment_get_value(adj) + delta); + + return TRUE; + } + + return FALSE; +} +static gboolean +window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win) +{ if (gdk_event->direction != GDK_SCROLL_UP && gdk_event->direction != GDK_SCROLL_DOWN) { @@ -1757,15 +1708,9 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win) } wxMouseEvent event(wxEVT_MOUSEWHEEL); - // Can't use InitMouse macro because scroll events don't have button - event.SetTimestamp( gdk_event->time ); - event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK); - event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK); - event.m_altDown = (gdk_event->state & GDK_MOD1_MASK); - event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK); - event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK); - event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK); - event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK); + InitMouseEvent(win, event, gdk_event); + + // FIXME: Get these values from GTK or GDK event.m_linesPerAction = 3; event.m_wheelDelta = 120; if (gdk_event->direction == GDK_SCROLL_UP) @@ -1773,15 +1718,24 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win) else event.m_wheelRotation = -120; - wxPoint pt = win->GetClientAreaOrigin(); - event.m_x = (wxCoord)gdk_event->x - pt.x; - event.m_y = (wxCoord)gdk_event->y - pt.y; + if (win->GTKProcessEvent(event)) + return TRUE; - event.SetEventObject( win ); - event.SetId( win->GetId() ); - event.SetTimestamp( gdk_event->time ); + GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Vert]; - return win->GTKProcessEvent(event); + if (range && gtk_widget_get_visible(GTK_WIDGET(range))) + { + GtkAdjustment* adj = gtk_range_get_adjustment(range); + double delta = gtk_adjustment_get_step_increment(adj) * 3; + if (gdk_event->direction == GDK_SCROLL_UP) + delta = -delta; + + gtk_range_set_value(range, gtk_adjustment_get_value(adj) + delta); + + return TRUE; + } + + return FALSE; } //----------------------------------------------------------------------------- @@ -1800,49 +1754,11 @@ static gboolean wxgtk_window_popup_menu_callback(GtkWidget*, wxWindowGTK* win) //----------------------------------------------------------------------------- static gboolean -gtk_window_focus_in_callback( GtkWidget *widget, +gtk_window_focus_in_callback( GtkWidget * WXUNUSED(widget), GdkEventFocus *WXUNUSED(event), - wxWindow *win ) + wxWindowGTK *win ) { - DEBUG_MAIN_THREAD - - if (win->m_imData) - gtk_im_context_focus_in(win->m_imData->context); - - g_focusWindowLast = - g_focusWindow = win; - - wxLogTrace(TRACE_FOCUS, - _T("%s: focus in"), win->GetName().c_str()); - -#if wxUSE_CARET - // caret needs to be informed about focus change - wxCaret *caret = win->GetCaret(); - if ( caret ) - { - caret->OnSetFocus(); - } -#endif // wxUSE_CARET - - gboolean ret = FALSE; - - // does the window itself think that it has the focus? - if ( !win->m_hasFocus ) - { - // not yet, notify it - win->m_hasFocus = true; - - (void)DoSendFocusEvents(win); - - ret = TRUE; - } - - // Disable default focus handling for custom windows - // since the default GTK+ handler issues a repaint - if (win->m_wxwindow) - return ret; - - return FALSE; + return win->GTKHandleFocusIn(); } //----------------------------------------------------------------------------- @@ -1850,66 +1766,23 @@ gtk_window_focus_in_callback( GtkWidget *widget, //----------------------------------------------------------------------------- static gboolean -gtk_window_focus_out_callback( GtkWidget *widget, - GdkEventFocus *gdk_event, +gtk_window_focus_out_callback( GtkWidget * WXUNUSED(widget), + GdkEventFocus * WXUNUSED(gdk_event), wxWindowGTK *win ) { - DEBUG_MAIN_THREAD - - if (win->m_imData) - gtk_im_context_focus_out(win->m_imData->context); - - wxLogTrace( TRACE_FOCUS, - _T("%s: focus out"), win->GetName().c_str() ); - - - wxWindowGTK *winFocus = wxFindFocusedChild(win); - if ( winFocus ) - win = winFocus; - - g_focusWindow = (wxWindowGTK *)NULL; - -#if wxUSE_CARET - // caret needs to be informed about focus change - wxCaret *caret = win->GetCaret(); - if ( caret ) - { - caret->OnKillFocus(); - } -#endif // wxUSE_CARET - - // don't send the window a kill focus event if it thinks that it doesn't - // have focus already - if ( win->m_hasFocus ) - { - // the event handler might delete the window when it loses focus, so - // check whether this is a custom window before calling it - const bool has_wxwindow = win->m_wxwindow != NULL; - - win->m_hasFocus = false; - - wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() ); - event.SetEventObject( win ); - - (void)win->GTKProcessEvent( event ); - - // Disable default focus handling for custom windows - // since the default GTK+ handler issues a repaint - if ( has_wxwindow ) - return TRUE; - } - - // continue with normal processing - return FALSE; + return win->GTKHandleFocusOut(); } +//----------------------------------------------------------------------------- +// "focus" +//----------------------------------------------------------------------------- + static gboolean wx_window_focus_callback(GtkWidget *widget, - GtkDirectionType direction, + GtkDirectionType WXUNUSED(direction), wxWindowGTK *win) { - // the default handler for focus signal in GtkPizza (or, rather, in - // GtkScrolledWindow from which GtkPizza inherits this behaviour) sets + // the default handler for focus signal in GtkScrolledWindow sets // focus to the window itself even if it doesn't accept focus, i.e. has no // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing // the signal from reaching gtk_scrolled_window_focus() if we don't have @@ -1940,7 +1813,7 @@ gtk_window_enter_callback( GtkWidget *widget, int y = 0; GdkModifierType state = (GdkModifierType)0; - gdk_window_get_pointer( widget->window, &x, &y, &state ); + gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, &state); wxMouseEvent event( wxEVT_ENTER_WINDOW ); InitMouseEvent(win, event, gdk_event); @@ -1975,26 +1848,14 @@ gtk_window_leave_callback( GtkWidget *widget, if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE; wxMouseEvent event( wxEVT_LEAVE_WINDOW ); - event.SetTimestamp( gdk_event->time ); - event.SetEventObject( win ); int x = 0; int y = 0; GdkModifierType state = (GdkModifierType)0; - gdk_window_get_pointer( widget->window, &x, &y, &state ); - - event.m_shiftDown = (state & GDK_SHIFT_MASK) != 0; - event.m_controlDown = (state & GDK_CONTROL_MASK) != 0; - event.m_altDown = (state & GDK_MOD1_MASK) != 0; - event.m_metaDown = (state & GDK_MOD2_MASK) != 0; - event.m_leftDown = (state & GDK_BUTTON1_MASK) != 0; - event.m_middleDown = (state & GDK_BUTTON2_MASK) != 0; - event.m_rightDown = (state & GDK_BUTTON3_MASK) != 0; + gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, &state); - wxPoint pt = win->GetClientAreaOrigin(); - event.m_x = x + pt.x; - event.m_y = y + pt.y; + InitMouseEvent(win, event, gdk_event); return win->GTKProcessEvent(event); } @@ -2006,7 +1867,7 @@ gtk_window_leave_callback( GtkWidget *widget, static void gtk_scrollbar_value_changed(GtkRange* range, wxWindow* win) { - wxEventType eventType = win->GetScrollEventType(range); + wxEventType eventType = win->GTKGetScrollEventType(range); if (eventType != wxEVT_NULL) { // Convert scroll event type to scrollwin event type @@ -2020,9 +1881,7 @@ gtk_scrollbar_value_changed(GtkRange* range, wxWindow* win) wxScrollWinEvent event(eventType, win->GetScrollPos(orient), orient); event.SetEventObject(win); - win->m_blockValueChanged[dir] = true; win->GTKProcessEvent(event); - win->m_blockValueChanged[dir] = false; } } @@ -2033,8 +1892,6 @@ gtk_scrollbar_value_changed(GtkRange* range, wxWindow* win) static gboolean gtk_scrollbar_button_press_event(GtkRange*, GdkEventButton*, wxWindow* win) { - DEBUG_MAIN_THREAD - g_blockEventsOnScroll = true; win->m_mouseButtonDown = true; @@ -2054,9 +1911,10 @@ gtk_scrollbar_event_after(GtkRange* range, GdkEvent* event, wxWindow* win) const int orient = wxWindow::OrientFromScrollDir( win->ScrollDirFromRange(range)); - wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBRELEASE, win->GetScrollPos(orient), orient); - event.SetEventObject(win); - win->GTKProcessEvent(event); + wxScrollWinEvent evt(wxEVT_SCROLLWIN_THUMBRELEASE, + win->GetScrollPos(orient), orient); + evt.SetEventObject(win); + win->GTKProcessEvent(evt); } } @@ -2067,8 +1925,6 @@ gtk_scrollbar_event_after(GtkRange* range, GdkEvent* event, wxWindow* win) static gboolean gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* win) { - DEBUG_MAIN_THREAD - g_blockEventsOnScroll = false; win->m_mouseButtonDown = false; // If thumb tracking @@ -2089,15 +1945,12 @@ gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* w //----------------------------------------------------------------------------- static void -gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win ) +gtk_window_realized_callback(GtkWidget* widget, wxWindow* win) { - DEBUG_MAIN_THREAD - if (win->m_imData) { - GtkPizza *pizza = GTK_PIZZA( m_widget ); gtk_im_context_set_client_window( win->m_imData->context, - pizza->bin_window ); + win->m_wxwindow ? win->GTKGetDrawingWindow() : gtk_widget_get_window(widget)); } // We cannot set colours and fonts before the widget @@ -2113,36 +1966,82 @@ gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win ) wxWindowCreateEvent event( win ); event.SetEventObject( win ); win->GTKProcessEvent( event ); + + win->GTKUpdateCursor(true, false); } //----------------------------------------------------------------------------- -// "size_allocate" +// "size_allocate" from m_wxwindow or m_widget //----------------------------------------------------------------------------- -static -void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), - GtkAllocation *alloc, - wxWindow *win ) +static void +size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win) { - int client_width = 0; - int client_height = 0; - win->GetClientSize( &client_width, &client_height ); - if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight)) - return; + int w = alloc->width; + int h = alloc->height; + if (win->m_wxwindow) + { + int border_x, border_y; + WX_PIZZA(win->m_wxwindow)->get_border_widths(border_x, border_y); + w -= 2 * border_x; + h -= 2 * border_y; + if (w < 0) w = 0; + if (h < 0) h = 0; + } + if (win->m_oldClientWidth != w || win->m_oldClientHeight != h) + { + win->m_oldClientWidth = w; + win->m_oldClientHeight = h; + // this callback can be connected to m_wxwindow, + // so always get size from m_widget->allocation + GtkAllocation a; + gtk_widget_get_allocation(win->m_widget, &a); + win->m_width = a.width; + win->m_height = a.height; + if (!win->m_nativeSizeEvent) + { + wxSizeEvent event(win->GetSize(), win->GetId()); + event.SetEventObject(win); + win->GTKProcessEvent(event); + } + } +} + +//----------------------------------------------------------------------------- +// "grab_broken" +//----------------------------------------------------------------------------- - if ( !client_width && !client_height ) +#if GTK_CHECK_VERSION(2, 8, 0) +static gboolean +gtk_window_grab_broken( GtkWidget*, + GdkEventGrabBroken *event, + wxWindow *win ) +{ + // Mouse capture has been lost involuntarily, notify the application + if(!event->keyboard && wxWindow::GetCapture() == win) { - // the window is currently unmapped, don't generate size events - return; + wxMouseCaptureLostEvent evt( win->GetId() ); + evt.SetEventObject( win ); + win->HandleWindowEvent( evt ); } + return false; +} +#endif - win->m_oldClientWidth = client_width; - win->m_oldClientHeight = client_height; +//----------------------------------------------------------------------------- +// "style_set" +//----------------------------------------------------------------------------- - if (!win->m_nativeSizeEvent) +static +void gtk_window_style_set_callback( GtkWidget *WXUNUSED(widget), + GtkStyle *previous_style, + wxWindow* win ) +{ + if (win && previous_style) { - wxSizeEvent event( win->GetSize(), win->GetId() ); - event.SetEventObject( win ); + wxSysColourChangedEvent event; + event.SetEventObject(win); + win->GTKProcessEvent( event ); } } @@ -2156,35 +2055,24 @@ void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), wxWindow *wxWindowBase::DoFindFocus() { + wxWindowGTK *focus = gs_pendingFocus ? gs_pendingFocus : gs_currentFocus; // the cast is necessary when we compile in wxUniversal mode - return (wxWindow *)g_focusWindow; + return static_cast(focus); } -//----------------------------------------------------------------------------- -// InsertChild for wxWindowGTK. -//----------------------------------------------------------------------------- - -/* Callback for wxWindowGTK. This very strange beast has to be used because - * C++ has no virtual methods in a constructor. We have to emulate a - * virtual function here as wxNotebook requires a different way to insert - * a child in it. I had opted for creating a wxNotebookPage window class - * which would have made this superfluous (such in the MDI window system), - * but no-one was listening to me... */ - -static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child ) +void wxWindowGTK::AddChildGTK(wxWindowGTK* child) { - /* the window might have been scrolled already, do we - have to adapt the position */ - GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow); - child->m_x += gtk_pizza_get_xoffset( pizza ); - child->m_y += gtk_pizza_get_yoffset( pizza ); + wxASSERT_MSG(m_wxwindow, "Cannot add a child to a window without a client area"); - gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow), - child->m_widget, - child->m_x, - child->m_y, - child->m_width, - child->m_height ); + // the window might have been scrolled already, we + // have to adapt the position + wxPizza* pizza = WX_PIZZA(m_wxwindow); + child->m_x += pizza->m_scroll_x; + child->m_y += pizza->m_scroll_y; + + gtk_widget_set_size_request( + child->m_widget, child->m_width, child->m_height); + pizza->put(child->m_widget, child->m_x, child->m_y); } //----------------------------------------------------------------------------- @@ -2209,14 +2097,17 @@ wxMouseState wxGetMouseState() ms.SetX(x); ms.SetY(y); - ms.SetLeftDown(mask & GDK_BUTTON1_MASK); - ms.SetMiddleDown(mask & GDK_BUTTON2_MASK); - ms.SetRightDown(mask & GDK_BUTTON3_MASK); - - ms.SetControlDown(mask & GDK_CONTROL_MASK); - ms.SetShiftDown(mask & GDK_SHIFT_MASK); - ms.SetAltDown(mask & GDK_MOD1_MASK); - ms.SetMetaDown(mask & GDK_MOD2_MASK); + ms.SetLeftDown((mask & GDK_BUTTON1_MASK) != 0); + ms.SetMiddleDown((mask & GDK_BUTTON2_MASK) != 0); + ms.SetRightDown((mask & GDK_BUTTON3_MASK) != 0); + // see the comment in InitMouseEvent() + ms.SetAux1Down((mask & GDK_BUTTON4_MASK) != 0); + ms.SetAux2Down((mask & GDK_BUTTON5_MASK) != 0); + + ms.SetControlDown((mask & GDK_CONTROL_MASK) != 0); + ms.SetShiftDown((mask & GDK_SHIFT_MASK) != 0); + ms.SetAltDown((mask & GDK_MOD1_MASK) != 0); + ms.SetMetaDown((mask & GDK_META_MASK) != 0); return ms; } @@ -2229,16 +2120,14 @@ wxMouseState wxGetMouseState() // method #ifdef __WXUNIVERSAL__ IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase) -#else // __WXGTK__ - IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase) -#endif // __WXUNIVERSAL__/__WXGTK__ +#endif // __WXUNIVERSAL__ void wxWindowGTK::Init() { // GTK specific - m_widget = (GtkWidget *) NULL; - m_wxwindow = (GtkWidget *) NULL; - m_focusWidget = (GtkWidget *) NULL; + m_widget = NULL; + m_wxwindow = NULL; + m_focusWidget = NULL; // position/size m_x = 0; @@ -2247,35 +2136,25 @@ void wxWindowGTK::Init() m_height = 0; m_hasVMT = false; - m_isBeingDeleted = false; - m_showOnIdle= false; + m_showOnIdle = false; m_noExpose = false; m_nativeSizeEvent = false; - m_hasScrolling = false; m_isScrolling = false; m_mouseButtonDown = false; - m_blockScrollEvent = false; // initialize scrolling stuff for ( int dir = 0; dir < ScrollDir_Max; dir++ ) { m_scrollBar[dir] = NULL; m_scrollPos[dir] = 0; - m_blockValueChanged[dir] = false; } m_oldClientWidth = m_oldClientHeight = 0; - m_resizing = false; - - m_insertCallback = wxInsertChildInWindow; - - m_hasFocus = false; - m_clipPaintRegion = false; m_needsStyleChange = false; @@ -2310,6 +2189,12 @@ bool wxWindowGTK::Create( wxWindow *parent, long style, const wxString &name ) { + // Get default border + wxBorder border = GetBorder(style); + + style &= ~wxBORDER_MASK; + style |= border; + if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) { @@ -2317,37 +2202,29 @@ bool wxWindowGTK::Create( wxWindow *parent, return false; } - if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL)) - { - m_wxwindow = gtk_pizza_new_no_scroll(); + // We should accept the native look +#if 0 + GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) ); + scroll_class->scrollbar_spacing = 0; +#endif -#ifndef __WXUNIVERSAL__ - if (HasFlag(wxSIMPLE_BORDER)) - gtk_container_set_border_width((GtkContainer*)m_wxwindow, 1); - else if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER)) - gtk_container_set_border_width((GtkContainer*)m_wxwindow, 2); -#endif // __WXUNIVERSAL__ - m_widget = m_wxwindow; + m_wxwindow = wxPizza::New(m_windowStyle); +#ifndef __WXUNIVERSAL__ + if (HasFlag(wxPizza::BORDER_STYLES)) + { + g_signal_connect(m_wxwindow, "parent_set", + G_CALLBACK(parent_set), this); } +#endif + if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL)) + m_widget = m_wxwindow; else { - m_wxwindow = gtk_pizza_new(); - -#ifndef __WXUNIVERSAL__ - if (HasFlag(wxSIMPLE_BORDER)) - gtk_container_set_border_width((GtkContainer*)m_wxwindow, 1); - else if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER)) - gtk_container_set_border_width((GtkContainer*)m_wxwindow, 2); -#endif // __WXUNIVERSAL__ - - m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL ); + m_widget = gtk_scrolled_window_new( NULL, NULL ); GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget); - GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) ); - scroll_class->scrollbar_spacing = 0; - // There is a conflict with default bindings at GTK+ // level between scrolled windows and notebooks both of which want to use // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal @@ -2368,17 +2245,14 @@ bool wxWindowGTK::Create( wxWindow *parent, if (HasFlag(wxALWAYS_SHOW_SB)) { gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS ); - - scrolledWindow->hscrollbar_visible = TRUE; - scrolledWindow->vscrollbar_visible = TRUE; } else { gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); } - m_scrollBar[ScrollDir_Horz] = GTK_RANGE(scrolledWindow->hscrollbar); - m_scrollBar[ScrollDir_Vert] = GTK_RANGE(scrolledWindow->vscrollbar); + m_scrollBar[ScrollDir_Horz] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow)); + m_scrollBar[ScrollDir_Vert] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow)); if (GetLayoutDirection() == wxLayout_RightToLeft) gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE ); @@ -2400,18 +2274,21 @@ bool wxWindowGTK::Create( wxWindow *parent, g_signal_handler_block(m_scrollBar[dir], handler_id); // these handlers get notified when scrollbar slider moves - g_signal_connect(m_scrollBar[dir], "value_changed", + g_signal_connect_after(m_scrollBar[dir], "value_changed", G_CALLBACK(gtk_scrollbar_value_changed), this); } gtk_widget_show( m_wxwindow ); } + g_object_ref(m_widget); if (m_parent) m_parent->DoAddChild( this ); m_focusWidget = m_wxwindow; + SetCanFocus(AcceptsFocus()); + PostCreation(); return true; @@ -2421,13 +2298,14 @@ wxWindowGTK::~wxWindowGTK() { SendDestroyEvent(); - if (g_focusWindow == this) - g_focusWindow = NULL; + if (gs_currentFocus == this) + gs_currentFocus = NULL; + if (gs_pendingFocus == this) + gs_pendingFocus = NULL; - if ( g_delayedFocus == this ) - g_delayedFocus = NULL; + if ( gs_deferredFocusOut == this ) + gs_deferredFocusOut = NULL; - m_isBeingDeleted = true; m_hasVMT = false; // destroy children before destroying this window itself @@ -2451,17 +2329,23 @@ wxWindowGTK::~wxWindowGTK() // delete before the widgets to avoid a crash on solaris delete m_imData; - if (m_wxwindow && (m_wxwindow != m_widget)) - { - gtk_widget_destroy( m_wxwindow ); - m_wxwindow = (GtkWidget*) NULL; - } + // avoid problem with GTK+ 2.18 where a frozen window causes the whole + // TLW to be frozen, and if the window is then destroyed, nothing ever + // gets painted again + if (IsFrozen()) + DoThaw(); if (m_widget) { - gtk_widget_destroy( m_widget ); - m_widget = (GtkWidget*) NULL; + // Note that gtk_widget_destroy() does not destroy the widget, it just + // emits the "destroy" signal. The widget is not actually destroyed + // until its reference count drops to zero. + gtk_widget_destroy(m_widget); + // Release our reference, should be the last one + g_object_unref(m_widget); + m_widget = NULL; } + m_wxwindow = NULL; } bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size ) @@ -2496,7 +2380,7 @@ void wxWindowGTK::PostCreation() G_CALLBACK (gtk_window_expose_callback), this); if (GetLayoutDirection() == wxLayout_LeftToRight) - gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), HasFlag( wxFULL_REPAINT_ON_RESIZE ) ); + gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE)); } // Create input method handler @@ -2507,10 +2391,6 @@ void wxWindowGTK::PostCreation() g_signal_connect (m_imData->context, "commit", G_CALLBACK (gtk_wxwindow_commit_cb), this); - - // these are called when the "sunken" or "raised" borders are drawn - g_signal_connect (m_widget, "expose_event", - G_CALLBACK (gtk_window_own_expose_callback), this); } // focus handling @@ -2555,31 +2435,31 @@ void wxWindowGTK::PostCreation() g_signal_connect (connect_widget, "realize", G_CALLBACK (gtk_window_realized_callback), this); - if (m_wxwindow) + if (!IsTopLevel()) { - // Catch native resize events - g_signal_connect (m_wxwindow, "size_allocate", - G_CALLBACK (gtk_window_size_callback), this); + g_signal_connect(m_wxwindow ? m_wxwindow : m_widget, "size_allocate", + G_CALLBACK(size_allocate), this); } - if (GTK_IS_COMBO(m_widget)) +#if GTK_CHECK_VERSION(2, 8, 0) + if ( gtk_check_version(2,8,0) == NULL ) { - GtkCombo *gcombo = GTK_COMBO(m_widget); + // Make sure we can notify the app when mouse capture is lost + if ( m_wxwindow ) + { + g_signal_connect (m_wxwindow, "grab_broken_event", + G_CALLBACK (gtk_window_grab_broken), this); + } - g_signal_connect (gcombo->entry, "size_request", - G_CALLBACK (wxgtk_combo_size_request_callback), - this); - } -#ifdef GTK_IS_FILE_CHOOSER_BUTTON - else if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget)) - { - // If we connect to the "size_request" signal of a GtkFileChooserButton - // then that control won't be sized properly when placed inside sizers - // (this can be tested removing this elseif and running XRC or WIDGETS samples) - // FIXME: what should be done here ? + if ( connect_widget != m_wxwindow ) + { + g_signal_connect (connect_widget, "grab_broken_event", + G_CALLBACK (gtk_window_grab_broken), this); + } } -#endif - else if ( !IsTopLevel() ) // top level windows use their own callback +#endif // GTK+ >= 2.8 + + if ( GTKShouldConnectSizeRequest() ) { // This is needed if we want to add our windows into native // GTK controls, such as the toolbar. With this callback, the @@ -2602,6 +2482,11 @@ void wxWindowGTK::PostCreation() gtk_widget_show( m_widget ); } +gulong wxWindowGTK::GTKConnectWidget(const char *signal, void (*callback)()) +{ + return g_signal_connect(m_widget, signal, callback, this); +} + void wxWindowGTK::ConnectWidget( GtkWidget *widget ) { g_signal_connect (widget, "key_press_event", @@ -2614,20 +2499,30 @@ void wxWindowGTK::ConnectWidget( GtkWidget *widget ) G_CALLBACK (gtk_window_button_release_callback), this); g_signal_connect (widget, "motion_notify_event", G_CALLBACK (gtk_window_motion_notify_callback), this); + g_signal_connect (widget, "scroll_event", G_CALLBACK (window_scroll_event), this); + if (m_scrollBar[ScrollDir_Horz]) + g_signal_connect (m_scrollBar[ScrollDir_Horz], "scroll_event", + G_CALLBACK (window_scroll_event_hscrollbar), this); + if (m_scrollBar[ScrollDir_Vert]) + g_signal_connect (m_scrollBar[ScrollDir_Vert], "scroll_event", + G_CALLBACK (window_scroll_event), this); + g_signal_connect (widget, "popup_menu", G_CALLBACK (wxgtk_window_popup_menu_callback), this); g_signal_connect (widget, "enter_notify_event", G_CALLBACK (gtk_window_enter_callback), this); g_signal_connect (widget, "leave_notify_event", G_CALLBACK (gtk_window_leave_callback), this); + + if (IsTopLevel() && m_wxwindow) + g_signal_connect (m_wxwindow, "style_set", + G_CALLBACK (gtk_window_style_set_callback), this); } bool wxWindowGTK::Destroy() { - wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); - m_hasVMT = false; return wxWindowBase::Destroy(); @@ -2635,9 +2530,12 @@ bool wxWindowGTK::Destroy() void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height) { - // inform the parent to perform the move - gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height ); + gtk_widget_set_size_request(m_widget, width, height); + // inform the parent to perform the move + wxASSERT_MSG(m_parent && m_parent->m_wxwindow, + "the parent window has no client area?"); + WX_PIZZA(m_parent->m_wxwindow)->move(m_widget, x, y); } void wxWindowGTK::ConstrainSize() @@ -2662,9 +2560,6 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") ); - if (m_resizing) return; /* I don't like recursions */ - m_resizing = true; - int currentX, currentY; GetPosition(¤tX, ¤tY); if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE)) @@ -2684,43 +2579,17 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags height = sizeBest.y; } + const wxSize oldSize(m_width, m_height); if (width != -1) m_width = width; if (height != -1) m_height = height; - ConstrainSize(); - -#if wxUSE_TOOLBAR_NATIVE - if (wxDynamicCast(GetParent(), wxToolBar)) - { - // don't take the x,y values, they're wrong because toolbar sets them - GtkWidget *widget = m_widget; - gtk_widget_set_size_request (widget, m_width, m_height); - } - else -#endif - if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook - { - // don't set the size for children of wxNotebook, just take the values. - m_x = x; - m_y = y; - m_width = width; - m_height = height; - } - else + if (m_parent->m_wxwindow) { - GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow); - if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0) - { - if (x != -1) m_x = x + gtk_pizza_get_xoffset( pizza ); - if (y != -1) m_y = y + gtk_pizza_get_yoffset( pizza ); - } - else - { - m_x = x + gtk_pizza_get_xoffset( pizza ); - m_y = y + gtk_pizza_get_yoffset( pizza ); - } + wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow); + m_x = x + pizza->m_scroll_x; + m_y = y + pizza->m_scroll_y; int left_border = 0; int right_border = 0; @@ -2728,7 +2597,7 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags int bottom_border = 0; /* the default button has a border around it */ - if (GTK_WIDGET_CAN_DEFAULT(m_widget)) + if (gtk_widget_get_can_default(m_widget)) { GtkBorder *default_border = NULL; gtk_widget_style_get( m_widget, "default_border", &default_border, NULL ); @@ -2738,47 +2607,41 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags right_border += default_border->right; top_border += default_border->top; bottom_border += default_border->bottom; - g_free( default_border ); + gtk_border_free( default_border ); } } - DoMoveWindow( m_x-top_border, - m_y-left_border, + DoMoveWindow( m_x - left_border, + m_y - top_border, m_width+left_border+right_border, m_height+top_border+bottom_border ); } - if (m_hasScrolling) + if (m_width != oldSize.x || m_height != oldSize.y) { - /* Sometimes the client area changes size without the - whole windows's size changing, but if the whole - windows's size doesn't change, no wxSizeEvent will - normally be sent. Here we add an extra test if - the client test has been changed and this will - be used then. */ + // update these variables to keep size_allocate handler + // from sending another size event for this change GetClientSize( &m_oldClientWidth, &m_oldClientHeight ); - } -/* - wxPrintf( "OnSize sent from " ); - if (GetClassInfo() && GetClassInfo()->GetClassName()) - wxPrintf( GetClassInfo()->GetClassName() ); - wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height ); -*/ - - if (!m_nativeSizeEvent) + gtk_widget_queue_resize(m_widget); + if (!m_nativeSizeEvent) + { + wxSizeEvent event( wxSize(m_width,m_height), GetId() ); + event.SetEventObject( this ); + HandleWindowEvent( event ); + } + } else + if (sizeFlags & wxSIZE_FORCE_EVENT) { wxSizeEvent event( wxSize(m_width,m_height), GetId() ); event.SetEventObject( this ); - GetEventHandler()->ProcessEvent( event ); + HandleWindowEvent( event ); } - - m_resizing = false; } -bool wxWindowGTK::GtkShowFromOnIdle() +bool wxWindowGTK::GTKShowFromOnIdle() { - if (IsShown() && m_showOnIdle && !GTK_WIDGET_VISIBLE (m_widget)) + if (IsShown() && m_showOnIdle && !gtk_widget_get_visible (m_widget)) { GtkAllocation alloc; alloc.x = m_x; @@ -2789,7 +2652,7 @@ bool wxWindowGTK::GtkShowFromOnIdle() gtk_widget_show( m_widget ); wxShowEvent eventShow(GetId(), true); eventShow.SetEventObject(this); - GetEventHandler()->ProcessEvent(eventShow); + HandleWindowEvent(eventShow); m_showOnIdle = false; return true; } @@ -2799,8 +2662,11 @@ bool wxWindowGTK::GtkShowFromOnIdle() void wxWindowGTK::OnInternalIdle() { + if ( gs_deferredFocusOut ) + GTKHandleDeferredFocusOut(); + // Check if we have to show window now - if (GtkShowFromOnIdle()) return; + if (GTKShowFromOnIdle()) return; if ( m_dirtyTabOrder ) { @@ -2808,48 +2674,15 @@ void wxWindowGTK::OnInternalIdle() RealizeTabOrder(); } - // Update style if the window was not yet realized - // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called + // Update style if the window was not yet realized when + // SetBackgroundStyle() was called if (m_needsStyleChange) { SetBackgroundStyle(GetBackgroundStyle()); m_needsStyleChange = false; } - wxCursor cursor = m_cursor; - if (g_globalCursor.Ok()) cursor = g_globalCursor; - - if (cursor.Ok()) - { - /* I now set the cursor anew in every OnInternalIdle call - as setting the cursor in a parent window also effects the - windows above so that checking for the current cursor is - not possible. */ - - if (m_wxwindow && (m_wxwindow != m_widget)) - { - GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window; - if (window) - gdk_window_set_cursor( window, cursor.GetCursor() ); - - if (!g_globalCursor.Ok()) - cursor = *wxSTANDARD_CURSOR; - - window = m_widget->window; - if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget))) - gdk_window_set_cursor( window, cursor.GetCursor() ); - - } - else if ( m_widget ) - { - GdkWindow *window = m_widget->window; - if ( window && !GTK_WIDGET_NO_WINDOW(m_widget) ) - gdk_window_set_cursor( window, cursor.GetCursor() ); - } - } - - if (wxUpdateUIEvent::CanUpdate(this)) - UpdateWindowUI(wxUPDATE_UI_FROMIDLE); + wxWindowBase::OnInternalIdle(); } void wxWindowGTK::DoGetSize( int *width, int *height ) const @@ -2876,23 +2709,60 @@ void wxWindowGTK::DoGetClientSize( int *width, int *height ) const int w = m_width; int h = m_height; - if (m_wxwindow) + if ( m_wxwindow ) { - int dw = 0; - int dh = 0; + // if window is scrollable, account for scrollbars + if ( GTK_IS_SCROLLED_WINDOW(m_widget) ) + { + GtkPolicyType policy[ScrollDir_Max]; + gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget), + &policy[ScrollDir_Horz], + &policy[ScrollDir_Vert]); - if (m_hasScrolling) - GetScrollbarWidth(m_widget, dw, dh); + for ( int i = 0; i < ScrollDir_Max; i++ ) + { + // don't account for the scrollbars we don't have + GtkRange * const range = m_scrollBar[i]; + if ( !range ) + continue; - const int border = GTK_CONTAINER(m_wxwindow)->border_width; - dw += 2 * border; - dh += 2 * border; + // nor for the ones we have but don't current show + switch ( policy[i] ) + { + case GTK_POLICY_NEVER: + // never shown so doesn't take any place + continue; + + case GTK_POLICY_ALWAYS: + // no checks necessary + break; + + case GTK_POLICY_AUTOMATIC: + // may be shown or not, check + GtkAdjustment *adj = gtk_range_get_adjustment(range); + if (gtk_adjustment_get_upper(adj) <= gtk_adjustment_get_page_size(adj)) + continue; + } - w -= dw; - h -= dh; - if (w < 0) - w = 0; - if (h < 0) + GtkScrolledWindowClass *scroll_class = + GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) ); + + GtkRequisition req; + gtk_widget_size_request(GTK_WIDGET(range), &req); + if (i == ScrollDir_Horz) + h -= req.height + scroll_class->scrollbar_spacing; + else + w -= req.width + scroll_class->scrollbar_spacing; + } + } + + const wxSize sizeBorders = DoGetBorderSize(); + w -= sizeBorders.x; + h -= sizeBorders.y; + + if (w < 0) + w = 0; + if (h < 0) h = 0; } @@ -2900,26 +2770,37 @@ void wxWindowGTK::DoGetClientSize( int *width, int *height ) const if (height) *height = h; } +wxSize wxWindowGTK::DoGetBorderSize() const +{ + if ( !m_wxwindow ) + return wxWindowBase::DoGetBorderSize(); + + int x, y; + WX_PIZZA(m_wxwindow)->get_border_widths(x, y); + + return 2*wxSize(x, y); +} + void wxWindowGTK::DoGetPosition( int *x, int *y ) const { wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); int dx = 0; int dy = 0; - if (m_parent && m_parent->m_wxwindow) + if (!IsTopLevel() && m_parent && m_parent->m_wxwindow) { - GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow); - dx = gtk_pizza_get_xoffset( pizza ); - dy = gtk_pizza_get_yoffset( pizza ); + wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow); + dx = pizza->m_scroll_x; + dy = pizza->m_scroll_y; } if (m_x == -1 && m_y == -1) { - GdkWindow *source = (GdkWindow *) NULL; + GdkWindow *source = NULL; if (m_wxwindow) - source = GTK_PIZZA(m_wxwindow)->bin_window; + source = gtk_widget_get_window(m_wxwindow); else - source = m_widget->window; + source = gtk_widget_get_window(m_widget); if (source) { @@ -2930,8 +2811,8 @@ void wxWindowGTK::DoGetPosition( int *x, int *y ) const if (m_parent) m_parent->ScreenToClient(&org_x, &org_y); - wx_const_cast(wxWindowGTK*, this)->m_x = org_x; - wx_const_cast(wxWindowGTK*, this)->m_y = org_y; + const_cast(this)->m_x = org_x; + const_cast(this)->m_y = org_y; } } @@ -2943,13 +2824,13 @@ void wxWindowGTK::DoClientToScreen( int *x, int *y ) const { wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); - if (!m_widget->window) return; + if (gtk_widget_get_window(m_widget) == NULL) return; - GdkWindow *source = (GdkWindow *) NULL; + GdkWindow *source = NULL; if (m_wxwindow) - source = GTK_PIZZA(m_wxwindow)->bin_window; + source = gtk_widget_get_window(m_wxwindow); else - source = m_widget->window; + source = gtk_widget_get_window(m_widget); int org_x = 0; int org_y = 0; @@ -2957,10 +2838,12 @@ void wxWindowGTK::DoClientToScreen( int *x, int *y ) const if (!m_wxwindow) { - if (GTK_WIDGET_NO_WINDOW (m_widget)) + if (!gtk_widget_get_has_window(m_widget)) { - org_x += m_widget->allocation.x; - org_y += m_widget->allocation.y; + GtkAllocation a; + gtk_widget_get_allocation(m_widget, &a); + org_x += a.x; + org_y += a.y; } } @@ -2980,13 +2863,13 @@ void wxWindowGTK::DoScreenToClient( int *x, int *y ) const { wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); - if (!m_widget->window) return; + if (!gtk_widget_get_realized(m_widget)) return; - GdkWindow *source = (GdkWindow *) NULL; + GdkWindow *source = NULL; if (m_wxwindow) - source = GTK_PIZZA(m_wxwindow)->bin_window; + source = gtk_widget_get_window(m_wxwindow); else - source = m_widget->window; + source = gtk_widget_get_window(m_widget); int org_x = 0; int org_y = 0; @@ -2994,10 +2877,12 @@ void wxWindowGTK::DoScreenToClient( int *x, int *y ) const if (!m_wxwindow) { - if (GTK_WIDGET_NO_WINDOW (m_widget)) + if (!gtk_widget_get_has_window(m_widget)) { - org_x += m_widget->allocation.x; - org_y += m_widget->allocation.y; + GtkAllocation a; + gtk_widget_get_allocation(m_widget, &a); + org_x += a.x; + org_y += a.y; } } @@ -3013,32 +2898,40 @@ void wxWindowGTK::DoScreenToClient( int *x, int *y ) const bool wxWindowGTK::Show( bool show ) { - wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") ); - - if (!wxWindowBase::Show(show)) + if ( !wxWindowBase::Show(show) ) { // nothing to do return false; } - if (show) + // notice that we may call Hide() before the window is created and this is + // actually useful to create it hidden initially -- but we can't call + // Show() before it is created + if ( !m_widget ) + { + wxASSERT_MSG( !show, "can't show invalid window" ); + return true; + } + + if ( show ) { - if (!m_showOnIdle) + if ( m_showOnIdle ) { - gtk_widget_show( m_widget ); - wxShowEvent eventShow(GetId(), show); - eventShow.SetEventObject(this); - GetEventHandler()->ProcessEvent(eventShow); + // defer until later + return true; } + + gtk_widget_show(m_widget); } - else + else // hide { - gtk_widget_hide( m_widget ); - wxShowEvent eventShow(GetId(), show); - eventShow.SetEventObject(this); - GetEventHandler()->ProcessEvent(eventShow); + gtk_widget_hide(m_widget); } + wxShowEvent eventShow(GetId(), show); + eventShow.SetEventObject(this); + HandleWindowEvent(eventShow); + return true; } @@ -3056,11 +2949,9 @@ int wxWindowGTK::GetCharHeight() const wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") ); wxFont font = GetFont(); - wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") ); + wxCHECK_MSG( font.IsOk(), 12, wxT("invalid font") ); - PangoContext *context = NULL; - if (m_widget) - context = gtk_widget_get_pango_context( m_widget ); + PangoContext* context = gtk_widget_get_pango_context(m_widget); if (!context) return 0; @@ -3084,11 +2975,9 @@ int wxWindowGTK::GetCharWidth() const wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") ); wxFont font = GetFont(); - wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") ); + wxCHECK_MSG( font.IsOk(), 8, wxT("invalid font") ); - PangoContext *context = NULL; - if (m_widget) - context = gtk_widget_get_pango_context( m_widget ); + PangoContext* context = gtk_widget_get_pango_context(m_widget); if (!context) return 0; @@ -3107,16 +2996,16 @@ int wxWindowGTK::GetCharWidth() const return (int) PANGO_PIXELS(rect.width); } -void wxWindowGTK::GetTextExtent( const wxString& string, - int *x, - int *y, - int *descent, - int *externalLeading, - const wxFont *theFont ) const +void wxWindowGTK::DoGetTextExtent( const wxString& string, + int *x, + int *y, + int *descent, + int *externalLeading, + const wxFont *theFont ) const { wxFont fontToUse = theFont ? *theFont : GetFont(); - wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") ); + wxCHECK_RET( fontToUse.IsOk(), wxT("invalid font") ); if (string.empty()) { @@ -3162,96 +3051,214 @@ void wxWindowGTK::GetTextExtent( const wxString& string, g_object_unref (layout); } -bool wxWindowGTK::GTKSetDelayedFocusIfNeeded() +void wxWindowGTK::GTKDisableFocusOutEvent() { - if ( g_delayedFocus == this ) + g_signal_handlers_block_by_func( m_focusWidget, + (gpointer) gtk_window_focus_out_callback, this); +} + +void wxWindowGTK::GTKEnableFocusOutEvent() +{ + g_signal_handlers_unblock_by_func( m_focusWidget, + (gpointer) gtk_window_focus_out_callback, this); +} + +bool wxWindowGTK::GTKHandleFocusIn() +{ + // Disable default focus handling for custom windows since the default GTK+ + // handler issues a repaint + const bool retval = m_wxwindow ? true : false; + + + // NB: if there's still unprocessed deferred focus-out event (see + // GTKHandleFocusOut() for explanation), we need to process it first so + // that the order of focus events -- focus-out first, then focus-in + // elsewhere -- is preserved + if ( gs_deferredFocusOut ) { - if ( GTK_WIDGET_REALIZED(m_widget) ) + if ( GTKNeedsToFilterSameWindowFocus() && + gs_deferredFocusOut == this ) { - gtk_widget_grab_focus(m_widget); - g_delayedFocus = NULL; - - return true; + // GTK+ focus changed from this wxWindow back to itself, so don't + // emit any events at all + wxLogTrace(TRACE_FOCUS, + "filtered out spurious focus change within %s(%p, %s)", + GetClassInfo()->GetClassName(), this, GetLabel()); + gs_deferredFocusOut = NULL; + return retval; } + + // otherwise we need to send focus-out first + wxASSERT_MSG ( gs_deferredFocusOut != this, + "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" ); + GTKHandleDeferredFocusOut(); } - return false; + + wxLogTrace(TRACE_FOCUS, + "handling focus_in event for %s(%p, %s)", + GetClassInfo()->GetClassName(), this, GetLabel()); + + if (m_imData) + gtk_im_context_focus_in(m_imData->context); + + gs_currentFocus = this; + gs_pendingFocus = NULL; + +#if wxUSE_CARET + // caret needs to be informed about focus change + wxCaret *caret = GetCaret(); + if ( caret ) + { + caret->OnSetFocus(); + } +#endif // wxUSE_CARET + + // Notify the parent keeping track of focus for the kbd navigation + // purposes that we got it. + wxChildFocusEvent eventChildFocus(static_cast(this)); + GTKProcessEvent(eventChildFocus); + + wxFocusEvent eventFocus(wxEVT_SET_FOCUS, GetId()); + eventFocus.SetEventObject(this); + GTKProcessEvent(eventFocus); + + return retval; } -void wxWindowGTK::SetFocus() +bool wxWindowGTK::GTKHandleFocusOut() { - wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); - if ( m_hasFocus ) + // Disable default focus handling for custom windows since the default GTK+ + // handler issues a repaint + const bool retval = m_wxwindow ? true : false; + + + // NB: If a control is composed of several GtkWidgets and when focus + // changes from one of them to another within the same wxWindow, we get + // a focus-out event followed by focus-in for another GtkWidget owned + // by the same wx control. We don't want to generate two spurious + // wxEVT_SET_FOCUS events in this case, so we defer sending wx events + // from GTKHandleFocusOut() until we know for sure it's not coming back + // (i.e. in GTKHandleFocusIn() or at idle time). + if ( GTKNeedsToFilterSameWindowFocus() ) { - // don't do anything if we already have focus - return; + wxASSERT_MSG( gs_deferredFocusOut == NULL, + "deferred focus out event already pending" ); + wxLogTrace(TRACE_FOCUS, + "deferring focus_out event for %s(%p, %s)", + GetClassInfo()->GetClassName(), this, GetLabel()); + gs_deferredFocusOut = this; + return retval; } - if (m_wxwindow) + GTKHandleFocusOutNoDeferring(); + + return retval; +} + +void wxWindowGTK::GTKHandleFocusOutNoDeferring() +{ + wxLogTrace(TRACE_FOCUS, + "handling focus_out event for %s(%p, %s)", + GetClassInfo()->GetClassName(), this, GetLabel()); + + if (m_imData) + gtk_im_context_focus_out(m_imData->context); + + if ( gs_currentFocus != this ) { - if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow)) - { - gtk_widget_grab_focus (m_wxwindow); - } + // Something is terribly wrong, gs_currentFocus is out of sync with the + // real focus. We will reset it to NULL anyway, because after this + // focus-out event is handled, one of the following with happen: + // + // * either focus will go out of the app altogether, in which case + // gs_currentFocus _should_ be NULL + // + // * or it goes to another control, in which case focus-in event will + // follow immediately and it will set gs_currentFocus to the right + // value + wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it", + GetClassInfo()->GetClassName(), this, GetLabel()); } - else if (m_widget) + gs_currentFocus = NULL; + +#if wxUSE_CARET + // caret needs to be informed about focus change + wxCaret *caret = GetCaret(); + if ( caret ) { - if (GTK_IS_CONTAINER(m_widget)) - { - if (IsKindOf(CLASSINFO(wxRadioButton))) - { - gtk_widget_grab_focus (m_widget); - return; - } + caret->OnKillFocus(); + } +#endif // wxUSE_CARET - gtk_widget_child_focus( m_widget, GTK_DIR_TAB_FORWARD ); - } - else - if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) ) - { + wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() ); + event.SetEventObject( this ); + GTKProcessEvent( event ); +} - if (!GTK_WIDGET_REALIZED(m_widget)) - { - // we can't set the focus to the widget now so we remember that - // it should be focused and will do it later, during the idle - // time, as soon as we can - wxLogTrace(TRACE_FOCUS, - _T("Delaying setting focus to %s(%s)"), - GetClassInfo()->GetClassName(), GetLabel().c_str()); - - g_delayedFocus = this; - } - else - { - wxLogTrace(TRACE_FOCUS, - _T("Setting focus to %s(%s)"), - GetClassInfo()->GetClassName(), GetLabel().c_str()); +/*static*/ +void wxWindowGTK::GTKHandleDeferredFocusOut() +{ + // NB: See GTKHandleFocusOut() for explanation. This function is called + // from either GTKHandleFocusIn() or OnInternalIdle() to process + // deferred event. + if ( gs_deferredFocusOut ) + { + wxWindowGTK *win = gs_deferredFocusOut; + gs_deferredFocusOut = NULL; - gtk_widget_grab_focus (m_widget); - } - } - else - { - wxLogTrace(TRACE_FOCUS, - _T("Can't set focus to %s(%s)"), - GetClassInfo()->GetClassName(), GetLabel().c_str()); - } + wxLogTrace(TRACE_FOCUS, + "processing deferred focus_out event for %s(%p, %s)", + win->GetClassInfo()->GetClassName(), win, win->GetLabel()); + + win->GTKHandleFocusOutNoDeferring(); } } -void wxWindowGTK::SetCanFocus(bool canFocus) +void wxWindowGTK::SetFocus() { - if ( canFocus ) - GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS); + wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); + + // Setting "physical" focus is not immediate in GTK+ and while + // gtk_widget_is_focus ("determines if the widget is the focus widget + // within its toplevel", i.e. returns true for one widget per TLW, not + // globally) returns true immediately after grabbing focus, + // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that + // has focus at the moment) takes effect only after the window is shown + // (if it was hidden at the moment of the call) or at the next event loop + // iteration. + // + // Because we want to FindFocus() call immediately following + // foo->SetFocus() to return foo, we have to keep track of "pending" focus + // ourselves. + gs_pendingFocus = this; + + GtkWidget *widget = m_wxwindow ? m_wxwindow : m_focusWidget; + + if ( GTK_IS_CONTAINER(widget) && + !gtk_widget_get_can_focus(widget) ) + { + wxLogTrace(TRACE_FOCUS, + wxT("Setting focus to a child of %s(%p, %s)"), + GetClassInfo()->GetClassName(), this, GetLabel().c_str()); + gtk_widget_child_focus(widget, GTK_DIR_TAB_FORWARD); + } else - GTK_WIDGET_UNSET_FLAGS(m_widget, GTK_CAN_FOCUS); + { + wxLogTrace(TRACE_FOCUS, + wxT("Setting focus to %s(%p, %s)"), + GetClassInfo()->GetClassName(), this, GetLabel().c_str()); + gtk_widget_grab_focus(widget); + } +} + +void wxWindowGTK::SetCanFocus(bool canFocus) +{ + gtk_widget_set_can_focus(m_widget, canFocus); if ( m_wxwindow && (m_widget != m_wxwindow) ) { - if ( canFocus ) - GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS); - else - GTK_WIDGET_UNSET_FLAGS(m_wxwindow, GTK_CAN_FOCUS); + gtk_widget_set_can_focus(m_wxwindow, canFocus); } } @@ -3259,8 +3266,7 @@ bool wxWindowGTK::Reparent( wxWindowBase *newParentBase ) { wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") ); - wxWindowGTK *oldParent = m_parent, - *newParent = (wxWindowGTK *)newParentBase; + wxWindowGTK * const newParent = (wxWindowGTK *)newParentBase; wxASSERT( GTK_IS_WIDGET(m_widget) ); @@ -3269,31 +3275,25 @@ bool wxWindowGTK::Reparent( wxWindowBase *newParentBase ) wxASSERT( GTK_IS_WIDGET(m_widget) ); - /* prevent GTK from deleting the widget arbitrarily */ - gtk_widget_ref( m_widget ); - - if (oldParent) - { - gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget ); - } + // Notice that old m_parent pointer might be non-NULL here but the widget + // still not have any parent at GTK level if it's a notebook page that had + // been removed from the notebook so test this at GTK level and not wx one. + if ( GtkWidget *parentGTK = gtk_widget_get_parent(m_widget) ) + gtk_container_remove(GTK_CONTAINER(parentGTK), m_widget); wxASSERT( GTK_IS_WIDGET(m_widget) ); if (newParent) { - if (GTK_WIDGET_VISIBLE (newParent->m_widget)) + if (gtk_widget_get_visible (newParent->m_widget)) { m_showOnIdle = true; gtk_widget_hide( m_widget ); } - /* insert GTK representation */ - (*(newParent->m_insertCallback))(newParent, this); + newParent->AddChildGTK(this); } - /* reverse: prevent GTK from deleting the widget arbitrarily */ - gtk_widget_unref( m_widget ); - SetLayoutDirection(wxLayout_Default); return true; @@ -3308,7 +3308,7 @@ void wxWindowGTK::DoAddChild(wxWindowGTK *child) AddChild( child ); /* insert GTK representation */ - (*m_insertCallback)(this, child); + AddChildGTK(child); } void wxWindowGTK::AddChild(wxWindowBase *child) @@ -3336,7 +3336,7 @@ wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget) /* static */ void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir) { - wxASSERT_MSG( dir != wxLayout_Default, _T("invalid layout direction") ); + wxASSERT_MSG( dir != wxLayout_Default, wxT("invalid layout direction") ); gtk_widget_set_direction(widget, dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL @@ -3378,11 +3378,11 @@ wxWindowGTK::AdjustForLayoutDirection(wxCoord x, wxCoord WXUNUSED(width), wxCoord WXUNUSED(widthTotal)) const { - // We now mirrors the coordinates of RTL windows in GtkPizza + // We now mirror the coordinates of RTL windows in wxPizza return x; } -void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, MoveKind move) +void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, WindowOrder move) { wxWindowBase::DoMoveInTabOrder(win, move); m_dirtyTabOrder = true; @@ -3393,14 +3393,14 @@ bool wxWindowGTK::DoNavigateIn(int flags) { if ( flags & wxNavigationKeyEvent::WinChange ) { - wxFAIL_MSG( _T("not implemented") ); + wxFAIL_MSG( wxT("not implemented") ); return false; } else // navigate inside the container { - wxWindow *parent = wxGetTopLevelParent(this); - wxCHECK_MSG( parent, false, _T("every window must have a TLW parent") ); + wxWindow *parent = wxGetTopLevelParent((wxWindow *)this); + wxCHECK_MSG( parent, false, wxT("every window must have a TLW parent") ); GtkDirectionType dir; dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD @@ -3443,18 +3443,20 @@ void wxWindowGTK::RealizeTabOrder() { wxWindowGTK *win = *i; + bool focusableFromKeyboard = win->AcceptsFocusFromKeyboard(); + if ( mnemonicWindow ) { - if ( win->AcceptsFocusFromKeyboard() ) + if ( focusableFromKeyboard ) { // wxComboBox et al. needs to focus on on a different // widget than m_widget, so if the main widget isn't // focusable try the connect widget GtkWidget* w = win->m_widget; - if ( !GTK_WIDGET_CAN_FOCUS(w) ) + if ( !gtk_widget_get_can_focus(w) ) { w = win->GetConnectWidget(); - if ( !GTK_WIDGET_CAN_FOCUS(w) ) + if ( !gtk_widget_get_can_focus(w) ) w = NULL; } @@ -3470,7 +3472,8 @@ void wxWindowGTK::RealizeTabOrder() mnemonicWindow = win; } - chain = g_list_prepend(chain, win->m_widget); + if ( focusableFromKeyboard ) + chain = g_list_prepend(chain, win->m_widget); } chain = g_list_reverse(chain); @@ -3489,13 +3492,13 @@ void wxWindowGTK::Raise() { wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); - if (m_wxwindow && m_wxwindow->window) + if (m_wxwindow && gtk_widget_get_window(m_wxwindow)) { - gdk_window_raise( m_wxwindow->window ); + gdk_window_raise(gtk_widget_get_window(m_wxwindow)); } - else if (m_widget->window) + else if (gtk_widget_get_window(m_widget)) { - gdk_window_raise( m_widget->window ); + gdk_window_raise(gtk_widget_get_window(m_widget)); } } @@ -3503,19 +3506,19 @@ void wxWindowGTK::Lower() { wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); - if (m_wxwindow && m_wxwindow->window) + if (m_wxwindow && gtk_widget_get_window(m_wxwindow)) { - gdk_window_lower( m_wxwindow->window ); + gdk_window_lower(gtk_widget_get_window(m_wxwindow)); } - else if (m_widget->window) + else if (gtk_widget_get_window(m_widget)) { - gdk_window_lower( m_widget->window ); + gdk_window_lower(gtk_widget_get_window(m_widget)); } } bool wxWindowGTK::SetCursor( const wxCursor &cursor ) { - if ( !wxWindowBase::SetCursor(cursor.Ok() ? cursor : *wxSTANDARD_CURSOR) ) + if ( !wxWindowBase::SetCursor(cursor.IsOk() ? cursor : *wxSTANDARD_CURSOR) ) return false; GTKUpdateCursor(); @@ -3523,33 +3526,40 @@ bool wxWindowGTK::SetCursor( const wxCursor &cursor ) return true; } -void wxWindowGTK::GTKUpdateCursor() +void wxWindowGTK::GTKUpdateCursor(bool update_self /*=true*/, bool recurse /*=true*/) { - wxCursor cursor(g_globalCursor.Ok() ? g_globalCursor : GetCursor()); - if ( cursor.Ok() ) + if (update_self) { - wxArrayGdkWindows windowsThis; - GdkWindow * const winThis = GTKGetWindow(windowsThis); - if ( winThis ) - { - gdk_window_set_cursor(winThis, cursor.GetCursor()); - } - else + wxCursor cursor(g_globalCursor.IsOk() ? g_globalCursor : GetCursor()); + if ( cursor.IsOk() ) { - const size_t count = windowsThis.size(); - for ( size_t n = 0; n < count; n++ ) + wxArrayGdkWindows windowsThis; + GdkWindow* window = GTKGetWindow(windowsThis); + if (window) + gdk_window_set_cursor( window, cursor.GetCursor() ); + else { - GdkWindow *win = windowsThis[n]; - if ( !win ) + const size_t count = windowsThis.size(); + for ( size_t n = 0; n < count; n++ ) { - wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?")); - continue; + GdkWindow *win = windowsThis[n]; + // It can be zero if the window has not been realized yet. + if ( win ) + { + gdk_window_set_cursor(win, cursor.GetCursor()); + } } - - gdk_window_set_cursor(win, cursor.GetCursor()); } } } + + if (recurse) + { + for (wxWindowList::iterator it = GetChildren().begin(); it != GetChildren().end(); ++it) + { + (*it)->GTKUpdateCursor( true ); + } + } } void wxWindowGTK::WarpPointer( int x, int y ) @@ -3559,11 +3569,11 @@ void wxWindowGTK::WarpPointer( int x, int y ) // We provide this function ourselves as it is // missing in GDK (top of this file). - GdkWindow *window = (GdkWindow*) NULL; + GdkWindow *window = NULL; if (m_wxwindow) - window = GTK_PIZZA(m_wxwindow)->bin_window; + window = gtk_widget_get_window(m_wxwindow); else - window = GetConnectWidget()->window; + window = gtk_widget_get_window(GetConnectWidget()); if (window) gdk_window_warp_pointer( window, x, y ); @@ -3578,7 +3588,7 @@ wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const return (ScrollDir)dir; } - wxFAIL_MSG( _T("event from unknown scrollbar received") ); + wxFAIL_MSG( wxT("event from unknown scrollbar received") ); return ScrollDir_Max; } @@ -3589,14 +3599,14 @@ bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units) GtkRange* range = m_scrollBar[dir]; if ( range && units ) { - GtkAdjustment* adj = range->adjustment; - gdouble inc = unit == ScrollUnit_Line ? adj->step_increment - : adj->page_increment; + GtkAdjustment* adj = gtk_range_get_adjustment(range); + double inc = unit == ScrollUnit_Line ? gtk_adjustment_get_step_increment(adj) + : gtk_adjustment_get_page_increment(adj); - const int posOld = int(adj->value + 0.5); + const int posOld = wxRound(gtk_adjustment_get_value(adj)); gtk_range_set_value(range, posOld + units*inc); - changed = int(adj->value + 0.5) != posOld; + changed = wxRound(gtk_adjustment_get_value(adj)) != posOld; } return changed; @@ -3612,65 +3622,65 @@ bool wxWindowGTK::ScrollPages(int pages) return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages); } -void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect ) +void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground), + const wxRect *rect) { - if (!m_widget) - return; - if (!m_widget->window) + if ( !m_widget ) + { + // it is valid to call Refresh() for a window which hasn't been created + // yet, it simply doesn't do anything in this case return; + } - if (m_wxwindow) + if (!m_wxwindow) { - if (!GTK_PIZZA(m_wxwindow)->bin_window) return; + if (rect) + gtk_widget_queue_draw_area( m_widget, rect->x, rect->y, rect->width, rect->height ); + else + gtk_widget_queue_draw( m_widget ); + } + else + { + // Just return if the widget or one of its ancestors isn't mapped + GtkWidget *w; + for (w = m_wxwindow; w != NULL; w = gtk_widget_get_parent(w)) + if (!gtk_widget_get_mapped (w)) + return; - GdkRectangle gdk_rect, - *p; + GdkWindow* window = GTKGetDrawingWindow(); if (rect) { - gdk_rect.x = rect->x; - gdk_rect.y = rect->y; - gdk_rect.width = rect->width; - gdk_rect.height = rect->height; + int x = rect->x; if (GetLayoutDirection() == wxLayout_RightToLeft) - gdk_rect.x = GetClientSize().x - gdk_rect.x - gdk_rect.width; - - p = &gdk_rect; - } - else // invalidate everything - { - p = NULL; + x = GetClientSize().x - x - rect->width; + GdkRectangle r; + r.x = rect->x; + r.y = rect->y; + r.width = rect->width; + r.height = rect->height; + gdk_window_invalidate_rect(window, &r, true); } - - gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, p, TRUE ); + else + gdk_window_invalidate_rect(window, NULL, true); } } void wxWindowGTK::Update() { - GtkUpdate(); + if (m_widget && gtk_widget_get_mapped(m_widget)) + { + GdkDisplay* display = gtk_widget_get_display(m_widget); + // Flush everything out to the server, and wait for it to finish. + // This ensures nothing will overwrite the drawing we are about to do. + gdk_display_sync(display); - // when we call Update() we really want to update the window immediately on - // screen, even if it means flushing the entire queue and hence slowing down - // everything -- but it should still be done, it's just that Update() should - // be called very rarely - gdk_flush(); -} + GdkWindow* window = GTKGetDrawingWindow(); + if (window == NULL) + window = gtk_widget_get_window(m_widget); + gdk_window_process_updates(window, true); -void wxWindowGTK::GtkUpdate() -{ - if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window) - gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE ); - if (m_widget && m_widget->window && (m_wxwindow != m_widget)) - gdk_window_process_updates( m_widget->window, FALSE ); - - // for consistency with other platforms (and also because it's convenient - // to be able to update an entire TLW by calling Update() only once), we - // should also update all our children here - for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); - node; - node = node->GetNext() ) - { - node->GetData()->GtkUpdate(); + // Flush again, but no need to wait for it to finish + gdk_display_flush(display); } } @@ -3679,7 +3689,6 @@ bool wxWindowGTK::DoIsExposed( int x, int y ) const return m_updateRegion.Contains(x, y) != wxOutRegion; } - bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const { if (GetLayoutDirection() == wxLayout_RightToLeft) @@ -3707,8 +3716,7 @@ void wxWindowGTK::GtkSendPaintEvents() m_updateRegion.Clear(); gint width; - gdk_window_get_geometry( GTK_PIZZA(m_wxwindow)->bin_window, - NULL, NULL, &width, NULL, NULL ); + gdk_drawable_get_size(gtk_widget_get_window(m_wxwindow), &width, NULL); wxRegionIterator upd( m_nativeUpdateRegion ); while (upd) @@ -3726,58 +3734,83 @@ void wxWindowGTK::GtkSendPaintEvents() } } - // widget to draw on - GtkPizza *pizza = GTK_PIZZA (m_wxwindow); - - if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM)) + switch ( GetBackgroundStyle() ) { - // find ancestor from which to steal background - wxWindow *parent = wxGetTopLevelParent((wxWindow *)this); - if (!parent) - parent = (wxWindow*)this; + case wxBG_STYLE_ERASE: + { + wxWindowDC dc( (wxWindow*)this ); + dc.SetDeviceClippingRegion( m_updateRegion ); + + // Work around gtk-qt <= 0.60 bug whereby the window colour + // remains grey + if ( UseBgCol() && + wxSystemOptions:: + GetOptionInt("gtk.window.force-background-colour") ) + { + dc.SetBackground(GetBackgroundColour()); + dc.Clear(); + } - if (GTK_WIDGET_MAPPED(parent->m_widget)) - { - wxRegionIterator upd( m_nativeUpdateRegion ); - while (upd) + wxEraseEvent erase_event( GetId(), &dc ); + erase_event.SetEventObject( this ); + + if ( HandleWindowEvent(erase_event) ) + { + // background erased, don't do it again + break; + } + } + // fall through + + case wxBG_STYLE_SYSTEM: + if ( GetThemeEnabled() ) { - GdkRectangle rect; - rect.x = upd.GetX(); - rect.y = upd.GetY(); - rect.width = upd.GetWidth(); - rect.height = upd.GetHeight(); - - gtk_paint_flat_box( parent->m_widget->style, - pizza->bin_window, - (GtkStateType)GTK_WIDGET_STATE(m_wxwindow), - GTK_SHADOW_NONE, - &rect, - parent->m_widget, - (char *)"base", - 0, 0, -1, -1 ); - - ++upd; + // find ancestor from which to steal background + wxWindow *parent = wxGetTopLevelParent((wxWindow *)this); + if (!parent) + parent = (wxWindow*)this; + + if (gtk_widget_get_mapped(parent->m_widget)) + { + wxRegionIterator upd( m_nativeUpdateRegion ); + while (upd) + { + GdkRectangle rect; + rect.x = upd.GetX(); + rect.y = upd.GetY(); + rect.width = upd.GetWidth(); + rect.height = upd.GetHeight(); + + gtk_paint_flat_box(gtk_widget_get_style(parent->m_widget), + GTKGetDrawingWindow(), + gtk_widget_get_state(m_wxwindow), + GTK_SHADOW_NONE, + &rect, + parent->m_widget, + (char *)"base", + 0, 0, -1, -1 ); + + ++upd; + } + } } - } - } - else - { - wxWindowDC dc( (wxWindow*)this ); - dc.SetClippingRegion( m_updateRegion ); + break; - wxEraseEvent erase_event( GetId(), &dc ); - erase_event.SetEventObject( this ); + case wxBG_STYLE_PAINT: + // nothing to do: window will be painted over in EVT_PAINT + break; - GetEventHandler()->ProcessEvent(erase_event); + default: + wxFAIL_MSG( "unsupported background style" ); } wxNcPaintEvent nc_paint_event( GetId() ); nc_paint_event.SetEventObject( this ); - GetEventHandler()->ProcessEvent( nc_paint_event ); + HandleWindowEvent( nc_paint_event ); wxPaintEvent paint_event( GetId() ); paint_event.SetEventObject( this ); - GetEventHandler()->ProcessEvent( paint_event ); + HandleWindowEvent( paint_event ); m_clipPaintRegion = false; @@ -3795,7 +3828,7 @@ void wxWindowGTK::SetDoubleBuffered( bool on ) bool wxWindowGTK::IsDoubleBuffered() const { - return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow ); + return gtk_widget_get_double_buffered( m_wxwindow ); } void wxWindowGTK::ClearBackground() @@ -3806,15 +3839,20 @@ void wxWindowGTK::ClearBackground() #if wxUSE_TOOLTIPS void wxWindowGTK::DoSetToolTip( wxToolTip *tip ) { - wxWindowBase::DoSetToolTip(tip); + if (m_tooltip != tip) + { + wxWindowBase::DoSetToolTip(tip); - if (m_tooltip) - m_tooltip->Apply( (wxWindow *)this ); + if (m_tooltip) + m_tooltip->GTKSetWindow(static_cast(this)); + else + GTKApplyToolTip(NULL); + } } -void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const gchar *tip ) +void wxWindowGTK::GTKApplyToolTip(const char* tip) { - gtk_tooltips_set_tip(tips, GetConnectWidget(), tip, NULL); + wxToolTip::GTKApply(GetConnectWidget(), tip); } #endif // wxUSE_TOOLTIPS @@ -3825,7 +3863,7 @@ bool wxWindowGTK::SetBackgroundColour( const wxColour &colour ) if (!wxWindowBase::SetBackgroundColour(colour)) return false; - if (colour.Ok()) + if (colour.IsOk()) { // We need the pixel value e.g. for background clearing. m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget)); @@ -3833,8 +3871,7 @@ bool wxWindowGTK::SetBackgroundColour( const wxColour &colour ) // apply style change (forceStyle=true so that new style is applied // even if the bg colour changed from valid to wxNullColour) - if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM) - ApplyWidgetStyle(true); + GTKApplyWidgetStyle(true); return true; } @@ -3848,7 +3885,7 @@ bool wxWindowGTK::SetForegroundColour( const wxColour &colour ) return false; } - if (colour.Ok()) + if (colour.IsOk()) { // We need the pixel value e.g. for background clearing. m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget)); @@ -3856,29 +3893,29 @@ bool wxWindowGTK::SetForegroundColour( const wxColour &colour ) // apply style change (forceStyle=true so that new style is applied // even if the bg colour changed from valid to wxNullColour): - ApplyWidgetStyle(true); + GTKApplyWidgetStyle(true); return true; } -PangoContext *wxWindowGTK::GtkGetPangoDefaultContext() +PangoContext *wxWindowGTK::GTKGetPangoDefaultContext() { return gtk_widget_get_pango_context( m_widget ); } -GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle) +GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle) { // do we need to apply any changes at all? if ( !forceStyle && - !m_font.Ok() && - !m_foregroundColour.Ok() && !m_backgroundColour.Ok() ) + !m_font.IsOk() && + !m_foregroundColour.IsOk() && !m_backgroundColour.IsOk() ) { return NULL; } GtkRcStyle *style = gtk_rc_style_new(); - if ( m_font.Ok() ) + if ( m_font.IsOk() ) { style->font_desc = pango_font_description_copy( m_font.GetNativeFontInfo()->description ); @@ -3889,7 +3926,7 @@ GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle) flagsActive = 0, flagsInsensitive = 0; - if ( m_foregroundColour.Ok() ) + if ( m_foregroundColour.IsOk() ) { const GdkColor *fg = m_foregroundColour.GetColor(); @@ -3906,7 +3943,7 @@ GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle) flagsActive |= GTK_RC_FG | GTK_RC_TEXT; } - if ( m_backgroundColour.Ok() ) + if ( m_backgroundColour.IsOk() ) { const GdkColor *bg = m_backgroundColour.GetColor(); @@ -3935,13 +3972,13 @@ GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle) return style; } -void wxWindowGTK::ApplyWidgetStyle(bool forceStyle) +void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle) { - GtkRcStyle *style = CreateWidgetStyle(forceStyle); + GtkRcStyle *style = GTKCreateWidgetStyle(forceStyle); if ( style ) { DoApplyWidgetStyle(style); - gtk_rc_style_unref(style); + g_object_unref(style); } // Style change may affect GTK+'s size calculation: @@ -3950,23 +3987,48 @@ void wxWindowGTK::ApplyWidgetStyle(bool forceStyle) void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style) { - if (m_wxwindow) + if ( m_wxwindow ) + { + // block the signal temporarily to avoid sending + // wxSysColourChangedEvents when we change the colours ourselves + bool unblock = false; + if ( IsTopLevel() ) + { + unblock = true; + g_signal_handlers_block_by_func( + m_wxwindow, (void *)gtk_window_style_set_callback, this); + } + gtk_widget_modify_style(m_wxwindow, style); + + if ( unblock ) + { + g_signal_handlers_unblock_by_func( + m_wxwindow, (void *)gtk_window_style_set_callback, this); + } + } else + { gtk_widget_modify_style(m_widget, style); + } } bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) { wxWindowBase::SetBackgroundStyle(style); - if (style == wxBG_STYLE_CUSTOM) + if ( style == wxBG_STYLE_PAINT ) { - GdkWindow *window = (GdkWindow*) NULL; - if (m_wxwindow) - window = GTK_PIZZA(m_wxwindow)->bin_window; + GdkWindow *window; + if ( m_wxwindow ) + { + window = GTKGetDrawingWindow(); + } else - window = GetConnectWidget()->window; + { + GtkWidget * const w = GetConnectWidget(); + window = w ? gtk_widget_get_window(w) : NULL; + } if (window) { @@ -3979,9 +4041,11 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) #endif m_needsStyleChange = false; } - else + else // window not realized yet + { // Do in OnIdle, because the window is not yet available m_needsStyleChange = true; + } // Don't apply widget style, or we get a grey background } @@ -3989,11 +4053,83 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) { // apply style change (forceStyle=true so that new style is applied // even if the bg colour changed from valid to wxNullColour): - ApplyWidgetStyle(true); + GTKApplyWidgetStyle(true); + } + + return true; +} + +// ---------------------------------------------------------------------------- +// Pop-up menu stuff +// ---------------------------------------------------------------------------- + +#if wxUSE_MENUS_NATIVE + +extern "C" { +static +void wxPopupMenuPositionCallback( GtkMenu *menu, + gint *x, gint *y, + gboolean * WXUNUSED(whatever), + gpointer user_data ) +{ + // ensure that the menu appears entirely on screen + GtkRequisition req; + gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req); + + wxSize sizeScreen = wxGetDisplaySize(); + wxPoint *pos = (wxPoint*)user_data; + + gint xmax = sizeScreen.x - req.width, + ymax = sizeScreen.y - req.height; + + *x = pos->x < xmax ? pos->x : xmax; + *y = pos->y < ymax ? pos->y : ymax; +} +} + +bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y ) +{ + wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") ); + + menu->UpdateUI(); + + wxPoint pos; + gpointer userdata; + GtkMenuPositionFunc posfunc; + if ( x == -1 && y == -1 ) + { + // use GTK's default positioning algorithm + userdata = NULL; + posfunc = NULL; + } + else + { + pos = ClientToScreen(wxPoint(x, y)); + userdata = &pos; + posfunc = wxPopupMenuPositionCallback; } + + menu->m_popupShown = true; + gtk_menu_popup( + GTK_MENU(menu->m_menu), + NULL, // parent menu shell + NULL, // parent menu item + posfunc, // function to position it + userdata, // client data + 0, // button used to activate it + gtk_get_current_event_time() + ); + + while (menu->m_popupShown) + { + gtk_main_iteration(); + } + return true; } +#endif // wxUSE_MENUS_NATIVE + #if wxUSE_DRAG_AND_DROP void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget ) @@ -4002,12 +4138,12 @@ void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget ) GtkWidget *dnd_widget = GetConnectWidget(); - if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget ); + if (m_dropTarget) m_dropTarget->GtkUnregisterWidget( dnd_widget ); if (m_dropTarget) delete m_dropTarget; m_dropTarget = dropTarget; - if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget ); + if (m_dropTarget) m_dropTarget->GtkRegisterWidget( dnd_widget ); } #endif // wxUSE_DRAG_AND_DROP @@ -4031,7 +4167,7 @@ bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const { - return m_wxwindow ? GTK_PIZZA(m_wxwindow)->bin_window : m_widget->window; + return m_wxwindow ? GTKGetDrawingWindow() : gtk_widget_get_window(m_widget); } bool wxWindowGTK::SetFont( const wxFont &font ) @@ -4043,7 +4179,7 @@ bool wxWindowGTK::SetFont( const wxFont &font ) // apply style change (forceStyle=true so that new style is applied // even if the font changed from valid to wxNullFont): - ApplyWidgetStyle(true); + GTKApplyWidgetStyle(true); return true; } @@ -4052,16 +4188,16 @@ void wxWindowGTK::DoCaptureMouse() { wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); - GdkWindow *window = (GdkWindow*) NULL; + GdkWindow *window = NULL; if (m_wxwindow) - window = GTK_PIZZA(m_wxwindow)->bin_window; + window = GTKGetDrawingWindow(); else - window = GetConnectWidget()->window; + window = gtk_widget_get_window(GetConnectWidget()); - wxCHECK_RET( window, _T("CaptureMouse() failed") ); + wxCHECK_RET( window, wxT("CaptureMouse() failed") ); const wxCursor* cursor = &m_cursor; - if (!cursor->Ok()) + if (!cursor->IsOk()) cursor = wxSTANDARD_CURSOR; gdk_pointer_grab( window, FALSE, @@ -4070,7 +4206,7 @@ void wxWindowGTK::DoCaptureMouse() GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_POINTER_MOTION_MASK), - (GdkWindow *) NULL, + NULL, cursor->GetCursor(), (guint32)GDK_CURRENT_TIME ); g_captureWindow = this; @@ -4083,13 +4219,13 @@ void wxWindowGTK::DoReleaseMouse() wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") ); - g_captureWindow = (wxWindowGTK*) NULL; + g_captureWindow = NULL; - GdkWindow *window = (GdkWindow*) NULL; + GdkWindow *window = NULL; if (m_wxwindow) - window = GTK_PIZZA(m_wxwindow)->bin_window; + window = GTKGetDrawingWindow(); else - window = GetConnectWidget()->window; + window = gtk_widget_get_window(GetConnectWidget()); if (!window) return; @@ -4097,6 +4233,14 @@ void wxWindowGTK::DoReleaseMouse() gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME ); } +void wxWindowGTK::GTKReleaseMouseAndNotify() +{ + DoReleaseMouse(); + wxMouseCaptureLostEvent evt(GetId()); + evt.SetEventObject( this ); + HandleWindowEvent( evt ); +} + /* static */ wxWindow *wxWindowBase::GetCapture() { @@ -4108,104 +4252,79 @@ bool wxWindowGTK::IsRetained() const return false; } -void wxWindowGTK::BlockScrollEvent() -{ - wxASSERT(!m_blockScrollEvent); - m_blockScrollEvent = true; -} - -void wxWindowGTK::UnblockScrollEvent() -{ - wxASSERT(m_blockScrollEvent); - m_blockScrollEvent = false; -} - void wxWindowGTK::SetScrollbar(int orient, int pos, int thumbVisible, int range, bool WXUNUSED(update)) { - wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); - wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") ); - wxCHECK_RET( m_wxwindow != m_widget, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") ); + const int dir = ScrollDirFromOrient(orient); + GtkRange* const sb = m_scrollBar[dir]; + wxCHECK_RET( sb, wxT("this window is not scrollable") ); - if (range > 0) - { - m_hasScrolling = true; - } - else + if (range <= 0) { // GtkRange requires upper > lower range = thumbVisible = 1; } - if (pos > range - thumbVisible) - pos = range - thumbVisible; - if (pos < 0) - pos = 0; - GtkAdjustment* adj = m_scrollBar[ScrollDirFromOrient(orient)]->adjustment; - adj->step_increment = 1; - adj->page_increment = - adj->page_size = thumbVisible; - adj->upper = range; - SetScrollPos(orient, pos); - gtk_adjustment_changed(adj); + g_signal_handlers_block_by_func( + sb, (void*)gtk_scrollbar_value_changed, this); + + gtk_range_set_increments(sb, 1, thumbVisible); + gtk_adjustment_set_page_size(gtk_range_get_adjustment(sb), thumbVisible); + gtk_range_set_range(sb, 0, range); + gtk_range_set_value(sb, pos); + m_scrollPos[dir] = gtk_range_get_value(sb); + + g_signal_handlers_unblock_by_func( + sb, (void*)gtk_scrollbar_value_changed, this); } void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh)) { - wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); - wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") ); - wxCHECK_RET( m_wxwindow != m_widget, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") ); + const int dir = ScrollDirFromOrient(orient); + GtkRange * const sb = m_scrollBar[dir]; + wxCHECK_RET( sb, wxT("this window is not scrollable") ); // This check is more than an optimization. Without it, the slider // will not move smoothly while tracking when using wxScrollHelper. if (GetScrollPos(orient) != pos) { - const int dir = ScrollDirFromOrient(orient); - GtkAdjustment* adj = m_scrollBar[dir]->adjustment; - const int max = int(adj->upper - adj->page_size); - if (pos > max) - pos = max; - if (pos < 0) - pos = 0; - m_scrollPos[dir] = adj->value = pos; - - // If a "value_changed" signal emission is not already in progress - if (!m_blockValueChanged[dir]) - { - gtk_adjustment_value_changed(adj); - } + g_signal_handlers_block_by_func( + sb, (void*)gtk_scrollbar_value_changed, this); + + gtk_range_set_value(sb, pos); + m_scrollPos[dir] = gtk_range_get_value(sb); + + g_signal_handlers_unblock_by_func( + sb, (void*)gtk_scrollbar_value_changed, this); } } int wxWindowGTK::GetScrollThumb(int orient) const { - wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") ); - wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") ); - wxCHECK_MSG( m_wxwindow != m_widget, 0, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") ); + GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)]; + wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") ); - return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->page_size); + return wxRound(gtk_adjustment_get_page_size(gtk_range_get_adjustment(sb))); } int wxWindowGTK::GetScrollPos( int orient ) const { - wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") ); - wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") ); - wxCHECK_MSG( m_wxwindow != m_widget, 0, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") ); + GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)]; + wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") ); - return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->value + 0.5); + return wxRound(gtk_range_get_value(sb)); } int wxWindowGTK::GetScrollRange( int orient ) const { - wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") ); - wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") ); - wxCHECK_MSG( m_wxwindow != m_widget, 0, wxT("no scrolling for this wxWindow, use wxHSCROLL or wxVSCROLL") ); + GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)]; + wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") ); - return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->upper); + return wxRound(gtk_adjustment_get_upper(gtk_range_get_adjustment(sb))); } // Determine if increment is the same as +/-x, allowing for some small @@ -4217,23 +4336,20 @@ static inline bool IsScrollIncrement(double increment, double x) return fabs(increment - fabs(x)) < tolerance; } -wxEventType wxWindowGTK::GetScrollEventType(GtkRange* range) +wxEventType wxWindowGTK::GTKGetScrollEventType(GtkRange* range) { - DEBUG_MAIN_THREAD - wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]); const int barIndex = range == m_scrollBar[1]; - GtkAdjustment* adj = range->adjustment; - const int value = int(adj->value + 0.5); + const double value = gtk_range_get_value(range); // save previous position const double oldPos = m_scrollPos[barIndex]; // update current position - m_scrollPos[barIndex] = adj->value; + m_scrollPos[barIndex] = value; // If event should be ignored, or integral position has not changed - if (!m_hasVMT || g_blockEventsOnDrag || value == int(oldPos + 0.5)) + if (!m_hasVMT || g_blockEventsOnDrag || wxRound(value) == wxRound(oldPos)) { return wxEVT_NULL; } @@ -4242,14 +4358,15 @@ wxEventType wxWindowGTK::GetScrollEventType(GtkRange* range) if (!m_isScrolling) { // Difference from last change event - const double diff = adj->value - oldPos; + const double diff = value - oldPos; const bool isDown = diff > 0; - if (IsScrollIncrement(adj->step_increment, diff)) + GtkAdjustment* adj = gtk_range_get_adjustment(range); + if (IsScrollIncrement(gtk_adjustment_get_step_increment(adj), diff)) { eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP; } - else if (IsScrollIncrement(adj->page_increment, diff)) + else if (IsScrollIncrement(gtk_adjustment_get_page_increment(adj), diff)) { eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP; } @@ -4273,10 +4390,7 @@ void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) ) m_clipPaintRegion = true; - if (GetLayoutDirection() == wxLayout_RightToLeft) - gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), dx, -dy ); - else - gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy ); + WX_PIZZA(m_wxwindow)->scroll(dx, dy); m_clipPaintRegion = false; @@ -4303,7 +4417,7 @@ void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) ) #endif // wxUSE_CARET } -void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget* w, int wxstyle) +void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget* w, int wxstyle) { //RN: Note that static controls usually have no border on gtk, so maybe //it makes sense to treat that as simply no border at the wx level @@ -4314,10 +4428,13 @@ void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget* w, int wxstyle) if(wxstyle & wxBORDER_RAISED) gtkstyle = GTK_SHADOW_OUT; - else if (wxstyle & wxBORDER_SUNKEN) + else if ((wxstyle & wxBORDER_SUNKEN) || (wxstyle & wxBORDER_THEME)) gtkstyle = GTK_SHADOW_IN; +#if 0 + // Now obsolete else if (wxstyle & wxBORDER_DOUBLE) gtkstyle = GTK_SHADOW_ETCHED_IN; +#endif else //default gtkstyle = GTK_SHADOW_IN; @@ -4371,13 +4488,103 @@ wxPoint wxGetMousePosition() } -// Needed for implementing e.g. combobox on wxGTK within a modal dialog. -void wxAddGrab(wxWindow* window) +GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const +{ + GdkWindow* window = NULL; + if (m_wxwindow) + window = gtk_widget_get_window(m_wxwindow); + return window; +} + +// ---------------------------------------------------------------------------- +// freeze/thaw +// ---------------------------------------------------------------------------- + +extern "C" +{ + +// this is called if we attempted to freeze unrealized widget when it finally +// is realized (and so can be frozen): +static void wx_frozen_widget_realize(GtkWidget* w, wxWindowGTK* win) +{ + wxASSERT( w && gtk_widget_get_has_window(w) ); + wxASSERT( gtk_widget_get_realized(w) ); + + g_signal_handlers_disconnect_by_func + ( + w, + (void*)wx_frozen_widget_realize, + win + ); + + GdkWindow* window; + if (w == win->m_wxwindow) + window = win->GTKGetDrawingWindow(); + else + window = gtk_widget_get_window(w); + gdk_window_freeze_updates(window); +} + +} // extern "C" + +void wxWindowGTK::GTKFreezeWidget(GtkWidget *w) +{ + if ( !w || !gtk_widget_get_has_window(w) ) + return; // window-less widget, cannot be frozen + + GdkWindow* window = gtk_widget_get_window(w); + if (window == NULL) + { + // we can't thaw unrealized widgets because they don't have GdkWindow, + // so set it up to be done immediately after realization: + g_signal_connect_after + ( + w, + "realize", + G_CALLBACK(wx_frozen_widget_realize), + this + ); + return; + } + + if (w == m_wxwindow) + window = GTKGetDrawingWindow(); + gdk_window_freeze_updates(window); +} + +void wxWindowGTK::GTKThawWidget(GtkWidget *w) +{ + if ( !w || !gtk_widget_get_has_window(w) ) + return; // window-less widget, cannot be frozen + + GdkWindow* window = gtk_widget_get_window(w); + if (window == NULL) + { + // the widget wasn't realized yet, no need to thaw + g_signal_handlers_disconnect_by_func + ( + w, + (void*)wx_frozen_widget_realize, + this + ); + return; + } + + if (w == m_wxwindow) + window = GTKGetDrawingWindow(); + gdk_window_thaw_updates(window); +} + +void wxWindowGTK::DoFreeze() { - gtk_grab_add( (GtkWidget*) window->GetHandle() ); + GTKFreezeWidget(m_widget); + if ( m_wxwindow && m_widget != m_wxwindow ) + GTKFreezeWidget(m_wxwindow); } -void wxRemoveGrab(wxWindow* window) +void wxWindowGTK::DoThaw() { - gtk_grab_remove( (GtkWidget*) window->GetHandle() ); + GTKThawWidget(m_widget); + if ( m_wxwindow && m_widget != m_wxwindow ) + GTKThawWidget(m_wxwindow); }