/////////////////////////////////////////////////////////////////////////////
-// Name: toplevel.cpp
+// Name: src/gtk/toplevel.cpp
// Purpose:
// Author: Robert Roebling
// Id: $Id$
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
// ============================================================================
// declarations
// ============================================================================
// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "toplevel.h"
-#endif
-
#ifdef __VMS
#define XIconifyWindow XICONIFYWINDOW
#endif
-#include "wx/defs.h"
+#include "wx/toplevel.h"
+
+#ifndef WX_PRECOMP
+ #include "wx/frame.h"
+ #include "wx/icon.h"
+ #include "wx/log.h"
+ #include "wx/app.h"
+#endif
-#include "wx/log.h"
-#include "wx/dialog.h"
-#include "wx/control.h"
-#include "wx/app.h"
-#include "wx/dcclient.h"
#include "wx/gtk/private.h"
-#include "wx/timer.h"
+#include "wx/evtloop.h"
-#include <glib.h>
-#include <gdk/gdk.h>
#include <gtk/gtk.h>
-#include <gdk/gdkkeysyms.h>
#include <gdk/gdkx.h>
#include "wx/gtk/win_gtk.h"
#include <X11/Xatom.h>
// ----------------------------------------------------------------------------
-// idle system
+// data
// ----------------------------------------------------------------------------
-extern void wxapp_install_idle_handler();
-extern bool g_isIdle;
+extern int g_openDialogs;
+extern wxWindowGTK *g_delayedFocus;
-// ----------------------------------------------------------------------------
-// data
-// ----------------------------------------------------------------------------
+// the frame that is currently active (i.e. its child has focus). It is
+// used to generate wxActivateEvents
+static wxTopLevelWindowGTK *g_activeFrame = (wxTopLevelWindowGTK*) NULL;
+static wxTopLevelWindowGTK *g_lastActiveFrame = (wxTopLevelWindowGTK*) NULL;
+
+// if we detect that the app has got/lost the focus, we set this variable to
+// either TRUE or FALSE and an activate event will be sent during the next
+// OnIdle() call and it is reset to -1: this value means that we shouldn't
+// 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;
+}
+}
-extern wxList wxPendingDelete;
+//-----------------------------------------------------------------------------
+// "focus_in_event"
+//-----------------------------------------------------------------------------
+
+extern "C" {
+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:
+ // we've got focus from outside, synthetize wxActivateEvent
+ g_sendActivateEvent = 1;
+ break;
+
+ case 0:
+ // another our window just lost focus, it was already ours before
+ // - don't send any wxActivateEvent
+ g_sendActivateEvent = -1;
+ break;
+ }
+
+ g_activeFrame = win;
+ g_lastActiveFrame = g_activeFrame;
+
+ // 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;
+ }
-extern int g_openDialogs;
-extern wxWindowGTK *g_delayedFocus;
+ 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);
+
+ return FALSE;
+}
+}
+
+//-----------------------------------------------------------------------------
+// "focus_out_event"
+//-----------------------------------------------------------------------------
+
+extern "C" {
+static gboolean gtk_frame_focus_out_callback( GtkWidget *widget,
+ GdkEventFocus *WXUNUSED(gdk_event),
+ wxTopLevelWindowGTK *win )
+{
+ // don't need to install idle handler, its done from "event" signal
+
+ // if the focus goes out of our app alltogether, OnIdle() will send
+ // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
+ // g_sendActivateEvent to -1
+ g_sendActivateEvent = 0;
+
+ // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
+
+ // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
+
+ if (g_activeFrame)
+ {
+ 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 = NULL;
+ }
+
+ return FALSE;
+}
+}
//-----------------------------------------------------------------------------
// "focus" from m_window
//-----------------------------------------------------------------------------
-static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
+extern "C" {
+static gboolean gtk_frame_focus_callback( GtkWidget *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;
}
+}
//-----------------------------------------------------------------------------
// "size_allocate"
//-----------------------------------------------------------------------------
+extern "C" {
static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win )
{
if (g_isIdle)
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 );
win->m_width = alloc->width;
win->m_height = alloc->height;
- win->m_queuedFullRedraw = TRUE;
win->GtkUpdateSize();
}
}
+}
//-----------------------------------------------------------------------------
// "delete_event"
//-----------------------------------------------------------------------------
-static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxTopLevelWindowGTK *win )
+extern "C" {
+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) ||
return TRUE;
}
+}
//-----------------------------------------------------------------------------
// "configure_event"
//-----------------------------------------------------------------------------
-static gint
-gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxTopLevelWindowGTK *win )
+extern "C" {
+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;
+
int x = 0;
int y = 0;
gdk_window_get_root_origin( win->m_widget->window, &x, &y );
return FALSE;
}
+}
//-----------------------------------------------------------------------------
// "realize" from m_widget
// we cannot MWM hints and icons before the widget has been realized,
// so we do this directly after realization
+extern "C" {
static void
gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
wxTopLevelWindowGTK *win )
// 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);
win->SetIcons( iconsOld );
}
}
+}
//-----------------------------------------------------------------------------
// "map_event" from m_widget
//-----------------------------------------------------------------------------
+extern "C" {
static void
gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
GdkEvent * WXUNUSED(event),
wxTopLevelWindow *win )
{
- win->SetIconizeState(FALSE);
+ win->SetIconizeState(false);
+}
}
//-----------------------------------------------------------------------------
// "unmap_event" from m_widget
//-----------------------------------------------------------------------------
+extern "C" {
static void
gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
GdkEvent * WXUNUSED(event),
wxTopLevelWindow *win )
{
- win->SetIconizeState(TRUE);
+ win->SetIconizeState(true);
+}
}
//-----------------------------------------------------------------------------
// "expose_event" of m_client
//-----------------------------------------------------------------------------
-static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )
+extern "C" {
+static gboolean
+gtk_window_expose_callback( GtkWidget *widget,
+ GdkEventExpose *gdk_event,
+ wxWindow *win )
{
GtkPizza *pizza = GTK_PIZZA(widget);
return FALSE;
}
-
-//-----------------------------------------------------------------------------
-// "draw" of m_client
-//-----------------------------------------------------------------------------
-
-#ifndef __WXGTK20__
-
-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
// ----------------------------------------------------------------------------
/* 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 wxWindows requires different ways to insert
+ * virtual function here as wxWidgets requires different ways to insert
* a child in container classes. */
static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child )
child->m_width,
child->m_height );
}
-
- // resize on OnInternalIdle
- parent->GtkUpdateSize();
}
// ----------------------------------------------------------------------------
void wxTopLevelWindowGTK::Init()
{
- m_sizeSet = FALSE;
+ m_sizeSet = false;
m_miniEdge = 0;
m_miniTitle = 0;
m_mainWidget = (GtkWidget*) NULL;
- m_insertInClientArea = TRUE;
- m_isIconized = FALSE;
- m_fsIsShowing = FALSE;
- m_themeEnabled = TRUE;
+ m_insertInClientArea = true;
+ m_isIconized = false;
+ m_fsIsShowing = false;
+ m_themeEnabled = true;
m_gdkDecor = m_gdkFunc = 0;
- m_grabbed = FALSE;
+ m_grabbed = false;
+
+ m_urgency_hint = -2;
}
bool wxTopLevelWindowGTK::Create( wxWindow *parent,
// always create a frame of some reasonable, even if arbitrary, size (at
// least for MSW compatibility)
wxSize size = sizeOrig;
- if ( size.x == -1 || size.y == -1 )
- {
- wxSize sizeDpy = wxGetDisplaySize();
- if ( size.x == -1 )
- size.x = sizeDpy.x / 3;
- if ( size.y == -1 )
- size.y = sizeDpy.y / 5;
- }
+ size.x = WidthDefault(size.x);
+ size.y = HeightDefault(size.y);
wxTopLevelWindows.Append( this );
- m_needParent = FALSE;
+ m_needParent = false;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
- return FALSE;
+ return false;
}
m_title = title;
m_insertCallback = (wxInsertChildFunction) wxInsertChildInTopLevelWindow;
- GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;
-
- if (style & wxFRAME_TOOL_WINDOW)
- win_type = GTK_WINDOW_POPUP;
-
- if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
+ // NB: m_widget may be !=NULL if it was created by derived class' Create,
+ // e.g. in wxTaskBarIconAreaGTK
+ if (m_widget == NULL)
{
- // there is no more GTK_WINDOW_DIALOG in 2.0
-#ifdef __WXGTK20__
- win_type = GTK_WINDOW_TOPLEVEL;
-#else
- win_type = GTK_WINDOW_DIALOG;
+ 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),
+ 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_TOPLEVEL);
+#if GTK_CHECK_VERSION(2,1,0)
+ if (!gtk_check_version(2,1,0))
+ {
+ 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;
+ }
+ }
#endif
+ }
}
- m_widget = gtk_window_new( win_type );
+ wxWindow *topParent = wxGetTopLevelParent(m_parent);
+ if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
+ (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
+ (style & wxFRAME_FLOAT_ON_PARENT)))
+ {
+ gtk_window_set_transient_for( GTK_WINDOW(m_widget),
+ GTK_WINDOW(topParent->m_widget) );
+ }
+
+#if GTK_CHECK_VERSION(2,2,0)
+ if (!gtk_check_version(2,2,0))
+ {
+ if (style & wxFRAME_NO_TASKBAR)
+ {
+ gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
+ }
+ }
+#endif
- if (m_parent && (((GTK_IS_WINDOW(m_parent->m_widget)) &&
- (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
- (style & wxFRAME_FLOAT_ON_PARENT)))
+#ifdef __WXGTK24__
+ if (!gtk_check_version(2,4,0))
{
- gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) );
+ if (style & wxSTAY_ON_TOP)
+ {
+ gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE);
+ }
}
+#endif
- if (!name.IsEmpty())
- gtk_window_set_wmclass( GTK_WINDOW(m_widget), wxGTK_CONV( name ), wxGTK_CONV( name ) );
+#if 0
+ if (!name.empty())
+ 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();
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
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();
// 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
+ 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
{
m_gdkDecor = (long) GDK_DECOR_BORDER;
m_gdkFunc = (long) GDK_FUNC_MOVE;
}
}
- return TRUE;
+ return true;
}
wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
{
if (m_grabbed)
{
- wxASSERT_MSG( FALSE, _T("Window still grabbed"));
+ wxFAIL_MSG(_T("Window still grabbed"));
RemoveGrab();
}
- m_isBeingDeleted = TRUE;
+ m_isBeingDeleted = true;
// it may also be GtkScrolledWindow in the case of an MDI child
if (GTK_IS_WINDOW(m_widget))
{
gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
}
+
+ if (g_activeFrame == this)
+ g_activeFrame = NULL;
+ if (g_lastActiveFrame == this)
+ g_lastActiveFrame = NULL;
}
bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
{
- if (show == m_fsIsShowing) return FALSE; // return what?
+ if (show == m_fsIsShowing)
+ return false; // return what?
m_fsIsShowing = show;
- GdkWindow *window = m_widget->window;
wxX11FullScreenMethod method =
wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(),
(WXWindow)GDK_ROOT_WINDOW());
- if (show)
+#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) )
{
- m_fsSaveFlag = style;
- GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
- GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
-
- int screen_width,screen_height;
- wxDisplaySize( &screen_width, &screen_height );
-
- 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);
- }
-
- gdk_window_get_origin (m_widget->window, &root_x, &root_y);
- gdk_window_get_geometry (m_widget->window, &client_x, &client_y,
- &width, &height, NULL);
-
- gdk_window_move_resize (m_widget->window, -client_x, -client_y,
- screen_width + 1, screen_height + 1);
-
- wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
- (WXWindow)GDK_ROOT_WINDOW(),
- (WXWindow)GDK_WINDOW_XWINDOW(window),
- show, &m_fsSaveFrame, method);
+ if (show)
+ gtk_window_fullscreen( GTK_WINDOW( m_widget ) );
+ else
+ gtk_window_unfullscreen( GTK_WINDOW( m_widget ) );
}
else
+#endif // GTK+ >= 2.2.0
{
- if (method != wxX11_FS_WMSPEC)
+ GdkWindow *window = m_widget->window;
+
+ if (show)
{
- // 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_fsSaveFlag = style;
+ GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
+ GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
+
+ int screen_width,screen_height;
+ wxDisplaySize( &screen_width, &screen_height );
+
+ 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);
+ }
+
+ gdk_window_get_origin (m_widget->window, &root_x, &root_y);
+ gdk_window_get_geometry (m_widget->window, &client_x, &client_y,
+ &width, &height, NULL);
+
+ gdk_window_move_resize (m_widget->window, -client_x, -client_y,
+ screen_width + 1, screen_height + 1);
+
+ wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
+ (WXWindow)GDK_ROOT_WINDOW(),
+ (WXWindow)GDK_WINDOW_XWINDOW(window),
+ show, &m_fsSaveFrame, method);
+ }
+ else // hide
+ {
+ 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);
+ }
+
+ wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
+ (WXWindow)GDK_ROOT_WINDOW(),
+ (WXWindow)GDK_WINDOW_XWINDOW(window),
+ show, &m_fsSaveFrame, method);
+
+ SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
+ m_fsSaveFrame.width, m_fsSaveFrame.height);
}
-
- wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
- (WXWindow)GDK_ROOT_WINDOW(),
- (WXWindow)GDK_WINDOW_XWINDOW(window),
- show, &m_fsSaveFrame, method);
-
- SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
- m_fsSaveFrame.width, m_fsSaveFrame.height);
}
+ // documented behaviour is to show the window if it's still hidden when
+ // showing it full screen
+ if ( show && !IsShown() )
+ Show();
- return TRUE;
+ return true;
}
// ----------------------------------------------------------------------------
{
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
GtkOnSize( m_x, m_y, m_width, m_height );
}
+ // 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()
+{
+ gtk_window_present( GTK_WINDOW( m_widget ) );
+}
+
void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
{
wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
// avoid recursions
if (m_resizing)
return;
- m_resizing = TRUE;
+ m_resizing = true;
int old_x = m_x;
int old_y = m_y;
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;
/* 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_sizeSet = false;
}
- m_resizing = FALSE;
+ m_resizing = false;
}
void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
// avoid recursions
if (m_resizing) return;
- m_resizing = TRUE;
+ m_resizing = true;
if ( m_wxwindow == NULL ) return;
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;
// is no need to set the size or position of m_wxwindow.
}
- m_sizeSet = TRUE;
+ 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;
+ m_resizing = false;
}
void wxTopLevelWindowGTK::OnInternalIdle()
}
wxWindow::OnInternalIdle();
+
+ // Synthetize activate events.
+ if ( g_sendActivateEvent != -1 )
+ {
+ bool activate = g_sendActivateEvent != 0;
+
+ // if (!activate) wxPrintf( wxT("de") );
+ // wxPrintf( wxT("activate\n") );
+
+ // do it only once
+ g_sendActivateEvent = -1;
+
+ wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
+ }
}
// ----------------------------------------------------------------------------
{
wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
- m_title = title;
- gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
-}
-
-void wxTopLevelWindowGTK::DoSetIcon( const wxIcon &icon )
-{
- if ( !icon.Ok() )
- return;
-
- if (!m_widget->window)
+ if ( title == m_title )
return;
- wxMask *mask = icon.GetMask();
- GdkBitmap *bm = (GdkBitmap *) NULL;
- if (mask) bm = mask->GetBitmap();
+ m_title = title;
- gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
+ gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
}
void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon )
void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
{
wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
- GdkWindow* window = m_widget->window;
wxTopLevelWindowBase::SetIcons( icons );
- DoSetIcon( icons.GetIcon( -1 ) );
- if ( window )
+ GList *list = NULL;
+ size_t max = icons.m_icons.GetCount();
+
+ for (size_t i = 0; i < max; i++)
{
- wxSetIconsX11( (WXDisplay*)GDK_WINDOW_XDISPLAY( window ),
- (WXWindow)GDK_WINDOW_XWINDOW( window ), icons );
+ if (icons.m_icons[i].Ok())
+ {
+ list = g_list_prepend(list, icons.m_icons[i].GetPixbuf());
+ }
}
+ gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
+ g_list_free(list);
}
// ----------------------------------------------------------------------------
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
{
- // wxFAIL_MSG( _T("not implemented") );
+ if(!m_widget->window)
+ return false;
- // This is an approximation
- return FALSE;
+ return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
}
void wxTopLevelWindowGTK::Restore()
{
-#ifdef __GTK20__
// "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
{
if (!m_grabbed)
{
- m_grabbed = TRUE;
+ m_grabbed = true;
gtk_grab_add( m_widget );
- gtk_main();
+ wxEventLoop().Run();
gtk_grab_remove( m_widget );
}
}
if (m_grabbed)
{
gtk_main_quit();
- m_grabbed = FALSE;
+ m_grabbed = false;
}
}
}
else
{
-#ifdef __WXGTK20__
- gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
-#else
- wxBitmap bmp = region.ConvertToBitmap();
- bmp.SetMask(new wxMask(bmp, *wxWHITE));
- GdkBitmap* mask = bmp.GetMask()->GetBitmap();
- gdk_window_shape_combine_mask(window, mask, 0, 0);
-#endif
- return TRUE;
+ gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
+ return true;
}
}
- return FALSE;
+ return false;
}
bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
{
- wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), FALSE,
+ wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
_T("Shaped windows must be created with the wxFRAME_SHAPED style."));
GdkWindow *window = NULL;
return do_shape_combine_region(window, region);
}
-// vi:sts=4:sw=4:et
+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 <X11/Xlib.h>
+
+/* 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
+}
projects / wxWidgets.git / blobdiff