X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/8938c6ca912d5e699a3093820b47ac60359959c8..4e15d1caa03346c126015019c1fdf093033ef40b:/src/gtk/toplevel.cpp?ds=inline diff --git a/src/gtk/toplevel.cpp b/src/gtk/toplevel.cpp index 4d73a656d9..0fb82f4d64 100644 --- a/src/gtk/toplevel.cpp +++ b/src/gtk/toplevel.cpp @@ -31,20 +31,20 @@ #include "wx/app.h" #endif -#include "wx/gtk/private.h" #include "wx/evtloop.h" #include "wx/sysopt.h" #include -#include +#ifdef GDK_WINDOWING_X11 + #include + #include // XA_CARDINAL + #include "wx/unix/utilsx11.h" +#endif +#include "wx/gtk/private.h" +#include "wx/gtk/private/gtk2-compat.h" #include "wx/gtk/private/win_gtk.h" -#include "wx/unix/utilsx11.h" - -// XA_CARDINAL -#include - #if wxUSE_LIBHILDON #include #include @@ -80,36 +80,44 @@ static int gs_requestFrameExtentsStatus; // RequestUserAttention related functions //----------------------------------------------------------------------------- -extern "C" { +#ifndef __WXGTK3__ static void wxgtk_window_set_urgency_hint (GtkWindow *win, gboolean setting) { - GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(win)); - wxASSERT_MSG(window, "wxgtk_window_set_urgency_hint: GdkWindow not realized"); - 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; @@ -151,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; @@ -185,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; @@ -240,22 +240,6 @@ size_allocate(GtkWidget*, GtkAllocation* alloc, wxTopLevelWindowGTK* win) } } -// ---------------------------------------------------------------------------- -// "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" //----------------------------------------------------------------------------- @@ -285,7 +269,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; @@ -320,7 +304,7 @@ void wxTopLevelWindowGTK::GTKHandleRealized() // GTK's shrinking/growing policy if ( !(m_gdkFunc & GDK_FUNC_RESIZE) ) gtk_window_set_resizable(GTK_WINDOW(m_widget), FALSE); -#if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED) +#ifndef __WXGTK3__ else gtk_window_set_policy(GTK_WINDOW(m_widget), 1, 1, 1); #endif @@ -329,8 +313,15 @@ void wxTopLevelWindowGTK::GTKHandleRealized() if (icons.GetIconCount()) SetIcons(icons); - if (HasFlag(wxFRAME_SHAPED)) - SetShape(win->m_shape); // it will really set the window shape now +#ifdef __WXGTK3__ + if (gtk_window_get_has_resize_grip(GTK_WINDOW(m_widget))) + { + // 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 } //----------------------------------------------------------------------------- @@ -363,13 +354,8 @@ gtk_frame_map_callback( GtkWidget*, 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+ + // restore focus-on-map setting in case ShowWithoutActivating() was called + gtk_window_set_focus_on_map(GTK_WINDOW(win->m_widget), true); return false; } @@ -391,11 +377,14 @@ gtk_frame_window_state_callback( GtkWidget* WXUNUSED(widget), // if maximized bit changed and it is now set if (event->changed_mask & event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) { - wxMaximizeEvent event(win->GetId()); - event.SetEventObject(win); - win->HandleWindowEvent(event); + 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; } } @@ -404,16 +393,17 @@ gtk_frame_window_state_callback( GtkWidget* WXUNUSED(widget), 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); - Atom xproperty = gdk_x11_atom_to_xatom_for_display( - gdk_drawable_get_display(window), property); + 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_x11_drawable_get_xdisplay(window), - gdk_x11_drawable_get_xid(window), + GDK_DISPLAY_XDISPLAY(display), + GDK_WINDOW_XID(window), xproperty, 0, 4, false, XA_CARDINAL, &type, &format, &nitems, &bytes_after, &data); @@ -429,8 +419,12 @@ bool wxGetFrameExtents(GdkWindow* window, int* left, int* right, int* top, int* if (data) XFree(data); return success; +#else + return false; +#endif } +#ifdef GDK_WINDOWING_X11 //----------------------------------------------------------------------------- // "property_notify_event" from m_widget //----------------------------------------------------------------------------- @@ -479,6 +473,7 @@ static gboolean request_frame_extents_timeout(void* data) return false; } } +#endif // GDK_WINDOWING_X11 // ---------------------------------------------------------------------------- // wxTopLevelWindowGTK creation @@ -497,6 +492,7 @@ void wxTopLevelWindowGTK::Init() m_deferShowAllowed = true; m_updateDecorSize = true; m_netFrameExtentsTimerId = 0; + m_incWidth = m_incHeight = 0; m_urgency_hint = -2; } @@ -621,11 +617,9 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, 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(); -#if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED) +#ifndef __WXGTK3__ if ((m_x != -1) || (m_y != -1)) gtk_widget_set_uposition( m_widget, m_x, m_y ); #endif @@ -649,9 +643,24 @@ 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); + // GTK processes key events at the top level first, which handles for + // menu accelerators and shortcuts before passing the event on to the + // focus child window to begin propagation. We want to propagate + // first, so we connect gtk_window_propagate_key_event to + // key_press_event. + g_signal_connect (m_widget, "key_press_event", + G_CALLBACK (gtk_window_propagate_key_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) @@ -696,6 +705,9 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, } } + // 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); @@ -763,32 +775,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 = 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; @@ -800,14 +817,14 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long) gdk_window_set_functions(window, (GdkWMFunction)0); gdk_window_get_origin(window, &root_x, &root_y); - gdk_window_get_geometry(window, &client_x, &client_y, &width, &height, NULL); + gdk_window_get_geometry(window, &client_x, &client_y, &width, &height); 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 @@ -817,15 +834,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 @@ -856,24 +874,22 @@ bool wxTopLevelWindowGTK::Show( bool show ) { wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); +#ifdef GDK_WINDOWING_X11 bool deferShow = show && !m_isShown && m_deferShow; if (deferShow) { - deferShow = gs_requestFrameExtentsStatus != 2 && - m_deferShowAllowed && !gtk_widget_get_realized(m_widget); - if (deferShow) - { - deferShow = g_signal_handler_find(m_widget, + 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) != 0; - } - GdkScreen* screen = NULL; + 0, NULL, NULL, this); if (deferShow) { - screen = gtk_widget_get_screen(m_widget); + 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 @@ -916,12 +932,12 @@ bool wxTopLevelWindowGTK::Show( bool show ) memset(&xevent, 0, sizeof(xevent)); xevent.type = ClientMessage; GdkWindow* window = gtk_widget_get_window(m_widget); - xevent.window = gdk_x11_drawable_get_xid(window); + xevent.window = GDK_WINDOW_XID(window); xevent.message_type = gdk_x11_atom_to_xatom_for_display( - gdk_drawable_get_display(window), + gdk_window_get_display(window), gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false)); xevent.format = 32; - Display* display = gdk_x11_drawable_get_xdisplay(window); + Display* display = GDK_DISPLAY_XDISPLAY(gdk_window_get_display(window)); XSendEvent(display, DefaultRootWindow(display), false, SubstructureNotifyMask | SubstructureRedirectMask, (XEvent*)&xevent); @@ -938,6 +954,7 @@ bool wxTopLevelWindowGTK::Show( bool show ) m_isShown = true; return true; } +#endif // GDK_WINDOWING_X11 if (show && !gtk_widget_get_realized(m_widget)) { @@ -966,11 +983,7 @@ 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+ - + gtk_window_set_focus_on_map(GTK_WINDOW(m_widget), false); Show(true); } } @@ -1020,8 +1033,6 @@ void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int si { 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; @@ -1051,8 +1062,12 @@ 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; + int w, h; GTKDoGetSize(&w, &h); gtk_window_resize(GTK_WINDOW(m_widget), w, h); @@ -1098,30 +1113,34 @@ void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH, int incW, int 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; - if (minSize.x > 0 || minSize.y > 0) - { - hints_mask |= GDK_HINT_MIN_SIZE; + // 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 (hints.min_width < 0) - hints.min_width = 0; + if (minSize.y > m_decorSize.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) + if (maxSize.x > 0) { - hints_mask |= GDK_HINT_MAX_SIZE; hints.max_width = maxSize.x - m_decorSize.x; - if (hints.max_width < 0) - hints.max_width = INT_MAX; + if (hints.max_width < hints.min_width) + hints.max_width = hints.min_width; + } + if (maxSize.y > 0) + { hints.max_height = maxSize.y - m_decorSize.y; - if (hints.max_height < 0) - hints.max_height = INT_MAX; + if (hints.max_height < hints.min_height) + hints.max_height = hints.min_height; } if (incW > 0 || incH > 0) { @@ -1133,6 +1152,7 @@ void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH, (GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask); } +#ifdef GDK_WINDOWING_X11 void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize) { if (!IsMaximized() && !IsFullScreen()) @@ -1142,14 +1162,18 @@ void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize) 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) + { + // 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 - const wxSize minSize = GetMinSize(); - if (w >= minSize.x && h >= minSize.y) + if (w >= m_minWidth - decorSize.x && h >= m_minHeight - decorSize.y ) { gtk_window_resize(GTK_WINDOW(m_widget), w, h); resized = true; @@ -1160,8 +1184,8 @@ void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize) // 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; + if (m_width < 1) m_width = 1; + if (m_height < 1) m_height = 1; m_oldClientWidth = 0; gtk_widget_queue_resize(m_wxwindow); } @@ -1182,6 +1206,7 @@ void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize) HandleWindowEvent(showEvent); } } +#endif // GDK_WINDOWING_X11 wxSize& wxTopLevelWindowGTK::GetCachedDecorSize() { @@ -1268,7 +1293,9 @@ void wxTopLevelWindowGTK::Maximize(bool maximize) bool wxTopLevelWindowGTK::IsMaximized() const { - GdkWindow* window = gtk_widget_get_window(m_widget); + GdkWindow* window = NULL; + if (m_widget) + window = gtk_widget_get_window(m_widget); return window && (gdk_window_get_state(window) & GDK_WINDOW_STATE_MAXIMIZED); } @@ -1320,49 +1347,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, - wxT("Shaped windows must be created with the wxFRAME_SHAPED style.")); - - if ( gtk_widget_get_realized(m_widget) ) - { - if ( m_wxwindow ) - do_shape_combine_region(gtk_widget_get_window(m_wxwindow), region); - - return do_shape_combine_region(gtk_widget_get_window(m_widget), 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; - } -} - bool wxTopLevelWindowGTK::IsActive() { return (this == (wxTopLevelWindowGTK*)g_activeFrame); @@ -1396,12 +1380,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 ) @@ -1430,26 +1409,6 @@ 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) { GdkWindow* window = NULL; @@ -1458,12 +1417,9 @@ bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha) if (window == NULL) return false; +#ifdef GDK_WINDOWING_X11 Display* dpy = GDK_WINDOW_XDISPLAY(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(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) @@ -1477,6 +1433,9 @@ 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() @@ -1488,16 +1447,20 @@ bool wxTopLevelWindowGTK::CanSetTransparent() 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;