X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/d475dd224790d3fcd530492228eee431a1e44356..05e0b047d879cdbfade7f2ab346c0acdf3e29f96:/src/gtk/toplevel.cpp diff --git a/src/gtk/toplevel.cpp b/src/gtk/toplevel.cpp index bde85936ac..7ddd774e3b 100644 --- a/src/gtk/toplevel.cpp +++ b/src/gtk/toplevel.cpp @@ -38,7 +38,7 @@ #include #include -#include "wx/gtk/win_gtk.h" +#include "wx/gtk/private/win_gtk.h" #include "wx/unix/utilsx11.h" @@ -57,8 +57,6 @@ // 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; @@ -202,25 +200,6 @@ gboolean gtk_frame_focus_out_callback(GtkWidget * WXUNUSED(widget), } } -//----------------------------------------------------------------------------- - -// Get cached size of WM decorations for given GdkWMDecoration. -static wxSize& GetDecorSize(int decor) -{ - // In testing, only the title bar and GDK_DECOR_BORDER made a difference. - // 4 possible combinations of title bar and border - static wxSize size[4]; - - int index = 0; - // title bar - if (decor & (GDK_DECOR_MENU | GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE | GDK_DECOR_TITLE)) - index = 1; - // border - if (decor & GDK_DECOR_BORDER) - index |= 2; - return size[index]; -} - //----------------------------------------------------------------------------- // "size_allocate" from m_wxwindow //----------------------------------------------------------------------------- @@ -237,8 +216,7 @@ size_allocate(GtkWidget*, GtkAllocation* alloc, wxTopLevelWindowGTK* win) wxSize size(win->m_widget->allocation.width, win->m_widget->allocation.height); - if (!win->IsFullScreen()) - size += win->m_decorSize; + size += win->m_decorSize; win->m_width = size.x; win->m_height = size.y; @@ -288,7 +266,6 @@ gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), } } - //----------------------------------------------------------------------------- // "configure_event" //----------------------------------------------------------------------------- @@ -340,13 +317,12 @@ gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), 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 } } @@ -356,29 +332,10 @@ gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), extern "C" { static gboolean -gtk_frame_map_callback( GtkWidget* widget, +gtk_frame_map_callback( GtkWidget*, GdkEvent * WXUNUSED(event), wxTopLevelWindow *win ) { - // Calculate size of WM decorations. - // Done here in case WM does not support the _NET_FRAME_EXTENTS property. - if (win->IsDecorCacheable() && !win->IsFullScreen()) - { - GdkRectangle rect; - gdk_window_get_frame_extents(widget->window, &rect); - int w, h; - gdk_drawable_get_size(widget->window, &w, &h); - const wxSize decorSize = wxSize(rect.width - w, rect.height - h); - if (win->m_decorSize != decorSize) - { - // Update window size and frame extents cache - win->m_width = rect.width; - win->m_height = rect.height; - win->m_decorSize = decorSize; - GetDecorSize(win->m_gdkDecor) = decorSize; - } - } - const bool wasIconized = win->IsIconized(); win->SetIconizeState(false); @@ -414,6 +371,37 @@ gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget), } } +//----------------------------------------------------------------------------- + +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 //----------------------------------------------------------------------------- @@ -424,63 +412,15 @@ static gboolean property_notify_event( { // Watch for changes to _NET_FRAME_EXTENTS property static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false); - if (event->state == GDK_PROPERTY_NEW_VALUE && event->atom == property && - win->IsDecorCacheable() && !win->IsFullScreen()) + 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; - long* data = NULL; - 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, (guchar**)&data); - if (status == Success && data && nitems == 4) + int left, right, top, bottom; + if (wxGetFrameExtents(event->window, &left, &right, &top, &bottom)) { const wxSize decorSize = - wxSize(int(data[0] + data[1]), int(data[2] + data[3])); - if (win->m_decorSize != decorSize) - { - const wxSize diff = win->m_decorSize - decorSize; - win->m_decorSize = decorSize; - GetDecorSize(win->m_gdkDecor) = decorSize; - if (GTK_WIDGET_VISIBLE(win->m_widget)) - { - // adjust overall size to match change in frame extents - win->m_width -= diff.x; - win->m_height -= diff.y; - if (win->m_width < 0) win->m_width = 0; - if (win->m_height < 0) win->m_height = 0; - win->m_oldClientWidth = 0; - gtk_widget_queue_resize(win->m_wxwindow); - } - else - { - // Window not yet visible, adjust client size. This would - // cause an obvious size change if window was visible. - int w, h; - win->GTKDoGetSize(&w, &h); - gtk_window_resize(GTK_WINDOW(win->m_widget), w, h); - } - } - if (!GTK_WIDGET_VISIBLE(win->m_widget)) - { - // gtk_widget_show() was deferred, do it now - wxSizeEvent sizeEvent(win->GetSize(), win->GetId()); - sizeEvent.SetEventObject(win); - win->HandleWindowEvent(sizeEvent); - gtk_widget_show(win->m_widget); - wxShowEvent showEvent(win->GetId(), true); - showEvent.SetEventObject(win); - win->HandleWindowEvent(showEvent); - } + wxSize(left + right, top + bottom); + win->GTKUpdateDecorSize(decorSize); } - if (data) - XFree(data); } return false; } @@ -490,7 +430,6 @@ BEGIN_EVENT_TABLE(wxTopLevelWindowGTK, wxTopLevelWindowBase) EVT_SYS_COLOUR_CHANGED(wxTopLevelWindowGTK::OnSysColourChanged) END_EVENT_TABLE() - // ---------------------------------------------------------------------------- // wxTopLevelWindowGTK creation // ---------------------------------------------------------------------------- @@ -503,6 +442,7 @@ void wxTopLevelWindowGTK::Init() m_themeEnabled = true; m_gdkDecor = m_gdkFunc = 0; m_grabbed = false; + m_deferShow = true; m_urgency_hint = -2; } @@ -697,9 +637,7 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, } } - m_decorSize = GetDecorSize(m_gdkDecor); - - // m_sizeDecor needs to be set before calling GTKDoGetSize + m_decorSize = GetCachedDecorSize(); int w, h; GTKDoGetSize(&w, &h); gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h); @@ -839,7 +777,20 @@ bool wxTopLevelWindowGTK::Show( bool show ) { wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); - if (show && !GTK_WIDGET_REALIZED(m_widget)) + bool deferShow = show && m_deferShow && !m_isShown; + if (deferShow) + { + m_deferShow = + deferShow = !GTK_WIDGET_REALIZED(m_widget) && + gdk_x11_screen_supports_net_wm_hint( + gtk_widget_get_screen(m_widget), + gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false)) && + 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); + } + if (deferShow) { // Initial show. If WM supports _NET_REQUEST_FRAME_EXTENTS, defer // calling gtk_widget_show() until _NET_FRAME_EXTENTS property @@ -848,49 +799,38 @@ 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 WM supports _NET_REQUEST_FRAME_EXTENTS - GdkAtom request_extents = - gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false); - GdkScreen* screen = gdk_drawable_get_screen(m_widget->window); - if (gdk_x11_screen_supports_net_wm_hint(screen, request_extents)) - { - // send _NET_REQUEST_FRAME_EXTENTS - XClientMessageEvent xevent; - memset(&xevent, 0, sizeof(xevent)); - xevent.type = ClientMessage; - xevent.window = gdk_x11_drawable_get_xid(m_widget->window); - xevent.message_type = gdk_x11_atom_to_xatom_for_display( - gdk_drawable_get_display(m_widget->window), request_extents); - xevent.format = 32; - Display* display = gdk_x11_drawable_get_xdisplay(m_widget->window); - XSendEvent(display, DefaultRootWindow(display), false, - SubstructureNotifyMask | SubstructureRedirectMask, - (XEvent*)&xevent); - - // defer calling gtk_widget_show() - m_isShown = true; - return true; - } - // WM does not support _NET_REQUEST_FRAME_EXTENTS, overall size may - // change when correct frame extents become known. + if (alloc_width == 1) + m_widget->allocation.width = 1; + + // send _NET_REQUEST_FRAME_EXTENTS + XClientMessageEvent xevent; + memset(&xevent, 0, sizeof(xevent)); + xevent.type = ClientMessage; + xevent.window = gdk_x11_drawable_get_xid(m_widget->window); + xevent.message_type = gdk_x11_atom_to_xatom_for_display( + gdk_drawable_get_display(m_widget->window), + gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false)); + xevent.format = 32; + Display* display = gdk_x11_drawable_get_xdisplay(m_widget->window); + XSendEvent(display, DefaultRootWindow(display), false, + SubstructureNotifyMask | SubstructureRedirectMask, + (XEvent*)&xevent); + + // defer calling gtk_widget_show() + m_isShown = true; + return true; + } + 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 // top down), before the initial size_allocate signals occur. @@ -929,12 +869,9 @@ void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXU void wxTopLevelWindowGTK::GTKDoGetSize(int *width, int *height) const { wxSize size(m_width, m_height); - if (!IsFullScreen()) - { - size -= m_decorSize; - if (size.x < 0) size.x = 0; - if (size.y < 0) size.y = 0; - } + size -= m_decorSize; + if (size.x < 0) size.x = 0; + if (size.y < 0) size.y = 0; if (width) *width = size.x; if (height) *height = size.y; } @@ -985,6 +922,14 @@ 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); +} + void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const { wxASSERT_MSG(m_widget, wxT("invalid frame")); @@ -1044,29 +989,75 @@ void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH, (GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask); } -bool wxTopLevelWindowGTK::IsDecorCacheable() const +void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize) { - return true; -} - -void wxTopLevelWindowGTK::OnInternalIdle() -{ - // set the focus if not done yet and if we can already do it - if ( GTK_WIDGET_REALIZED(m_wxwindow) ) + if (!IsMaximized() && !IsFullScreen()) + GetCachedDecorSize() = decorSize; + if (m_decorSize != decorSize) { - if ( g_delayedFocus && - wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this ) + const wxSize diff = decorSize - m_decorSize; + m_decorSize = decorSize; + bool resized = false; + if (m_deferShow) { - 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; + // keep overall size unchanged by shrinking m_widget + int w, h; + GTKDoGetSize(&w, &h); + // but not if size would be less than minimum, it won't take effect + const wxSize minSize = GetMinSize(); + if (w >= minSize.x && h >= minSize.y) + { + gtk_window_resize(GTK_WINDOW(m_widget), w, h); + resized = true; + } + } + if (!resized) + { + // adjust overall size to match change in frame extents + m_width += diff.x; + m_height += diff.y; + if (m_width < 0) m_width = 0; + if (m_height < 0) m_height = 0; + m_oldClientWidth = 0; + gtk_widget_queue_resize(m_wxwindow); } } + if (m_deferShow) + { + // gtk_widget_show() was deferred, do it now + m_deferShow = false; + GetClientSize(&m_oldClientWidth, &m_oldClientHeight); + wxSizeEvent sizeEvent(GetSize(), GetId()); + sizeEvent.SetEventObject(this); + HandleWindowEvent(sizeEvent); + gtk_widget_show(m_widget); + + wxShowEvent showEvent(GetId(), true); + showEvent.SetEventObject(this); + HandleWindowEvent(showEvent); + } +} + +wxSize& wxTopLevelWindowGTK::GetCachedDecorSize() +{ + 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. @@ -1106,16 +1097,17 @@ void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons ) wxTopLevelWindowBase::SetIcons( icons ); - GList *list = NULL; - - 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); } // ---------------------------------------------------------------------------- @@ -1211,13 +1203,22 @@ bool wxTopLevelWindowGTK::SetShape(const wxRegion& region) wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false, _T("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()