X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/cca410b336cd5628a944ede9e9944fdbb04552d4..3201a1046ba71ba8e5ef2ed694fde34d12f743f3:/src/gtk/toplevel.cpp diff --git a/src/gtk/toplevel.cpp b/src/gtk/toplevel.cpp index 28503b6538..d87eec8b6a 100644 --- a/src/gtk/toplevel.cpp +++ b/src/gtk/toplevel.cpp @@ -38,19 +38,24 @@ #include #include -#include "wx/gtk/win_gtk.h" +#include "wx/gtk/private/win_gtk.h" #include "wx/unix/utilsx11.h" // XA_CARDINAL #include +#if wxUSE_LIBHILDON + #include + #include +#endif // wxUSE_LIBHILDON + // ---------------------------------------------------------------------------- // data // ---------------------------------------------------------------------------- -extern int g_openDialogs; -extern wxWindowGTK *g_delayedFocus; +// this is incremented while a modal dialog is shown +int wxOpenModalDialogsCount = 0; // the frame that is currently active (i.e. its child has focus). It is // used to generate wxActivateEvents @@ -156,7 +161,7 @@ static gboolean gtk_frame_focus_in_callback( GtkWidget *widget, wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame); wxActivateEvent event(wxEVT_ACTIVATE, true, g_activeFrame->GetId()); event.SetEventObject(g_activeFrame); - g_activeFrame->GetEventHandler()->ProcessEvent(event); + g_activeFrame->HandleWindowEvent(event); return FALSE; } @@ -186,7 +191,7 @@ gboolean gtk_frame_focus_out_callback(GtkWidget * WXUNUSED(widget), wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame); wxActivateEvent event(wxEVT_ACTIVATE, false, g_activeFrame->GetId()); event.SetEventObject(g_activeFrame); - g_activeFrame->GetEventHandler()->ProcessEvent(event); + g_activeFrame->HandleWindowEvent(event); g_activeFrame = NULL; } @@ -195,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 //----------------------------------------------------------------------------- @@ -227,16 +213,18 @@ size_allocate(GtkWidget*, GtkAllocation* alloc, wxTopLevelWindowGTK* win) { win->m_oldClientWidth = alloc->width; win->m_oldClientHeight = alloc->height; - wxSize sizeDecor; - if (!win->IsFullScreen()) - sizeDecor = GetDecorSize(win->m_gdkDecor); - win->m_width = win->m_widget->allocation.width + sizeDecor.x; - win->m_height = win->m_widget->allocation.height + sizeDecor.y; + + wxSize size(win->m_widget->allocation.width, + win->m_widget->allocation.height); + size += win->m_decorSize; + win->m_width = size.x; + win->m_height = size.y; + if (!win->IsIconized()) { - wxSizeEvent event(win->GetSize(), win->GetId()); + wxSizeEvent event(size, win->GetId()); event.SetEventObject(win); - win->GetEventHandler()->ProcessEvent(event); + win->HandleWindowEvent(event); } // else the window is currently unmapped, don't generate size events } @@ -270,7 +258,7 @@ gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), wxTopLevelWindowGTK *win ) { if (win->IsEnabled() && - (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) || + (wxOpenModalDialogsCount == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) || win->IsGrabbed())) win->Close(); @@ -278,7 +266,6 @@ gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), } } - //----------------------------------------------------------------------------- // "configure_event" //----------------------------------------------------------------------------- @@ -299,7 +286,7 @@ gtk_frame_configure_callback( GtkWidget* widget, win->m_y = point.y; wxMoveEvent mevent(point, win->GetId()); mevent.SetEventObject( win ); - win->GetEventHandler()->ProcessEvent( mevent ); + win->HandleWindowEvent( mevent ); return FALSE; } @@ -337,6 +324,9 @@ gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), win->SetIcon( wxNullIcon ); win->SetIcons( iconsOld ); } + + if (win->HasFlag(wxFRAME_SHAPED)) + win->SetShape(win->m_shape); // it will really set the window shape now } } @@ -346,33 +336,26 @@ 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()) + const bool wasIconized = win->IsIconized(); + + win->SetIconizeState(false); + + if (wasIconized) { - GdkRectangle rect; - gdk_window_get_frame_extents(widget->window, &rect); - int w, h; - gdk_drawable_get_size(widget->window, &w, &h); - wxSize& decorSize = GetDecorSize(win->m_gdkDecor); - const wxSize size = wxSize(rect.width - w, rect.height - h); - if (decorSize.x != size.x || decorSize.y != size.y) - { - // Update window size and frame extents cache - win->m_width = rect.width; - win->m_height = rect.height; - decorSize = size; - wxSizeEvent event(win->GetSize(), win->GetId()); - event.SetEventObject(win); - win->GetEventHandler()->ProcessEvent(event); - } + // Because GetClientSize() returns (0,0) when IsIconized() is true, + // a size event must be generated, just in case GetClientSize() was + // called while iconized. This specifically happens when restoring a + // tlw that was "rolled up" with some WMs. + // Queue a resize rather than sending size event directly to allow + // children to be made visible first. + win->m_oldClientWidth = 0; + gtk_widget_queue_resize(win->m_wxwindow); } - win->SetIconizeState(false); return false; } } @@ -392,6 +375,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 //----------------------------------------------------------------------------- @@ -402,56 +416,24 @@ 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; -#if GTK_CHECK_VERSION(2, 2, 0) - if (gtk_check_version(2, 2, 0) == NULL) - { - xproperty = gdk_x11_atom_to_xatom_for_display( - gdk_drawable_get_display(event->window), property); - } - else -#endif + int left, right, top, bottom; + if (wxGetFrameExtents(event->window, &left, &right, &top, &bottom)) { - xproperty = gdk_x11_atom_to_xatom(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) - { - wxSize& decorSize = GetDecorSize(win->m_gdkDecor); - const wxSize size = - wxSize(int(data[0] + data[1]), int(data[2] + data[3])); - if (decorSize.x != size.x || decorSize.y != size.y) - { - // Update window size and frame extents cache - win->m_width += size.x - decorSize.x; - win->m_height += size.y - decorSize.y; - if (win->m_width < 0) win->m_width = 0; - if (win->m_height < 0) win->m_height = 0; - decorSize = size; - wxSizeEvent event(win->GetSize(), win->GetId()); - event.SetEventObject(win); - win->GetEventHandler()->ProcessEvent(event); - } + const wxSize decorSize = + wxSize(left + right, top + bottom); + win->GTKUpdateDecorSize(decorSize); } - if (data) - XFree(data); } return false; } } +BEGIN_EVENT_TABLE(wxTopLevelWindowGTK, wxTopLevelWindowBase) + EVT_SYS_COLOUR_CHANGED(wxTopLevelWindowGTK::OnSysColourChanged) +END_EVENT_TABLE() + // ---------------------------------------------------------------------------- // wxTopLevelWindowGTK creation // ---------------------------------------------------------------------------- @@ -464,6 +446,7 @@ void wxTopLevelWindowGTK::Init() m_themeEnabled = true; m_gdkDecor = m_gdkFunc = 0; m_grabbed = false; + m_deferShow = true; m_urgency_hint = -2; } @@ -497,6 +480,14 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, // e.g. in wxTaskBarIconAreaGTK if (m_widget == NULL) { +#if wxUSE_LIBHILDON + // 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 m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL); if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) { @@ -509,25 +500,21 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, } else { -#if GTK_CHECK_VERSION(2,1,0) - if (!gtk_check_version(2,1,0)) + if (style & wxFRAME_TOOL_WINDOW) { - if (style & wxFRAME_TOOL_WINDOW) - { - gtk_window_set_type_hint(GTK_WINDOW(m_widget), - GDK_WINDOW_TYPE_HINT_UTILITY); - - // On some WMs, like KDE, a TOOL_WINDOW will still show - // on the taskbar, but on Gnome a TOOL_WINDOW will not. - // For consistency between WMs and with Windows, we - // should set the NO_TASKBAR flag which will apply - // the set_skip_taskbar_hint if it is available, - // ensuring no taskbar entry will appear. - style |= wxFRAME_NO_TASKBAR; - } + gtk_window_set_type_hint(GTK_WINDOW(m_widget), + GDK_WINDOW_TYPE_HINT_UTILITY); + + // On some WMs, like KDE, a TOOL_WINDOW will still show + // on the taskbar, but on Gnome a TOOL_WINDOW will not. + // For consistency between WMs and with Windows, we + // should set the NO_TASKBAR flag which will apply + // the set_skip_taskbar_hint if it is available, + // ensuring no taskbar entry will appear. + style |= wxFRAME_NO_TASKBAR; } -#endif } +#endif // wxUSE_LIBHILDON/!wxUSE_LIBHILDON } wxWindow *topParent = wxGetTopLevelParent(m_parent); @@ -539,25 +526,15 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, GTK_WINDOW(topParent->m_widget) ); } -#if GTK_CHECK_VERSION(2,2,0) - if (!gtk_check_version(2,2,0)) + if (style & wxFRAME_NO_TASKBAR) { - if (style & wxFRAME_NO_TASKBAR) - { - gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE); - } + gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE); } -#endif -#ifdef __WXGTK24__ - if (!gtk_check_version(2,4,0)) + if (style & wxSTAY_ON_TOP) { - if (style & wxSTAY_ON_TOP) - { - gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE); - } + gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE); } -#endif #if 0 if (!name.empty()) @@ -577,7 +554,7 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget ); // m_wxwindow is the client area - m_wxwindow = gtk_pizza_new_no_scroll(); + m_wxwindow = wxPizza::New(); gtk_widget_show( m_wxwindow ); gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow ); @@ -664,7 +641,7 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, } } - // m_gdkDecor 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); @@ -674,6 +651,15 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, wxTopLevelWindowGTK::~wxTopLevelWindowGTK() { +#if wxUSE_LIBHILDON + // 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 + if (m_grabbed) { wxFAIL_MSG(_T("Window still grabbed")); @@ -718,12 +704,11 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long) wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(), (WXWindow)GDK_ROOT_WINDOW()); -#if GTK_CHECK_VERSION(2,2,0) // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions // to switch to fullscreen, which is not always available. We must // check if WM supports the spec and use legacy methods if it // doesn't. - if ( (method == wxX11_FS_WMSPEC) && !gtk_check_version(2,2,0) ) + if ( method == wxX11_FS_WMSPEC ) { if (show) gtk_window_fullscreen( GTK_WINDOW( m_widget ) ); @@ -731,7 +716,6 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long) gtk_window_unfullscreen( GTK_WINDOW( m_widget ) ); } else -#endif // GTK+ >= 2.2.0 { GdkWindow *window = m_widget->window; @@ -746,15 +730,11 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long) gint client_x, client_y, root_x, root_y; gint width, height; - if (method != wxX11_FS_WMSPEC) - { - // don't do it always, Metacity hates it - m_fsSaveGdkFunc = m_gdkFunc; - m_fsSaveGdkDecor = m_gdkDecor; - m_gdkFunc = m_gdkDecor = 0; - gdk_window_set_decorations(window, (GdkWMDecoration)0); - gdk_window_set_functions(window, (GdkWMFunction)0); - } + m_fsSaveGdkFunc = m_gdkFunc; + m_fsSaveGdkDecor = m_gdkDecor; + m_gdkFunc = m_gdkDecor = 0; + gdk_window_set_decorations(window, (GdkWMDecoration)0); + gdk_window_set_functions(window, (GdkWMFunction)0); gdk_window_get_origin (m_widget->window, &root_x, &root_y); gdk_window_get_geometry (m_widget->window, &client_x, &client_y, @@ -770,14 +750,10 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long) } else // hide { - if (method != wxX11_FS_WMSPEC) - { - // don't do it always, Metacity hates it - m_gdkFunc = m_fsSaveGdkFunc; - m_gdkDecor = m_fsSaveGdkDecor; - gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor); - gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc); - } + m_gdkFunc = m_fsSaveGdkFunc; + m_gdkDecor = m_fsSaveGdkDecor; + gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor); + gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc); wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(), (WXWindow)GDK_ROOT_WINDOW(), @@ -805,14 +781,66 @@ bool wxTopLevelWindowGTK::Show( bool show ) { wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); - if (show && !IsShown()) + 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 + // notification is received, so correct frame extents are known. + // This allows resizing m_widget to keep the overall size in sync with + // 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 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 (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. wxSizeEvent event(GetSize(), GetId()); event.SetEventObject(this); - GetEventHandler()->ProcessEvent(event); + HandleWindowEvent(event); } bool change = wxTopLevelWindowBase::Show(show); @@ -845,12 +873,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 -= GetDecorSize(m_gdkDecor); - 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; } @@ -859,10 +884,6 @@ void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int si { wxCHECK_RET( m_widget, wxT("invalid frame") ); - // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow - wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") ); - - // deal with the position first int old_x = m_x; int old_y = m_y; @@ -901,10 +922,18 @@ void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int si GetClientSize(&m_oldClientWidth, &m_oldClientHeight); wxSizeEvent event(GetSize(), GetId()); event.SetEventObject(this); - GetEventHandler()->ProcessEvent(event); + HandleWindowEvent(event); } } +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")); @@ -934,24 +963,23 @@ void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH, const wxSize maxSize = GetMaxSize(); GdkGeometry hints; int hints_mask = 0; - const wxSize sizeDecor = GetDecorSize(m_gdkDecor); if (minSize.x > 0 || minSize.y > 0) { hints_mask |= GDK_HINT_MIN_SIZE; - hints.min_width = minSize.x - sizeDecor.x; + hints.min_width = minSize.x - m_decorSize.x; if (hints.min_width < 0) hints.min_width = 0; - hints.min_height = minSize.y - sizeDecor.y; + hints.min_height = minSize.y - m_decorSize.y; if (hints.min_height < 0) hints.min_height = 0; } if (maxSize.x > 0 || maxSize.y > 0) { hints_mask |= GDK_HINT_MAX_SIZE; - hints.max_width = maxSize.x - sizeDecor.x; + hints.max_width = maxSize.x - m_decorSize.x; if (hints.max_width < 0) hints.max_width = INT_MAX; - hints.max_height = maxSize.y - sizeDecor.y; + hints.max_height = maxSize.y - m_decorSize.y; if (hints.max_height < 0) hints.max_height = INT_MAX; } @@ -965,29 +993,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. @@ -1132,14 +1206,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) ) { - window = GTK_PIZZA(m_wxwindow)->bin_window; - do_shape_combine_region(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() @@ -1184,10 +1266,8 @@ void wxTopLevelWindowGTK::RequestUserAttention(int flags) void wxTopLevelWindowGTK::SetWindowStyleFlag( long style ) { -#if defined(__WXGTK24__) || GTK_CHECK_VERSION(2,2,0) // Store which styles were changed long styleChanges = style ^ m_windowStyle; -#endif // Process wxWindow styles. This also updates the internal variable // Therefore m_windowStyle bits carry now the _new_ style values @@ -1197,16 +1277,17 @@ void wxTopLevelWindowGTK::SetWindowStyleFlag( long style ) if (!m_widget) return; -#ifdef __WXGTK24__ - if ( (styleChanges & wxSTAY_ON_TOP) && !gtk_check_version(2,4,0) ) - gtk_window_set_keep_above(GTK_WINDOW(m_widget), m_windowStyle & wxSTAY_ON_TOP); -#endif // GTK+ 2.4 -#if GTK_CHECK_VERSION(2,2,0) - if ( (styleChanges & wxFRAME_NO_TASKBAR) && !gtk_check_version(2,2,0) ) + if ( styleChanges & wxSTAY_ON_TOP ) { - gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), m_windowStyle & wxFRAME_NO_TASKBAR); + gtk_window_set_keep_above(GTK_WINDOW(m_widget), + m_windowStyle & wxSTAY_ON_TOP); + } + + if ( styleChanges & wxFRAME_NO_TASKBAR ) + { + gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), + m_windowStyle & wxFRAME_NO_TASKBAR); } -#endif // GTK+ 2.2 } /* Get the X Window between child and the root window. @@ -1282,3 +1363,16 @@ 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(); +}