X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/e2f3bc41106f177e3d4ab717961c1a2469abdbef..ad653fa23069c5d9378247084f03c9a718c3ad62:/src/gtk/toplevel.cpp?ds=inline diff --git a/src/gtk/toplevel.cpp b/src/gtk/toplevel.cpp index caca06176d..542cfc0cc5 100644 --- a/src/gtk/toplevel.cpp +++ b/src/gtk/toplevel.cpp @@ -31,36 +31,40 @@ #include "wx/app.h" #endif -#include "wx/gtk/private.h" #include "wx/evtloop.h" #include "wx/sysopt.h" #include -#include - -#include "wx/gtk/win_gtk.h" - -#include "wx/unix/utilsx11.h" +#ifdef GDK_WINDOWING_X11 + #include + #include // XA_CARDINAL + #include "wx/unix/utilsx11.h" +#endif -// XA_CARDINAL -#include +#include "wx/gtk/private.h" +#include "wx/gtk/private/gtk2-compat.h" +#include "wx/gtk/private/win_gtk.h" #if wxUSE_LIBHILDON #include #include #endif // wxUSE_LIBHILDON +#if wxUSE_LIBHILDON2 + #include +#endif // wxUSE_LIBHILDON2 + // ---------------------------------------------------------------------------- // 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 -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 @@ -68,40 +72,52 @@ static wxTopLevelWindowGTK *g_lastActiveFrame = (wxTopLevelWindowGTK*) NULL; // send any activate events at all static int g_sendActivateEvent = -1; +// Whether _NET_REQUEST_FRAME_EXTENTS support is working +// 0 == not tested yet, 1 == working, 2 == broken +static int gs_requestFrameExtentsStatus; + //----------------------------------------------------------------------------- // RequestUserAttention related functions //----------------------------------------------------------------------------- -extern "C" { +#ifndef __WXGTK3__ static void wxgtk_window_set_urgency_hint (GtkWindow *win, gboolean setting) { - wxASSERT_MSG( GTK_WIDGET_REALIZED(win), wxT("wxgtk_window_set_urgency_hint: GdkWindow not realized") ); - GdkWindow *window = GTK_WIDGET(win)->window; - XWMHints *wm_hints; +#if GTK_CHECK_VERSION(2,7,0) + if (gtk_check_version(2,7,0) == NULL) + gtk_window_set_urgency_hint(win, setting); + else +#endif + { +#ifdef GDK_WINDOWING_X11 + GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(win)); + wxCHECK_RET(window, "wxgtk_window_set_urgency_hint: GdkWindow not realized"); - wm_hints = XGetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window)); + Display* dpy = GDK_WINDOW_XDISPLAY(window); + Window xid = GDK_WINDOW_XID(window); + XWMHints* wm_hints = XGetWMHints(dpy, xid); - if (!wm_hints) - wm_hints = XAllocWMHints(); + if (!wm_hints) + wm_hints = XAllocWMHints(); - if (setting) - wm_hints->flags |= XUrgencyHint; - else - wm_hints->flags &= ~XUrgencyHint; + if (setting) + wm_hints->flags |= XUrgencyHint; + else + wm_hints->flags &= ~XUrgencyHint; - XSetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window), wm_hints); - XFree(wm_hints); + XSetWMHints(dpy, xid, wm_hints); + XFree(wm_hints); +#endif // GDK_WINDOWING_X11 + } } +#define gtk_window_set_urgency_hint wxgtk_window_set_urgency_hint +#endif +extern "C" { static gboolean gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK *win ) { -#if GTK_CHECK_VERSION(2,7,0) - if(!gtk_check_version(2,7,0)) - gtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE); - else -#endif - wxgtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE); + gtk_window_set_urgency_hint(GTK_WINDOW(win->m_widget), false); win->m_urgency_hint = -2; return FALSE; @@ -143,15 +159,7 @@ static gboolean gtk_frame_focus_in_callback( GtkWidget *widget, g_source_remove( win->m_urgency_hint ); // no break, fallthrough to remove hint too case -1: -#if GTK_CHECK_VERSION(2,7,0) - if(!gtk_check_version(2,7,0)) - gtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE); - else -#endif - { - wxgtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE); - } - + gtk_window_set_urgency_hint(GTK_WINDOW(widget), false); win->m_urgency_hint = -2; break; @@ -161,7 +169,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; } @@ -177,7 +185,7 @@ gboolean gtk_frame_focus_out_callback(GtkWidget * WXUNUSED(widget), GdkEventFocus *WXUNUSED(gdk_event), wxTopLevelWindowGTK * WXUNUSED(win)) { - // if the focus goes out of our app alltogether, OnIdle() will send + // if the focus goes out of our app altogether, OnIdle() will send // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset // g_sendActivateEvent to -1 g_sendActivateEvent = 0; @@ -191,7 +199,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; } @@ -200,23 +208,35 @@ gboolean gtk_frame_focus_out_callback(GtkWidget * WXUNUSED(widget), } } -//----------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- +// "key_press_event" +// ---------------------------------------------------------------------------- -// Get cached size of WM decorations for given GdkWMDecoration. -static wxSize& GetDecorSize(int decor) +extern "C" { +static gboolean +wxgtk_tlw_key_press_event(GtkWidget *widget, GdkEventKey *event) { - // 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]; + GtkWindow* const window = GTK_WINDOW(widget); - 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]; + // By default GTK+ checks for the menu accelerators in this (top level) + // window first and then propagates the event to the currently focused + // child from where it bubbles up the window parent chain. In wxWidgets, + // however, we want the child window to have the event first but still + // handle it as an accelerator if it's not processed there, so we need to + // customize this by reversing the order of the steps done in the standard + // GTK+ gtk_window_key_press_event() handler. + + if ( gtk_window_propagate_key_event(window, event) ) + return TRUE; + + if ( gtk_window_activate_key(window, event) ) + return TRUE; + + if (GTK_WIDGET_GET_CLASS(widget)->key_press_event(widget, event)) + return TRUE; + + return FALSE; +} } //----------------------------------------------------------------------------- @@ -227,43 +247,31 @@ extern "C" { static void size_allocate(GtkWidget*, GtkAllocation* alloc, wxTopLevelWindowGTK* win) { - if (win->m_oldClientWidth != alloc->width || - win->m_oldClientHeight != alloc->height) + win->m_useCachedClientSize = true; + if (win->m_clientWidth != alloc->width || + win->m_clientHeight != alloc->height) { - 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; + win->m_clientWidth = alloc->width; + win->m_clientHeight = alloc->height; + + GtkAllocation a; + gtk_widget_get_allocation(win->m_widget, &a); + wxSize size(a.width, a.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 } } } -// ---------------------------------------------------------------------------- -// "size_request" -// ---------------------------------------------------------------------------- - -extern "C" { -static -void wxgtk_tlw_size_request_callback(GtkWidget * WXUNUSED(widget), - GtkRequisition *requisition, - wxTopLevelWindowGTK *win) -{ - // we must return the size of the window without WM decorations, otherwise - // GTK+ gets confused, so don't call just GetSize() here - win->GTKDoGetSize(&requisition->width, &requisition->height); -} -} - //----------------------------------------------------------------------------- // "delete_event" //----------------------------------------------------------------------------- @@ -275,7 +283,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(); @@ -283,7 +291,6 @@ gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), } } - //----------------------------------------------------------------------------- // "configure_event" //----------------------------------------------------------------------------- @@ -294,7 +301,7 @@ gtk_frame_configure_callback( GtkWidget* widget, GdkEventConfigure *WXUNUSED(event), wxTopLevelWindowGTK *win ) { - if (!win->m_hasVMT || !win->IsShown()) + if (!win->IsShown()) return FALSE; wxPoint point; @@ -304,7 +311,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; } @@ -314,35 +321,39 @@ 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" { -static void -gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), - wxTopLevelWindowGTK *win ) +void wxTopLevelWindowGTK::GTKHandleRealized() { - // 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); + wxNonOwnedWindow::GTKHandleRealized(); + + gdk_window_set_decorations(gtk_widget_get_window(m_widget), + (GdkWMDecoration)m_gdkDecor); + gdk_window_set_functions(gtk_widget_get_window(m_widget), + (GdkWMFunction)m_gdkFunc); // GTK's shrinking/growing policy - if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0) - gtk_window_set_resizable(GTK_WINDOW(win->m_widget), FALSE); + if ( !(m_gdkFunc & GDK_FUNC_RESIZE) ) + gtk_window_set_resizable(GTK_WINDOW(m_widget), FALSE); +#ifndef __WXGTK3__ else - gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1); + gtk_window_set_policy(GTK_WINDOW(m_widget), 1, 1, 1); +#endif + + const wxIconBundle& icons = GetIcons(); + if (icons.GetIconCount()) + SetIcons(icons); - // reset the icon - wxIconBundle iconsOld = win->GetIcons(); - if ( !iconsOld.IsEmpty() ) +#ifdef __WXGTK3__ + if (gtk_window_get_has_resize_grip(GTK_WINDOW(m_widget))) { - win->SetIcon( wxNullIcon ); - win->SetIcons( iconsOld ); + // Grip window can end up obscured, probably due to deferred show. + // Reset grip to ensure it is visible. + gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), false); + gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), true); } -} +#endif } //----------------------------------------------------------------------------- @@ -351,33 +362,11 @@ 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); - 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; - } - } - const bool wasIconized = win->IsIconized(); - - win->SetIconizeState(false); - if (wasIconized) { // Because GetClientSize() returns (0,0) when IsIconized() is true, @@ -386,29 +375,89 @@ gtk_frame_map_callback( GtkWidget* widget, // 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; + win->m_useCachedClientSize = false; + win->m_clientWidth = 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); + } + + // restore focus-on-map setting in case ShowWithoutActivating() was called + gtk_window_set_focus_on_map(GTK_WINDOW(win->m_widget), true); return false; } } //----------------------------------------------------------------------------- -// "unmap_event" from m_widget +// "window-state-event" from m_widget //----------------------------------------------------------------------------- extern "C" { static gboolean -gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget), - GdkEvent * WXUNUSED(event), +gtk_frame_window_state_callback( GtkWidget* WXUNUSED(widget), + GdkEventWindowState *event, wxTopLevelWindow *win ) { - win->SetIconizeState(true); + if (event->changed_mask & GDK_WINDOW_STATE_ICONIFIED) + win->SetIconizeState((event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) != 0); + + // if maximized bit changed and it is now set + if (event->changed_mask & event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) + { + wxMaximizeEvent evt(win->GetId()); + evt.SetEventObject(win); + win->HandleWindowEvent(evt); + } + + if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) + win->m_fsIsShowing = (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) != 0; + return false; } } +//----------------------------------------------------------------------------- + +bool wxGetFrameExtents(GdkWindow* window, int* left, int* right, int* top, int* bottom) +{ +#ifdef GDK_WINDOWING_X11 + static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false); + GdkDisplay* display = gdk_window_get_display(window); + Atom xproperty = gdk_x11_atom_to_xatom_for_display(display, property); + Atom type; + int format; + gulong nitems, bytes_after; + guchar* data; + Status status = XGetWindowProperty( + GDK_DISPLAY_XDISPLAY(display), + GDK_WINDOW_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; +#else + return false; +#endif +} + +#ifdef GDK_WINDOWING_X11 //----------------------------------------------------------------------------- // "property_notify_event" from m_widget //----------------------------------------------------------------------------- @@ -419,49 +468,45 @@ 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) + if (win->m_netFrameExtentsTimerId) { - 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; - win->m_oldClientWidth = 0; - gtk_widget_queue_resize(win->m_wxwindow); - } + // WM support for _NET_REQUEST_FRAME_EXTENTS is working + gs_requestFrameExtentsStatus = 1; + g_source_remove(win->m_netFrameExtentsTimerId); + win->m_netFrameExtentsTimerId = 0; } - 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() - +extern "C" { +static gboolean request_frame_extents_timeout(void* data) +{ + // WM support for _NET_REQUEST_FRAME_EXTENTS is broken + gs_requestFrameExtentsStatus = 2; + gdk_threads_enter(); + wxTopLevelWindowGTK* win = static_cast(data); + win->m_netFrameExtentsTimerId = 0; + wxSize decorSize = win->m_decorSize; + int left, right, top, bottom; + if (wxGetFrameExtents(gtk_widget_get_window(win->m_widget), &left, &right, &top, &bottom)) + decorSize.Set(left + right, top + bottom); + win->GTKUpdateDecorSize(decorSize); + gdk_threads_leave(); + return false; +} +} +#endif // GDK_WINDOWING_X11 // ---------------------------------------------------------------------------- // wxTopLevelWindowGTK creation @@ -469,12 +514,18 @@ END_EVENT_TABLE() 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_netFrameExtentsTimerId = 0; + m_incWidth = m_incHeight = 0; m_urgency_hint = -2; } @@ -508,14 +559,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) { @@ -542,7 +593,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); @@ -563,6 +616,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()) @@ -570,48 +625,46 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, #endif gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) ); - GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS ); + gtk_widget_set_can_focus(m_widget, false); g_signal_connect (m_widget, "delete_event", G_CALLBACK (gtk_frame_delete_callback), this); // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow) - m_mainWidget = gtk_vbox_new(false, 0); + m_mainWidget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show( m_mainWidget ); - GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS ); + gtk_widget_set_can_focus(m_mainWidget, false); gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget ); // m_wxwindow is the client area m_wxwindow = wxPizza::New(); gtk_widget_show( m_wxwindow ); - gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow ); + gtk_box_pack_start(GTK_BOX(m_mainWidget), m_wxwindow, true, true, 0); // we donm't allow the frame to get the focus as otherwise // the frame will grab it at arbitrary focus changes - GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS ); + gtk_widget_set_can_focus(m_wxwindow, false); if (m_parent) m_parent->AddChild( this ); g_signal_connect(m_wxwindow, "size_allocate", G_CALLBACK(size_allocate), this); - g_signal_connect (m_widget, "size_request", - G_CALLBACK (wxgtk_tlw_size_request_callback), this); PostCreation(); +#ifndef __WXGTK3__ if ((m_x != -1) || (m_y != -1)) gtk_widget_set_uposition( m_widget, m_x, m_y ); +#endif - // we cannot set MWM hints and icons before the widget has - // been realized, so we do this directly after realization - g_signal_connect (m_widget, "realize", - G_CALLBACK (gtk_frame_realized_callback), this); - - // map and unmap for iconized state + // for some reported size corrections g_signal_connect (m_widget, "map_event", G_CALLBACK (gtk_frame_map_callback), this); - g_signal_connect (m_widget, "unmap_event", - G_CALLBACK (gtk_frame_unmap_callback), this); + + // for iconized state + g_signal_connect (m_widget, "window_state_event", + G_CALLBACK (gtk_frame_window_state_callback), this); + // for wxMoveEvent g_signal_connect (m_widget, "configure_event", @@ -623,53 +676,69 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, g_signal_connect_after (m_widget, "focus_out_event", G_CALLBACK (gtk_frame_focus_out_callback), this); - gtk_widget_add_events(m_widget, GDK_PROPERTY_CHANGE_MASK); - g_signal_connect(m_widget, "property_notify_event", - G_CALLBACK(property_notify_event), this); + // We need to customize the default GTK+ logic for key processing to make + // it conforming to wxWidgets event processing order. + g_signal_connect (m_widget, "key_press_event", + G_CALLBACK (wxgtk_tlw_key_press_event), NULL); + +#ifdef GDK_WINDOWING_X11 +#ifdef __WXGTK3__ + if (GDK_IS_X11_SCREEN(gtk_window_get_screen(GTK_WINDOW(m_widget)))) +#endif + { + gtk_widget_add_events(m_widget, GDK_PROPERTY_CHANGE_MASK); + g_signal_connect(m_widget, "property_notify_event", + G_CALLBACK(property_notify_event), this); + } +#endif // GDK_WINDOWING_X11 + + // 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; - // decorations - if ((style & wxSIMPLE_BORDER) || (style & wxNO_BORDER)) + 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; } } - // m_gdkDecor needs to be set before calling GTKDoGetSize + // GTK sometimes chooses very small size if max size hint is not explicitly set + DoSetSizeHints(m_minWidth, m_minHeight, m_maxWidth, m_maxHeight, m_incWidth, m_incHeight); + + m_decorSize = GetCachedDecorSize(); int w, h; GTKDoGetSize(&w, &h); gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h); @@ -679,18 +748,29 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, wxTopLevelWindowGTK::~wxTopLevelWindowGTK() { -#if wxUSE_LIBHILDON - hildon_program_remove_window(wxTheApp->GetHildonProgram(), - HILDON_WINDOW(m_widget)); -#endif // wxUSE_LIBHILDON + if ( m_netFrameExtentsTimerId ) + { + // Don't let the timer callback fire as the window pointer passed to it + // will become invalid very soon. + g_source_remove(m_netFrameExtentsTimerId); + } + +#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 || 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)) @@ -711,8 +791,9 @@ bool wxTopLevelWindowGTK::EnableCloseButton( bool enable ) else m_gdkFunc &= ~GDK_FUNC_CLOSE; - if (GTK_WIDGET_REALIZED(m_widget) && (m_widget->window)) - gdk_window_set_functions( m_widget->window, (GdkWMFunction)m_gdkFunc ); + GdkWindow* window = gtk_widget_get_window(m_widget); + if (window) + gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc); return true; } @@ -724,32 +805,37 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long) m_fsIsShowing = show; - wxX11FullScreenMethod method = - wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(), - (WXWindow)GDK_ROOT_WINDOW()); +#ifdef GDK_WINDOWING_X11 + Display* xdpy = GDK_DISPLAY_XDISPLAY(gtk_widget_get_display(m_widget)); + Window xroot = GDK_WINDOW_XID(gtk_widget_get_root_window(m_widget)); + wxX11FullScreenMethod method = wxGetFullScreenMethodX11(xdpy, (WXWindow)xroot); // 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 ) +#endif // GDK_WINDOWING_X11 { if (show) gtk_window_fullscreen( GTK_WINDOW( m_widget ) ); else gtk_window_unfullscreen( GTK_WINDOW( m_widget ) ); } +#ifdef GDK_WINDOWING_X11 else { - GdkWindow *window = m_widget->window; + GdkWindow* window = gtk_widget_get_window(m_widget); + Window xid = GDK_WINDOW_XID(window); if (show) { GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y ); GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height ); - int screen_width,screen_height; - wxDisplaySize( &screen_width, &screen_height ); + GdkScreen* screen = gtk_widget_get_screen(m_widget); + const int screen_width = gdk_screen_get_width(screen); + const int screen_height = gdk_screen_get_height(screen); gint client_x, client_y, root_x, root_y; gint width, height; @@ -760,16 +846,15 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long) 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, - &width, &height, NULL); + gdk_window_get_origin(window, &root_x, &root_y); + gdk_window_get_geometry(window, &client_x, &client_y, &width, &height); - gdk_window_move_resize (m_widget->window, -client_x, -client_y, - screen_width + 1, screen_height + 1); + gdk_window_move_resize( + window, -client_x, -client_y, screen_width + 1, screen_height + 1); - wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(), - (WXWindow)GDK_ROOT_WINDOW(), - (WXWindow)GDK_WINDOW_XWINDOW(window), + wxSetFullScreenStateX11(xdpy, + (WXWindow)xroot, + (WXWindow)xid, show, &m_fsSaveFrame, method); } else // hide @@ -779,15 +864,16 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long) gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor); gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc); - wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(), - (WXWindow)GDK_ROOT_WINDOW(), - (WXWindow)GDK_WINDOW_XWINDOW(window), + wxSetFullScreenStateX11(xdpy, + (WXWindow)xroot, + (WXWindow)xid, show, &m_fsSaveFrame, method); SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y, m_fsSaveFrame.width, m_fsSaveFrame.height); } } +#endif // GDK_WINDOWING_X11 // documented behaviour is to show the window if it's still hidden when // showing it full screen @@ -801,21 +887,116 @@ 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 ); + + GdkWindow* window = NULL; + if (m_wxwindow) + window = gtk_widget_get_window(m_wxwindow); + if (window) + gdk_window_invalidate_rect(window, NULL, true); +} + bool wxTopLevelWindowGTK::Show( bool show ) { wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); - if (show && !IsShown()) +#ifdef GDK_WINDOWING_X11 + bool deferShow = show && !m_isShown && m_deferShow; + if (deferShow) + { + deferShow = m_deferShowAllowed && gs_requestFrameExtentsStatus != 2 && + !gtk_widget_get_realized(m_widget) && + 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) + { + GdkScreen* 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; + } + + m_deferShow = deferShow; + } + 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). + GtkAllocation alloc; + gtk_widget_get_allocation(m_widget, &alloc); + const int alloc_width = alloc.width; + if (alloc_width == 1) + { + alloc.width = 2; + gtk_widget_set_allocation(m_widget, &alloc); + } + gtk_widget_realize(m_widget); + if (alloc_width == 1) + { + alloc.width = 1; + gtk_widget_set_allocation(m_widget, &alloc); + } + + // send _NET_REQUEST_FRAME_EXTENTS + XClientMessageEvent xevent; + memset(&xevent, 0, sizeof(xevent)); + xevent.type = ClientMessage; + GdkWindow* window = gtk_widget_get_window(m_widget); + xevent.window = GDK_WINDOW_XID(window); + xevent.message_type = gdk_x11_atom_to_xatom_for_display( + gdk_window_get_display(window), + gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false)); + xevent.format = 32; + Display* display = GDK_DISPLAY_XDISPLAY(gdk_window_get_display(window)); + XSendEvent(display, DefaultRootWindow(display), false, + SubstructureNotifyMask | SubstructureRedirectMask, + (XEvent*)&xevent); + + if (gs_requestFrameExtentsStatus == 0) + { + // if WM does not respond to request within 1 second, + // we assume support for _NET_REQUEST_FRAME_EXTENTS is not working + m_netFrameExtentsTimerId = + g_timeout_add(1000, request_frame_extents_timeout, this); + } + + // defer calling gtk_widget_show() + m_isShown = true; + return true; + } +#endif // GDK_WINDOWING_X11 + + if (show && !gtk_widget_get_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); + bool change = base_type::Show(show); if (change && !show) { @@ -828,6 +1009,15 @@ bool wxTopLevelWindowGTK::Show( bool show ) return change; } +void wxTopLevelWindowGTK::ShowWithoutActivating() +{ + if (!m_isShown) + { + gtk_window_set_focus_on_map(GTK_WINDOW(m_widget), false); + Show(true); + } +} + void wxTopLevelWindowGTK::Raise() { gtk_window_present( GTK_WINDOW( m_widget ) ); @@ -845,14 +1035,28 @@ 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 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 ) @@ -888,19 +1092,34 @@ void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int si if (height >= 0) m_height = height; ConstrainSize(); + if (m_width < 1) m_width = 1; + if (m_height < 1) m_height = 1; if (m_width != oldSize.x || m_height != oldSize.y) { + m_deferShowAllowed = true; + m_useCachedClientSize = false; + int w, h; GTKDoGetSize(&w, &h); gtk_window_resize(GTK_WINDOW(m_widget), w, h); - GetClientSize(&m_oldClientWidth, &m_oldClientHeight); + DoGetClientSize(&m_clientWidth, &m_clientHeight); wxSizeEvent event(GetSize(), GetId()); event.SetEventObject(this); - GetEventHandler()->ProcessEvent(event); + HandleWindowEvent(event); } } +void wxTopLevelWindowGTK::DoSetClientSize(int width, int 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 { wxASSERT_MSG(m_widget, wxT("invalid frame")); @@ -914,6 +1133,8 @@ void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const if ( height ) *height = 0; } + else if (m_useCachedClientSize) + base_type::DoGetClientSize(width, height); else { GTKDoGetSize(width, height); @@ -924,32 +1145,35 @@ 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); + m_incWidth = incW; + m_incHeight = incH; const wxSize minSize = GetMinSize(); const wxSize maxSize = GetMaxSize(); GdkGeometry hints; - int hints_mask = 0; - const wxSize sizeDecor = GetDecorSize(m_gdkDecor); - if (minSize.x > 0 || minSize.y > 0) + // always set both min and max hints, otherwise GTK will + // make assumptions we don't want about the unset values + int hints_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE; + hints.min_width = 1; + hints.min_height = 1; + hints.max_width = INT_MAX; + hints.max_height = INT_MAX; + if (minSize.x > m_decorSize.x) + hints.min_width = minSize.x - m_decorSize.x; + if (minSize.y > m_decorSize.y) + hints.min_height = minSize.y - m_decorSize.y; + if (maxSize.x > 0) { - hints_mask |= GDK_HINT_MIN_SIZE; - hints.min_width = minSize.x - sizeDecor.x; - if (hints.min_width < 0) - hints.min_width = 0; - hints.min_height = minSize.y - sizeDecor.y; - if (hints.min_height < 0) - hints.min_height = 0; + hints.max_width = maxSize.x - m_decorSize.x; + if (hints.max_width < hints.min_width) + hints.max_width = hints.min_width; } - if (maxSize.x > 0 || maxSize.y > 0) + if (maxSize.y > 0) { - hints_mask |= GDK_HINT_MAX_SIZE; - hints.max_width = maxSize.x - sizeDecor.x; - if (hints.max_width < 0) - hints.max_width = INT_MAX; - hints.max_height = maxSize.y - sizeDecor.y; - if (hints.max_height < 0) - hints.max_height = INT_MAX; + hints.max_height = maxSize.y - m_decorSize.y; + if (hints.max_height < hints.min_height) + hints.max_height = hints.min_height; } if (incW > 0 || incH > 0) { @@ -961,30 +1185,83 @@ void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH, (GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask); } -bool wxTopLevelWindowGTK::IsDecorCacheable() const +#ifdef GDK_WINDOWING_X11 +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_updateDecorSize && m_decorSize != decorSize) { - if ( g_delayedFocus && - wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this ) + m_useCachedClientSize = false; + const wxSize diff = decorSize - m_decorSize; + m_decorSize = decorSize; + bool resized = false; + if (m_minWidth > 0 || m_minHeight > 0 || m_maxWidth > 0 || m_maxHeight > 0) { - 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; + // update size hints, they depend on m_decorSize + DoSetSizeHints(m_minWidth, m_minHeight, m_maxWidth, m_maxHeight, m_incWidth, m_incHeight); } + if (m_deferShow) + { + // 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 + if (w >= m_minWidth - decorSize.x && h >= m_minHeight - decorSize.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 < 1) m_width = 1; + if (m_height < 1) m_height = 1; + m_clientWidth = 0; + gtk_widget_queue_resize(m_wxwindow); + } + } + if (m_deferShow) + { + // gtk_widget_show() was deferred, do it now + m_deferShow = false; + DoGetClientSize(&m_clientWidth, &m_clientHeight); + wxSizeEvent sizeEvent(GetSize(), GetId()); + sizeEvent.SetEventObject(this); + HandleWindowEvent(sizeEvent); + + gtk_widget_show(m_widget); + + wxShowEvent showEvent(GetId(), true); + showEvent.SetEventObject(this); + HandleWindowEvent(showEvent); } +} +#endif // GDK_WINDOWING_X11 + +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]; +} - wxWindow::OnInternalIdle(); +void wxTopLevelWindowGTK::OnInternalIdle() +{ + wxTopLevelWindowBase::OnInternalIdle(); // Synthetize activate events. if ( g_sendActivateEvent != -1 ) @@ -1021,18 +1298,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_get_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); } // ---------------------------------------------------------------------------- @@ -1049,10 +1327,10 @@ void wxTopLevelWindowGTK::Maximize(bool maximize) bool wxTopLevelWindowGTK::IsMaximized() const { - if(!m_widget->window) - return false; - - return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED; + GdkWindow* window = NULL; + if (m_widget) + window = gtk_widget_get_window(m_widget); + return window && (gdk_window_get_state(window) & GDK_WINDOW_STATE_MAXIMIZED); } void wxTopLevelWindowGTK::Restore() @@ -1103,40 +1381,6 @@ void wxTopLevelWindowGTK::RemoveGrab() } } - -// helper -static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region) -{ - if (window) - { - if (region.IsEmpty()) - { - gdk_window_shape_combine_mask(window, NULL, 0, 0); - } - else - { - gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0); - return true; - } - } - return false; -} - - -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) - { - do_shape_combine_region(m_wxwindow->window, region); - } - window = m_widget->window; - return do_shape_combine_region(window, region); -} - bool wxTopLevelWindowGTK::IsActive() { return (this == (wxTopLevelWindowGTK*)g_activeFrame); @@ -1147,17 +1391,18 @@ 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); m_urgency_hint = -2; - if( GTK_WIDGET_REALIZED(m_widget) && !IsActive() ) + if( gtk_widget_get_realized(m_widget) && !IsActive() ) { new_hint_value = true; @@ -1169,12 +1414,7 @@ void wxTopLevelWindowGTK::RequestUserAttention(int flags) } } -#if GTK_CHECK_VERSION(2,7,0) - if(!gtk_check_version(2,7,0)) - gtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value); - else -#endif - wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value); + gtk_window_set_urgency_hint(GTK_WINDOW(m_widget), new_hint_value); } void wxTopLevelWindowGTK::SetWindowStyleFlag( long style ) @@ -1203,37 +1443,17 @@ void wxTopLevelWindowGTK::SetWindowStyleFlag( long style ) } } -/* Get the X Window between child and the root window. - This should usually be the WM managed XID */ -static Window wxGetTopmostWindowX11(Display *dpy, Window child) -{ - Window root, parent; - Window* children; - unsigned int nchildren; - - XQueryTree(dpy, child, &root, &parent, &children, &nchildren); - XFree(children); - - while (parent != root) { - child = parent; - XQueryTree(dpy, child, &root, &parent, &children, &nchildren); - XFree(children); - } - - return child; -} - bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha) { - if (!m_widget || !m_widget->window) + GdkWindow* window = NULL; + if (m_widget) + window = gtk_widget_get_window(m_widget); + if (window == NULL) return false; - Display* dpy = GDK_WINDOW_XDISPLAY (m_widget->window); - // We need to get the X Window that has the root window as the immediate parent - // and m_widget->window as a child. This should be the X Window that the WM manages and - // from which the opacity property is checked from. - Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window)); - +#ifdef GDK_WINDOWING_X11 + Display* dpy = GDK_WINDOW_XDISPLAY(window); + Window win = GDK_WINDOW_XID(window); // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay if (alpha == 0xff) @@ -1247,27 +1467,34 @@ bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha) } XSync(dpy, False); return true; +#else // !GDK_WINDOWING_X11 + return false; +#endif // GDK_WINDOWING_X11 / !GDK_WINDOWING_X11 } 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; } +#ifdef __WXGTK3__ + return gtk_widget_is_composited(m_widget) != 0; +#else #if GTK_CHECK_VERSION(2,10,0) if (!gtk_check_version(2,10,0)) { - return (gtk_widget_is_composited (m_widget)); + return gtk_widget_is_composited(m_widget) != 0; } else #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves { return false; } +#endif // !__WXGTK3__ #if 0 // Don't be optimistic here for the sake of wxAUI int opcode, event, error; @@ -1276,16 +1503,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(); -}