X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/b890136bc6827757e2c5903b9a697086f4237579..5778dedc92f6d31435aa1cda6846979a0e9ad35b:/src/gtk/toplevel.cpp diff --git a/src/gtk/toplevel.cpp b/src/gtk/toplevel.cpp index a02c0ac69d..5a77576b0a 100644 --- a/src/gtk/toplevel.cpp +++ b/src/gtk/toplevel.cpp @@ -50,6 +50,10 @@ #include #endif // wxUSE_LIBHILDON +#if wxUSE_LIBHILDON2 + #include +#endif // wxUSE_LIBHILDON2 + // ---------------------------------------------------------------------------- // data // ---------------------------------------------------------------------------- @@ -57,12 +61,10 @@ // this is incremented while a modal dialog is shown int wxOpenModalDialogsCount = 0; -extern wxWindowGTK *g_delayedFocus; - // the frame that is currently active (i.e. its child has focus). It is // used to generate wxActivateEvents -static wxTopLevelWindowGTK *g_activeFrame = (wxTopLevelWindowGTK*) NULL; -static wxTopLevelWindowGTK *g_lastActiveFrame = (wxTopLevelWindowGTK*) NULL; +static wxTopLevelWindowGTK *g_activeFrame = NULL; +static wxTopLevelWindowGTK *g_lastActiveFrame = NULL; // if we detect that the app has got/lost the focus, we set this variable to // either TRUE or FALSE and an activate event will be sent during the next @@ -298,7 +300,7 @@ gtk_frame_configure_callback( GtkWidget* widget, // "realize" from m_widget //----------------------------------------------------------------------------- -// we cannot MWM hints and icons before the widget has been realized, +// we cannot the WM hints and icons before the widget has been realized, // so we do this directly after realization extern "C" { @@ -306,26 +308,23 @@ static void gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), wxTopLevelWindowGTK *win ) { - // All this is for Motif Window Manager "hints" and is supposed to be - // recognized by other WM as well. Not tested. gdk_window_set_decorations(win->m_widget->window, (GdkWMDecoration)win->m_gdkDecor); gdk_window_set_functions(win->m_widget->window, (GdkWMFunction)win->m_gdkFunc); // GTK's shrinking/growing policy - if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0) + if ( !(win->m_gdkFunc & GDK_FUNC_RESIZE) ) gtk_window_set_resizable(GTK_WINDOW(win->m_widget), FALSE); else gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1); - // reset the icon - wxIconBundle iconsOld = win->GetIcons(); - if ( !iconsOld.IsEmpty() ) - { - win->SetIcon( wxNullIcon ); - win->SetIcons( iconsOld ); - } + const wxIconBundle& icons = win->GetIcons(); + if (icons.GetIconCount()) + win->SetIcons(icons); + + if (win->HasFlag(wxFRAME_SHAPED)) + win->SetShape(win->m_shape); // it will really set the window shape now } } @@ -340,9 +339,7 @@ gtk_frame_map_callback( GtkWidget*, wxTopLevelWindow *win ) { const bool wasIconized = win->IsIconized(); - win->SetIconizeState(false); - if (wasIconized) { // Because GetClientSize() returns (0,0) when IsIconized() is true, @@ -354,6 +351,21 @@ gtk_frame_map_callback( GtkWidget*, win->m_oldClientWidth = 0; gtk_widget_queue_resize(win->m_wxwindow); } + // it is possible for m_isShown to be false here, see bug #9909 + if (win->wxWindowBase::Show(true)) + { + wxShowEvent eventShow(win->GetId(), true); + eventShow.SetEventObject(win); + win->GetEventHandler()->ProcessEvent(eventShow); + } + +#if GTK_CHECK_VERSION(2,6,0) + if (!gtk_check_version(2,6,0)) + { + // restore focus-on-map setting in case ShowWithoutActivating() was called + gtk_window_set_focus_on_map(GTK_WINDOW(win->m_widget), true); + } +#endif // GTK+ 2.6+ return false; } @@ -369,11 +381,44 @@ gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget), GdkEvent * WXUNUSED(event), wxTopLevelWindow *win ) { - win->SetIconizeState(true); + // hiding the window doesn't count as minimizing it + if (win->IsShown()) + win->SetIconizeState(true); return false; } } +//----------------------------------------------------------------------------- + +bool wxGetFrameExtents(GdkWindow* window, int* left, int* right, int* top, int* bottom) +{ + static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false); + Atom xproperty = gdk_x11_atom_to_xatom_for_display( + gdk_drawable_get_display(window), property); + Atom type; + int format; + gulong nitems, bytes_after; + guchar* data; + Status status = XGetWindowProperty( + gdk_x11_drawable_get_xdisplay(window), + gdk_x11_drawable_get_xid(window), + xproperty, + 0, 4, false, XA_CARDINAL, + &type, &format, &nitems, &bytes_after, &data); + const bool success = status == Success && data && nitems == 4; + if (success) + { + long* p = (long*)data; + if (left) *left = int(p[0]); + if (right) *right = int(p[1]); + if (top) *top = int(p[2]); + if (bottom) *bottom = int(p[3]); + } + if (data) + XFree(data); + return success; +} + //----------------------------------------------------------------------------- // "property_notify_event" from m_widget //----------------------------------------------------------------------------- @@ -386,49 +431,33 @@ static gboolean property_notify_event( static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false); if (event->state == GDK_PROPERTY_NEW_VALUE && event->atom == property) { - Atom xproperty = gdk_x11_atom_to_xatom_for_display( - gdk_drawable_get_display(event->window), property); - Atom type; - int format; - gulong nitems, bytes_after; - guchar* data; - Status status = XGetWindowProperty( - gdk_x11_drawable_get_xdisplay(event->window), - gdk_x11_drawable_get_xid(event->window), - xproperty, - 0, 4, false, XA_CARDINAL, - &type, &format, &nitems, &bytes_after, &data); - if (status == Success && data && nitems == 4) - { - long* p = (long*)data; - const wxSize decorSize = - wxSize(int(p[0] + p[1]), int(p[2] + p[3])); - win->GTKUpdateDecorSize(decorSize); - } - if (data) - XFree(data); + wxSize decorSize = win->m_decorSize; + int left, right, top, bottom; + if (wxGetFrameExtents(event->window, &left, &right, &top, &bottom)) + decorSize.Set(left + right, top + bottom); + + win->GTKUpdateDecorSize(decorSize); } return false; } } -BEGIN_EVENT_TABLE(wxTopLevelWindowGTK, wxTopLevelWindowBase) - EVT_SYS_COLOUR_CHANGED(wxTopLevelWindowGTK::OnSysColourChanged) -END_EVENT_TABLE() - // ---------------------------------------------------------------------------- // wxTopLevelWindowGTK creation // ---------------------------------------------------------------------------- void wxTopLevelWindowGTK::Init() { - m_mainWidget = (GtkWidget*) NULL; + m_mainWidget = NULL; m_isIconized = false; m_fsIsShowing = false; m_themeEnabled = true; - m_gdkDecor = m_gdkFunc = 0; + m_gdkDecor = + m_gdkFunc = 0; m_grabbed = false; m_deferShow = true; + m_deferShowAllowed = true; + m_updateDecorSize = true; m_urgency_hint = -2; } @@ -462,14 +491,14 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, // e.g. in wxTaskBarIconAreaGTK if (m_widget == NULL) { -#if wxUSE_LIBHILDON +#if wxUSE_LIBHILDON || wxUSE_LIBHILDON2 // we must create HildonWindow and not a normal GtkWindow as the latter // doesn't look correctly in Maemo environment and it must also be // registered with the main program object m_widget = hildon_window_new(); hildon_program_add_window(wxTheApp->GetHildonProgram(), HILDON_WINDOW(m_widget)); -#else // !wxUSE_LIBHILDON +#else // !wxUSE_LIBHILDON || !wxUSE_LIBHILDON2 m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL); if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) { @@ -496,7 +525,9 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, style |= wxFRAME_NO_TASKBAR; } } -#endif // wxUSE_LIBHILDON/!wxUSE_LIBHILDON +#endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2/!wxUSE_LIBHILDON || !wxUSE_LIBHILDON2 + + g_object_ref(m_widget); } wxWindow *topParent = wxGetTopLevelParent(m_parent); @@ -517,6 +548,8 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, { gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE); } + if (style & wxMAXIMIZE) + gtk_window_maximize(GTK_WINDOW(m_widget)); #if 0 if (!name.empty()) @@ -581,71 +614,75 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, g_signal_connect(m_widget, "property_notify_event", G_CALLBACK(property_notify_event), this); - // decorations - if ((style & wxSIMPLE_BORDER) || (style & wxNO_BORDER)) + // translate wx decorations styles into Motif WM hints (they are recognized + // by other WMs as well) + + // always enable moving the window as we have no separate flag for enabling + // it + m_gdkFunc = GDK_FUNC_MOVE; + + if ( style & wxCLOSE_BOX ) + m_gdkFunc |= GDK_FUNC_CLOSE; + + if ( style & wxMINIMIZE_BOX ) + m_gdkFunc |= GDK_FUNC_MINIMIZE; + + if ( style & wxMAXIMIZE_BOX ) + m_gdkFunc |= GDK_FUNC_MAXIMIZE; + + if ( (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER) ) { m_gdkDecor = 0; - m_gdkFunc = 0; } - else + else // have border { m_gdkDecor = GDK_DECOR_BORDER; - m_gdkFunc = GDK_FUNC_MOVE; - // All this is for Motif Window Manager "hints" and is supposed to be - // recognized by other WMs as well. - if ((style & wxCAPTION) != 0) - { + if ( style & wxCAPTION ) m_gdkDecor |= GDK_DECOR_TITLE; - } - if ((style & wxCLOSE_BOX) != 0) - { - m_gdkFunc |= GDK_FUNC_CLOSE; - } - if ((style & wxSYSTEM_MENU) != 0) - { + + if ( style & wxSYSTEM_MENU ) m_gdkDecor |= GDK_DECOR_MENU; - } - if ((style & wxMINIMIZE_BOX) != 0) - { - m_gdkFunc |= GDK_FUNC_MINIMIZE; + + if ( style & wxMINIMIZE_BOX ) m_gdkDecor |= GDK_DECOR_MINIMIZE; - } - if ((style & wxMAXIMIZE_BOX) != 0) - { - m_gdkFunc |= GDK_FUNC_MAXIMIZE; + + if ( style & wxMAXIMIZE_BOX ) m_gdkDecor |= GDK_DECOR_MAXIMIZE; - } - if ((style & wxRESIZE_BORDER) != 0) + + if ( style & wxRESIZE_BORDER ) { m_gdkFunc |= GDK_FUNC_RESIZE; m_gdkDecor |= GDK_DECOR_RESIZEH; } } - gtk_window_set_default_size(GTK_WINDOW(m_widget), m_width, m_height); + m_decorSize = GetCachedDecorSize(); + int w, h; + GTKDoGetSize(&w, &h); + gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h); return true; } wxTopLevelWindowGTK::~wxTopLevelWindowGTK() { -#if wxUSE_LIBHILDON +#if wxUSE_LIBHILDON || wxUSE_LIBHILDON2 // it can also be a (standard) dialog if ( HILDON_IS_WINDOW(m_widget) ) { hildon_program_remove_window(wxTheApp->GetHildonProgram(), HILDON_WINDOW(m_widget)); } -#endif // wxUSE_LIBHILDON +#endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2 if (m_grabbed) { - wxFAIL_MSG(_T("Window still grabbed")); + wxFAIL_MSG(wxT("Window still grabbed")); RemoveGrab(); } - m_isBeingDeleted = true; + SendDestroyEvent(); // it may also be GtkScrolledWindow in the case of an MDI child if (GTK_IS_WINDOW(m_widget)) @@ -756,17 +793,53 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long) // overridden wxWindow methods // ---------------------------------------------------------------------------- +void wxTopLevelWindowGTK::Refresh( bool WXUNUSED(eraseBackground), const wxRect *WXUNUSED(rect) ) +{ + wxCHECK_RET( m_widget, wxT("invalid frame") ); + + gtk_widget_queue_draw( m_widget ); + + if (m_wxwindow && m_wxwindow->window) + gdk_window_invalidate_rect( m_wxwindow->window, NULL, TRUE ); +} + bool wxTopLevelWindowGTK::Show( bool show ) { wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); - const bool wasRealized = GTK_WIDGET_REALIZED(m_widget); - bool deferShow = - show && m_deferShow && !wasRealized && - g_signal_handler_find(m_widget, - GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA), - g_signal_lookup("property_notify_event", GTK_TYPE_WIDGET), - 0, NULL, NULL, this); + bool deferShow = show && !m_isShown && m_deferShow; + if (deferShow) + { + deferShow = m_deferShowAllowed && !GTK_WIDGET_REALIZED(m_widget); + if (deferShow) + { + deferShow = g_signal_handler_find(m_widget, + GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA), + g_signal_lookup("property_notify_event", GTK_TYPE_WIDGET), + 0, NULL, NULL, this) != 0; + } + GdkScreen* screen = NULL; + if (deferShow) + { + screen = gtk_widget_get_screen(m_widget); + GdkAtom atom = gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false); + deferShow = gdk_x11_screen_supports_net_wm_hint(screen, atom) != 0; + // If _NET_REQUEST_FRAME_EXTENTS not supported, don't allow changes + // to m_decorSize, it breaks saving/restoring window size with + // GetSize()/SetSize() because it makes window bigger between each + // restore and save. + m_updateDecorSize = deferShow; + } + if (deferShow) + { + // Fluxbox support for _NET_REQUEST_FRAME_EXTENTS is broken + const char* name = gdk_x11_screen_get_window_manager_name(screen); + deferShow = strcmp(name, "Fluxbox") != 0; + m_updateDecorSize = deferShow; + } + + m_deferShow = deferShow; + } if (deferShow) { // Initial show. If WM supports _NET_REQUEST_FRAME_EXTENTS, defer @@ -776,30 +849,17 @@ bool wxTopLevelWindowGTK::Show( bool show ) // what wxWidgets expects it to be without an obvious change in the // window size immediately after it becomes visible. - // Realize m_widget, so m_widget->window can be used. Realizing causes - // the widget tree to be size_allocated, which generates size events in - // the wrong order. So temporarily remove child from m_widget while - // realizing. - GtkWidget* child = GTK_BIN(m_widget)->child; - if (child) - { - g_object_ref(child); - gtk_container_remove(GTK_CONTAINER(m_widget), child); - } + // Realize m_widget, so m_widget->window can be used. Realizing normally + // causes the widget tree to be size_allocated, which generates size + // events in the wrong order. However, the size_allocates will not be + // done if the allocation is not the default (1,1). + const int alloc_width = m_widget->allocation.width; + if (alloc_width == 1) + m_widget->allocation.width = 2; gtk_widget_realize(m_widget); - if (child) - { - gtk_container_add(GTK_CONTAINER(m_widget), child); - g_object_unref(child); - } + if (alloc_width == 1) + m_widget->allocation.width = 1; - m_deferShow = - deferShow = gdk_x11_screen_supports_net_wm_hint( - gdk_drawable_get_screen(m_widget->window), - gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false)) != 0; - } - if (deferShow) - { // send _NET_REQUEST_FRAME_EXTENTS XClientMessageEvent xevent; memset(&xevent, 0, sizeof(xevent)); @@ -819,7 +879,7 @@ bool wxTopLevelWindowGTK::Show( bool show ) return true; } - if (show && !wasRealized) + if (show && !GTK_WIDGET_REALIZED(m_widget)) { // size_allocate signals occur in reverse order (bottom to top). // Things work better if the initial wxSizeEvents are sent (from the @@ -829,7 +889,7 @@ bool wxTopLevelWindowGTK::Show( bool show ) HandleWindowEvent(event); } - bool change = wxTopLevelWindowBase::Show(show); + bool change = base_type::Show(show); if (change && !show) { @@ -842,6 +902,19 @@ bool wxTopLevelWindowGTK::Show( bool show ) return change; } +void wxTopLevelWindowGTK::ShowWithoutActivating() +{ + if (!m_isShown) + { +#if GTK_CHECK_VERSION(2,6,0) + if (!gtk_check_version(2,6,0)) + gtk_window_set_focus_on_map(GTK_WINDOW(m_widget), false); +#endif // GTK+ 2.6+ + + Show(true); + } +} + void wxTopLevelWindowGTK::Raise() { gtk_window_present( GTK_WINDOW( m_widget ) ); @@ -862,14 +935,33 @@ void wxTopLevelWindowGTK::GTKDoGetSize(int *width, int *height) const size -= m_decorSize; if (size.x < 0) size.x = 0; if (size.y < 0) size.y = 0; +#if wxUSE_LIBHILDON2 + if (width) { + if (size.x == 720) + *width = 696; + else + *width = size.x; + } + if (height) { + if (size.y == 420) + *height = 396; + else if (size.y == 270) + *height = 246; + else + *height = size.y; + } +#else // wxUSE_LIBHILDON2 if (width) *width = size.x; if (height) *height = size.y; +#endif // wxUSE_LIBHILDON2 /!wxUSE_LIBHILDON2 } void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags ) { wxCHECK_RET( m_widget, wxT("invalid frame") ); + m_deferShowAllowed = true; + // deal with the position first int old_x = m_x; int old_y = m_y; @@ -914,10 +1006,12 @@ void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int si void wxTopLevelWindowGTK::DoSetClientSize(int width, int height) { - if (m_deferShow && !m_isShown) - // Since client size is being explicitly set, don't change it later - m_deferShow = false; - wxTopLevelWindowBase::DoSetClientSize(width, height); + base_type::DoSetClientSize(width, height); + + // Since client size is being explicitly set, don't change it later + // Has to be done after calling base because it calls SetSize, + // which sets this true + m_deferShowAllowed = false; } void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const @@ -943,7 +1037,7 @@ void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH, int maxW, int maxH, int incW, int incH ) { - wxTopLevelWindowBase::DoSetSizeHints( minW, minH, maxW, maxH, incW, incH ); + base_type::DoSetSizeHints(minW, minH, maxW, maxH, incW, incH); const wxSize minSize = GetMinSize(); const wxSize maxSize = GetMaxSize(); @@ -981,7 +1075,9 @@ void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH, void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize) { - if (m_decorSize != decorSize) + if (!IsMaximized() && !IsFullScreen()) + GetCachedDecorSize() = decorSize; + if (m_updateDecorSize && m_decorSize != decorSize) { const wxSize diff = decorSize - m_decorSize; m_decorSize = decorSize; @@ -1006,11 +1102,8 @@ void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize) m_height += diff.y; if (m_width < 0) m_width = 0; if (m_height < 0) m_height = 0; - if (!m_deferShow) - { - m_oldClientWidth = 0; - gtk_widget_queue_resize(m_wxwindow); - } + m_oldClientWidth = 0; + gtk_widget_queue_resize(m_wxwindow); } } if (m_deferShow) @@ -1030,24 +1123,25 @@ void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize) } } -void wxTopLevelWindowGTK::OnInternalIdle() +wxSize& wxTopLevelWindowGTK::GetCachedDecorSize() { - // set the focus if not done yet and if we can already do it - if ( GTK_WIDGET_REALIZED(m_wxwindow) ) - { - if ( g_delayedFocus && - wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this ) - { - wxLogTrace(_T("focus"), - _T("Setting focus from wxTLW::OnIdle() to %s(%s)"), - g_delayedFocus->GetClassInfo()->GetClassName(), - g_delayedFocus->GetLabel().c_str()); - - g_delayedFocus->SetFocus(); - g_delayedFocus = NULL; - } - } + static wxSize size[8]; + + int index = 0; + // title bar + if (m_gdkDecor & (GDK_DECOR_MENU | GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE | GDK_DECOR_TITLE)) + index = 1; + // border + if (m_gdkDecor & GDK_DECOR_BORDER) + index |= 2; + // utility window decor can be different + if (m_windowStyle & wxFRAME_TOOL_WINDOW) + index |= 4; + return size[index]; +} +void wxTopLevelWindowGTK::OnInternalIdle() +{ wxWindow::OnInternalIdle(); // Synthetize activate events. @@ -1085,18 +1179,19 @@ void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons ) { wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); - wxTopLevelWindowBase::SetIcons( icons ); - - GList *list = NULL; + base_type::SetIcons(icons); - const size_t numIcons = icons.GetIconCount(); - for ( size_t i = 0; i < numIcons; i++ ) + // Setting icons before window is realized can cause a GTK assertion if + // another TLW is realized before this one, and it has this one as it's + // transient parent. The life demo exibits this problem. + if (GTK_WIDGET_REALIZED(m_widget)) { - list = g_list_prepend(list, icons.GetIconByIndex(i).GetPixbuf()); + GList* list = NULL; + for (size_t i = icons.GetIconCount(); i--;) + list = g_list_prepend(list, icons.GetIconByIndex(i).GetPixbuf()); + gtk_window_set_icon_list(GTK_WINDOW(m_widget), list); + g_list_free(list); } - - gtk_window_set_icon_list(GTK_WINDOW(m_widget), list); - g_list_free(list); } // ---------------------------------------------------------------------------- @@ -1190,15 +1285,24 @@ static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region) bool wxTopLevelWindowGTK::SetShape(const wxRegion& region) { wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false, - _T("Shaped windows must be created with the wxFRAME_SHAPED style.")); + wxT("Shaped windows must be created with the wxFRAME_SHAPED style.")); - GdkWindow *window = NULL; - if (m_wxwindow) + if ( GTK_WIDGET_REALIZED(m_widget) ) { - do_shape_combine_region(m_wxwindow->window, region); + if ( m_wxwindow ) + do_shape_combine_region(m_wxwindow->window, region); + + return do_shape_combine_region(m_widget->window, region); + } + else // not realized yet + { + // store the shape to set, it will be really set once we're realized + m_shape = region; + + // we don't know if we're going to succeed or fail, be optimistic by + // default + return true; } - window = m_widget->window; - return do_shape_combine_region(window, region); } bool wxTopLevelWindowGTK::IsActive() @@ -1211,10 +1315,11 @@ void wxTopLevelWindowGTK::RequestUserAttention(int flags) bool new_hint_value = false; // FIXME: This is a workaround to focus handling problem - // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't - // yet been processed, and the internal focus system is not up to date yet. - // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR - ::wxYieldIfNeeded(); + // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle + // hasn't yet been processed, and the internal focus system is not up to date yet. + // YieldFor(wxEVT_CATEGORY_UI) ensures the processing of it (hopefully it + // won't have side effects) - MR + wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI); if(m_urgency_hint >= 0) g_source_remove(m_urgency_hint); @@ -1316,7 +1421,7 @@ bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha) bool wxTopLevelWindowGTK::CanSetTransparent() { // allow to override automatic detection as it's far from perfect - static const wxChar *SYSOPT_TRANSPARENT = wxT("gtk.tlw.can-set-transparent"); + const wxString SYSOPT_TRANSPARENT = "gtk.tlw.can-set-transparent"; if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT) ) { return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT) != 0; @@ -1340,16 +1445,3 @@ bool wxTopLevelWindowGTK::CanSetTransparent() "Composite", &opcode, &event, &error); #endif } - -void wxTopLevelWindowGTK::OnSysColourChanged(wxSysColourChangedEvent& event) -{ - // We don't know the order in which top-level windows will - // be notified, so we need to clear the system objects - // for each top-level window. - extern void wxClearGtkSystemObjects(); - wxClearGtkSystemObjects(); - - // wxWindowBase::OnSysColourChanged will propagate event - // to children - event.Skip(); -}