X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/abdb7725e101288775e9752eecaac4dbc4fcf409..88932ec82d048d006cdc81bd309f5e59aee799ac:/src/gtk/toplevel.cpp?ds=sidebyside diff --git a/src/gtk/toplevel.cpp b/src/gtk/toplevel.cpp index 75371738e9..b1188837b5 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,289 +18,462 @@ // 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/msgdlg.h" -#include "wx/control.h" -#include "wx/app.h" -#include "wx/dcclient.h" -#include "wx/gtk/private.h" -#include "wx/timer.h" -#include "wx/settings.h" +#ifndef WX_PRECOMP + #include "wx/frame.h" + #include "wx/icon.h" + #include "wx/log.h" + #include "wx/app.h" +#endif + +#include "wx/evtloop.h" +#include "wx/sysopt.h" -#include -#include #include -#include -#include +#ifdef GDK_WINDOWING_X11 + #include + #include // XA_CARDINAL + #include "wx/unix/utilsx11.h" +#endif -#include "wx/gtk/win_gtk.h" +#include "wx/gtk/private.h" +#include "wx/gtk/private/gtk2-compat.h" +#include "wx/gtk/private/win_gtk.h" -#include "wx/unix/utilsx11.h" +#if wxUSE_LIBHILDON + #include + #include +#endif // wxUSE_LIBHILDON -// XA_CARDINAL -#include +#if wxUSE_LIBHILDON2 + #include +#endif // wxUSE_LIBHILDON2 // ---------------------------------------------------------------------------- -// idle system +// data // ---------------------------------------------------------------------------- -extern void wxapp_install_idle_handler(); -extern bool g_isIdle; +// this is incremented while a modal dialog is shown +int wxOpenModalDialogsCount = 0; -// ---------------------------------------------------------------------------- -// data -// ---------------------------------------------------------------------------- +// the frame that is currently active (i.e. its child has focus). It is +// used to generate wxActivateEvents +static wxTopLevelWindowGTK *g_activeFrame = NULL; +static wxTopLevelWindowGTK *g_lastActiveFrame = NULL; -extern wxList wxPendingDelete; +// 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; -extern int g_openDialogs; -extern wxWindowGTK *g_delayedFocus; +// Whether _NET_REQUEST_FRAME_EXTENTS support is working +// 0 == not tested yet, 1 == working, 2 == broken +static int gs_requestFrameExtentsStatus; //----------------------------------------------------------------------------- -// "focus" from m_window +// RequestUserAttention related functions //----------------------------------------------------------------------------- -static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) ) +#ifndef __WXGTK3__ +static void wxgtk_window_set_urgency_hint (GtkWindow *win, + gboolean setting) { - if (g_isIdle) - wxapp_install_idle_handler(); +#if GTK_CHECK_VERSION(2,7,0) + if (gtk_check_version(2,7,0) == NULL) + gtk_window_set_urgency_hint(win, setting); + else +#endif + { +#ifdef GDK_WINDOWING_X11 + GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(win)); + wxCHECK_RET(window, "wxgtk_window_set_urgency_hint: GdkWindow not realized"); - // This disables GTK's tab traversal - gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" ); - return TRUE; + Display* dpy = GDK_WINDOW_XDISPLAY(window); + Window xid = GDK_WINDOW_XID(window); + XWMHints* wm_hints = XGetWMHints(dpy, xid); + + if (!wm_hints) + wm_hints = XAllocWMHints(); + + if (setting) + wm_hints->flags |= XUrgencyHint; + else + wm_hints->flags &= ~XUrgencyHint; + + XSetWMHints(dpy, xid, wm_hints); + XFree(wm_hints); +#endif // GDK_WINDOWING_X11 + } +} +#define gtk_window_set_urgency_hint wxgtk_window_set_urgency_hint +#endif + +extern "C" { +static gboolean gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK *win ) +{ + gtk_window_set_urgency_hint(GTK_WINDOW(win->m_widget), false); + + win->m_urgency_hint = -2; + return FALSE; +} } //----------------------------------------------------------------------------- -// "size_allocate" +// "focus_in_event" //----------------------------------------------------------------------------- -static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win ) +extern "C" { +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: + // 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; + } - if (!win->m_hasVMT) - return; + g_activeFrame = win; + g_lastActiveFrame = g_activeFrame; - if ((win->m_width != alloc->width) || (win->m_height != alloc->height)) + // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() ); + + // MR: wxRequestUserAttention related block + switch( win->m_urgency_hint ) { -/* - 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_queuedFullRedraw = TRUE; - win->GtkUpdateSize(); + default: + g_source_remove( win->m_urgency_hint ); + // no break, fallthrough to remove hint too + case -1: + gtk_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); + g_activeFrame->HandleWindowEvent(event); + + return FALSE; +} } //----------------------------------------------------------------------------- -// "delete_event" +// "focus_out_event" +//----------------------------------------------------------------------------- + +extern "C" { +static +gboolean gtk_frame_focus_out_callback(GtkWidget * WXUNUSED(widget), + GdkEventFocus *WXUNUSED(gdk_event), + wxTopLevelWindowGTK * WXUNUSED(win)) +{ + // if the focus goes out of our app altogether, 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->HandleWindowEvent(event); + + g_activeFrame = NULL; + } + + return FALSE; +} +} + +//----------------------------------------------------------------------------- +// "size_allocate" from m_wxwindow //----------------------------------------------------------------------------- -static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxTopLevelWindowGTK *win ) +extern "C" { +static void +size_allocate(GtkWidget*, GtkAllocation* alloc, wxTopLevelWindowGTK* win) { - if (g_isIdle) - wxapp_install_idle_handler(); + if (win->m_oldClientWidth != alloc->width || + win->m_oldClientHeight != alloc->height) + { + win->m_oldClientWidth = alloc->width; + win->m_oldClientHeight = alloc->height; + + GtkAllocation a; + gtk_widget_get_allocation(win->m_widget, &a); + wxSize size(a.width, a.height); + size += win->m_decorSize; + win->m_width = size.x; + win->m_height = size.y; + + if (!win->IsIconized()) + { + wxSizeEvent event(size, win->GetId()); + event.SetEventObject(win); + win->HandleWindowEvent(event); + } + // else the window is currently unmapped, don't generate size events + } +} +} +//----------------------------------------------------------------------------- +// "delete_event" +//----------------------------------------------------------------------------- + +extern "C" { +static gboolean +gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), + GdkEvent *WXUNUSED(event), + wxTopLevelWindowGTK *win ) +{ if (win->IsEnabled() && - (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) || + (wxOpenModalDialogsCount == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) || win->IsGrabbed())) win->Close(); 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* widget, + GdkEventConfigure *WXUNUSED(event), + wxTopLevelWindowGTK *win ) { - if (g_isIdle) - wxapp_install_idle_handler(); - - if (!win->m_hasVMT || !win->IsShown()) + if (!win->IsShown()) return FALSE; - 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; + wxPoint point; + gtk_window_get_position((GtkWindow*)widget, &point.x, &point.y); - wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() ); + win->m_x = point.x; + win->m_y = point.y; + wxMoveEvent mevent(point, win->GetId()); mevent.SetEventObject( win ); - win->GetEventHandler()->ProcessEvent( mevent ); + win->HandleWindowEvent( mevent ); return FALSE; } +} //----------------------------------------------------------------------------- // "realize" from m_widget //----------------------------------------------------------------------------- -// we cannot MWM hints and icons before the widget has been realized, +// we cannot the WM hints and icons before the widget has been realized, // so we do this directly after realization -static void -gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), - wxTopLevelWindowGTK *win ) +void wxTopLevelWindowGTK::GTKHandleRealized() { - if (g_isIdle) - wxapp_install_idle_handler(); + wxNonOwnedWindow::GTKHandleRealized(); - // 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, - (GdkWMDecoration)win->m_gdkDecor); - gdk_window_set_functions(win->m_widget->window, - (GdkWMFunction)win->m_gdkFunc); + gdk_window_set_decorations(gtk_widget_get_window(m_widget), + (GdkWMDecoration)m_gdkDecor); + gdk_window_set_functions(gtk_widget_get_window(m_widget), + (GdkWMFunction)m_gdkFunc); // 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); + if ( !(m_gdkFunc & GDK_FUNC_RESIZE) ) + gtk_window_set_resizable(GTK_WINDOW(m_widget), FALSE); +#ifndef __WXGTK3__ else - gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1); + gtk_window_set_policy(GTK_WINDOW(m_widget), 1, 1, 1); +#endif - // reset the icon - wxIconBundle iconsOld = win->GetIcons(); - if ( iconsOld.GetIcon(-1).Ok() ) + const wxIconBundle& icons = GetIcons(); + if (icons.GetIconCount()) + SetIcons(icons); + +#ifdef __WXGTK3__ + if (gtk_window_get_has_resize_grip(GTK_WINDOW(m_widget))) { - win->SetIcon( wxNullIcon ); - win->SetIcons( iconsOld ); + // Grip window can end up obscured, probably due to deferred show. + // Reset grip to ensure it is visible. + gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), false); + gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), true); } +#endif } //----------------------------------------------------------------------------- // "map_event" from m_widget //----------------------------------------------------------------------------- -static void -gtk_frame_map_callback( GtkWidget * WXUNUSED(widget), +extern "C" { +static gboolean +gtk_frame_map_callback( GtkWidget*, GdkEvent * WXUNUSED(event), wxTopLevelWindow *win ) { - win->SetIconizeState(FALSE); -} + const bool wasIconized = win->IsIconized(); + if (wasIconized) + { + // Because GetClientSize() returns (0,0) when IsIconized() is true, + // a size event must be generated, just in case GetClientSize() was + // called while iconized. This specifically happens when restoring a + // tlw that was "rolled up" with some WMs. + // Queue a resize rather than sending size event directly to allow + // children to be made visible first. + win->m_oldClientWidth = 0; + gtk_widget_queue_resize(win->m_wxwindow); + } + // it is possible for m_isShown to be false here, see bug #9909 + if (win->wxWindowBase::Show(true)) + { + wxShowEvent eventShow(win->GetId(), true); + eventShow.SetEventObject(win); + win->GetEventHandler()->ProcessEvent(eventShow); + } -//----------------------------------------------------------------------------- -// "unmap_event" from m_widget -//----------------------------------------------------------------------------- + // restore focus-on-map setting in case ShowWithoutActivating() was called + gtk_window_set_focus_on_map(GTK_WINDOW(win->m_widget), true); -static void -gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget), - GdkEvent * WXUNUSED(event), - wxTopLevelWindow *win ) -{ - win->SetIconizeState(TRUE); + return false; +} } //----------------------------------------------------------------------------- -// "expose_event" of m_client +// "window-state-event" from m_widget //----------------------------------------------------------------------------- -static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win ) +extern "C" { +static gboolean +gtk_frame_window_state_callback( GtkWidget* WXUNUSED(widget), + GdkEventWindowState *event, + wxTopLevelWindow *win ) { - GtkPizza *pizza = GTK_PIZZA(widget); + if (event->changed_mask & GDK_WINDOW_STATE_ICONIFIED) + win->SetIconizeState((event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) != 0); - 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); + // if maximized bit changed and it is now set + if (event->changed_mask & event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) + { + wxMaximizeEvent evt(win->GetId()); + evt.SetEventObject(win); + win->HandleWindowEvent(evt); + } - return FALSE; + if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) + win->m_fsIsShowing = (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) != 0; + + return false; +} } //----------------------------------------------------------------------------- -// "draw" of m_client -//----------------------------------------------------------------------------- - -#ifndef __WXGTK20__ -static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win ) +bool wxGetFrameExtents(GdkWindow* window, int* left, int* right, int* top, int* bottom) { - GtkPizza *pizza = GTK_PIZZA(widget); - - gtk_paint_flat_box (win->m_widget->style, - pizza->bin_window, GTK_STATE_NORMAL, - GTK_SHADOW_NONE, - rect, - win->m_widget, - (char *)"base", - 0, 0, -1, -1); +#ifdef GDK_WINDOWING_X11 + static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false); + GdkDisplay* display = gdk_window_get_display(window); + Atom xproperty = gdk_x11_atom_to_xatom_for_display(display, property); + Atom type; + int format; + gulong nitems, bytes_after; + guchar* data; + Status status = XGetWindowProperty( + GDK_DISPLAY_XDISPLAY(display), + GDK_WINDOW_XID(window), + xproperty, + 0, 4, false, XA_CARDINAL, + &type, &format, &nitems, &bytes_after, &data); + const bool success = status == Success && data && nitems == 4; + if (success) + { + long* p = (long*)data; + if (left) *left = int(p[0]); + if (right) *right = int(p[1]); + if (top) *top = int(p[2]); + if (bottom) *bottom = int(p[3]); + } + if (data) + XFree(data); + return success; +#else + return false; +#endif } -#endif // GTK+ 1.x - -// ---------------------------------------------------------------------------- -// wxTopLevelWindowGTK itself -// ---------------------------------------------------------------------------- - +#ifdef GDK_WINDOWING_X11 //----------------------------------------------------------------------------- -// InsertChild for wxTopLevelWindowGTK +// "property_notify_event" from m_widget //----------------------------------------------------------------------------- -/* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because - * C++ has no virtual methods in a constructor. We have to emulate a - * virtual function here as wxWindows requires different ways to insert - * a child in container classes. */ - -static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child ) +extern "C" { +static gboolean property_notify_event( + GtkWidget*, GdkEventProperty* event, wxTopLevelWindowGTK* win) { - wxASSERT( GTK_IS_WIDGET(child->m_widget) ); - - if (!parent->m_insertInClientArea) - { - // these are outside the client area - wxTopLevelWindowGTK* frame = (wxTopLevelWindowGTK*) parent; - gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget), - GTK_WIDGET(child->m_widget), - child->m_x, - child->m_y, - child->m_width, - child->m_height ); - } - else + // Watch for changes to _NET_FRAME_EXTENTS property + static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false); + if (event->state == GDK_PROPERTY_NEW_VALUE && event->atom == property) { - // these are inside the client area - gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow), - GTK_WIDGET(child->m_widget), - child->m_x, - child->m_y, - child->m_width, - child->m_height ); + if (win->m_netFrameExtentsTimerId) + { + // WM support for _NET_REQUEST_FRAME_EXTENTS is working + gs_requestFrameExtentsStatus = 1; + g_source_remove(win->m_netFrameExtentsTimerId); + win->m_netFrameExtentsTimerId = 0; + } + + wxSize decorSize = win->m_decorSize; + int left, right, top, bottom; + if (wxGetFrameExtents(event->window, &left, &right, &top, &bottom)) + decorSize.Set(left + right, top + bottom); + + win->GTKUpdateDecorSize(decorSize); } + return false; +} +} - // resize on OnInternalIdle - parent->GtkUpdateSize(); +extern "C" { +static gboolean request_frame_extents_timeout(void* data) +{ + // WM support for _NET_REQUEST_FRAME_EXTENTS is broken + gs_requestFrameExtentsStatus = 2; + gdk_threads_enter(); + wxTopLevelWindowGTK* win = static_cast(data); + win->m_netFrameExtentsTimerId = 0; + wxSize decorSize = win->m_decorSize; + int left, right, top, bottom; + if (wxGetFrameExtents(gtk_widget_get_window(win->m_widget), &left, &right, &top, &bottom)) + decorSize.Set(left + right, top + bottom); + win->GTKUpdateDecorSize(decorSize); + gdk_threads_leave(); + return false; } +} +#endif // GDK_WINDOWING_X11 // ---------------------------------------------------------------------------- // wxTopLevelWindowGTK creation @@ -305,16 +481,20 @@ static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow void wxTopLevelWindowGTK::Init() { - m_sizeSet = FALSE; - m_miniEdge = 0; - m_miniTitle = 0; - m_mainWidget = (GtkWidget*) NULL; - m_insertInClientArea = TRUE; - m_isIconized = FALSE; - m_fsIsShowing = FALSE; - m_themeEnabled = TRUE; - m_gdkDecor = m_gdkFunc = 0; - m_grabbed = FALSE; + m_mainWidget = NULL; + m_isIconized = false; + m_fsIsShowing = false; + m_themeEnabled = true; + m_gdkDecor = + m_gdkFunc = 0; + m_grabbed = false; + m_deferShow = true; + m_deferShowAllowed = true; + m_updateDecorSize = true; + m_netFrameExtentsTimerId = 0; + m_incWidth = m_incHeight = 0; + + m_urgency_hint = -2; } bool wxTopLevelWindowGTK::Create( wxWindow *parent, @@ -333,266 +513,484 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, wxTopLevelWindows.Append( this ); - 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; + // NB: m_widget may be !=NULL if it was created by derived class' Create, + // e.g. in wxTaskBarIconAreaGTK + if (m_widget == NULL) + { +#if wxUSE_LIBHILDON || wxUSE_LIBHILDON2 + // we must create HildonWindow and not a normal GtkWindow as the latter + // doesn't look correctly in Maemo environment and it must also be + // registered with the main program object + m_widget = hildon_window_new(); + hildon_program_add_window(wxTheApp->GetHildonProgram(), + HILDON_WINDOW(m_widget)); +#else // !wxUSE_LIBHILDON || !wxUSE_LIBHILDON2 + m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL); + if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) + { + // 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 + { + 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 // wxUSE_LIBHILDON || wxUSE_LIBHILDON2/!wxUSE_LIBHILDON || !wxUSE_LIBHILDON2 - if (style & wxFRAME_TOOL_WINDOW) - win_type = GTK_WINDOW_POPUP; + g_object_ref(m_widget); + } - if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) + wxWindow *topParent = wxGetTopLevelParent(m_parent); + if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) && + (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) || + (style & wxFRAME_FLOAT_ON_PARENT))) { - // there is no more GTK_WINDOW_DIALOG in 2.0 -#ifdef __WXGTK20__ - win_type = GTK_WINDOW_TOPLEVEL; -#else - win_type = GTK_WINDOW_DIALOG; -#endif + gtk_window_set_transient_for( GTK_WINDOW(m_widget), + GTK_WINDOW(topParent->m_widget) ); } - m_widget = gtk_window_new( win_type ); + if (style & wxFRAME_NO_TASKBAR) + { + gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE); + } - if (m_parent && (((GTK_IS_WINDOW(m_parent->m_widget)) && - (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) || - (style & wxFRAME_FLOAT_ON_PARENT))) + if (style & wxSTAY_ON_TOP) { - gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) ); + gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE); } + if (style & wxMAXIMIZE) + gtk_window_maximize(GTK_WINDOW(m_widget)); - 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_widget_set_can_focus(m_widget, false); - 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(); + // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow) + m_mainWidget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show( m_mainWidget ); - GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS ); + gtk_widget_set_can_focus(m_mainWidget, false); gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget ); - 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 - } - - // m_wxwindow only represents the client area without toolbar and menubar - m_wxwindow = gtk_pizza_new(); + // m_wxwindow is the client area + m_wxwindow = wxPizza::New(); gtk_widget_show( m_wxwindow ); - gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow ); + gtk_box_pack_start(GTK_BOX(m_mainWidget), m_wxwindow, true, true, 0); // we donm't allow the frame to get the focus as otherwise // the frame will grab it at arbitrary focus changes - GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS ); + gtk_widget_set_can_focus(m_wxwindow, false); 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_wxwindow, "size_allocate", + G_CALLBACK(size_allocate), this); PostCreation(); +#ifndef __WXGTK3__ if ((m_x != -1) || (m_y != -1)) gtk_widget_set_uposition( m_widget, m_x, m_y ); +#endif + + // for some reported size corrections + g_signal_connect (m_widget, "map_event", + G_CALLBACK (gtk_frame_map_callback), this); + + // for iconized state + g_signal_connect (m_widget, "window_state_event", + G_CALLBACK (gtk_frame_window_state_callback), this); + - gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height ); + // for wxMoveEvent + g_signal_connect (m_widget, "configure_event", + G_CALLBACK (gtk_frame_configure_callback), this); - // 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 ); + // 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); - // 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 ); + // GTK processes key events at the top level first, which handles for + // menu accelerators and shortcuts before passing the event on to the + // focus child window to begin propagation. We want to propagate + // first, so we connect gtk_window_propagate_key_event to + // key_press_event. + g_signal_connect (m_widget, "key_press_event", + G_CALLBACK (gtk_window_propagate_key_event), NULL); - // 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 ); +#ifdef GDK_WINDOWING_X11 +#ifdef __WXGTK3__ + if (GDK_IS_X11_SCREEN(gtk_window_get_screen(GTK_WINDOW(m_widget)))) +#endif + { + gtk_widget_add_events(m_widget, GDK_PROPERTY_CHANGE_MASK); + g_signal_connect(m_widget, "property_notify_event", + G_CALLBACK(property_notify_event), this); + } +#endif // GDK_WINDOWING_X11 + + // translate wx decorations styles into Motif WM hints (they are recognized + // by other WMs as well) + + // always enable moving the window as we have no separate flag for enabling + // it + m_gdkFunc = GDK_FUNC_MOVE; + + if ( style & wxCLOSE_BOX ) + m_gdkFunc |= GDK_FUNC_CLOSE; - // 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 ); + if ( style & wxMINIMIZE_BOX ) + m_gdkFunc |= GDK_FUNC_MINIMIZE; - // disable native tab traversal - gtk_signal_connect( GTK_OBJECT(m_widget), "focus", - GTK_SIGNAL_FUNC(gtk_frame_focus_callback), (gpointer)this ); + if ( style & wxMAXIMIZE_BOX ) + m_gdkFunc |= GDK_FUNC_MAXIMIZE; - // 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 + else // have border { - m_gdkDecor = (long) GDK_DECOR_BORDER; - m_gdkFunc = (long) GDK_FUNC_MOVE; + m_gdkDecor = GDK_DECOR_BORDER; - // All this is for Motif Window Manager "hints" and is supposed to be - // recognized by other WMs as well. - if ((style & wxCAPTION) != 0) - { + if ( style & wxCAPTION ) m_gdkDecor |= GDK_DECOR_TITLE; - } - if ((style & wxCLOSE_BOX) != 0) - { - m_gdkFunc |= GDK_FUNC_CLOSE; - } - if ((style & wxSYSTEM_MENU) != 0) - { + + if ( style & wxSYSTEM_MENU ) m_gdkDecor |= GDK_DECOR_MENU; - } - if ((style & wxMINIMIZE_BOX) != 0) - { - m_gdkFunc |= GDK_FUNC_MINIMIZE; + + if ( style & wxMINIMIZE_BOX ) m_gdkDecor |= GDK_DECOR_MINIMIZE; - } - if ((style & wxMAXIMIZE_BOX) != 0) - { - m_gdkFunc |= GDK_FUNC_MAXIMIZE; + + if ( style & wxMAXIMIZE_BOX ) m_gdkDecor |= GDK_DECOR_MAXIMIZE; - } - if ((style & wxRESIZE_BORDER) != 0) + + if ( style & wxRESIZE_BORDER ) { m_gdkFunc |= GDK_FUNC_RESIZE; m_gdkDecor |= GDK_DECOR_RESIZEH; } } - return TRUE; + // GTK sometimes chooses very small size if max size hint is not explicitly set + DoSetSizeHints(m_minWidth, m_minHeight, m_maxWidth, m_maxHeight, m_incWidth, m_incHeight); + + m_decorSize = GetCachedDecorSize(); + int w, h; + GTKDoGetSize(&w, &h); + gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h); + + return true; } wxTopLevelWindowGTK::~wxTopLevelWindowGTK() { + if ( m_netFrameExtentsTimerId ) + { + // Don't let the timer callback fire as the window pointer passed to it + // will become invalid very soon. + g_source_remove(m_netFrameExtentsTimerId); + } + +#if wxUSE_LIBHILDON || wxUSE_LIBHILDON2 + // it can also be a (standard) dialog + if ( HILDON_IS_WINDOW(m_widget) ) + { + hildon_program_remove_window(wxTheApp->GetHildonProgram(), + HILDON_WINDOW(m_widget)); + } +#endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2 + if (m_grabbed) { - wxASSERT_MSG( FALSE, _T("Window still grabbed")); + wxFAIL_MSG(wxT("Window still grabbed")); RemoveGrab(); } - m_isBeingDeleted = TRUE; + SendDestroyEvent(); // 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::EnableCloseButton( bool enable ) +{ + if (enable) + m_gdkFunc |= GDK_FUNC_CLOSE; + else + m_gdkFunc &= ~GDK_FUNC_CLOSE; + + GdkWindow* window = gtk_widget_get_window(m_widget); + if (window) + gdk_window_set_functions(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? + 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) +#ifdef GDK_WINDOWING_X11 + Display* xdpy = GDK_DISPLAY_XDISPLAY(gtk_widget_get_display(m_widget)); + Window xroot = GDK_WINDOW_XID(gtk_widget_get_root_window(m_widget)); + wxX11FullScreenMethod method = wxGetFullScreenMethodX11(xdpy, (WXWindow)xroot); + + // 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 ) +#endif // GDK_WINDOWING_X11 { - m_fsSaveFlag = style; - GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y ); - GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height ); + if (show) + gtk_window_fullscreen( GTK_WINDOW( m_widget ) ); + else + gtk_window_unfullscreen( GTK_WINDOW( m_widget ) ); + } +#ifdef GDK_WINDOWING_X11 + else + { + GdkWindow* window = gtk_widget_get_window(m_widget); + Window xid = GDK_WINDOW_XID(window); + + if (show) + { + GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y ); + GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height ); - int screen_width,screen_height; - wxDisplaySize( &screen_width, &screen_height ); + GdkScreen* screen = gtk_widget_get_screen(m_widget); + const int screen_width = gdk_screen_get_width(screen); + const int screen_height = gdk_screen_get_height(screen); - gint client_x, client_y, root_x, root_y; - gint width, 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_get_origin(window, &root_x, &root_y); + gdk_window_get_geometry(window, &client_x, &client_y, &width, &height); - gdk_window_move_resize (m_widget->window, -client_x, -client_y, - screen_width + 1, screen_height + 1); + gdk_window_move_resize( + 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 - { - if (method != wxX11_FS_WMSPEC) + wxSetFullScreenStateX11(xdpy, + (WXWindow)xroot, + (WXWindow)xid, + show, &m_fsSaveFrame, method); + } + else // hide { - // 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); + wxSetFullScreenStateX11(xdpy, + (WXWindow)xroot, + (WXWindow)xid, + show, &m_fsSaveFrame, method); - SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y, - m_fsSaveFrame.width, m_fsSaveFrame.height); + SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y, + m_fsSaveFrame.width, m_fsSaveFrame.height); + } } +#endif // GDK_WINDOWING_X11 + // documented behaviour is to show the window if it's still hidden when + // showing it full screen + if (show) + Show(); - return TRUE; + return true; } // ---------------------------------------------------------------------------- // overridden wxWindow methods // ---------------------------------------------------------------------------- +void wxTopLevelWindowGTK::Refresh( bool WXUNUSED(eraseBackground), const wxRect *WXUNUSED(rect) ) +{ + wxCHECK_RET( m_widget, wxT("invalid frame") ); + + gtk_widget_queue_draw( m_widget ); + + GdkWindow* window = NULL; + if (m_wxwindow) + window = gtk_widget_get_window(m_wxwindow); + if (window) + gdk_window_invalidate_rect(window, NULL, true); +} + bool wxTopLevelWindowGTK::Show( bool show ) { - wxCHECK_VALID_WIDGET(FALSE); + wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); + +#ifdef GDK_WINDOWING_X11 + bool deferShow = show && !m_isShown && m_deferShow; + if (deferShow) + { + deferShow = m_deferShowAllowed && gs_requestFrameExtentsStatus != 2 && + !gtk_widget_get_realized(m_widget) && + g_signal_handler_find(m_widget, + GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA), + g_signal_lookup("property_notify_event", GTK_TYPE_WIDGET), + 0, NULL, NULL, this); + if (deferShow) + { + GdkScreen* screen = gtk_widget_get_screen(m_widget); + GdkAtom atom = gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false); + deferShow = gdk_x11_screen_supports_net_wm_hint(screen, atom) != 0; + + // If _NET_REQUEST_FRAME_EXTENTS not supported, don't allow changes + // to m_decorSize, it breaks saving/restoring window size with + // GetSize()/SetSize() because it makes window bigger between each + // restore and save. + m_updateDecorSize = deferShow; + } - if (show && !m_sizeSet) + m_deferShow = deferShow; + } + if (deferShow) { - /* by calling GtkOnSize here, we don't have to call - either after showing the frame, which would entail - much ugly flicker or from within the size_allocate - handler, because GTK 1.1.X forbids that. */ + // Initial show. If WM supports _NET_REQUEST_FRAME_EXTENTS, defer + // calling gtk_widget_show() until _NET_FRAME_EXTENTS property + // notification is received, so correct frame extents are known. + // This allows resizing m_widget to keep the overall size in sync with + // what wxWidgets expects it to be without an obvious change in the + // window size immediately after it becomes visible. + + // Realize m_widget, so m_widget->window can be used. Realizing normally + // causes the widget tree to be size_allocated, which generates size + // events in the wrong order. However, the size_allocates will not be + // done if the allocation is not the default (1,1). + GtkAllocation alloc; + gtk_widget_get_allocation(m_widget, &alloc); + const int alloc_width = alloc.width; + if (alloc_width == 1) + { + alloc.width = 2; + gtk_widget_set_allocation(m_widget, &alloc); + } + gtk_widget_realize(m_widget); + if (alloc_width == 1) + { + alloc.width = 1; + gtk_widget_set_allocation(m_widget, &alloc); + } - GtkOnSize( m_x, m_y, m_width, m_height ); + // send _NET_REQUEST_FRAME_EXTENTS + XClientMessageEvent xevent; + memset(&xevent, 0, sizeof(xevent)); + xevent.type = ClientMessage; + GdkWindow* window = gtk_widget_get_window(m_widget); + xevent.window = GDK_WINDOW_XID(window); + xevent.message_type = gdk_x11_atom_to_xatom_for_display( + gdk_window_get_display(window), + gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false)); + xevent.format = 32; + Display* display = GDK_DISPLAY_XDISPLAY(gdk_window_get_display(window)); + XSendEvent(display, DefaultRootWindow(display), false, + SubstructureNotifyMask | SubstructureRedirectMask, + (XEvent*)&xevent); + + if (gs_requestFrameExtentsStatus == 0) + { + // if WM does not respond to request within 1 second, + // we assume support for _NET_REQUEST_FRAME_EXTENTS is not working + m_netFrameExtentsTimerId = + g_timeout_add(1000, request_frame_extents_timeout, this); + } + + // defer calling gtk_widget_show() + m_isShown = true; + return true; + } +#endif // GDK_WINDOWING_X11 + + if (show && !gtk_widget_get_realized(m_widget)) + { + // size_allocate signals occur in reverse order (bottom to top). + // Things work better if the initial wxSizeEvents are sent (from the + // top down), before the initial size_allocate signals occur. + wxSizeEvent event(GetSize(), GetId()); + event.SetEventObject(this); + HandleWindowEvent(event); } - return wxWindow::Show( show ); + bool change = base_type::Show(show); + + if (change && !show) + { + // make sure window has a non-default position, so when it is shown + // again, it won't be repositioned by WM as if it were a new window + // Note that this must be done _after_ the window is hidden. + gtk_window_move((GtkWindow*)m_widget, m_x, m_y); + } + + return change; +} + +void wxTopLevelWindowGTK::ShowWithoutActivating() +{ + if (!m_isShown) + { + gtk_window_set_focus_on_map(GTK_WINDOW(m_widget), false); + Show(true); + } +} + +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) ) @@ -600,259 +998,250 @@ void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXU wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") ); } -void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags ) +// ---------------------------------------------------------------------------- +// window geometry +// ---------------------------------------------------------------------------- + +void wxTopLevelWindowGTK::GTKDoGetSize(int *width, int *height) const { - wxCHECK_VALID_WIDGET_RET(); - - // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow - wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") ); + wxSize size(m_width, m_height); + size -= m_decorSize; + if (size.x < 0) size.x = 0; + if (size.y < 0) size.y = 0; +#if wxUSE_LIBHILDON2 + if (width) { + if (size.x == 720) + *width = 696; + else + *width = size.x; + } + if (height) { + if (size.y == 420) + *height = 396; + else if (size.y == 270) + *height = 246; + else + *height = size.y; + } +#else // wxUSE_LIBHILDON2 + if (width) *width = size.x; + if (height) *height = size.y; +#endif // wxUSE_LIBHILDON2 /!wxUSE_LIBHILDON2 +} - // avoid recursions - if (m_resizing) - return; - m_resizing = TRUE; +void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags ) +{ + wxCHECK_RET( m_widget, wxT("invalid frame") ); + // 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 ( m_x != old_x || m_y != old_y ) { - if (width == -1) m_width = 80; + gtk_window_move( GTK_WINDOW(m_widget), m_x, m_y ); } - if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT) + const wxSize oldSize(m_width, m_height); + if (width >= 0) + m_width = width; + if (height >= 0) + m_height = height; + ConstrainSize(); + if (m_width < 1) m_width = 1; + if (m_height < 1) m_height = 1; + if (m_width != oldSize.x || m_height != oldSize.y) { - if (height == -1) m_height = 26; - } -*/ - - 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; + m_deferShowAllowed = true; - 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 ); - } - } + int w, h; + GTKDoGetSize(&w, &h); + gtk_window_resize(GTK_WINDOW(m_widget), w, h); - if ((m_width != old_width) || (m_height != old_height)) - { - 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; + GetClientSize(&m_oldClientWidth, &m_oldClientHeight); + wxSizeEvent event(GetSize(), GetId()); + event.SetEventObject(this); + HandleWindowEvent(event); } +} + +void wxTopLevelWindowGTK::DoSetClientSize(int width, int height) +{ + base_type::DoSetClientSize(width, height); - m_resizing = FALSE; + // Since client size is being explicitly set, don't change it later + // Has to be done after calling base because it calls SetSize, + // which sets this true + m_deferShowAllowed = false; } void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const { - wxCHECK_VALID_WIDGET_RET(); - - wxWindow::DoGetClientSize( width, height ); - if (height) + wxASSERT_MSG(m_widget, wxT("invalid frame")); + + if ( IsIconized() ) { - // mini edge - *height -= m_miniEdge*2 + m_miniTitle; + // for consistency with wxMSW, client area is supposed to be empty for + // the iconized windows + if ( width ) + *width = 0; + if ( height ) + *height = 0; } - if (width) + else { - *width -= m_miniEdge*2; + GTKDoGetSize(width, height); } } -void wxTopLevelWindowGTK::DoSetClientSize( int width, int height ) +void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH, + int maxW, int maxH, + int incW, int incH ) { - wxCHECK_VALID_WIDGET_RET(); - - DoSetSize(-1, -1, - width + m_miniEdge*2, height + m_miniEdge*2 + m_miniTitle, 0); + base_type::DoSetSizeHints(minW, minH, maxW, maxH, incW, incH); + m_incWidth = incW; + m_incHeight = incH; + + const wxSize minSize = GetMinSize(); + const wxSize maxSize = GetMaxSize(); + GdkGeometry hints; + // always set both min and max hints, otherwise GTK will + // make assumptions we don't want about the unset values + int hints_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE; + hints.min_width = 1; + hints.min_height = 1; + hints.max_width = INT_MAX; + hints.max_height = INT_MAX; + if (minSize.x > m_decorSize.x) + hints.min_width = minSize.x - m_decorSize.x; + if (minSize.y > m_decorSize.y) + hints.min_height = minSize.y - m_decorSize.y; + if (maxSize.x > 0) + { + hints.max_width = maxSize.x - m_decorSize.x; + if (hints.max_width < hints.min_width) + hints.max_width = hints.min_width; + } + if (maxSize.y > 0) + { + hints.max_height = maxSize.y - m_decorSize.y; + if (hints.max_height < hints.min_height) + hints.max_height = hints.min_height; + } + 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 ) +#ifdef GDK_WINDOWING_X11 +void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize) { - // 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; - - if (m_mainWidget) + if (!IsMaximized() && !IsFullScreen()) + GetCachedDecorSize() = decorSize; + if (m_updateDecorSize && m_decorSize != decorSize) { - // 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; - - gtk_pizza_set_size( GTK_PIZZA(m_mainWidget), - m_wxwindow, - client_x, client_y, client_w, client_h ); + const wxSize diff = decorSize - m_decorSize; + m_decorSize = decorSize; + bool resized = false; + if (m_minWidth > 0 || m_minHeight > 0 || m_maxWidth > 0 || m_maxHeight > 0) + { + // update size hints, they depend on m_decorSize + DoSetSizeHints(m_minWidth, m_minHeight, m_maxWidth, m_maxHeight, m_incWidth, m_incHeight); + } + if (m_deferShow) + { + // keep overall size unchanged by shrinking m_widget + int w, h; + GTKDoGetSize(&w, &h); + // but not if size would be less than minimum, it won't take effect + if (w >= m_minWidth - decorSize.x && h >= m_minHeight - decorSize.y ) + { + gtk_window_resize(GTK_WINDOW(m_widget), w, h); + resized = true; + } + } + if (!resized) + { + // adjust overall size to match change in frame extents + m_width += diff.x; + m_height += diff.y; + if (m_width < 1) m_width = 1; + if (m_height < 1) m_height = 1; + m_oldClientWidth = 0; + gtk_widget_queue_resize(m_wxwindow); + } } - else + if (m_deferShow) { - // If there is no m_mainWidget between m_widget and m_wxwindow there - // is no need to set the size or position of m_wxwindow. + // gtk_widget_show() was deferred, do it now + m_deferShow = false; + GetClientSize(&m_oldClientWidth, &m_oldClientHeight); + wxSizeEvent sizeEvent(GetSize(), GetId()); + sizeEvent.SetEventObject(this); + HandleWindowEvent(sizeEvent); + + gtk_widget_show(m_widget); + + wxShowEvent showEvent(GetId(), true); + showEvent.SetEventObject(this); + HandleWindowEvent(showEvent); } +} +#endif // GDK_WINDOWING_X11 - m_sizeSet = TRUE; - - // send size event to frame - wxSizeEvent event( wxSize(m_width,m_height), GetId() ); - event.SetEventObject( this ); - GetEventHandler()->ProcessEvent( event ); - - m_resizing = FALSE; +wxSize& wxTopLevelWindowGTK::GetCachedDecorSize() +{ + static wxSize size[8]; + + int index = 0; + // title bar + if (m_gdkDecor & (GDK_DECOR_MENU | GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE | GDK_DECOR_TITLE)) + index = 1; + // border + if (m_gdkDecor & GDK_DECOR_BORDER) + index |= 2; + // utility window decor can be different + if (m_windowStyle & wxFRAME_TOOL_WINDOW) + index |= 4; + return size[index]; } void wxTopLevelWindowGTK::OnInternalIdle() { - if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow)) + wxTopLevelWindowBase::OnInternalIdle(); + + // Synthetize activate events. + if ( g_sendActivateEvent != -1 ) { - GtkOnSize( m_x, m_y, m_width, m_height ); + bool activate = g_sendActivateEvent != 0; - // we'll come back later - if (g_isIdle) - wxapp_install_idle_handler(); - return; - } + // if (!activate) wxPrintf( wxT("de") ); + // wxPrintf( wxT("activate\n") ); - // set the focus if not done yet and if we can already do it - if ( GTK_WIDGET_REALIZED(m_wxwindow) ) - { - if ( g_delayedFocus && - wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this ) - { - wxLogTrace(_T("focus"), - _T("Setting focus from wxTLW::OnIdle() to %s(%s)"), - g_delayedFocus->GetClassInfo()->GetClassName(), - g_delayedFocus->GetLabel().c_str()); + // do it only once + g_sendActivateEvent = -1; - g_delayedFocus->SetFocus(); - g_delayedFocus = NULL; - } + wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame); } - - wxWindow::OnInternalIdle(); } // ---------------------------------------------------------------------------- @@ -861,44 +1250,32 @@ void wxTopLevelWindowGTK::OnInternalIdle() void wxTopLevelWindowGTK::SetTitle( const wxString &title ) { - wxCHECK_VALID_WIDGET_RET(); - - m_title = title; - gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) ); -} + wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); -void wxTopLevelWindowGTK::DoSetIcon( const wxIcon &icon ) -{ - if ( !icon.Ok() ) + if ( title == m_title ) return; - if (!m_widget->window) - return; - - 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 ); -} + m_title = 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 ) { - wxCHECK_VALID_WIDGET_RET(); - GdkWindow* window = m_widget->window; + wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); - wxTopLevelWindowBase::SetIcons( icons ); + base_type::SetIcons(icons); - DoSetIcon( icons.GetIcon( -1 ) ); - if ( window ) + // Setting icons before window is realized can cause a GTK assertion if + // another TLW is realized before this one, and it has this one as it's + // transient parent. The life demo exibits this problem. + if (gtk_widget_get_realized(m_widget)) { - wxSetIconsX11( (WXDisplay*)GDK_WINDOW_XDISPLAY( window ), - (WXWindow)GDK_WINDOW_XWINDOW( window ), icons ); + GList* list = NULL; + for (size_t i = icons.GetIconCount(); i--;) + list = g_list_prepend(list, icons.GetIconByIndex(i).GetPixbuf()); + gtk_window_set_icon_list(GTK_WINDOW(m_widget), list); + g_list_free(list); } } @@ -908,54 +1285,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 { - // wxFAIL_MSG( _T("not implemented") ); - - // This is an approximation - return FALSE; + GdkWindow* window = NULL; + if (m_widget) + window = gtk_widget_get_window(m_widget); + return window && (gdk_window_get_state(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 @@ -976,9 +1331,9 @@ void wxTopLevelWindowGTK::AddGrab() { if (!m_grabbed) { - m_grabbed = TRUE; + m_grabbed = true; gtk_grab_add( m_widget ); - gtk_main(); + wxGUIEventLoop().Run(); gtk_grab_remove( m_widget ); } } @@ -988,50 +1343,129 @@ void wxTopLevelWindowGTK::RemoveGrab() if (m_grabbed) { gtk_main_quit(); - m_grabbed = FALSE; + m_grabbed = false; } } +bool wxTopLevelWindowGTK::IsActive() +{ + return (this == (wxTopLevelWindowGTK*)g_activeFrame); +} -// helper -static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region) +void wxTopLevelWindowGTK::RequestUserAttention(int flags) { - if (window) + 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. + // YieldFor(wxEVT_CATEGORY_UI) ensures the processing of it (hopefully it + // won't have side effects) - MR + wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI); + + if(m_urgency_hint >= 0) + g_source_remove(m_urgency_hint); + + m_urgency_hint = -2; + + if( gtk_widget_get_realized(m_widget) && !IsActive() ) { - if (region.IsEmpty()) - { - gdk_window_shape_combine_mask(window, NULL, 0, 0); - } - else + new_hint_value = true; + + if (flags & wxUSER_ATTENTION_INFO) { -#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; + m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this); + } else { + m_urgency_hint = -1; } } - return FALSE; -} + gtk_window_set_urgency_hint(GTK_WINDOW(m_widget), new_hint_value); +} -bool wxTopLevelWindowGTK::SetShape(const wxRegion& region) +void wxTopLevelWindowGTK::SetWindowStyleFlag( long style ) { - wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), FALSE, - _T("Shaped windows must be created with the wxFRAME_SHAPED style.")); + // Store which styles were changed + long styleChanges = style ^ m_windowStyle; - GdkWindow *window = NULL; - if (m_wxwindow) + // 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; + + if ( styleChanges & wxSTAY_ON_TOP ) { - window = GTK_PIZZA(m_wxwindow)->bin_window; - do_shape_combine_region(window, region); + gtk_window_set_keep_above(GTK_WINDOW(m_widget), + m_windowStyle & wxSTAY_ON_TOP); + } + + if ( styleChanges & wxFRAME_NO_TASKBAR ) + { + gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), + m_windowStyle & wxFRAME_NO_TASKBAR); } - window = m_widget->window; - return do_shape_combine_region(window, region); } -// vi:sts=4:sw=4:et +bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha) +{ + GdkWindow* window = NULL; + if (m_widget) + window = gtk_widget_get_window(m_widget); + if (window == NULL) + return false; + +#ifdef GDK_WINDOWING_X11 + Display* dpy = GDK_WINDOW_XDISPLAY(window); + Window win = GDK_WINDOW_XID(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; +#else // !GDK_WINDOWING_X11 + return false; +#endif // GDK_WINDOWING_X11 / !GDK_WINDOWING_X11 +} + +bool wxTopLevelWindowGTK::CanSetTransparent() +{ + // allow to override automatic detection as it's far from perfect + const wxString SYSOPT_TRANSPARENT = "gtk.tlw.can-set-transparent"; + if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT) ) + { + return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT) != 0; + } + +#ifdef __WXGTK3__ + return gtk_widget_is_composited(m_widget) != 0; +#else +#if GTK_CHECK_VERSION(2,10,0) + if (!gtk_check_version(2,10,0)) + { + return gtk_widget_is_composited(m_widget) != 0; + } + else +#endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves + { + return false; + } +#endif // !__WXGTK3__ + +#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 +}