X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/ef1a9be407b4aed45f385adcb6cad04bfe4b5664..90254df808aa4261e414ebacbb1417f87fad3bc9:/src/gtk/toplevel.cpp diff --git a/src/gtk/toplevel.cpp b/src/gtk/toplevel.cpp index 03ce87246a..cb4a9cb491 100644 --- a/src/gtk/toplevel.cpp +++ b/src/gtk/toplevel.cpp @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: toplevel.cpp +// Name: src/gtk/toplevel.cpp // Purpose: // Author: Robert Roebling // Id: $Id$ @@ -7,6 +7,9 @@ // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// +// For compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" + // ============================================================================ // declarations // ============================================================================ @@ -15,34 +18,24 @@ // headers // ---------------------------------------------------------------------------- -#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) - #pragma implementation "toplevel.h" -#endif - -// For compilers that support precompilation, includes "wx.h". -#include "wx/wxprec.h" - #ifdef __VMS #define XIconifyWindow XICONIFYWINDOW #endif -#include "wx/defs.h" - #include "wx/toplevel.h" -#include "wx/log.h" -#include "wx/dialog.h" -#include "wx/control.h" -#include "wx/app.h" -#include "wx/dcclient.h" + +#ifndef WX_PRECOMP + #include "wx/frame.h" + #include "wx/icon.h" + #include "wx/log.h" + #include "wx/app.h" +#endif + #include "wx/gtk/private.h" -#include "wx/timer.h" -#include "wx/settings.h" #include "wx/evtloop.h" +#include "wx/sysopt.h" -#include -#include #include -#include #include #include "wx/gtk/win_gtk.h" @@ -52,19 +45,10 @@ // XA_CARDINAL #include -// ---------------------------------------------------------------------------- -// idle system -// ---------------------------------------------------------------------------- - -extern void wxapp_install_idle_handler(); -extern bool g_isIdle; - // ---------------------------------------------------------------------------- // data // ---------------------------------------------------------------------------- -extern wxList wxPendingDelete; - extern int g_openDialogs; extern wxWindowGTK *g_delayedFocus; @@ -105,9 +89,9 @@ static void wxgtk_window_set_urgency_hint (GtkWindow *win, XFree(wm_hints); } -static gint gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK *win ) +static gboolean gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK *win ) { -#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2,7,0) +#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 @@ -124,13 +108,10 @@ static gint gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK *win ) //----------------------------------------------------------------------------- extern "C" { -static gint gtk_frame_focus_in_callback( GtkWidget *widget, +static gboolean gtk_frame_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxTopLevelWindowGTK *win ) { - if (g_isIdle) - wxapp_install_idle_handler(); - switch ( g_sendActivateEvent ) { case -1: @@ -154,10 +135,10 @@ static gint gtk_frame_focus_in_callback( GtkWidget *widget, switch( win->m_urgency_hint ) { default: - gtk_timeout_remove( win->m_urgency_hint ); + g_source_remove( win->m_urgency_hint ); // no break, fallthrough to remove hint too case -1: -#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2,7,0) +#if GTK_CHECK_VERSION(2,7,0) if(!gtk_check_version(2,7,0)) gtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE); else @@ -186,13 +167,10 @@ static gint gtk_frame_focus_in_callback( GtkWidget *widget, //----------------------------------------------------------------------------- extern "C" { -static gint gtk_frame_focus_out_callback( GtkWidget *widget, +static gboolean gtk_frame_focus_out_callback( GtkWidget *widget, GdkEventFocus *WXUNUSED(gdk_event), wxTopLevelWindowGTK *win ) { - if (g_isIdle) - wxapp_install_idle_handler(); - // 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 @@ -216,20 +194,23 @@ static gint gtk_frame_focus_out_callback( GtkWidget *widget, } } -//----------------------------------------------------------------------------- -// "focus" from m_window //----------------------------------------------------------------------------- -extern "C" { -static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) ) +// Get cached size of WM decorations for given GdkWMDecoration. +static wxSize& GetDecorSize(int decor) { - if (g_isIdle) - wxapp_install_idle_handler(); - - // This disables GTK's tab traversal - gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" ); - return TRUE; -} + // 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]; } //----------------------------------------------------------------------------- @@ -239,41 +220,51 @@ static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUS 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( "OnSize from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - wxPrintf( win->GetClassInfo()->GetClassName() ); - wxPrintf( " %d %d %d %d\n", (int)alloc->x, - (int)alloc->y, - (int)alloc->width, - (int)alloc->height ); -*/ - - win->m_width = alloc->width; - win->m_height = alloc->height; + win->m_width = w; + win->m_height = h; + win->GtkUpdateSize(); } } } +// ---------------------------------------------------------------------------- +// "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" //----------------------------------------------------------------------------- extern "C" { -static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxTopLevelWindowGTK *win ) +static gboolean +gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), + GdkEvent *WXUNUSED(event), + wxTopLevelWindowGTK *win ) { - if (g_isIdle) - wxapp_install_idle_handler(); - if (win->IsEnabled() && (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) || win->IsGrabbed())) @@ -289,23 +280,20 @@ static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WX //----------------------------------------------------------------------------- extern "C" { -static gint -gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxTopLevelWindowGTK *win ) +static gboolean +gtk_frame_configure_callback( GtkWidget* widget, + GdkEventConfigure *WXUNUSED(event), + wxTopLevelWindowGTK *win ) { - if (g_isIdle) - wxapp_install_idle_handler(); - 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 ); @@ -325,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, @@ -337,13 +322,13 @@ gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), // GTK's shrinking/growing policy if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0) - gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1); + gtk_window_set_resizable(GTK_WINDOW(win->m_widget), FALSE); else gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1); // reset the icon wxIconBundle iconsOld = win->GetIcons(); - if ( iconsOld.GetIcon(-1).Ok() ) + if ( !iconsOld.IsEmpty() ) { win->SetIcon( wxNullIcon ); win->SetIcons( iconsOld ); @@ -356,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; } } @@ -370,100 +376,96 @@ 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); + win->SetIconizeState(true); + return false; } } //----------------------------------------------------------------------------- -// "expose_event" of m_client +// "property_notify_event" from m_widget //----------------------------------------------------------------------------- extern "C" { -static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win ) +static gboolean property_notify_event( + GtkWidget*, GdkEventProperty* event, wxTopLevelWindowGTK* win) { - 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; + // 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; } } //----------------------------------------------------------------------------- -// "draw" of m_client +// "expose_event" of m_client //----------------------------------------------------------------------------- -#ifndef __WXGTK20__ - extern "C" { -static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win ) +static gboolean +gtk_window_expose_callback( GtkWidget *widget, + GdkEventExpose *gdk_event, + wxWindow *win ) { GtkPizza *pizza = GTK_PIZZA(widget); gtk_paint_flat_box (win->m_widget->style, pizza->bin_window, GTK_STATE_NORMAL, GTK_SHADOW_NONE, - rect, + &gdk_event->area, win->m_widget, (char *)"base", 0, 0, -1, -1); -} -} - -#endif // GTK+ 1.x - -// ---------------------------------------------------------------------------- -// 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 ); - } - // resize on OnInternalIdle - parent->GtkUpdateSize(); + return FALSE; +} } // ---------------------------------------------------------------------------- @@ -476,7 +478,6 @@ void wxTopLevelWindowGTK::Init() m_miniEdge = 0; m_miniTitle = 0; m_mainWidget = (GtkWidget*) NULL; - m_insertInClientArea = true; m_isIconized = false; m_fsIsShowing = false; m_themeEnabled = true; @@ -502,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 )) { @@ -513,15 +512,12 @@ 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 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) { -#ifdef __WXGTK20__ 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): @@ -529,9 +525,6 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_position(GTK_WINDOW(m_widget), GTK_WIN_POS_CENTER_ON_PARENT); -#else - m_widget = gtk_window_new(GTK_WINDOW_DIALOG); -#endif } else { @@ -576,7 +569,7 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, } #endif -#if GTK_CHECK_VERSION(2,4,0) +#ifdef __WXGTK24__ if (!gtk_check_version(2,4,0)) { if (style & wxSTAY_ON_TOP) @@ -586,14 +579,16 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, } #endif +#if 0 if (!name.empty()) - gtk_window_set_wmclass( GTK_WINDOW(m_widget), wxGTK_CONV( name ), wxGTK_CONV( name ) ); + gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) ); +#endif gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) ); GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS ); - gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event", - GTK_SIGNAL_FUNC(gtk_frame_delete_callback), (gpointer)this ); + 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(); @@ -604,12 +599,8 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, if (m_miniEdge == 0) // wxMiniFrame has its own version. { // For m_mainWidget themes - gtk_signal_connect( GTK_OBJECT(m_mainWidget), "expose_event", - GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this ); -#ifndef __WXGTK20__ - gtk_signal_connect( GTK_OBJECT(m_mainWidget), "draw", - GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this ); -#endif + 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 @@ -624,51 +615,60 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, if (m_parent) m_parent->AddChild( this ); // the user resized the frame by dragging etc. - gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate", - GTK_SIGNAL_FUNC(gtk_frame_size_callback), (gpointer)this ); + g_signal_connect (m_widget, "size_allocate", + G_CALLBACK (gtk_frame_size_callback), 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 - gtk_signal_connect( GTK_OBJECT(m_widget), "realize", - GTK_SIGNAL_FUNC(gtk_frame_realized_callback), (gpointer) this ); + g_signal_connect (m_widget, "realize", + G_CALLBACK (gtk_frame_realized_callback), this); // map and unmap for iconized state - gtk_signal_connect( GTK_OBJECT(m_widget), "map_event", - GTK_SIGNAL_FUNC(gtk_frame_map_callback), (gpointer)this ); - gtk_signal_connect( GTK_OBJECT(m_widget), "unmap_event", - GTK_SIGNAL_FUNC(gtk_frame_unmap_callback), (gpointer)this ); + 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); - // the only way to get the window size is to connect to this event - gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event", - GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this ); - - // disable native tab traversal - gtk_signal_connect( GTK_OBJECT(m_widget), "focus", - GTK_SIGNAL_FUNC(gtk_frame_focus_callback), (gpointer)this ); + // for wxMoveEvent + g_signal_connect (m_widget, "configure_event", + G_CALLBACK (gtk_frame_configure_callback), this); // activation - gtk_signal_connect( GTK_OBJECT(m_widget), "focus_in_event", - GTK_SIGNAL_FUNC(gtk_frame_focus_in_callback), (gpointer)this ); - gtk_signal_connect( GTK_OBJECT(m_widget), "focus_out_event", - GTK_SIGNAL_FUNC(gtk_frame_focus_out_callback), (gpointer)this ); + 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 ((m_miniEdge > 0) || (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER)) + if ((style & wxSIMPLE_BORDER) || (style & wxNO_BORDER)) { m_gdkDecor = 0; m_gdkFunc = 0; } else + if (m_miniEdge > 0) { - m_gdkDecor = (long) GDK_DECOR_BORDER; - m_gdkFunc = (long) GDK_FUNC_MOVE; + m_gdkDecor = 0; + m_gdkFunc = 0; + + if ((style & wxRESIZE_BORDER) != 0) + m_gdkFunc |= GDK_FUNC_RESIZE; + } + else + { + 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. @@ -701,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; } @@ -708,7 +713,7 @@ wxTopLevelWindowGTK::~wxTopLevelWindowGTK() { if (m_grabbed) { - wxASSERT_MSG( FALSE, _T("Window still grabbed")); + wxFAIL_MSG(_T("Window still grabbed")); RemoveGrab(); } @@ -726,9 +731,20 @@ wxTopLevelWindowGTK::~wxTopLevelWindowGTK() g_lastActiveFrame = NULL; } +bool wxTopLevelWindowGTK::EnableCloseButton( bool enable ) +{ + if (enable) + m_gdkFunc |= GDK_FUNC_CLOSE; + 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 ); + return true; +} -bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style ) +bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long) { if (show == m_fsIsShowing) return false; // return what? @@ -758,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 ); @@ -813,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; @@ -827,6 +842,9 @@ bool wxTopLevelWindowGTK::Show( bool show ) { wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); + if (show == IsShown()) + return false; + if (show && !m_sizeSet) { /* by calling GtkOnSize here, we don't have to call @@ -834,22 +852,25 @@ bool wxTopLevelWindowGTK::Show( bool show ) much ugly flicker or from within the size_allocate handler, because GTK 1.1.X forbids that. */ - GtkOnSize( m_x, m_y, m_width, m_height ); + GtkOnSize(); } - if (show) - gtk_widget_set_uposition( m_widget, m_x, m_y ); + wxTopLevelWindowBase::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 wxWindow::Show( show ); + return true; } void wxTopLevelWindowGTK::Raise() { -#ifdef __WXGTK20__ gtk_window_present( GTK_WINDOW( m_widget ) ); -#else - wxWindow::Raise(); -#endif } void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) ) @@ -857,218 +878,162 @@ void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXU wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") ); } +// ---------------------------------------------------------------------------- +// window geometry +// ---------------------------------------------------------------------------- + +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; + } + if (width) *width = size.x; + if (height) *height = size.y; +} + void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags ) { - wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); + 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") ); - // avoid recursions - if (m_resizing) - return; - m_resizing = true; + // deal with the position first int old_x = m_x; int old_y = m_y; - int old_width = m_width; - int old_height = m_height; - - if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0) + if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) ) { - if (x != -1) m_x = x; - if (y != -1) m_y = y; + // -1 means "use existing" unless the flag above is specified + if ( x != -1 ) + m_x = x; + if ( y != -1 ) + m_y = y; } - else + else // wxSIZE_ALLOW_MINUS_ONE { m_x = x; m_y = y; } - if (width != -1) m_width = width; - if (height != -1) m_height = height; - -/* - if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH) - { - if (width == -1) m_width = 80; - } - if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT) + if ( m_x != old_x || m_y != old_y ) { - if (height == -1) m_height = 26; + gtk_window_move( GTK_WINDOW(m_widget), m_x, m_y ); } -*/ - - 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_x != -1) || (m_y != -1)) - { - if ((m_x != old_x) || (m_y != old_y)) - { - gtk_widget_set_uposition( m_widget, m_x, m_y ); - } - } + m_resizing = true; - if ((m_width != old_width) || (m_height != old_height)) + 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) { - if (m_widget->window) - gdk_window_resize( m_widget->window, m_width, m_height ); - else - gtk_window_set_default_size( 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; + int w, h; + GTKDoGetSize(&w, &h); + gtk_window_resize(GTK_WINDOW(m_widget), w, h); + GtkUpdateSize(); } - m_resizing = false; } void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const { + if ( IsIconized() ) + { + // for consistency with wxMSW, client area is supposed to be empty for + // the iconized windows + if ( width ) + *width = 0; + if ( height ) + *height = 0; + + return; + } + wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); - wxWindow::DoGetClientSize( width, height ); - if (height) + int w, h; + GTKDoGetSize(&w, &h); + if (width) { - // mini edge - *height -= m_miniEdge*2 + m_miniTitle; + *width = w - 2 * m_miniEdge; + if (*width < 0) + *width = 0; } - if (width) + if (height) { - *width -= m_miniEdge*2; + *height = h - 2 * m_miniEdge - m_miniTitle; + if (*height < 0) + *height = 0; } } -void wxTopLevelWindowGTK::DoSetClientSize( int width, int height ) +void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH, + int maxW, int maxH, + int incW, int incH ) { - wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); - - DoSetSize(-1, -1, - width + m_miniEdge*2, height + m_miniEdge*2 + m_miniTitle, 0); + wxTopLevelWindowBase::DoSetSizeHints( minW, minH, maxW, maxH, incW, 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) + { + 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; + } + if (maxSize.x > 0 || 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; + } + if (incW > 0 || incH > 0) + { + hints_mask |= GDK_HINT_RESIZE_INC; + hints.width_inc = incW > 0 ? incW : 1; + hints.height_inc = incH > 0 ? incH : 1; + } + gtk_window_set_geometry_hints( + (GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask); } -void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), - int width, int height ) +void wxTopLevelWindowGTK::GtkOnSize() { - // due to a bug in gtk, x,y are always 0 - // m_x = x; - // m_y = y; - // avoid recursions if (m_resizing) return; m_resizing = true; if ( m_wxwindow == NULL ) return; - m_width = width; - m_height = height; - - /* 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) { - // set size hints - gint flag = 0; // GDK_HINT_POS; - GdkGeometry geom; - - if ((minWidth != -1) || (minHeight != -1)) flag |= GDK_HINT_MIN_SIZE; - if ((maxWidth != -1) || (maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE; - - geom.min_width = minWidth; - geom.min_height = minHeight; - - // Because of the way we set GDK_HINT_MAX_SIZE above, if either of - // maxHeight or maxWidth is set, we must set them both, else the - // remaining -1 will be taken literally. - - // I'm certain this also happens elsewhere, and is the probable - // cause of other such things as: - // Gtk-WARNING **: gtk_widget_size_allocate(): - // attempt to allocate widget with width 65535 and height 600 - // but I don't have time to track them all now.. - // - // Really we need to encapulate all this height/width business and - // stop any old method from ripping at the members directly and - // scattering -1's without regard for who might resolve them later. - - geom.max_width = ( maxHeight == -1 ) ? maxWidth - : ( maxWidth == -1 ) ? wxGetDisplaySize().GetWidth() - : maxWidth ; - - geom.max_height = ( maxWidth == -1 ) ? maxHeight // ( == -1 here ) - : ( maxHeight == -1 ) ? wxGetDisplaySize().GetHeight() - : maxHeight ; - - gtk_window_set_geometry_hints( GTK_WINDOW(m_widget), - (GtkWidget*) NULL, - &geom, - (GdkWindowHints) flag ); - - /* I revert back to wxGTK's original behaviour. m_mainWidget holds the - * menubar, the toolbar and the client area, which is represented by - * m_wxwindow. - * this hurts in the eye, but I don't want to call SetSize() - * because I don't want to call any non-native functions here. */ - - 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; - + 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; @@ -1081,15 +1046,18 @@ void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), m_resizing = false; } +bool wxTopLevelWindowGTK::IsDecorCacheable() const +{ + return true; +} + void wxTopLevelWindowGTK::OnInternalIdle() { if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow)) { - GtkOnSize( m_x, m_y, m_width, m_height ); + GtkOnSize(); // we'll come back later - if (g_isIdle) - wxapp_install_idle_handler(); return; } @@ -1134,13 +1102,12 @@ void wxTopLevelWindowGTK::SetTitle( const wxString &title ) { wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); + if ( title == m_title ) + return; + m_title = title; - gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) ); -} -void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon ) -{ - SetIcons( wxIconBundle( icon ) ); + gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) ); } void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons ) @@ -1149,38 +1116,16 @@ void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons ) wxTopLevelWindowBase::SetIcons( icons ); -#ifdef __WXGTK20__ 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); - -#else // !__WXGTK20__ - GdkWindow* window = m_widget->window; - if (!window) - return; - - wxIcon icon = icons.GetIcon(-1); - if (icon.Ok()) - { - wxMask *mask = icon.GetMask(); - GdkBitmap *bm = (GdkBitmap *) NULL; - if (mask) bm = mask->GetBitmap(); - - gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm ); - } - - wxSetIconsX11( (WXDisplay*)GDK_WINDOW_XDISPLAY( window ), - (WXWindow)GDK_WINDOW_XWINDOW( window ), icons ); -#endif // !__WXGTK20__ } // ---------------------------------------------------------------------------- @@ -1189,61 +1134,32 @@ void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons ) void wxTopLevelWindowGTK::Maximize(bool maximize) { -#ifdef __WXGTK20__ if (maximize) gtk_window_maximize( GTK_WINDOW( m_widget ) ); else gtk_window_unmaximize( GTK_WINDOW( m_widget ) ); -#else - wxFAIL_MSG( _T("not implemented") ); -#endif } bool wxTopLevelWindowGTK::IsMaximized() const { -#ifdef __WXGTK20__ if(!m_widget->window) return false; return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED; -#else - // wxFAIL_MSG( _T("not implemented") ); - - // This is an approximation - return false; -#endif } void wxTopLevelWindowGTK::Restore() { -#ifdef __WXGTK20__ // "Present" seems similar enough to "restore" gtk_window_present( GTK_WINDOW( m_widget ) ); -#else - wxFAIL_MSG( _T("not implemented") ); -#endif } void wxTopLevelWindowGTK::Iconize( bool iconize ) { -#ifdef __WXGTK20__ if (iconize) gtk_window_iconify( GTK_WINDOW( m_widget ) ); else gtk_window_deiconify( GTK_WINDOW( m_widget ) ); -#else - if (iconize) - { - GdkWindow *window = m_widget->window; - - // you should do it later, for example from OnCreate() handler - wxCHECK_RET( window, _T("frame not created yet - can't iconize") ); - - XIconifyWindow( GDK_WINDOW_XDISPLAY( window ), - GDK_WINDOW_XWINDOW( window ), - DefaultScreen( GDK_DISPLAY() ) ); - } -#endif } bool wxTopLevelWindowGTK::IsIconized() const @@ -1266,7 +1182,7 @@ void wxTopLevelWindowGTK::AddGrab() { m_grabbed = true; gtk_grab_add( m_widget ); - wxEventLoop().Run(); + wxGUIEventLoop().Run(); gtk_grab_remove( m_widget ); } } @@ -1292,14 +1208,7 @@ static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region) } else { -#ifdef __WXGTK20__ gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0); -#else - wxBitmap bmp = region.ConvertToBitmap(); - bmp.SetMask(new wxMask(bmp, *wxBLACK)); - GdkBitmap* mask = bmp.GetMask()->GetBitmap(); - gdk_window_shape_combine_mask(window, mask, 0, 0); -#endif return true; } } @@ -1338,7 +1247,7 @@ void wxTopLevelWindowGTK::RequestUserAttention(int flags) ::wxYieldIfNeeded(); if(m_urgency_hint >= 0) - gtk_timeout_remove(m_urgency_hint); + g_source_remove(m_urgency_hint); m_urgency_hint = -2; @@ -1348,16 +1257,117 @@ void wxTopLevelWindowGTK::RequestUserAttention(int flags) if (flags & wxUSER_ATTENTION_INFO) { - m_urgency_hint = gtk_timeout_add(5000, (GtkFunction)gtk_frame_urgency_timer_callback, this); + m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this); } else { m_urgency_hint = -1; } } -#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2,7,0) +#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); } + +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 + wxWindow::SetWindowStyleFlag(style); + + // just return for now if widget does not exist yet + 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) ) + { + gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), m_windowStyle & wxFRAME_NO_TASKBAR); + } +#endif // GTK+ 2.2 +} + +/* Get the X Window between child and the root window. + 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) + 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)); + + + // 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)) + { + return (gtk_widget_is_composited (m_widget)); + } + else +#endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves + { + return false; + } + +#if 0 // Don't be optimistic here for the sake of wxAUI + int opcode, event, error; + // Check for the existence of a RGBA visual instead? + return XQueryExtension(gdk_x11_get_default_xdisplay (), + "Composite", &opcode, &event, &error); +#endif +}