X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/ea098413d0e9c3f794f43826137a636e229f26f9..a7b9ab6200402e1cb0cfd1ecfa751b681341b6a1:/src/gtk/toplevel.cpp diff --git a/src/gtk/toplevel.cpp b/src/gtk/toplevel.cpp index 66c6dfa436..cb4a9cb491 100644 --- a/src/gtk/toplevel.cpp +++ b/src/gtk/toplevel.cpp @@ -112,8 +112,6 @@ static gboolean gtk_frame_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxTopLevelWindowGTK *win ) { - // don't need to install idle handler, its done from "event" signal - switch ( g_sendActivateEvent ) { case -1: @@ -173,8 +171,6 @@ static gboolean gtk_frame_focus_out_callback( GtkWidget *widget, GdkEventFocus *WXUNUSED(gdk_event), wxTopLevelWindowGTK *win ) { - // don't need to install idle handler, its done from "event" signal - // if the focus goes out of our app alltogether, OnIdle() will send // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset // g_sendActivateEvent to -1 @@ -198,6 +194,25 @@ static gboolean gtk_frame_focus_out_callback( GtkWidget *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" //----------------------------------------------------------------------------- @@ -205,27 +220,19 @@ static gboolean gtk_frame_focus_out_callback( GtkWidget *widget, extern "C" { static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win ) { - if (g_isIdle) - wxapp_install_idle_handler(); - if (!win->m_hasVMT) return; - if ((win->m_width != alloc->width) || (win->m_height != alloc->height)) + wxSize sizeDecor; + if (!win->IsFullScreen()) + sizeDecor = GetDecorSize(win->m_gdkDecor); + const int w = alloc->width + sizeDecor.x; + const int h = alloc->height + sizeDecor.y; + + if (win->m_width != w || win->m_height != h) { -/* - wxPrintf( wxT("gtk_frame_size_callback from ") ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - wxPrintf( win->GetClassInfo()->GetClassName() ); - wxPrintf( wxT(" %d %d %d %d\n"), (int)alloc->x, - (int)alloc->y, - (int)alloc->width, - (int)alloc->height ); -*/ - - // Tell the wxWindow class about the new size - win->m_width = alloc->width; - win->m_height = alloc->height; + win->m_width = w; + win->m_height = h; win->GtkUpdateSize(); } @@ -237,19 +244,17 @@ static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* // ---------------------------------------------------------------------------- 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 - int w, h; - win->GTKDoGetSize(&w, &h); - - requisition->height = h; - requisition->width = w; + win->GTKDoGetSize(&requisition->width, &requisition->height); } } + //----------------------------------------------------------------------------- // "delete_event" //----------------------------------------------------------------------------- @@ -260,8 +265,6 @@ gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxTopLevelWindowGTK *win ) { - // don't need to install idle handler, its done from "event" signal - if (win->IsEnabled() && (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) || win->IsGrabbed())) @@ -278,23 +281,19 @@ gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), extern "C" { static gboolean -gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), +gtk_frame_configure_callback( GtkWidget* widget, GdkEventConfigure *WXUNUSED(event), wxTopLevelWindowGTK *win ) { - // don't need to install idle handler, its done from "event" signal - if (!win->m_hasVMT || !win->IsShown()) return FALSE; + wxPoint point; + gtk_window_get_position((GtkWindow*)widget, &point.x, &point.y); - int x = 0; - int y = 0; - gdk_window_get_root_origin( win->m_widget->window, &x, &y ); - win->m_x = x; - win->m_y = y; - - wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() ); + win->m_x = point.x; + win->m_y = point.y; + wxMoveEvent mevent(point, win->GetId()); mevent.SetEventObject( win ); win->GetEventHandler()->ProcessEvent( mevent ); @@ -314,9 +313,6 @@ static void gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), wxTopLevelWindowGTK *win ) { - if (g_isIdle) - wxapp_install_idle_handler(); - // 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, @@ -345,12 +341,33 @@ gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), //----------------------------------------------------------------------------- extern "C" { -static void -gtk_frame_map_callback( GtkWidget * WXUNUSED(widget), +static gboolean +gtk_frame_map_callback( GtkWidget* widget, 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; + win->GtkUpdateSize(); + decorSize = size; + } + } + win->SetIconizeState(false); + return false; } } @@ -359,12 +376,71 @@ gtk_frame_map_callback( GtkWidget * WXUNUSED(widget), //----------------------------------------------------------------------------- extern "C" { -static void +static gboolean gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget), GdkEvent * WXUNUSED(event), wxTopLevelWindow *win ) { win->SetIconizeState(true); + return false; +} +} + +//----------------------------------------------------------------------------- +// "property_notify_event" from m_widget +//----------------------------------------------------------------------------- + +extern "C" { +static gboolean property_notify_event( + GtkWidget*, GdkEventProperty* event, wxTopLevelWindowGTK* win) +{ + // 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()) + { + 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 + { + 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; + win->GtkUpdateSize(); + decorSize = size; + } + } + if (data) + XFree(data); + } + return false; } } @@ -392,46 +468,6 @@ gtk_window_expose_callback( GtkWidget *widget, } } -// ---------------------------------------------------------------------------- -// wxTopLevelWindowGTK itself -// ---------------------------------------------------------------------------- - -//----------------------------------------------------------------------------- -// InsertChild for wxTopLevelWindowGTK -//----------------------------------------------------------------------------- - -/* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because - * C++ has no virtual methods in a constructor. We have to emulate a - * virtual function here as wxWidgets requires different ways to insert - * a child in container classes. */ - -static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child ) -{ - wxASSERT( GTK_IS_WIDGET(child->m_widget) ); - - if (!parent->m_insertInClientArea) - { - // these are outside the client area - wxTopLevelWindowGTK* frame = (wxTopLevelWindowGTK*) parent; - gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget), - GTK_WIDGET(child->m_widget), - child->m_x, - child->m_y, - child->m_width, - child->m_height ); - } - else - { - // these are inside the client area - gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow), - GTK_WIDGET(child->m_widget), - child->m_x, - child->m_y, - child->m_width, - child->m_height ); - } -} - // ---------------------------------------------------------------------------- // wxTopLevelWindowGTK creation // ---------------------------------------------------------------------------- @@ -442,10 +478,8 @@ void wxTopLevelWindowGTK::Init() m_miniEdge = 0; m_miniTitle = 0; m_mainWidget = (GtkWidget*) NULL; - m_insertInClientArea = true; m_isIconized = false; m_fsIsShowing = false; - m_fsSaveFlag = 0; m_themeEnabled = true; m_gdkDecor = m_gdkFunc = 0; m_grabbed = false; @@ -469,8 +503,6 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, wxTopLevelWindows.Append( this ); - m_needParent = false; - if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) { @@ -480,8 +512,6 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, m_title = title; - m_insertCallback = (wxInsertChildFunction) wxInsertChildInTopLevelWindow; - // NB: m_widget may be !=NULL if it was created by derived class' Create, // e.g. in wxTaskBarIconAreaGTK if (m_widget == NULL) @@ -595,8 +625,6 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, if ((m_x != -1) || (m_y != -1)) gtk_widget_set_uposition( m_widget, m_x, m_y ); - gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height ); - // 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", @@ -608,7 +636,7 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, g_signal_connect (m_widget, "unmap_event", G_CALLBACK (gtk_frame_unmap_callback), this); - // the only way to get the window size is to connect to this event + // for wxMoveEvent g_signal_connect (m_widget, "configure_event", G_CALLBACK (gtk_frame_configure_callback), this); @@ -618,6 +646,10 @@ 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); + // decorations if ((style & wxSIMPLE_BORDER) || (style & wxNO_BORDER)) { @@ -635,8 +667,8 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, } else { - m_gdkDecor = (long) GDK_DECOR_BORDER; - m_gdkFunc = (long) GDK_FUNC_MOVE; + 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. @@ -669,6 +701,11 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, } } + // m_gdkDecor needs to be set before calling GTKDoGetSize + int w, h; + GTKDoGetSize(&w, &h); + gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h); + return true; } @@ -707,7 +744,7 @@ bool wxTopLevelWindowGTK::EnableCloseButton( bool enable ) return true; } -bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style ) +bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long) { if (show == m_fsIsShowing) return false; // return what? @@ -726,15 +763,9 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style ) if ( (method == wxX11_FS_WMSPEC) && !gtk_check_version(2,2,0) ) { if (show) - { - m_fsSaveFlag = style; gtk_window_fullscreen( GTK_WINDOW( m_widget ) ); - } else - { - m_fsSaveFlag = 0; gtk_window_unfullscreen( GTK_WINDOW( m_widget ) ); - } } else #endif // GTK+ >= 2.2.0 @@ -743,7 +774,6 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style ) if (show) { - m_fsSaveFlag = style; GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y ); GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height ); @@ -777,7 +807,6 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style ) } else // hide { - m_fsSaveFlag = 0; if (method != wxX11_FS_WMSPEC) { // don't do it always, Metacity hates it @@ -799,7 +828,7 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style ) // documented behaviour is to show the window if it's still hidden when // showing it full screen - if ( show && !IsShown() ) + if (show) Show(); return true; @@ -814,7 +843,7 @@ bool wxTopLevelWindowGTK::Show( bool show ) wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); if (show == IsShown()) - return true; + return false; if (show && !m_sizeSet) { @@ -826,13 +855,17 @@ bool wxTopLevelWindowGTK::Show( bool show ) GtkOnSize(); } - // This seems no longer to be needed and the call - // itself is deprecated. - // - //if (show) - // gtk_widget_set_uposition( m_widget, m_x, m_y ); + wxTopLevelWindowBase::Show(show); - return wxWindow::Show( show ); + if (!show) + { + // make sure window has a non-default position, so when it is shown + // again, it won't be repositioned by WM as if it were a new window + // Note that this must be done _after_ the window is hidden. + gtk_window_move((GtkWindow*)m_widget, m_x, m_y); + } + + return true; } void wxTopLevelWindowGTK::Raise() @@ -851,53 +884,15 @@ void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXU void wxTopLevelWindowGTK::GTKDoGetSize(int *width, int *height) const { - return wxTopLevelWindowBase::DoGetSize(width, height); -} - -void wxTopLevelWindowGTK::GTKDoSetSize(int width, int height) -{ - // avoid recursions - if (m_resizing) - return; - m_resizing = true; - - int old_width = m_width; - int old_height = m_height; - - if ( width != -1 ) - m_width = width; - if ( height != -1 ) - m_height = height; - - // GPE's window manager doesn't like size hints at all, esp. when the user - // has to use the virtual keyboard, so don't constrain size there -#ifndef __WXGPE__ - int minWidth = GetMinWidth(), - minHeight = GetMinHeight(), - maxWidth = GetMaxWidth(), - maxHeight = GetMaxHeight(); - - if ( minWidth != -1 && m_width < minWidth ) - m_width = minWidth; - if ( minHeight != -1 && m_height < minHeight ) - m_height = minHeight; - if ( maxWidth != -1 && m_width > maxWidth ) - m_width = maxWidth; - if ( maxHeight != -1 && m_height > maxHeight ) - m_height = maxHeight; -#endif // __WXGPE__ - - if ( m_width != old_width || m_height != old_height ) + wxSize size(m_width, m_height); + if (!IsFullScreen()) { - gtk_window_resize( GTK_WINDOW(m_widget), m_width, m_height ); - - /* we set the size in GtkOnSize, i.e. mostly the actual resizing is - done either directly before the frame is shown or in idle time - so that different calls to SetSize() don't lead to flicker. */ - m_sizeSet = false; + size -= GetDecorSize(m_gdkDecor); + if (size.x < 0) size.x = 0; + if (size.y < 0) size.y = 0; } - - m_resizing = false; + if (width) *width = size.x; + if (height) *height = size.y; } void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags ) @@ -931,48 +926,22 @@ void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int si gtk_window_move( GTK_WINDOW(m_widget), m_x, m_y ); } + m_resizing = true; - // and now change the size: as we want to set the size of the entire - // window, including decorations, we must adjust the size passed to - // GTKDoSetSize() which takes with the size of undecorated frame only - if ( width != -1 || height != -1 ) - { - int wTotal, - hTotal; - DoGetSize(&wTotal, &hTotal); - - int wUndec, - hUndec; - GTKDoGetSize(&wUndec, &hUndec); - - if ( width != -1 ) - width -= wTotal - wUndec; - if ( height != -1 ) - height -= hTotal - hUndec; - } - - GTKDoSetSize(width, height); -} - -void wxTopLevelWindowGTK::DoGetSize(int *width, int *height) const -{ - wxCHECK_RET( m_widget, wxT("invalid frame") ); - - if ( !m_widget->window ) + const wxSize oldSize(m_width, m_height); + if (width >= 0) + m_width = width; + if (height >= 0) + m_height = height; + ConstrainSize(); + if (m_width != oldSize.x || m_height != oldSize.y) { - // this can happen if we're called before the window is realized, so - // don't assert but just return the stored values - GTKDoGetSize(width, height); - return; + int w, h; + GTKDoGetSize(&w, &h); + gtk_window_resize(GTK_WINDOW(m_widget), w, h); + GtkUpdateSize(); } - - GdkRectangle rect; - gdk_window_get_frame_extents(m_widget->window, &rect); - - if ( width ) - *width = rect.width; - if ( height ) - *height = rect.height; + m_resizing = false; } void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const @@ -991,23 +960,20 @@ void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); - if (height) - { - *height = m_height - 2 * m_miniEdge - m_miniTitle; - if (*height < 0) - *height = 0; - } + int w, h; + GTKDoGetSize(&w, &h); if (width) { - *width = m_width - 2 * m_miniEdge; + *width = w - 2 * m_miniEdge; if (*width < 0) *width = 0; } -} - -void wxTopLevelWindowGTK::DoSetClientSize( int width, int height ) -{ - GTKDoSetSize(width + m_miniEdge*2, height + m_miniEdge*2 + m_miniTitle); + if (height) + { + *height = h - 2 * m_miniEdge - m_miniTitle; + if (*height < 0) + *height = 0; + } } void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH, @@ -1020,17 +986,26 @@ 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 > 0 ? minSize.x : 0; - hints.min_height = minSize.y > 0 ? minSize.y : 0; + 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; } if (maxSize.x > 0 || maxSize.y > 0) { hints_mask |= GDK_HINT_MAX_SIZE; - hints.max_width = maxSize.x > 0 ? maxSize.x : INT_MAX; - hints.max_height = maxSize.y > 0 ? maxSize.y : INT_MAX; + 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; } if (incW > 0 || incH > 0) { @@ -1042,7 +1017,6 @@ void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH, (GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask); } - void wxTopLevelWindowGTK::GtkOnSize() { // avoid recursions @@ -1051,55 +1025,15 @@ void wxTopLevelWindowGTK::GtkOnSize() if ( m_wxwindow == NULL ) return; - /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses - wxWindow::Create to create it's GTK equivalent. m_mainWidget is only - set in wxFrame::Create so it is used to check what kind of frame we - have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we - skip the part which handles m_frameMenuBar, m_frameToolBar and (most - importantly) m_mainWidget */ - - int minWidth = GetMinWidth(), - minHeight = GetMinHeight(), - maxWidth = GetMaxWidth(), - maxHeight = GetMaxHeight(); - -#ifdef __WXGPE__ - // GPE's window manager doesn't like size hints - // at all, esp. when the user has to use the - // virtual keyboard. - minWidth = -1; - minHeight = -1; - maxWidth = -1; - maxHeight = -1; -#endif - - if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth; - if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight; - if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth; - if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight; + ConstrainSize(); if (m_mainWidget) { - // m_mainWidget holds the menubar, the toolbar and the client area, - // which is represented by m_wxwindow. - int client_x = m_miniEdge; - int client_y = m_miniEdge + m_miniTitle; - int client_w = m_width - 2*m_miniEdge; - int client_h = m_height - 2*m_miniEdge - m_miniTitle; - if (client_w < 0) - client_w = 0; - if (client_h < 0) - client_h = 0; - - // Let the parent perform the resize + int w, h; + GTKDoGetSize(&w, &h); gtk_pizza_set_size( GTK_PIZZA(m_mainWidget), m_wxwindow, - client_x, client_y, client_w, client_h ); - } - else - { - // If there is no m_mainWidget between m_widget and m_wxwindow there - // is no need to set the size or position of m_wxwindow. + 0, 0, w, h); } m_sizeSet = true; @@ -1112,6 +1046,11 @@ void wxTopLevelWindowGTK::GtkOnSize() m_resizing = false; } +bool wxTopLevelWindowGTK::IsDecorCacheable() const +{ + return true; +} + void wxTopLevelWindowGTK::OnInternalIdle() { if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow)) @@ -1119,8 +1058,6 @@ void wxTopLevelWindowGTK::OnInternalIdle() GtkOnSize(); // we'll come back later - if (g_isIdle) - wxapp_install_idle_handler(); return; } @@ -1245,7 +1182,7 @@ void wxTopLevelWindowGTK::AddGrab() { m_grabbed = true; gtk_grab_add( m_widget ); - wxEventLoop().Run(); + wxGUIEventLoop().Run(); gtk_grab_remove( m_widget ); } } @@ -1361,8 +1298,6 @@ void wxTopLevelWindowGTK::SetWindowStyleFlag( long style ) #endif // GTK+ 2.2 } -#include - /* 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) @@ -1394,15 +1329,17 @@ bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha) // from which the opacity property is checked from. Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window)); - unsigned int opacity = alpha * 0x1010101; // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay if (alpha == 0xff) XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False)); else + { + long opacity = alpha * 0x1010101L; XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False), XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &opacity, 1L); + } XSync(dpy, False); return true; }