X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/0a164d4c4e75bd48f6a0a484fb267b0dc337c541..65d48a2acf559325968922906da647b3a77eb016:/src/gtk/toplevel.cpp?ds=sidebyside diff --git a/src/gtk/toplevel.cpp b/src/gtk/toplevel.cpp index 312f2ce56d..7b883348dc 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,23 @@ // 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 -#include #include -#include #include #include "wx/gtk/win_gtk.h" @@ -52,19 +44,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; @@ -79,17 +62,56 @@ static wxTopLevelWindowGTK *g_lastActiveFrame = (wxTopLevelWindowGTK*) NULL; // send any activate events at all static int g_sendActivateEvent = -1; +//----------------------------------------------------------------------------- +// RequestUserAttention related functions +//----------------------------------------------------------------------------- + +extern "C" { +static void wxgtk_window_set_urgency_hint (GtkWindow *win, + gboolean setting) +{ + wxASSERT_MSG( GTK_WIDGET_REALIZED(win), wxT("wxgtk_window_set_urgency_hint: GdkWindow not realized") ); + GdkWindow *window = GTK_WIDGET(win)->window; + XWMHints *wm_hints; + + wm_hints = XGetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window)); + + if (!wm_hints) + wm_hints = XAllocWMHints(); + + if (setting) + wm_hints->flags |= XUrgencyHint; + else + wm_hints->flags &= ~XUrgencyHint; + + XSetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window), wm_hints); + XFree(wm_hints); +} + +static gboolean gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK *win ) +{ +#if GTK_CHECK_VERSION(2,7,0) + if(!gtk_check_version(2,7,0)) + gtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE); + else +#endif + wxgtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE); + + win->m_urgency_hint = -2; + return FALSE; +} +} + //----------------------------------------------------------------------------- // "focus_in_event" //----------------------------------------------------------------------------- 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(); + // don't need to install idle handler, its done from "event" signal switch ( g_sendActivateEvent ) { @@ -110,6 +132,28 @@ static gint gtk_frame_focus_in_callback( GtkWidget *widget, // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() ); + // MR: wxRequestUserAttention related block + switch( win->m_urgency_hint ) + { + default: + g_source_remove( win->m_urgency_hint ); + // no break, fallthrough to remove hint too + case -1: +#if GTK_CHECK_VERSION(2,7,0) + if(!gtk_check_version(2,7,0)) + gtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE); + else +#endif + { + wxgtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE); + } + + win->m_urgency_hint = -2; + break; + + case -2: break; + } + wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame); wxActivateEvent event(wxEVT_ACTIVATE, true, g_activeFrame->GetId()); event.SetEventObject(g_activeFrame); @@ -124,12 +168,11 @@ 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(); + // 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 @@ -159,13 +202,14 @@ static gint gtk_frame_focus_out_callback( GtkWidget *widget, //----------------------------------------------------------------------------- extern "C" { -static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) ) +static gboolean gtk_frame_focus_callback( GtkWidget *WXUNUSED(widget), + GtkDirectionType WXUNUSED(d), + wxWindow *WXUNUSED(win) ) { 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; } } @@ -186,17 +230,22 @@ static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* if ((win->m_width != alloc->width) || (win->m_height != alloc->height)) { /* - wxPrintf( "OnSize from " ); + wxPrintf( wxT("gtk_frame_size_callback from ") ); if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) wxPrintf( win->GetClassInfo()->GetClassName() ); - wxPrintf( " %d %d %d %d\n", (int)alloc->x, + 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; + + if (win->m_mainWidget) + GTK_PIZZA(win->m_mainWidget)->m_width = win->m_width; + win->GtkUpdateSize(); } } @@ -207,10 +256,12 @@ static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* //----------------------------------------------------------------------------- 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(); + // don't need to install idle handler, its done from "event" signal if (win->IsEnabled() && (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) || @@ -227,11 +278,12 @@ 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 *WXUNUSED(widget), + GdkEventConfigure *WXUNUSED(event), + wxTopLevelWindowGTK *win ) { - if (g_isIdle) - wxapp_install_idle_handler(); + // don't need to install idle handler, its done from "event" signal if (!win->m_hasVMT || !win->IsShown()) return FALSE; @@ -275,7 +327,7 @@ 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); @@ -313,7 +365,7 @@ gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget), GdkEvent * WXUNUSED(event), wxTopLevelWindow *win ) { - win->SetIconizeState(TRUE); + win->SetIconizeState(true); } } @@ -322,7 +374,10 @@ gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget), //----------------------------------------------------------------------------- extern "C" { -static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win ) +static gboolean +gtk_window_expose_callback( GtkWidget *widget, + GdkEventExpose *gdk_event, + wxWindow *win ) { GtkPizza *pizza = GTK_PIZZA(widget); @@ -338,29 +393,6 @@ static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_ev } } -//----------------------------------------------------------------------------- -// "draw" of m_client -//----------------------------------------------------------------------------- - -#ifndef __WXGTK20__ - -extern "C" { -static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, 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, - win->m_widget, - (char *)"base", - 0, 0, -1, -1); -} -} - -#endif // GTK+ 1.x - // ---------------------------------------------------------------------------- // wxTopLevelWindowGTK itself // ---------------------------------------------------------------------------- @@ -399,9 +431,6 @@ static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow child->m_width, child->m_height ); } - - // resize on OnInternalIdle - parent->GtkUpdateSize(); } // ---------------------------------------------------------------------------- @@ -420,6 +449,8 @@ void wxTopLevelWindowGTK::Init() m_themeEnabled = true; m_gdkDecor = m_gdkFunc = 0; m_grabbed = false; + + m_urgency_hint = -2; } bool wxTopLevelWindowGTK::Create( wxWindow *parent, @@ -457,7 +488,6 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, { 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): @@ -465,9 +495,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 { @@ -512,7 +539,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) @@ -522,14 +549,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(); @@ -537,15 +566,13 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS ); gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget ); + GTK_PIZZA(m_mainWidget)->m_width = m_width; + 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 @@ -560,8 +587,8 @@ 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); PostCreation(); @@ -572,38 +599,43 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, // 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 ); - - // 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 ); + 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 ); + g_signal_connect (m_widget, "configure_event", + G_CALLBACK (gtk_frame_configure_callback), this); // disable native tab traversal - gtk_signal_connect( GTK_OBJECT(m_widget), "focus", - GTK_SIGNAL_FUNC(gtk_frame_focus_callback), (gpointer)this ); + g_signal_connect (m_widget, "focus", + G_CALLBACK (gtk_frame_focus_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); // 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 = 0; m_gdkFunc = 0; + + if ((style & wxRESIZE_BORDER) != 0) + m_gdkFunc |= GDK_FUNC_RESIZE; } else { @@ -648,7 +680,7 @@ wxTopLevelWindowGTK::~wxTopLevelWindowGTK() { if (m_grabbed) { - wxASSERT_MSG( FALSE, _T("Window still grabbed")); + wxFAIL_MSG(_T("Window still grabbed")); RemoveGrab(); } @@ -690,8 +722,6 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style ) gtk_window_fullscreen( GTK_WINDOW( m_widget ) ); else gtk_window_unfullscreen( GTK_WINDOW( m_widget ) ); - - return true; } else #endif // GTK+ >= 2.2.0 @@ -732,7 +762,7 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style ) (WXWindow)GDK_WINDOW_XWINDOW(window), show, &m_fsSaveFrame, method); } - else + else // hide { if (method != wxX11_FS_WMSPEC) { @@ -753,6 +783,11 @@ 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() ) + Show(); + return true; } @@ -764,6 +799,9 @@ bool wxTopLevelWindowGTK::Show( bool show ) { wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); + if (show == IsShown()) + return true; + if (show && !m_sizeSet) { /* by calling GtkOnSize here, we don't have to call @@ -771,22 +809,21 @@ 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 ); + // 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 ); return wxWindow::Show( show ); } 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) ) @@ -824,6 +861,9 @@ void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int si } if (width != -1) m_width = width; if (height != -1) m_height = height; + + if (m_mainWidget) + GTK_PIZZA(m_mainWidget)->m_width = m_width; /* if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH) @@ -885,15 +925,17 @@ void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const { wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); - wxWindow::DoGetClientSize( width, height ); if (height) { - // mini edge - *height -= m_miniEdge*2 + m_miniTitle; + *height = m_height - 2 * m_miniEdge + m_miniTitle; + if (*height < 0) + *height = 0; } if (width) { - *width -= m_miniEdge*2; + *width = m_width - 2 * m_miniEdge; + if (*width < 0) + *width = 0; } } @@ -905,22 +947,14 @@ void wxTopLevelWindowGTK::DoSetClientSize( int width, int height ) width + m_miniEdge*2, height + m_miniEdge*2 + m_miniTitle, 0); } -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 @@ -997,7 +1031,12 @@ void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), 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 ); @@ -1022,7 +1061,7 @@ 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) @@ -1071,7 +1110,11 @@ 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 ) ); } @@ -1086,7 +1129,6 @@ void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons ) wxTopLevelWindowBase::SetIcons( icons ); -#ifdef __WXGTK20__ GList *list = NULL; size_t max = icons.m_icons.GetCount(); @@ -1099,25 +1141,6 @@ void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons ) } 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__ } // ---------------------------------------------------------------------------- @@ -1126,61 +1149,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 @@ -1229,14 +1223,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; } } @@ -1263,3 +1250,133 @@ bool wxTopLevelWindowGTK::IsActive() { return (this == (wxTopLevelWindowGTK*)g_activeFrame); } + +void wxTopLevelWindowGTK::RequestUserAttention(int flags) +{ + bool new_hint_value = false; + + // FIXME: This is a workaround to focus handling problem + // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't + // yet been processed, and the internal focus system is not up to date yet. + // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR + ::wxYieldIfNeeded(); + + if(m_urgency_hint >= 0) + g_source_remove(m_urgency_hint); + + m_urgency_hint = -2; + + if( GTK_WIDGET_REALIZED(m_widget) && !IsActive() ) + { + new_hint_value = true; + + if (flags & wxUSER_ATTENTION_INFO) + { + m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this); + } else { + m_urgency_hint = -1; + } + } + +#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 +} + +#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) +{ + 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)); + + 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 + 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() +{ +#if GTK_CHECK_VERSION(2,10,0) + if (!gtk_check_version(2,10,0)) + { + if (gtk_widget_is_composited (m_widget)) + return true; + } + 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 +}