X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/bb596005f5dc9978dc1866686534dd9b8fac5e30..e185a681ddac3cecac57c99b0c0049fe21e4b29a:/src/gtk/toplevel.cpp diff --git a/src/gtk/toplevel.cpp b/src/gtk/toplevel.cpp index 062f13429a..d87eec8b6a 100644 --- a/src/gtk/toplevel.cpp +++ b/src/gtk/toplevel.cpp @@ -33,23 +33,29 @@ #include "wx/gtk/private.h" #include "wx/evtloop.h" +#include "wx/sysopt.h" #include #include -#include "wx/gtk/win_gtk.h" +#include "wx/gtk/private/win_gtk.h" #include "wx/unix/utilsx11.h" // XA_CARDINAL #include +#if wxUSE_LIBHILDON + #include + #include +#endif // wxUSE_LIBHILDON + // ---------------------------------------------------------------------------- // data // ---------------------------------------------------------------------------- -extern int g_openDialogs; -extern wxWindowGTK *g_delayedFocus; +// this is incremented while a modal dialog is shown +int wxOpenModalDialogsCount = 0; // the frame that is currently active (i.e. its child has focus). It is // used to generate wxActivateEvents @@ -111,8 +117,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: @@ -157,7 +161,7 @@ static gboolean gtk_frame_focus_in_callback( GtkWidget *widget, wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame); wxActivateEvent event(wxEVT_ACTIVATE, true, g_activeFrame->GetId()); event.SetEventObject(g_activeFrame); - g_activeFrame->GetEventHandler()->ProcessEvent(event); + g_activeFrame->HandleWindowEvent(event); return FALSE; } @@ -168,12 +172,11 @@ static gboolean gtk_frame_focus_in_callback( GtkWidget *widget, //----------------------------------------------------------------------------- extern "C" { -static gboolean gtk_frame_focus_out_callback( GtkWidget *widget, - GdkEventFocus *WXUNUSED(gdk_event), - wxTopLevelWindowGTK *win ) +static +gboolean gtk_frame_focus_out_callback(GtkWidget * WXUNUSED(widget), + GdkEventFocus *WXUNUSED(gdk_event), + wxTopLevelWindowGTK * WXUNUSED(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 @@ -188,7 +191,7 @@ static gboolean gtk_frame_focus_out_callback( GtkWidget *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; } @@ -198,53 +201,49 @@ static gboolean gtk_frame_focus_out_callback( GtkWidget *widget, } //----------------------------------------------------------------------------- -// "focus" from m_window +// "size_allocate" from m_wxwindow //----------------------------------------------------------------------------- extern "C" { -static gboolean gtk_frame_focus_callback( GtkWidget *WXUNUSED(widget), - GtkDirectionType WXUNUSED(d), - wxWindow *WXUNUSED(win) ) +static void +size_allocate(GtkWidget*, GtkAllocation* alloc, wxTopLevelWindowGTK* win) { - if (g_isIdle) - wxapp_install_idle_handler(); + if (win->m_oldClientWidth != alloc->width || + win->m_oldClientHeight != alloc->height) + { + win->m_oldClientWidth = alloc->width; + win->m_oldClientHeight = alloc->height; - // This disables GTK's tab traversal - return TRUE; + wxSize size(win->m_widget->allocation.width, + win->m_widget->allocation.height); + size += win->m_decorSize; + win->m_width = size.x; + win->m_height = size.y; + + if (!win->IsIconized()) + { + wxSizeEvent event(size, win->GetId()); + event.SetEventObject(win); + win->HandleWindowEvent(event); + } + // else the window is currently unmapped, don't generate size events + } } } -//----------------------------------------------------------------------------- -// "size_allocate" -//----------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- +// "size_request" +// ---------------------------------------------------------------------------- extern "C" { -static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win ) +static +void wxgtk_tlw_size_request_callback(GtkWidget * WXUNUSED(widget), + GtkRequisition *requisition, + 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)) - { -/* - 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->GtkUpdateSize(); - } + // 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); } } @@ -258,10 +257,8 @@ 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) || + (wxOpenModalDialogsCount == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) || win->IsGrabbed())) win->Close(); @@ -269,32 +266,27 @@ gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), } } - //----------------------------------------------------------------------------- // "configure_event" //----------------------------------------------------------------------------- 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 ); + win->HandleWindowEvent( mevent ); return FALSE; } @@ -312,9 +304,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, @@ -330,11 +319,14 @@ gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), // reset the icon wxIconBundle iconsOld = win->GetIcons(); - if ( iconsOld.GetIcon(-1).Ok() ) + if ( !iconsOld.IsEmpty() ) { win->SetIcon( wxNullIcon ); win->SetIcons( iconsOld ); } + + if (win->HasFlag(wxFRAME_SHAPED)) + win->SetShape(win->m_shape); // it will really set the window shape now } } @@ -343,12 +335,28 @@ 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*, GdkEvent * WXUNUSED(event), wxTopLevelWindow *win ) { + const bool wasIconized = win->IsIconized(); + win->SetIconizeState(false); + + if (wasIconized) + { + // Because GetClientSize() returns (0,0) when IsIconized() is true, + // a size event must be generated, just in case GetClientSize() was + // called while iconized. This specifically happens when restoring a + // tlw that was "rolled up" with some WMs. + // Queue a resize rather than sending size event directly to allow + // children to be made visible first. + win->m_oldClientWidth = 0; + gtk_widget_queue_resize(win->m_wxwindow); + } + + return false; } } @@ -357,78 +365,74 @@ 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; } } -//----------------------------------------------------------------------------- -// "expose_event" of m_client //----------------------------------------------------------------------------- -extern "C" { -static gboolean -gtk_window_expose_callback( GtkWidget *widget, - GdkEventExpose *gdk_event, - wxWindow *win ) +bool wxGetFrameExtents(GdkWindow* window, int* left, int* right, int* top, int* bottom) { - GtkPizza *pizza = GTK_PIZZA(widget); - - gtk_paint_flat_box (win->m_widget->style, - pizza->bin_window, GTK_STATE_NORMAL, - GTK_SHADOW_NONE, - &gdk_event->area, - win->m_widget, - (char *)"base", - 0, 0, -1, -1); - - return FALSE; -} + static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false); + Atom xproperty = gdk_x11_atom_to_xatom_for_display( + gdk_drawable_get_display(window), property); + Atom type; + int format; + gulong nitems, bytes_after; + guchar* data; + Status status = XGetWindowProperty( + gdk_x11_drawable_get_xdisplay(window), + gdk_x11_drawable_get_xid(window), + xproperty, + 0, 4, false, XA_CARDINAL, + &type, &format, &nitems, &bytes_after, &data); + const bool success = status == Success && data && nitems == 4; + if (success) + { + long* p = (long*)data; + if (left) *left = int(p[0]); + if (right) *right = int(p[1]); + if (top) *top = int(p[2]); + if (bottom) *bottom = int(p[3]); + } + if (data) + XFree(data); + return success; } -// ---------------------------------------------------------------------------- -// wxTopLevelWindowGTK itself -// ---------------------------------------------------------------------------- - //----------------------------------------------------------------------------- -// InsertChild for wxTopLevelWindowGTK +// "property_notify_event" from m_widget //----------------------------------------------------------------------------- -/* 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 ) +extern "C" { +static gboolean property_notify_event( + GtkWidget*, GdkEventProperty* event, wxTopLevelWindowGTK* win) { - 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 + // 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) { - // 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 ); + int left, right, top, bottom; + if (wxGetFrameExtents(event->window, &left, &right, &top, &bottom)) + { + const wxSize decorSize = + wxSize(left + right, top + bottom); + win->GTKUpdateDecorSize(decorSize); + } } + return false; } +} + +BEGIN_EVENT_TABLE(wxTopLevelWindowGTK, wxTopLevelWindowBase) + EVT_SYS_COLOUR_CHANGED(wxTopLevelWindowGTK::OnSysColourChanged) +END_EVENT_TABLE() // ---------------------------------------------------------------------------- // wxTopLevelWindowGTK creation @@ -436,17 +440,13 @@ static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow void wxTopLevelWindowGTK::Init() { - m_sizeSet = false; - 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; + m_deferShow = true; m_urgency_hint = -2; } @@ -467,8 +467,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 )) { @@ -478,15 +476,21 @@ 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) { +#if wxUSE_LIBHILDON + // we must create HildonWindow and not a normal GtkWindow as the latter + // doesn't look correctly in Maemo environment and it must also be + // registered with the main program object + m_widget = hildon_window_new(); + hildon_program_add_window(wxTheApp->GetHildonProgram(), + HILDON_WINDOW(m_widget)); +#else // !wxUSE_LIBHILDON + m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL); if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) { - m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL); // Tell WM that this is a dialog window and make it center // on parent by default (this is what GtkDialog ctor does): gtk_window_set_type_hint(GTK_WINDOW(m_widget), @@ -496,26 +500,21 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, } else { - m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL); -#if GTK_CHECK_VERSION(2,1,0) - if (!gtk_check_version(2,1,0)) + if (style & wxFRAME_TOOL_WINDOW) { - if (style & wxFRAME_TOOL_WINDOW) - { - gtk_window_set_type_hint(GTK_WINDOW(m_widget), - GDK_WINDOW_TYPE_HINT_UTILITY); - - // On some WMs, like KDE, a TOOL_WINDOW will still show - // on the taskbar, but on Gnome a TOOL_WINDOW will not. - // For consistency between WMs and with Windows, we - // should set the NO_TASKBAR flag which will apply - // the set_skip_taskbar_hint if it is available, - // ensuring no taskbar entry will appear. - style |= wxFRAME_NO_TASKBAR; - } + gtk_window_set_type_hint(GTK_WINDOW(m_widget), + GDK_WINDOW_TYPE_HINT_UTILITY); + + // On some WMs, like KDE, a TOOL_WINDOW will still show + // on the taskbar, but on Gnome a TOOL_WINDOW will not. + // For consistency between WMs and with Windows, we + // should set the NO_TASKBAR flag which will apply + // the set_skip_taskbar_hint if it is available, + // ensuring no taskbar entry will appear. + style |= wxFRAME_NO_TASKBAR; } -#endif } +#endif // wxUSE_LIBHILDON/!wxUSE_LIBHILDON } wxWindow *topParent = wxGetTopLevelParent(m_parent); @@ -527,25 +526,15 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, GTK_WINDOW(topParent->m_widget) ); } -#if GTK_CHECK_VERSION(2,2,0) - if (!gtk_check_version(2,2,0)) + if (style & wxFRAME_NO_TASKBAR) { - if (style & wxFRAME_NO_TASKBAR) - { - gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE); - } + gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE); } -#endif -#ifdef __WXGTK24__ - if (!gtk_check_version(2,4,0)) + if (style & wxSTAY_ON_TOP) { - if (style & wxSTAY_ON_TOP) - { - gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE); - } + gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE); } -#endif #if 0 if (!name.empty()) @@ -558,21 +547,14 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, g_signal_connect (m_widget, "delete_event", G_CALLBACK (gtk_frame_delete_callback), this); - // m_mainWidget holds the toolbar, the menubar and the client area - m_mainWidget = gtk_pizza_new(); + // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow) + m_mainWidget = gtk_vbox_new(false, 0); gtk_widget_show( m_mainWidget ); GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS ); gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget ); - if (m_miniEdge == 0) // wxMiniFrame has its own version. - { - // For m_mainWidget themes - g_signal_connect (m_mainWidget, "expose_event", - G_CALLBACK (gtk_window_expose_callback), this); - } - - // m_wxwindow only represents the client area without toolbar and menubar - m_wxwindow = gtk_pizza_new(); + // m_wxwindow is the client area + m_wxwindow = wxPizza::New(); gtk_widget_show( m_wxwindow ); gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow ); @@ -582,17 +564,16 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, if (m_parent) m_parent->AddChild( this ); - // the user resized the frame by dragging etc. - g_signal_connect (m_widget, "size_allocate", - G_CALLBACK (gtk_frame_size_callback), 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(); 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", @@ -604,20 +585,20 @@ 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); - // disable native tab traversal - g_signal_connect (m_widget, "focus", - G_CALLBACK (gtk_frame_focus_callback), this); - // activation g_signal_connect_after (m_widget, "focus_in_event", G_CALLBACK (gtk_frame_focus_in_callback), this); 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)) { @@ -625,18 +606,9 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, m_gdkFunc = 0; } else - if (m_miniEdge > 0) - { - m_gdkDecor = 0; - m_gdkFunc = 0; - - if ((style & wxRESIZE_BORDER) != 0) - m_gdkFunc |= GDK_FUNC_RESIZE; - } - 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,11 +641,25 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, } } + m_decorSize = GetCachedDecorSize(); + int w, h; + GTKDoGetSize(&w, &h); + gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h); + return true; } wxTopLevelWindowGTK::~wxTopLevelWindowGTK() { +#if wxUSE_LIBHILDON + // it can also be a (standard) dialog + if ( HILDON_IS_WINDOW(m_widget) ) + { + hildon_program_remove_window(wxTheApp->GetHildonProgram(), + HILDON_WINDOW(m_widget)); + } +#endif // wxUSE_LIBHILDON + if (m_grabbed) { wxFAIL_MSG(_T("Window still grabbed")); @@ -707,7 +693,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? @@ -718,32 +704,23 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style ) wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(), (WXWindow)GDK_ROOT_WINDOW()); -#if GTK_CHECK_VERSION(2,2,0) // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions // to switch to fullscreen, which is not always available. We must // check if WM supports the spec and use legacy methods if it // doesn't. - if ( (method == wxX11_FS_WMSPEC) && !gtk_check_version(2,2,0) ) + if ( method == wxX11_FS_WMSPEC ) { if (show) - { - 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 { GdkWindow *window = m_widget->window; if (show) { - m_fsSaveFlag = style; GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y ); GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height ); @@ -753,15 +730,11 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style ) gint client_x, client_y, root_x, root_y; gint width, height; - if (method != wxX11_FS_WMSPEC) - { - // don't do it always, Metacity hates it - m_fsSaveGdkFunc = m_gdkFunc; - m_fsSaveGdkDecor = m_gdkDecor; - m_gdkFunc = m_gdkDecor = 0; - gdk_window_set_decorations(window, (GdkWMDecoration)0); - gdk_window_set_functions(window, (GdkWMFunction)0); - } + m_fsSaveGdkFunc = m_gdkFunc; + m_fsSaveGdkDecor = m_gdkDecor; + m_gdkFunc = m_gdkDecor = 0; + gdk_window_set_decorations(window, (GdkWMDecoration)0); + gdk_window_set_functions(window, (GdkWMFunction)0); gdk_window_get_origin (m_widget->window, &root_x, &root_y); gdk_window_get_geometry (m_widget->window, &client_x, &client_y, @@ -777,15 +750,10 @@ 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 - m_gdkFunc = m_fsSaveGdkFunc; - m_gdkDecor = m_fsSaveGdkDecor; - gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor); - gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc); - } + m_gdkFunc = m_fsSaveGdkFunc; + m_gdkDecor = m_fsSaveGdkDecor; + gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor); + gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc); wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(), (WXWindow)GDK_ROOT_WINDOW(), @@ -799,7 +767,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; @@ -813,26 +781,79 @@ bool wxTopLevelWindowGTK::Show( bool show ) { wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); - if (show == IsShown()) + bool deferShow = show && m_deferShow && !m_isShown; + if (deferShow) + { + m_deferShow = + deferShow = !GTK_WIDGET_REALIZED(m_widget) && + gdk_x11_screen_supports_net_wm_hint( + gtk_widget_get_screen(m_widget), + gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false)) && + g_signal_handler_find(m_widget, + GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA), + g_signal_lookup("property_notify_event", GTK_TYPE_WIDGET), + 0, NULL, NULL, this); + } + if (deferShow) + { + // Initial show. If WM supports _NET_REQUEST_FRAME_EXTENTS, defer + // calling gtk_widget_show() until _NET_FRAME_EXTENTS property + // notification is received, so correct frame extents are known. + // This allows resizing m_widget to keep the overall size in sync with + // what wxWidgets expects it to be without an obvious change in the + // window size immediately after it becomes visible. + + // Realize m_widget, so m_widget->window can be used. Realizing normally + // causes the widget tree to be size_allocated, which generates size + // events in the wrong order. However, the size_allocates will not be + // done if the allocation is not the default (1,1). + const int alloc_width = m_widget->allocation.width; + if (alloc_width == 1) + m_widget->allocation.width = 2; + gtk_widget_realize(m_widget); + if (alloc_width == 1) + m_widget->allocation.width = 1; + + // send _NET_REQUEST_FRAME_EXTENTS + XClientMessageEvent xevent; + memset(&xevent, 0, sizeof(xevent)); + xevent.type = ClientMessage; + xevent.window = gdk_x11_drawable_get_xid(m_widget->window); + xevent.message_type = gdk_x11_atom_to_xatom_for_display( + gdk_drawable_get_display(m_widget->window), + gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false)); + xevent.format = 32; + Display* display = gdk_x11_drawable_get_xdisplay(m_widget->window); + XSendEvent(display, DefaultRootWindow(display), false, + SubstructureNotifyMask | SubstructureRedirectMask, + (XEvent*)&xevent); + + // defer calling gtk_widget_show() + m_isShown = true; return true; + } - if (show && !m_sizeSet) + if (show && !GTK_WIDGET_REALIZED(m_widget)) { - /* by calling GtkOnSize here, we don't have to call - either after showing the frame, which would entail - much ugly flicker or from within the size_allocate - handler, because GTK 1.1.X forbids that. */ - - GtkOnSize(); + // 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); + HandleWindowEvent(event); } - // 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 ); + bool change = wxTopLevelWindowBase::Show(show); + + if (change && !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 wxWindow::Show( show ); + return change; } void wxTopLevelWindowGTK::Raise() @@ -849,60 +870,20 @@ void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXU // window geometry // ---------------------------------------------------------------------------- -void wxTopLevelWindowGTK::GTKDoSetSize(int width, int height) +void wxTopLevelWindowGTK::GTKDoGetSize(int *width, int *height) const { - // 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 ) - { - 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; - } - - m_resizing = false; + wxSize size(m_width, m_height); + size -= m_decorSize; + if (size.x < 0) size.x = 0; + if (size.y < 0) size.y = 0; + if (width) *width = size.x; + if (height) *height = size.y; } void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags ) { wxCHECK_RET( m_widget, wxT("invalid frame") ); - // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow - wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") ); - - // deal with the position first int old_x = m_x; int old_y = m_y; @@ -926,52 +907,37 @@ void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int si gtk_window_move( GTK_WINDOW(m_widget), m_x, m_y ); } - - // 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 ) + 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) { - int wTotal, - hTotal; - DoGetSize(&wTotal, &hTotal); - - int wUndec, - hUndec; - wxTopLevelWindowBase::DoGetSize(&wUndec, &hUndec); - - if ( width != -1 ) - width -= wTotal - wUndec; - if ( height != -1 ) - height -= hTotal - hUndec; + int w, h; + GTKDoGetSize(&w, &h); + gtk_window_resize(GTK_WINDOW(m_widget), w, h); + + GetClientSize(&m_oldClientWidth, &m_oldClientHeight); + wxSizeEvent event(GetSize(), GetId()); + event.SetEventObject(this); + HandleWindowEvent(event); } - - GTKDoSetSize(width, height); } -void wxTopLevelWindowGTK::DoGetSize(int *width, int *height) const +void wxTopLevelWindowGTK::DoSetClientSize(int width, int height) { - wxCHECK_RET( m_widget, wxT("invalid frame") ); - - if ( !m_widget->window ) - { - // this can happen if we're called before the window is realized, so - // don't assert but just return the stored values - wxTopLevelWindowBase::DoGetSize(width, height); - return; - } - - GdkRectangle rect; - gdk_window_get_frame_extents(m_widget->window, &rect); - - if ( width ) - *width = rect.width; - if ( height ) - *height = rect.height; + if (m_deferShow && !m_isShown) + // Since client size is being explicitly set, don't change it later + m_deferShow = false; + wxTopLevelWindowBase::DoSetClientSize(width, height); } void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const { + wxASSERT_MSG(m_widget, wxT("invalid frame")); + if ( IsIconized() ) { // for consistency with wxMSW, client area is supposed to be empty for @@ -980,31 +946,13 @@ void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const *width = 0; if ( height ) *height = 0; - - return; } - - wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); - - if (height) - { - *height = m_height - 2 * m_miniEdge - m_miniTitle; - if (*height < 0) - *height = 0; - } - if (width) + else { - *width = m_width - 2 * m_miniEdge; - if (*width < 0) - *width = 0; + GTKDoGetSize(width, height); } } -void wxTopLevelWindowGTK::DoSetClientSize( int width, int height ) -{ - GTKDoSetSize(width + m_miniEdge*2, height + m_miniEdge*2 + m_miniTitle); -} - void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH, int maxW, int maxH, int incW, int incH ) @@ -1018,14 +966,22 @@ void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH, 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 - m_decorSize.x; + if (hints.min_width < 0) + hints.min_width = 0; + hints.min_height = minSize.y - m_decorSize.y; + if (hints.min_height < 0) + hints.min_height = 0; } if (maxSize.x > 0 || maxSize.y > 0) { hints_mask |= GDK_HINT_MAX_SIZE; - hints.max_width = maxSize.x > 0 ? maxSize.x : INT_MAX; - hints.max_height = maxSize.y > 0 ? maxSize.y : INT_MAX; + hints.max_width = maxSize.x - m_decorSize.x; + if (hints.max_width < 0) + hints.max_width = INT_MAX; + hints.max_height = maxSize.y - m_decorSize.y; + if (hints.max_height < 0) + hints.max_height = INT_MAX; } if (incW > 0 || incH > 0) { @@ -1037,104 +993,75 @@ void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH, (GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask); } - -void wxTopLevelWindowGTK::GtkOnSize() +void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize) { - // avoid recursions - if (m_resizing) return; - m_resizing = true; - - 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; - - if (m_mainWidget) + if (!IsMaximized() && !IsFullScreen()) + GetCachedDecorSize() = decorSize; + if (m_decorSize != decorSize) { - // 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 - gtk_pizza_set_size( GTK_PIZZA(m_mainWidget), - m_wxwindow, - client_x, client_y, client_w, client_h ); + const wxSize diff = decorSize - m_decorSize; + m_decorSize = decorSize; + bool resized = false; + 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) + { + gtk_window_resize(GTK_WINDOW(m_widget), w, h); + resized = true; + } + } + if (!resized) + { + // adjust overall size to match change in frame extents + m_width += diff.x; + m_height += diff.y; + if (m_width < 0) m_width = 0; + if (m_height < 0) m_height = 0; + m_oldClientWidth = 0; + gtk_widget_queue_resize(m_wxwindow); + } } - else + if (m_deferShow) { - // 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. + // gtk_widget_show() was deferred, do it now + m_deferShow = false; + GetClientSize(&m_oldClientWidth, &m_oldClientHeight); + wxSizeEvent sizeEvent(GetSize(), GetId()); + sizeEvent.SetEventObject(this); + HandleWindowEvent(sizeEvent); + + gtk_widget_show(m_widget); + + wxShowEvent showEvent(GetId(), true); + showEvent.SetEventObject(this); + HandleWindowEvent(showEvent); } +} - m_sizeSet = true; - - // send size event to frame - wxSizeEvent event( wxSize(m_width,m_height), GetId() ); - event.SetEventObject( this ); - GetEventHandler()->ProcessEvent( event ); - - m_resizing = false; +wxSize& wxTopLevelWindowGTK::GetCachedDecorSize() +{ + static wxSize size[8]; + + int index = 0; + // title bar + if (m_gdkDecor & (GDK_DECOR_MENU | GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE | GDK_DECOR_TITLE)) + index = 1; + // border + if (m_gdkDecor & GDK_DECOR_BORDER) + index |= 2; + // utility window decor can be different + if (m_windowStyle & wxFRAME_TOOL_WINDOW) + index |= 4; + return size[index]; } void wxTopLevelWindowGTK::OnInternalIdle() { - if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow)) - { - GtkOnSize(); - - // we'll come back later - if (g_isIdle) - wxapp_install_idle_handler(); - return; - } - - // set the focus if not done yet and if we can already do it - if ( GTK_WIDGET_REALIZED(m_wxwindow) ) - { - if ( g_delayedFocus && - wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this ) - { - 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; - } - } - wxWindow::OnInternalIdle(); // Synthetize activate events. @@ -1168,11 +1095,6 @@ void wxTopLevelWindowGTK::SetTitle( const wxString &title ) gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) ); } -void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon ) -{ - SetIcons( wxIconBundle( icon ) ); -} - void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons ) { wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); @@ -1180,15 +1102,13 @@ void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons ) wxTopLevelWindowBase::SetIcons( icons ); GList *list = NULL; - size_t max = icons.m_icons.GetCount(); - for (size_t i = 0; i < max; i++) + const size_t numIcons = icons.GetIconCount(); + for ( size_t i = 0; i < numIcons; i++ ) { - if (icons.m_icons[i].Ok()) - { - list = g_list_prepend(list, icons.m_icons[i].GetPixbuf()); - } + list = g_list_prepend(list, icons.GetIconByIndex(i).GetPixbuf()); } + gtk_window_set_icon_list(GTK_WINDOW(m_widget), list); g_list_free(list); } @@ -1247,7 +1167,7 @@ void wxTopLevelWindowGTK::AddGrab() { m_grabbed = true; gtk_grab_add( m_widget ); - wxEventLoop().Run(); + wxGUIEventLoop().Run(); gtk_grab_remove( m_widget ); } } @@ -1286,14 +1206,22 @@ bool wxTopLevelWindowGTK::SetShape(const wxRegion& region) wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false, _T("Shaped windows must be created with the wxFRAME_SHAPED style.")); - GdkWindow *window = NULL; - if (m_wxwindow) + if ( GTK_WIDGET_REALIZED(m_widget) ) + { + if ( m_wxwindow ) + do_shape_combine_region(m_wxwindow->window, region); + + return do_shape_combine_region(m_widget->window, region); + } + else // not realized yet { - window = GTK_PIZZA(m_wxwindow)->bin_window; - do_shape_combine_region(window, region); + // store the shape to set, it will be really set once we're realized + m_shape = region; + + // we don't know if we're going to succeed or fail, be optimistic by + // default + return true; } - window = m_widget->window; - return do_shape_combine_region(window, region); } bool wxTopLevelWindowGTK::IsActive() @@ -1338,10 +1266,8 @@ void wxTopLevelWindowGTK::RequestUserAttention(int flags) void wxTopLevelWindowGTK::SetWindowStyleFlag( long style ) { -#if defined(__WXGTK24__) || GTK_CHECK_VERSION(2,2,0) // Store which styles were changed long styleChanges = style ^ m_windowStyle; -#endif // Process wxWindow styles. This also updates the internal variable // Therefore m_windowStyle bits carry now the _new_ style values @@ -1351,19 +1277,18 @@ void wxTopLevelWindowGTK::SetWindowStyleFlag( long style ) if (!m_widget) return; -#ifdef __WXGTK24__ - if ( (styleChanges & wxSTAY_ON_TOP) && !gtk_check_version(2,4,0) ) - gtk_window_set_keep_above(GTK_WINDOW(m_widget), m_windowStyle & wxSTAY_ON_TOP); -#endif // GTK+ 2.4 -#if GTK_CHECK_VERSION(2,2,0) - if ( (styleChanges & wxFRAME_NO_TASKBAR) && !gtk_check_version(2,2,0) ) + if ( styleChanges & wxSTAY_ON_TOP ) { - gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), m_windowStyle & wxFRAME_NO_TASKBAR); + gtk_window_set_keep_above(GTK_WINDOW(m_widget), + m_windowStyle & wxSTAY_ON_TOP); } -#endif // GTK+ 2.2 -} -#include + if ( styleChanges & wxFRAME_NO_TASKBAR ) + { + gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), + m_windowStyle & wxFRAME_NO_TASKBAR); + } +} /* Get the X Window between child and the root window. This should usually be the WM managed XID */ @@ -1396,21 +1321,30 @@ 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; } 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"); + if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT) ) + { + return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT) != 0; + } + #if GTK_CHECK_VERSION(2,10,0) if (!gtk_check_version(2,10,0)) { @@ -1429,3 +1363,16 @@ bool wxTopLevelWindowGTK::CanSetTransparent() "Composite", &opcode, &event, &error); #endif } + +void wxTopLevelWindowGTK::OnSysColourChanged(wxSysColourChangedEvent& event) +{ + // We don't know the order in which top-level windows will + // be notified, so we need to clear the system objects + // for each top-level window. + extern void wxClearGtkSystemObjects(); + wxClearGtkSystemObjects(); + + // wxWindowBase::OnSysColourChanged will propagate event + // to children + event.Skip(); +}