if (!win->IsShown())
return false;
- const GtkAllocation& alloc = win->m_wxwindow->allocation;
+ GtkAllocation alloc;
+ gtk_widget_get_allocation(win->m_wxwindow, &alloc);
const int x = alloc.x;
const int y = alloc.y;
const int w = alloc.width;
if (win->HasFlag(wxBORDER_SIMPLE))
{
gdk_draw_rectangle(gdk_event->window,
- widget->style->black_gc, false, x, y, w - 1, h - 1);
+ gtk_widget_get_style(widget)->black_gc, false, x, y, w - 1, h - 1);
}
else
{
// for scrollable ones
detail = "viewport";
+ // clip rect is required to avoid painting background
+ // over upper left (w,h) of parent window
+ GdkRectangle clipRect = { x, y, w, h };
gtk_paint_shadow(
- win->m_wxwindow->style, gdk_event->window, GTK_STATE_NORMAL,
- shadow, NULL, wxGTKPrivate::GetEntryWidget(), detail, x, y, w, h);
+ gtk_widget_get_style(win->m_wxwindow), gdk_event->window, GTK_STATE_NORMAL,
+ shadow, &clipRect, wxGTKPrivate::GetEntryWidget(), detail, x, y, w, h);
}
return false;
}
g_signal_handlers_disconnect_by_func(
old_parent, (void*)expose_event_border, win);
}
- if (widget->parent)
+ GtkWidget* parent = gtk_widget_get_parent(widget);
+ if (parent)
{
- g_signal_connect_after(widget->parent, "expose_event",
+ g_signal_connect_after(parent, "expose_event",
G_CALLBACK(expose_event_border), win);
}
}
wxWindowGTK *win,
GdkEventKey *gdk_event)
{
- int x = 0;
- int y = 0;
- GdkModifierType state;
- if (gdk_event->window)
- gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
-
event.SetTimestamp( gdk_event->time );
event.SetId(win->GetId());
event.m_rawCode = (wxUint32) gdk_event->keyval;
event.m_rawFlags = gdk_event->hardware_keycode;
- wxGetMousePosition( &x, &y );
- win->ScreenToClient( &x, &y );
- event.m_x = x;
- event.m_y = y;
+ wxGetMousePosition(&event.m_x, &event.m_y);
+ win->ScreenToClient(&event.m_x, &event.m_y);
event.SetEventObject( win );
}
event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK) != 0;
event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK) != 0;
event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK) != 0;
+
+ // In gdk/win32 VK_XBUTTON1 is translated to GDK_BUTTON4_MASK
+ // and VK_XBUTTON2 to GDK_BUTTON5_MASK. In x11/gdk buttons 4/5
+ // are wheel rotation and buttons 8/9 don't change the state.
event.m_aux1Down = (gdk_event->state & GDK_BUTTON4_MASK) != 0;
event.m_aux2Down = (gdk_event->state & GDK_BUTTON5_MASK) != 0;
if ((win->m_wxwindow) && (win->GetLayoutDirection() == wxLayout_RightToLeft))
{
// origin in the upper right corner
- int window_width = win->m_wxwindow->allocation.width;
+ GtkAllocation a;
+ gtk_widget_get_allocation(win->m_wxwindow, &a);
+ int window_width = a.width;
event.m_x = window_width - event.m_x;
}
event.m_rightDown = !event.m_rightDown;
return;
}
+
+ if ((event.GetEventType() == wxEVT_AUX1_DOWN) ||
+ (event.GetEventType() == wxEVT_AUX1_DCLICK))
+ {
+ event.m_aux1Down = true;
+ return;
+ }
+
+ if ((event.GetEventType() == wxEVT_AUX2_DOWN) ||
+ (event.GetEventType() == wxEVT_AUX2_DCLICK))
+ {
+ event.m_aux2Down = true;
+ return;
+ }
}
// find the window to send the mouse event too
}
}
+ else if (gdk_event->button == 8)
+ {
+ switch (gdk_event->type)
+ {
+ case GDK_3BUTTON_PRESS:
+ case GDK_BUTTON_PRESS:
+ event_type = wxEVT_AUX1_DOWN;
+ break;
+
+ case GDK_2BUTTON_PRESS:
+ event_type = wxEVT_AUX1_DCLICK;
+ break;
+
+ default:
+ ;
+ }
+ }
+
+ else if (gdk_event->button == 9)
+ {
+ switch (gdk_event->type)
+ {
+ case GDK_3BUTTON_PRESS:
+ case GDK_BUTTON_PRESS:
+ event_type = wxEVT_AUX2_DOWN;
+ break;
+
+ case GDK_2BUTTON_PRESS:
+ event_type = wxEVT_AUX2_DCLICK;
+ break;
+
+ default:
+ ;
+ }
+ }
+
if ( event_type == wxEVT_NULL )
{
// unknown mouse button or click type
event_type = wxEVT_RIGHT_UP;
break;
+ case 8:
+ event_type = wxEVT_AUX1_UP;
+ break;
+
+ case 9:
+ event_type = wxEVT_AUX2_UP;
+ break;
+
default:
// unknown button, don't process
return FALSE;
if (range && gtk_widget_get_visible(GTK_WIDGET(range)))
{
- GtkAdjustment *adj = range->adjustment;
- gdouble delta = adj->step_increment * 3;
+ GtkAdjustment* adj = gtk_range_get_adjustment(range);
+ double delta = gtk_adjustment_get_step_increment(adj) * 3;
if (gdk_event->direction == GDK_SCROLL_LEFT)
delta = -delta;
- gdouble new_value = CLAMP (adj->value + delta, adj->lower, adj->upper - adj->page_size);
-
- gtk_adjustment_set_value (adj, new_value);
+ gtk_range_set_value(range, gtk_adjustment_get_value(adj) + delta);
return TRUE;
}
if (range && gtk_widget_get_visible(GTK_WIDGET(range)))
{
- GtkAdjustment *adj = range->adjustment;
- gdouble delta = adj->step_increment * 3;
+ GtkAdjustment* adj = gtk_range_get_adjustment(range);
+ double delta = gtk_adjustment_get_step_increment(adj) * 3;
if (gdk_event->direction == GDK_SCROLL_UP)
- delta = -delta;
-
- gdouble new_value = CLAMP (adj->value + delta, adj->lower, adj->upper - adj->page_size);
+ delta = -delta;
- gtk_adjustment_set_value (adj, new_value);
+ gtk_range_set_value(range, gtk_adjustment_get_value(adj) + delta);
return TRUE;
}
int y = 0;
GdkModifierType state = (GdkModifierType)0;
- gdk_window_get_pointer( widget->window, &x, &y, &state );
+ gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, &state);
wxMouseEvent event( wxEVT_ENTER_WINDOW );
InitMouseEvent(win, event, gdk_event);
int y = 0;
GdkModifierType state = (GdkModifierType)0;
- gdk_window_get_pointer( widget->window, &x, &y, &state );
+ gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, &state);
InitMouseEvent(win, event, gdk_event);
if (win->m_imData)
{
gtk_im_context_set_client_window( win->m_imData->context,
- win->m_wxwindow ? win->GTKGetDrawingWindow() : widget->window);
+ win->m_wxwindow ? win->GTKGetDrawingWindow() : gtk_widget_get_window(widget));
}
// We cannot set colours and fonts before the widget
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;
+ GtkAllocation a;
+ gtk_widget_get_allocation(win->m_widget, &a);
+ win->m_width = a.width;
+ win->m_height = a.height;
if (!win->m_nativeSizeEvent)
{
wxSizeEvent event(win->GetSize(), win->GetId());
ms.SetLeftDown((mask & GDK_BUTTON1_MASK) != 0);
ms.SetMiddleDown((mask & GDK_BUTTON2_MASK) != 0);
ms.SetRightDown((mask & GDK_BUTTON3_MASK) != 0);
+ // see the comment in InitMouseEvent()
ms.SetAux1Down((mask & GDK_BUTTON4_MASK) != 0);
ms.SetAux2Down((mask & GDK_BUTTON5_MASK) != 0);
if (HasFlag(wxALWAYS_SHOW_SB))
{
gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
-
- scrolledWindow->hscrollbar_visible = TRUE;
- scrolledWindow->vscrollbar_visible = TRUE;
}
else
{
gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
}
- m_scrollBar[ScrollDir_Horz] = GTK_RANGE(scrolledWindow->hscrollbar);
- m_scrollBar[ScrollDir_Vert] = GTK_RANGE(scrolledWindow->vscrollbar);
+ m_scrollBar[ScrollDir_Horz] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow));
+ m_scrollBar[ScrollDir_Vert] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow));
if (GetLayoutDirection() == wxLayout_RightToLeft)
gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );
bool wxWindowGTK::Destroy()
{
- wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
-
m_hasVMT = false;
return wxWindowBase::Destroy();
case GTK_POLICY_AUTOMATIC:
// may be shown or not, check
GtkAdjustment *adj = gtk_range_get_adjustment(range);
- if ( adj->upper <= adj->page_size )
+ if (gtk_adjustment_get_upper(adj) <= gtk_adjustment_get_page_size(adj))
continue;
}
{
GdkWindow *source = NULL;
if (m_wxwindow)
- source = m_wxwindow->window;
+ source = gtk_widget_get_window(m_wxwindow);
else
- source = m_widget->window;
+ source = gtk_widget_get_window(m_widget);
if (source)
{
{
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
- if (!m_widget->window) return;
+ if (gtk_widget_get_window(m_widget) == NULL) return;
GdkWindow *source = NULL;
if (m_wxwindow)
- source = m_wxwindow->window;
+ source = gtk_widget_get_window(m_wxwindow);
else
- source = m_widget->window;
+ source = gtk_widget_get_window(m_widget);
int org_x = 0;
int org_y = 0;
{
if (!gtk_widget_get_has_window(m_widget))
{
- org_x += m_widget->allocation.x;
- org_y += m_widget->allocation.y;
+ GtkAllocation a;
+ gtk_widget_get_allocation(m_widget, &a);
+ org_x += a.x;
+ org_y += a.y;
}
}
{
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
- if (!m_widget->window) return;
+ if (!gtk_widget_get_realized(m_widget)) return;
GdkWindow *source = NULL;
if (m_wxwindow)
- source = m_wxwindow->window;
+ source = gtk_widget_get_window(m_wxwindow);
else
- source = m_widget->window;
+ source = gtk_widget_get_window(m_widget);
int org_x = 0;
int org_y = 0;
{
if (!gtk_widget_get_has_window(m_widget))
{
- org_x += m_widget->allocation.x;
- org_y += m_widget->allocation.y;
+ GtkAllocation a;
+ gtk_widget_get_allocation(m_widget, &a);
+ org_x += a.x;
+ org_y += a.y;
}
}
wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
wxFont font = GetFont();
- wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
+ wxCHECK_MSG( font.IsOk(), 12, wxT("invalid font") );
PangoContext* context = gtk_widget_get_pango_context(m_widget);
wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
wxFont font = GetFont();
- wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
+ wxCHECK_MSG( font.IsOk(), 8, wxT("invalid font") );
PangoContext* context = gtk_widget_get_pango_context(m_widget);
{
wxFont fontToUse = theFont ? *theFont : GetFont();
- wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
+ wxCHECK_RET( fontToUse.IsOk(), wxT("invalid font") );
if (string.empty())
{
{
wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
- wxWindowGTK *oldParent = m_parent,
- *newParent = (wxWindowGTK *)newParentBase;
+ wxWindowGTK * const newParent = (wxWindowGTK *)newParentBase;
wxASSERT( GTK_IS_WIDGET(m_widget) );
wxASSERT( GTK_IS_WIDGET(m_widget) );
- if (oldParent)
- gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
+ // Notice that old m_parent pointer might be non-NULL here but the widget
+ // still not have any parent at GTK level if it's a notebook page that had
+ // been removed from the notebook so test this at GTK level and not wx one.
+ if ( GtkWidget *parentGTK = gtk_widget_get_parent(m_widget) )
+ gtk_container_remove(GTK_CONTAINER(parentGTK), m_widget);
wxASSERT( GTK_IS_WIDGET(m_widget) );
{
wxWindowGTK *win = *i;
+ bool focusableFromKeyboard = win->AcceptsFocusFromKeyboard();
+
if ( mnemonicWindow )
{
- if ( win->AcceptsFocusFromKeyboard() )
+ if ( focusableFromKeyboard )
{
// wxComboBox et al. needs to focus on on a different
// widget than m_widget, so if the main widget isn't
mnemonicWindow = win;
}
- chain = g_list_prepend(chain, win->m_widget);
+ if ( focusableFromKeyboard )
+ chain = g_list_prepend(chain, win->m_widget);
}
chain = g_list_reverse(chain);
{
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
- if (m_wxwindow && m_wxwindow->window)
+ if (m_wxwindow && gtk_widget_get_window(m_wxwindow))
{
- gdk_window_raise( m_wxwindow->window );
+ gdk_window_raise(gtk_widget_get_window(m_wxwindow));
}
- else if (m_widget->window)
+ else if (gtk_widget_get_window(m_widget))
{
- gdk_window_raise( m_widget->window );
+ gdk_window_raise(gtk_widget_get_window(m_widget));
}
}
{
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
- if (m_wxwindow && m_wxwindow->window)
+ if (m_wxwindow && gtk_widget_get_window(m_wxwindow))
{
- gdk_window_lower( m_wxwindow->window );
+ gdk_window_lower(gtk_widget_get_window(m_wxwindow));
}
- else if (m_widget->window)
+ else if (gtk_widget_get_window(m_widget))
{
- gdk_window_lower( m_widget->window );
+ gdk_window_lower(gtk_widget_get_window(m_widget));
}
}
bool wxWindowGTK::SetCursor( const wxCursor &cursor )
{
- if ( !wxWindowBase::SetCursor(cursor.Ok() ? cursor : *wxSTANDARD_CURSOR) )
+ if ( !wxWindowBase::SetCursor(cursor.IsOk() ? cursor : *wxSTANDARD_CURSOR) )
return false;
GTKUpdateCursor();
{
if (update_self)
{
- wxCursor cursor(g_globalCursor.Ok() ? g_globalCursor : GetCursor());
- if ( cursor.Ok() )
+ wxCursor cursor(g_globalCursor.IsOk() ? g_globalCursor : GetCursor());
+ if ( cursor.IsOk() )
{
wxArrayGdkWindows windowsThis;
GdkWindow* window = GTKGetWindow(windowsThis);
GdkWindow *window = NULL;
if (m_wxwindow)
- window = m_wxwindow->window;
+ window = gtk_widget_get_window(m_wxwindow);
else
- window = GetConnectWidget()->window;
+ window = gtk_widget_get_window(GetConnectWidget());
if (window)
gdk_window_warp_pointer( window, x, y );
GtkRange* range = m_scrollBar[dir];
if ( range && units )
{
- GtkAdjustment* adj = range->adjustment;
- gdouble inc = unit == ScrollUnit_Line ? adj->step_increment
- : adj->page_increment;
+ GtkAdjustment* adj = gtk_range_get_adjustment(range);
+ double inc = unit == ScrollUnit_Line ? gtk_adjustment_get_step_increment(adj)
+ : gtk_adjustment_get_page_increment(adj);
- const int posOld = int(adj->value + 0.5);
+ const int posOld = wxRound(gtk_adjustment_get_value(adj));
gtk_range_set_value(range, posOld + units*inc);
- changed = int(adj->value + 0.5) != posOld;
+ changed = wxRound(gtk_adjustment_get_value(adj)) != posOld;
}
return changed;
{
// Just return if the widget or one of its ancestors isn't mapped
GtkWidget *w;
- for (w = m_wxwindow; w != NULL; w = w->parent)
+ for (w = m_wxwindow; w != NULL; w = gtk_widget_get_parent(w))
if (!gtk_widget_get_mapped (w))
return;
GdkWindow* window = GTKGetDrawingWindow();
if (window == NULL)
- window = m_widget->window;
+ window = gtk_widget_get_window(m_widget);
gdk_window_process_updates(window, true);
// Flush again, but no need to wait for it to finish
m_updateRegion.Clear();
gint width;
- gdk_drawable_get_size(m_wxwindow->window, &width, NULL);
+ gdk_drawable_get_size(gtk_widget_get_window(m_wxwindow), &width, NULL);
wxRegionIterator upd( m_nativeUpdateRegion );
while (upd)
rect.width = upd.GetWidth();
rect.height = upd.GetHeight();
- gtk_paint_flat_box( parent->m_widget->style,
+ gtk_paint_flat_box(gtk_widget_get_style(parent->m_widget),
GTKGetDrawingWindow(),
- (GtkStateType)gtk_widget_get_state(m_wxwindow),
+ gtk_widget_get_state(m_wxwindow),
GTK_SHADOW_NONE,
&rect,
parent->m_widget,
if (!wxWindowBase::SetBackgroundColour(colour))
return false;
- if (colour.Ok())
+ if (colour.IsOk())
{
// We need the pixel value e.g. for background clearing.
m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
return false;
}
- if (colour.Ok())
+ if (colour.IsOk())
{
// We need the pixel value e.g. for background clearing.
m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
{
// do we need to apply any changes at all?
if ( !forceStyle &&
- !m_font.Ok() &&
- !m_foregroundColour.Ok() && !m_backgroundColour.Ok() )
+ !m_font.IsOk() &&
+ !m_foregroundColour.IsOk() && !m_backgroundColour.IsOk() )
{
return NULL;
}
GtkRcStyle *style = gtk_rc_style_new();
- if ( m_font.Ok() )
+ if ( m_font.IsOk() )
{
style->font_desc =
pango_font_description_copy( m_font.GetNativeFontInfo()->description );
flagsActive = 0,
flagsInsensitive = 0;
- if ( m_foregroundColour.Ok() )
+ if ( m_foregroundColour.IsOk() )
{
const GdkColor *fg = m_foregroundColour.GetColor();
flagsActive |= GTK_RC_FG | GTK_RC_TEXT;
}
- if ( m_backgroundColour.Ok() )
+ if ( m_backgroundColour.IsOk() )
{
const GdkColor *bg = m_backgroundColour.GetColor();
if ( style )
{
DoApplyWidgetStyle(style);
- gtk_rc_style_unref(style);
+ g_object_unref(style);
}
// Style change may affect GTK+'s size calculation:
else
{
GtkWidget * const w = GetConnectWidget();
- window = w ? w->window : NULL;
+ window = w ? gtk_widget_get_window(w) : NULL;
}
if (window)
GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
{
- return m_wxwindow ? GTKGetDrawingWindow() : m_widget->window;
+ return m_wxwindow ? GTKGetDrawingWindow() : gtk_widget_get_window(m_widget);
}
bool wxWindowGTK::SetFont( const wxFont &font )
if (m_wxwindow)
window = GTKGetDrawingWindow();
else
- window = GetConnectWidget()->window;
+ window = gtk_widget_get_window(GetConnectWidget());
wxCHECK_RET( window, wxT("CaptureMouse() failed") );
const wxCursor* cursor = &m_cursor;
- if (!cursor->Ok())
+ if (!cursor->IsOk())
cursor = wxSTANDARD_CURSOR;
gdk_pointer_grab( window, FALSE,
if (m_wxwindow)
window = GTKGetDrawingWindow();
else
- window = GetConnectWidget()->window;
+ window = gtk_widget_get_window(GetConnectWidget());
if (!window)
return;
thumbVisible = 1;
}
- GtkAdjustment * const adj = sb->adjustment;
- adj->page_size = thumbVisible;
-
g_signal_handlers_block_by_func(
sb, (void*)gtk_scrollbar_value_changed, this);
gtk_range_set_increments(sb, 1, thumbVisible);
+ gtk_adjustment_set_page_size(gtk_range_get_adjustment(sb), thumbVisible);
gtk_range_set_range(sb, 0, range);
gtk_range_set_value(sb, pos);
m_scrollPos[dir] = gtk_range_get_value(sb);
GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
- return wxRound(sb->adjustment->page_size);
+ return wxRound(gtk_adjustment_get_page_size(gtk_range_get_adjustment(sb)));
}
int wxWindowGTK::GetScrollPos( int orient ) const
GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
- return wxRound(sb->adjustment->upper);
+ return wxRound(gtk_adjustment_get_upper(gtk_range_get_adjustment(sb)));
}
// Determine if increment is the same as +/-x, allowing for some small
const bool isDown = diff > 0;
GtkAdjustment* adj = gtk_range_get_adjustment(range);
- if (IsScrollIncrement(adj->step_increment, diff))
+ if (IsScrollIncrement(gtk_adjustment_get_step_increment(adj), diff))
{
eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
}
- else if (IsScrollIncrement(adj->page_increment, diff))
+ else if (IsScrollIncrement(gtk_adjustment_get_page_increment(adj), diff))
{
eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
}
{
GdkWindow* window = NULL;
if (m_wxwindow)
- window = m_wxwindow->window;
+ window = gtk_widget_get_window(m_wxwindow);
return window;
}
win
);
- GdkWindow* window = w->window;
+ GdkWindow* window;
if (w == win->m_wxwindow)
window = win->GTKGetDrawingWindow();
+ else
+ window = gtk_widget_get_window(w);
gdk_window_freeze_updates(window);
}
if ( !w || !gtk_widget_get_has_window(w) )
return; // window-less widget, cannot be frozen
- if ( !gtk_widget_get_realized(w) )
+ GdkWindow* window = gtk_widget_get_window(w);
+ if (window == NULL)
{
// we can't thaw unrealized widgets because they don't have GdkWindow,
// so set it up to be done immediately after realization:
return;
}
- GdkWindow* window = w->window;
if (w == m_wxwindow)
window = GTKGetDrawingWindow();
gdk_window_freeze_updates(window);
if ( !w || !gtk_widget_get_has_window(w) )
return; // window-less widget, cannot be frozen
- if ( !gtk_widget_get_realized(w) )
+ GdkWindow* window = gtk_widget_get_window(w);
+ if (window == NULL)
{
// the widget wasn't realized yet, no need to thaw
g_signal_handlers_disconnect_by_func
return;
}
- GdkWindow* window = w->window;
if (w == m_wxwindow)
window = GTKGetDrawingWindow();
gdk_window_thaw_updates(window);
projects / wxWidgets.git / blobdiff