#include <ctype.h>
#include "wx/gtk/private.h"
-#include "wx/gtk/win_gtk.h"
+#include "wx/gtk/private/win_gtk.h"
#include <gdk/gdkkeysyms.h>
#include <gdk/gdkx.h>
static wxWindowGTK *g_captureWindow = (wxWindowGTK*) NULL;
static bool g_captureWindowHasMouse = false;
-wxWindowGTK *g_focusWindow = (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
}
}
-//-----------------------------------------------------------------------------
-// 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;
-}
//-----------------------------------------------------------------------------
// "size_request" of m_widget
extern "C" {
static gboolean
-gtk_window_expose_callback( GtkWidget*,
+gtk_window_expose_callback( GtkWidget* widget,
GdkEventExpose *gdk_event,
wxWindow *win )
{
-#if 0
- if (win->GetName())
+ if (gdk_event->window == widget->window)
{
- 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 );
+ win->GetUpdateRegion() = wxRegion( gdk_event->region );
+ win->GtkSendPaintEvents();
}
-
- 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
-
- win->GetUpdateRegion() = wxRegion( gdk_event->region );
-
- win->GtkSendPaintEvents();
-
// Let parent window draw window-less widgets
return FALSE;
}
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:
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;
int command = ancestor->GetAcceleratorTable()->GetCommand( event );
if (command != -1)
{
- wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
- ret = ancestor->HandleWindowEvent( 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())
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->HandleWindowEvent(eventChildFocus);
-
- wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
- eventFocus.SetEventObject(win);
-
- return win->HandleWindowEvent(eventFocus);
-}
-
// all event handlers must have C linkage as they're called from GTK+ C code
extern "C"
{
return TRUE;
if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() &&
- (g_focusWindow != win) /* && win->IsFocusable() */)
+ (gs_currentFocus != win) /* && win->IsFocusable() */)
{
win->SetFocus();
}
static gboolean
gtk_window_focus_in_callback( GtkWidget * WXUNUSED(widget),
GdkEventFocus *WXUNUSED(event),
- wxWindow *win )
+ wxWindowGTK *win )
{
- if (win->m_imData)
- gtk_im_context_focus_in(win->m_imData->context);
-
- 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();
}
//-----------------------------------------------------------------------------
GdkEventFocus * WXUNUSED(gdk_event),
wxWindowGTK *win )
{
- 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 WXUNUSED(direction),
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 wx_static_cast(wxWindow*, focus);
}
//-----------------------------------------------------------------------------
m_insertCallback = wxInsertChildInWindow;
- m_hasFocus = false;
-
m_clipPaintRegion = false;
m_needsStyleChange = false;
m_focusWidget = m_wxwindow;
+ SetCanFocus(AcceptsFocus());
+
PostCreation();
return true;
{
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;
if (height != -1)
m_height = height;
- ConstrainSize();
-
if (m_parent->m_wxwindow)
{
wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
void wxWindowGTK::OnInternalIdle()
{
+ if ( gs_deferredFocusOut )
+ GTKHandleDeferredFocusOut();
+
// Check if we have to show window now
if (GtkShowFromOnIdle()) return;
g_object_unref (layout);
}
-bool wxWindowGTK::GTKSetDelayedFocusIfNeeded()
+
+bool wxWindowGTK::GTKHandleFocusIn()
{
- if ( g_delayedFocus == this )
+ // 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(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);
+ // 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());
+ }
+ gs_currentFocus = NULL;
- if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
- {
- gtk_widget_grab_focus (m_wxwindow);
- }
+#if wxUSE_CARET
+ // caret needs to be informed about focus change
+ wxCaret *caret = GetCaret();
+ if ( caret )
+ {
+ caret->OnKillFocus();
}
- else
+#endif // wxUSE_CARET
+
+ wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
+ event.SetEventObject( this );
+ GTKProcessEvent( event );
+}
+
+/*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 )
{
- // 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);
+ wxWindowGTK *win = gs_deferredFocusOut;
+ gs_deferredFocusOut = NULL;
- if (GTK_IS_CONTAINER(m_widget))
- {
- if (GTK_IS_RADIO_BUTTON(m_widget))
- {
- gtk_widget_grab_focus (m_widget);
- return;
- }
+ wxLogTrace(TRACE_FOCUS,
+ "processing deferred focus_out event for %s(%p, %s)",
+ win->GetClassInfo()->GetClassName(), win, win->GetLabel());
- gtk_widget_child_focus( m_widget, GTK_DIR_TAB_FORWARD );
- }
- else
- if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
- {
+ win->GTKHandleFocusOutNoDeferring();
+ }
+}
- 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());
+void wxWindowGTK::SetFocus()
+{
+ wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
- gtk_widget_grab_focus (m_widget);
- }
- }
- else
- {
- wxLogTrace(TRACE_FOCUS,
- _T("Can't set focus to %s(%s)"),
- GetClassInfo()->GetClassName(), GetLabel().c_str());
- }
+ // 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);
}
}
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;
+}
+}
+
+void wxWindowGTK::DoPopupMenuUpdateUI(wxMenu* menu)
+{
+ menu->UpdateUI();
+}
+
+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 );
+
+ DoPopupMenuUpdateUI(menu);
+
+ 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),
+ (GtkWidget *) NULL, // parent menu shell
+ (GtkWidget *) 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 )
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()
+{
+ GTKFreezeWidget(m_widget);
+ if ( m_wxwindow && m_widget != m_wxwindow )
+ GTKFreezeWidget(m_wxwindow);
+}
+
+void wxWindowGTK::DoThaw()
+{
+ GTKThawWidget(m_widget);
+ if ( m_wxwindow && m_widget != m_wxwindow )
+ GTKThawWidget(m_wxwindow);
+}
projects / wxWidgets.git / blobdiff