X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/00ff24c81c0343c7372b9c45cbd1f9fbb8648555..55410bb4f67febe1ca20654f078ea4fb9a6223ae:/src/gtk/window.cpp?ds=sidebyside diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp index d8ae28d541..b996ff7fee 100644 --- a/src/gtk/window.cpp +++ b/src/gtk/window.cpp @@ -19,15 +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/toolbar.h" - #include "wx/combobox.h" - #include "wx/layout.h" #include "wx/math.h" #endif @@ -35,26 +31,38 @@ #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 "wx/gtk/private/win_gtk.h" #include #include +#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 //----------------------------------------------------------------------------- @@ -115,19 +123,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- @@ -141,10 +149,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) @@ -197,42 +205,28 @@ 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") @@ -258,158 +252,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 ); @@ -423,103 +275,96 @@ void wxgtk_window_size_request_callback(GtkWidget *widget, } } -#if wxUSE_COMBOBOX +//----------------------------------------------------------------------------- +// "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* widget, + 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 == widget->window) + { + win->GetUpdateRegion() = wxRegion( gdk_event->region ); + win->GtkSendPaintEvents(); + } + // Let parent window draw window-less widgets + return FALSE; } } -#endif // wxUSE_COMBOBOX - +#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 - - // 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 (gdk_event->window != widget->window) + 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; - } + const GtkAllocation& alloc = win->m_wxwindow->allocation; + 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, + widget->style->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 ); + gtk_paint_shadow( + win->m_wxwindow->style, gdk_event->window, GTK_STATE_NORMAL, + shadow, NULL, 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); + } + if (widget->parent) + { + g_signal_connect_after(widget->parent, "expose_event", + G_CALLBACK(expose_event_border), win); + } } } +#endif // !__WXUNIVERSAL__ //----------------------------------------------------------------------------- // "key_press_event" from any window @@ -689,11 +534,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: @@ -765,32 +610,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; @@ -837,8 +682,7 @@ static void wxFillOtherKeyEventFields(wxKeyEvent& event, 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; event.m_rawCode = (wxUint32) gdk_event->keyval; event.m_rawFlags = 0; #if wxUSE_UNICODE @@ -979,23 +823,15 @@ struct wxGtkIMData 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; - // GTK+ sends keypress events to the focus widget and then - // to all its parent and grandparent widget. We only want - // the key events from the focus widget. - if (!GTK_WIDGET_HAS_FOCUS(widget)) - return FALSE; - wxKeyEvent event( wxEVT_KEY_DOWN ); bool ret = false; bool return_after_IM = false; @@ -1003,7 +839,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 { @@ -1038,8 +874,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()) @@ -1098,13 +944,13 @@ gtk_window_key_press_callback( GtkWidget *widget, if (parent) { event.SetEventType( wxEVT_CHAR_HOOK ); - ret = parent->GetEventHandler()->ProcessEvent( event ); + ret = parent->HandleWindowEvent( event ); } if (!ret) { event.SetEventType(wxEVT_CHAR); - ret = win->GetEventHandler()->ProcessEvent( event ); + ret = win->HandleWindowEvent( event ); } } } @@ -1115,7 +961,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) { @@ -1174,13 +1020,13 @@ gtk_wxwindow_commit_cb (GtkIMContext *context, if (parent) { event.SetEventType( wxEVT_CHAR_HOOK ); - ret = parent->GetEventHandler()->ProcessEvent( event ); + ret = parent->HandleWindowEvent( event ); } if (!ret) { event.SetEventType(wxEVT_CHAR); - ret = window->GetEventHandler()->ProcessEvent( event ); + ret = window->HandleWindowEvent( event ); } } } @@ -1193,12 +1039,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; @@ -1230,15 +1074,15 @@ 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; - event.m_aux1Down = gdk_event->state & GDK_BUTTON4_MASK; - event.m_aux2Down = gdk_event->state & GDK_BUTTON5_MASK; + 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; + 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; @@ -1247,7 +1091,7 @@ 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) ); + int window_width = win->m_wxwindow->allocation.width; event.m_x = window_width - event.m_x; } @@ -1297,9 +1141,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(); @@ -1311,7 +1155,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; @@ -1337,7 +1181,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) && @@ -1361,13 +1205,11 @@ 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 { - DEBUG_MAIN_THREAD - if (!m_hasVMT) return FALSE; if (g_blockEventsOnDrag) @@ -1401,21 +1243,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" { @@ -1456,10 +1283,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 @@ -1469,7 +1293,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) { @@ -1544,10 +1367,6 @@ gtk_window_button_press_callback( GtkWidget *widget, 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. @@ -1563,8 +1382,8 @@ gtk_window_button_press_callback( GtkWidget *widget, if ( ret ) return TRUE; - if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() && - (g_focusWindow != win) /* && win->IsFocusable() */) + if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() && + (gs_currentFocus != win) /* && win->IsFocusable() */) { win->SetFocus(); } @@ -1594,7 +1413,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 ) { @@ -1630,9 +1449,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); @@ -1652,7 +1468,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 ) { @@ -1724,10 +1540,40 @@ gtk_window_motion_notify_callback( GtkWidget *widget, //----------------------------------------------------------------------------- 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; + } + + wxMouseEvent event(wxEVT_MOUSEWHEEL); + InitMouseEvent(win, event, gdk_event); + + GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Horz]; + if (!range) return FALSE; + + if (range && GTK_WIDGET_VISIBLE (range)) + { + GtkAdjustment *adj = range->adjustment; + gdouble delta = adj->step_increment * 3; + if (gdk_event->direction == GDK_SCROLL_LEFT) + delta = -delta; + + gdouble new_value = CLAMP (adj->value + delta, adj->lower, adj->upper - adj->page_size); + + gtk_adjustment_set_value (adj, new_value); + + 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) { @@ -1736,6 +1582,8 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win) wxMouseEvent event(wxEVT_MOUSEWHEEL); 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) @@ -1743,7 +1591,27 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win) else event.m_wheelRotation = -120; - return win->GTKProcessEvent(event); + if (win->GTKProcessEvent(event)) + return TRUE; + + GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Vert]; + if (!range) return FALSE; + + if (range && GTK_WIDGET_VISIBLE (range)) + { + GtkAdjustment *adj = range->adjustment; + gdouble delta = adj->step_increment * 3; + if (gdk_event->direction == GDK_SCROLL_UP) + delta = -delta; + + gdouble new_value = CLAMP (adj->value + delta, adj->lower, adj->upper - adj->page_size); + + gtk_adjustment_set_value (adj, new_value); + + return TRUE; + } + + return FALSE; } //----------------------------------------------------------------------------- @@ -1762,49 +1630,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(); } //----------------------------------------------------------------------------- @@ -1812,68 +1642,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 @@ -1958,7 +1743,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 @@ -1983,8 +1768,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; @@ -2004,9 +1787,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); } } @@ -2017,8 +1801,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 @@ -2039,15 +1821,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 ); + widget->window); } // We cannot set colours and fonts before the widget @@ -2066,60 +1845,105 @@ gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win ) } //----------------------------------------------------------------------------- -// "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; - - if ( !client_width && !client_height ) + int w = alloc->width; + int h = alloc->height; + if (win->m_wxwindow) { - // the window is currently unmapped, don't generate size events - return; + 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 + win->m_width = win->m_widget->allocation.width; + win->m_height = win->m_widget->allocation.height; + if (!win->m_nativeSizeEvent) + { + wxSizeEvent event(win->GetSize(), win->GetId()); + event.SetEventObject(win); + win->GTKProcessEvent(event); + } } +} - win->m_oldClientWidth = client_width; - win->m_oldClientHeight = client_height; +//----------------------------------------------------------------------------- +// "grab_broken" +//----------------------------------------------------------------------------- - if (!win->m_nativeSizeEvent) - { - wxSizeEvent event( win->GetSize(), win->GetId() ); - event.SetEventObject( win ); - win->GTKProcessEvent( event ); - } -} - -//----------------------------------------------------------------------------- -// "grab_broken" -//----------------------------------------------------------------------------- - -#ifdef __WXGTK210__ -static void -gtk_window_grab_broken( GtkWidget *m_widget, +#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 && win && wxWindow::GetCapture() == win ) + if(!event->keyboard && wxWindow::GetCapture() == win) { wxMouseCaptureLostEvent evt( win->GetId() ); evt.SetEventObject( win ); - win->GetEventHandler()->ProcessEvent( evt ); + win->HandleWindowEvent( evt ); } + return false; } #endif +//----------------------------------------------------------------------------- +// "style_set" +//----------------------------------------------------------------------------- + +static +void gtk_window_style_set_callback( GtkWidget *WXUNUSED(widget), + GtkStyle *previous_style, + wxWindow* win ) +{ + if (win && previous_style) + { + wxSysColourChangedEvent event; + event.SetEventObject(win); + + win->GTKProcessEvent( event ); + } +} } // extern "C" +// Helper to suspend colour change event event processing while we change a widget's style +class wxSuspendStyleEvents +{ +public: + wxSuspendStyleEvents(wxWindow* win) + { + m_win = NULL; + if (win->m_wxwindow && win->IsTopLevel()) + { + m_win = win; + g_signal_handlers_block_by_func( + m_win->m_wxwindow, (void*)gtk_window_style_set_callback, m_win); + } + } + ~wxSuspendStyleEvents() + { + if (m_win) + g_signal_handlers_unblock_by_func( + m_win->m_wxwindow, (void*)gtk_window_style_set_callback, m_win); + } + + wxWindow* m_win; +}; + // ---------------------------------------------------------------------------- // this wxWindowBase function is implemented here (in platform-specific file) // because it is static and so couldn't be made virtual @@ -2127,35 +1951,23 @@ gtk_window_grab_broken( GtkWidget *m_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 ); + wxPizza* pizza = WX_PIZZA(m_wxwindow); + child->m_x += pizza->m_scroll_x; + child->m_y += pizza->m_scroll_y; - gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow), - child->m_widget, - child->m_x, - child->m_y, - child->m_width, - child->m_height ); + gtk_widget_set_size_request( + child->m_widget, child->m_width, child->m_height); + gtk_fixed_put( + GTK_FIXED(m_wxwindow), child->m_widget, child->m_x, child->m_y); } //----------------------------------------------------------------------------- @@ -2180,16 +1992,16 @@ 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.SetAux1Down(mask & GDK_BUTTON4_MASK); - ms.SetAux2Down(mask & GDK_BUTTON5_MASK); + ms.SetLeftDown((mask & GDK_BUTTON1_MASK) != 0); + ms.SetMiddleDown((mask & GDK_BUTTON2_MASK) != 0); + ms.SetRightDown((mask & GDK_BUTTON3_MASK) != 0); + ms.SetAux1Down((mask & GDK_BUTTON4_MASK) != 0); + ms.SetAux2Down((mask & GDK_BUTTON5_MASK) != 0); - 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.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; } @@ -2209,9 +2021,9 @@ wxMouseState wxGetMouseState() 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; @@ -2220,14 +2032,12 @@ 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; @@ -2241,12 +2051,6 @@ void wxWindowGTK::Init() m_oldClientWidth = m_oldClientHeight = 0; - m_resizing = false; - - m_insertCallback = wxInsertChildInWindow; - - m_hasFocus = false; - m_clipPaintRegion = false; m_needsStyleChange = false; @@ -2281,6 +2085,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 )) { @@ -2288,37 +2098,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,this); +#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 @@ -2377,12 +2179,15 @@ bool wxWindowGTK::Create( wxWindow *parent, 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; @@ -2392,13 +2197,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 @@ -2422,17 +2228,17 @@ 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; - } - 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 ) @@ -2467,7 +2273,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 @@ -2478,10 +2284,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 @@ -2526,12 +2328,15 @@ void wxWindowGTK::PostCreation() g_signal_connect (connect_widget, "realize", G_CALLBACK (gtk_window_realized_callback), this); + if (!IsTopLevel()) + { + g_signal_connect(m_wxwindow ? m_wxwindow : m_widget, "size_allocate", + G_CALLBACK(size_allocate), this); + } + if (m_wxwindow) { - // Catch native resize events - g_signal_connect (m_wxwindow, "size_allocate", - G_CALLBACK (gtk_window_size_callback), this); -#ifdef __WXGTK210__ +#if GTK_CHECK_VERSION(2, 8, 0) if (!gtk_check_version(2,8,0)) { // Make sure we can notify the app when mouse capture is lost @@ -2543,7 +2348,7 @@ void wxWindowGTK::PostCreation() if ( connect_widget != m_wxwindow ) { -#ifdef __WXGTK210__ +#if GTK_CHECK_VERSION(2, 8, 0) if (!gtk_check_version(2,8,0)) { // Make sure we can notify app code when mouse capture is lost @@ -2553,16 +2358,6 @@ void wxWindowGTK::PostCreation() #endif } -#if wxUSE_COMBOBOX - if (GTK_IS_COMBO(m_widget)) - { - GtkCombo *gcombo = GTK_COMBO(m_widget); - - g_signal_connect (gcombo->entry, "size_request", - G_CALLBACK (wxgtk_combo_size_request_callback), - this); - } else -#endif // wxUSE_COMBOBOX #ifdef GTK_IS_FILE_CHOOSER_BUTTON if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget)) { @@ -2607,14 +2402,26 @@ 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() @@ -2628,9 +2435,9 @@ bool wxWindowGTK::Destroy() void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height) { + gtk_widget_set_size_request(m_widget, width, height); // inform the parent to perform the move - gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height ); - + WX_PIZZA(m_parent->m_wxwindow)->move(m_widget, x, y); } void wxWindowGTK::ConstrainSize() @@ -2655,9 +2462,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)) @@ -2677,43 +2481,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)) + if (m_parent->m_wxwindow) { - // 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 - { - 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; @@ -2741,35 +2519,29 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags 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)) { @@ -2782,7 +2554,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; } @@ -2792,8 +2564,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 ) { @@ -2821,7 +2596,7 @@ void wxWindowGTK::OnInternalIdle() if (m_wxwindow && (m_wxwindow != m_widget)) { - GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window; + GdkWindow *window = m_wxwindow->window; if (window) gdk_window_set_cursor( window, cursor.GetCursor() ); @@ -2841,7 +2616,7 @@ void wxWindowGTK::OnInternalIdle() } } - if (wxUpdateUIEvent::CanUpdate(this)) + if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen()) UpdateWindowUI(wxUPDATE_UI_FROMIDLE); } @@ -2869,20 +2644,58 @@ 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]); + + 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; - if (m_hasScrolling) - GetScrollbarWidth(m_widget, dw, dh); + // 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 ( adj->upper <= adj->page_size ) + continue; + } - const int border = GTK_CONTAINER(m_wxwindow)->border_width; - dw += 2 * border; - dh += 2 * border; + 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; + } + } + + int border_x, border_y; + WX_PIZZA(m_wxwindow)->get_border_widths(border_x, border_y); + w -= 2 * border_x; + h -= 2 * border_y; - w -= dw; - h -= dh; if (w < 0) w = 0; if (h < 0) @@ -2899,18 +2712,18 @@ void wxWindowGTK::DoGetPosition( int *x, int *y ) const 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 = m_wxwindow->window; else source = m_widget->window; @@ -2923,8 +2736,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; } } @@ -2938,9 +2751,9 @@ void wxWindowGTK::DoClientToScreen( int *x, int *y ) const if (!m_widget->window) return; - GdkWindow *source = (GdkWindow *) NULL; + GdkWindow *source = NULL; if (m_wxwindow) - source = GTK_PIZZA(m_wxwindow)->bin_window; + source = m_wxwindow->window; else source = m_widget->window; @@ -2975,9 +2788,9 @@ void wxWindowGTK::DoScreenToClient( int *x, int *y ) const if (!m_widget->window) return; - GdkWindow *source = (GdkWindow *) NULL; + GdkWindow *source = NULL; if (m_wxwindow) - source = GTK_PIZZA(m_wxwindow)->bin_window; + source = m_wxwindow->window; else source = m_widget->window; @@ -3014,22 +2827,19 @@ bool wxWindowGTK::Show( bool show ) return false; } - if (show) + if (show && m_showOnIdle) { - if (!m_showOnIdle) - { - gtk_widget_show( m_widget ); - wxShowEvent eventShow(GetId(), show); - eventShow.SetEventObject(this); - GetEventHandler()->ProcessEvent(eventShow); - } + // deferred } else { - gtk_widget_hide( m_widget ); + if (show) + gtk_widget_show(m_widget); + else + gtk_widget_hide(m_widget); wxShowEvent eventShow(GetId(), show); eventShow.SetEventObject(this); - GetEventHandler()->ProcessEvent(eventShow); + HandleWindowEvent(eventShow); } return true; @@ -3051,9 +2861,7 @@ int wxWindowGTK::GetCharHeight() const wxFont font = GetFont(); wxCHECK_MSG( font.Ok(), 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; @@ -3079,9 +2887,7 @@ int wxWindowGTK::GetCharWidth() const wxFont font = GetFont(); wxCHECK_MSG( font.Ok(), 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; @@ -3155,90 +2961,204 @@ 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 ) { - // wxWindow::SetFocus() should really set the focus to - // this control, whatever the flags are - if (!GTK_WIDGET_CAN_FOCUS(m_wxwindow)) - GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS); - - 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 ) { - // wxWindow::SetFocus() should really set the focus to - // this control, whatever the flags are - if (!GTK_WIDGET_CAN_FOCUS(m_widget)) - GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS); - - if (GTK_IS_CONTAINER(m_widget)) - { - if (GTK_IS_RADIO_BUTTON(m_widget)) - { - 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::SetFocus() +{ + 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 affect 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_CAN_FOCUS(widget) ) + { + wxLogTrace(TRACE_FOCUS, + _T("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 + { + wxLogTrace(TRACE_FOCUS, + _T("Setting focus to %s(%p, %s)"), + GetClassInfo()->GetClassName(), this, GetLabel().c_str()); + gtk_widget_grab_focus(widget); } } @@ -3272,13 +3192,8 @@ 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 ); - } wxASSERT( GTK_IS_WIDGET(m_widget) ); @@ -3289,14 +3204,10 @@ bool wxWindowGTK::Reparent( wxWindowBase *newParentBase ) 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; @@ -3311,7 +3222,7 @@ void wxWindowGTK::DoAddChild(wxWindowGTK *child) AddChild( child ); /* insert GTK representation */ - (*m_insertCallback)(this, child); + AddChildGTK(child); } void wxWindowGTK::AddChild(wxWindowBase *child) @@ -3381,11 +3292,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; @@ -3562,9 +3473,9 @@ 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 = m_wxwindow->window; else window = GetConnectWidget()->window; @@ -3615,65 +3526,54 @@ bool wxWindowGTK::ScrollPages(int pages) return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages); } -void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect ) +#include "wx/treectrl.h" + +void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground), + const wxRect *rect) { - if (!m_widget) + GtkWidget* widget; + if (m_wxwindow) + widget = m_wxwindow; + else if (m_widget) + widget = m_widget; + else return; - if (!m_widget->window) + + if (!widget->window) return; - if (m_wxwindow) + if (rect == NULL) { - if (!GTK_PIZZA(m_wxwindow)->bin_window) return; - - GdkRectangle gdk_rect, - *p; - if (rect) - { - gdk_rect.x = rect->x; - gdk_rect.y = rect->y; - gdk_rect.width = rect->width; - gdk_rect.height = rect->height; - if (GetLayoutDirection() == wxLayout_RightToLeft) - gdk_rect.x = GetClientSize().x - gdk_rect.x - gdk_rect.width; - - p = &gdk_rect; - } - else // invalidate everything - { - p = NULL; - } - - gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, p, TRUE ); + gdk_window_invalidate_rect( widget->window, NULL, TRUE ); + } + else + { + int x = rect->x; + if (GetLayoutDirection() == wxLayout_RightToLeft) + 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( m_wxwindow->window, &r, TRUE ); } } void wxWindowGTK::Update() { - GtkUpdate(); + if (m_widget && m_widget->window) + { + 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(); -} + gdk_window_process_updates(m_widget->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); } } @@ -3682,7 +3582,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) @@ -3710,8 +3609,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(m_wxwindow->window, &width, NULL); wxRegionIterator upd( m_nativeUpdateRegion ); while (upd) @@ -3729,9 +3627,6 @@ void wxWindowGTK::GtkSendPaintEvents() } } - // widget to draw on - GtkPizza *pizza = GTK_PIZZA (m_wxwindow); - if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM)) { // find ancestor from which to steal background @@ -3751,7 +3646,7 @@ void wxWindowGTK::GtkSendPaintEvents() rect.height = upd.GetHeight(); gtk_paint_flat_box( parent->m_widget->style, - pizza->bin_window, + m_wxwindow->window, (GtkStateType)GTK_WIDGET_STATE(m_wxwindow), GTK_SHADOW_NONE, &rect, @@ -3766,22 +3661,29 @@ void wxWindowGTK::GtkSendPaintEvents() else { wxWindowDC dc( (wxWindow*)this ); - dc.SetClippingRegion( m_updateRegion ); + dc.SetDeviceClippingRegion( m_updateRegion ); + + // Work around gtk-qt <= 0.60 bug whereby the window colour + // remains grey + if (GetBackgroundStyle() == wxBG_STYLE_COLOUR && GetBackgroundColour().Ok() && wxSystemOptions::GetOptionInt(wxT("gtk.window.force-background-colour")) == 1) + { + dc.SetBackground(wxBrush(GetBackgroundColour())); + dc.Clear(); + } wxEraseEvent erase_event( GetId(), &dc ); erase_event.SetEventObject( this ); - GetEventHandler()->ProcessEvent(erase_event); + HandleWindowEvent(erase_event); } 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; @@ -3813,10 +3715,10 @@ void wxWindowGTK::DoSetToolTip( wxToolTip *tip ) wxWindowBase::DoSetToolTip(tip); if (m_tooltip) - m_tooltip->Apply( (wxWindow *)this ); + m_tooltip->GTKApply( (wxWindow *)this ); } -void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const gchar *tip ) +void wxWindowGTK::GTKApplyToolTip( GtkTooltips *tips, const gchar *tip ) { gtk_tooltips_set_tip(tips, GetConnectWidget(), tip, NULL); } @@ -3838,7 +3740,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; } @@ -3860,17 +3762,17 @@ 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 && @@ -3939,9 +3841,9 @@ 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); @@ -3954,6 +3856,8 @@ void wxWindowGTK::ApplyWidgetStyle(bool forceStyle) void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style) { + wxSuspendStyleEvents s(static_cast(this)); + if (m_wxwindow) gtk_widget_modify_style(m_wxwindow, style); else @@ -3969,7 +3873,7 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) GdkWindow *window; if ( m_wxwindow ) { - window = GTK_PIZZA(m_wxwindow)->bin_window; + window = m_wxwindow->window; } else { @@ -4000,11 +3904,103 @@ 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 + +static void SetInvokingWindow( wxMenu *menu, wxWindow* win ) +{ + menu->SetInvokingWindow( win ); + + wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst(); + while (node) + { + wxMenuItem *menuitem = node->GetData(); + if (menuitem->IsSubMenu()) + { + SetInvokingWindow( menuitem->GetSubMenu(), win ); + } + + node = node->GetNext(); + } +} + +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") ); + + wxCHECK_MSG( menu != NULL, false, wxT("invalid popup-menu") ); + + SetInvokingWindow( menu, this ); + + 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 ) @@ -4013,12 +4009,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 @@ -4042,7 +4038,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 ? m_wxwindow->window : m_widget->window; } bool wxWindowGTK::SetFont( const wxFont &font ) @@ -4054,7 +4050,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; } @@ -4063,9 +4059,9 @@ 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 = m_wxwindow->window; else window = GetConnectWidget()->window; @@ -4081,7 +4077,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; @@ -4094,11 +4090,11 @@ 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 = m_wxwindow->window; else window = GetConnectWidget()->window; @@ -4113,7 +4109,7 @@ void wxWindowGTK::GTKReleaseMouseAndNotify() DoReleaseMouse(); wxMouseCaptureLostEvent evt(GetId()); evt.SetEventObject( this ); - GetEventHandler()->ProcessEvent( evt ); + HandleWindowEvent( evt ); } /* static */ @@ -4137,11 +4133,7 @@ void wxWindowGTK::SetScrollbar(int orient, GtkRange* const sb = m_scrollBar[dir]; wxCHECK_RET( sb, _T("this window is not scrollable") ); - if (range > 0) - { - m_hasScrolling = true; - } - else + if (range <= 0) { // GtkRange requires upper > lower range = @@ -4190,7 +4182,7 @@ int wxWindowGTK::GetScrollThumb(int orient) const GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)]; wxCHECK_MSG( sb, 0, _T("this window is not scrollable") ); - return int(sb->adjustment->page_size); + return wxRound(sb->adjustment->page_size); } int wxWindowGTK::GetScrollPos( int orient ) const @@ -4198,7 +4190,7 @@ int wxWindowGTK::GetScrollPos( int orient ) const GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)]; wxCHECK_MSG( sb, 0, _T("this window is not scrollable") ); - return int(sb->adjustment->value + 0.5); + return wxRound(sb->adjustment->value); } int wxWindowGTK::GetScrollRange( int orient ) const @@ -4206,7 +4198,7 @@ int wxWindowGTK::GetScrollRange( int orient ) const GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)]; wxCHECK_MSG( sb, 0, _T("this window is not scrollable") ); - return int(sb->adjustment->upper); + return wxRound(sb->adjustment->upper); } // Determine if increment is the same as +/-x, allowing for some small @@ -4218,23 +4210,21 @@ 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 int value = wxRound(adj->value); // save previous position const double oldPos = m_scrollPos[barIndex]; // update current position m_scrollPos[barIndex] = adj->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 || value == wxRound(oldPos)) { return wxEVT_NULL; } @@ -4274,10 +4264,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; @@ -4304,7 +4291,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 @@ -4317,8 +4304,11 @@ void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget* w, int wxstyle) gtkstyle = GTK_SHADOW_OUT; else if (wxstyle & wxBORDER_SUNKEN) 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; @@ -4372,13 +4362,92 @@ 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 = m_wxwindow->window; + 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, void* WXUNUSED(data)) +{ + wxASSERT( w && !GTK_WIDGET_NO_WINDOW(w) ); + wxASSERT( GTK_WIDGET_REALIZED(w) ); + + g_signal_handlers_disconnect_by_func + ( + w, + (void*)wx_frozen_widget_realize, + NULL + ); + + gdk_window_freeze_updates(w->window); +} + +} // extern "C" + +void wxWindowGTK::GTKFreezeWidget(GtkWidget *w) +{ + if ( !w || GTK_WIDGET_NO_WINDOW(w) ) + return; // window-less widget, cannot be frozen + + if ( !GTK_WIDGET_REALIZED(w) ) + { + // 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), + NULL + ); + return; + } + + gdk_window_freeze_updates(w->window); +} + +void wxWindowGTK::GTKThawWidget(GtkWidget *w) +{ + if ( !w || GTK_WIDGET_NO_WINDOW(w) ) + return; // window-less widget, cannot be frozen + + if ( !GTK_WIDGET_REALIZED(w) ) + { + // the widget wasn't realized yet, no need to thaw + g_signal_handlers_disconnect_by_func + ( + w, + (void*)wx_frozen_widget_realize, + NULL + ); + return; + } + + gdk_window_thaw_updates(w->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); }