Add missing WXK constants for the control keys

[wxWidgets.git] / src / gtk1 / toplevel.cpp

diff --git a/src/gtk1/toplevel.cpp b/src/gtk1/toplevel.cpp
index f6761890955e249842f22d5e5ff0634113facd42..22364cdcdc59e00a6b0f085136cacee9e2d39d95 100644 (file)
--- a/src/gtk1/toplevel.cpp
+++ b/src/gtk1/toplevel.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        toplevel.cpp
+// Name:        src/gtk1/toplevel.cpp

 // Purpose:
 // Author:      Robert Roebling
 // Id:          $Id$
 // Purpose:
 // Author:      Robert Roebling
 // Id:          $Id$


@@ -7,6 +7,9 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+

 // ============================================================================
 // declarations
 // ============================================================================
 // ============================================================================
 // declarations
 // ============================================================================


@@ -15,27 +18,24 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // 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
 
 #ifdef __VMS
 #define XIconifyWindow XICONIFYWINDOW
 #endif
 

-#include "wx/defs.h"
+#include "wx/toplevel.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/log.h"
+    #include "wx/app.h"
+    #include "wx/dcclient.h"
+    #include "wx/dialog.h"
+    #include "wx/timer.h"
+    #include "wx/settings.h"
+    #include "wx/control.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/settings.h"
+#include "wx/gtk1/private.h"
+#include "wx/evtloop.h"

 
 #include <glib.h>
 #include <gdk/gdk.h>
 
 #include <glib.h>
 #include <gdk/gdk.h>


@@ -43,7 +43,7 @@
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
 
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
 

-#include "wx/gtk/win_gtk.h"
+#include "wx/gtk1/win_gtk.h"

 
 #include "wx/unix/utilsx11.h"
 
 
 #include "wx/unix/utilsx11.h"
 


@@ -61,33 +61,67 @@ extern bool g_isIdle;
 // data
 // ----------------------------------------------------------------------------
 
 // data
 // ----------------------------------------------------------------------------
 

-extern wxList           wxPendingDelete;
-

 extern int              g_openDialogs;
 extern wxWindowGTK     *g_delayedFocus;
 
 // the frame that is currently active (i.e. its child has focus). It is
 // used to generate wxActivateEvents
 extern int              g_openDialogs;
 extern wxWindowGTK     *g_delayedFocus;
 
 // 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;
+static wxTopLevelWindowGTK *g_activeFrame = NULL;
+static wxTopLevelWindowGTK *g_lastActiveFrame = 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
 
 // 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;
+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 gint gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK *win )
+{
+    wxgtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE);
+
+    win->m_urgency_hint = -2;
+    return FALSE;
+}
+}

 
 //-----------------------------------------------------------------------------
 // "focus_in_event"
 //-----------------------------------------------------------------------------
 
 
 //-----------------------------------------------------------------------------
 // "focus_in_event"
 //-----------------------------------------------------------------------------
 

+extern "C" {

 static gint gtk_frame_focus_in_callback( GtkWidget *widget,
                                          GdkEvent *WXUNUSED(event),
                                          wxTopLevelWindowGTK *win )
 {
     if (g_isIdle)
         wxapp_install_idle_handler();
 static gint gtk_frame_focus_in_callback( GtkWidget *widget,
                                          GdkEvent *WXUNUSED(event),
                                          wxTopLevelWindowGTK *win )
 {
     if (g_isIdle)
         wxapp_install_idle_handler();

-        
+

     switch ( g_sendActivateEvent )
     {
         case -1:
     switch ( g_sendActivateEvent )
     {
         case -1:


@@ -104,24 +138,41 @@ static gint gtk_frame_focus_in_callback( GtkWidget *widget,
 
     g_activeFrame = win;
     g_lastActiveFrame = g_activeFrame;
 
     g_activeFrame = win;
     g_lastActiveFrame = g_activeFrame;

-        
+

     // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
     // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );

-        
+
+    // MR: wxRequestUserAttention related block
+    switch( win->m_urgency_hint )
+    {
+        default:
+            gtk_timeout_remove( win->m_urgency_hint );
+            // no break, fallthrough to remove hint too
+        case -1:
+            wxgtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
+
+            win->m_urgency_hint = -2;
+            break;
+
+        case -2: break;
+    }
+

     wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
     wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);

-    wxActivateEvent event(wxEVT_ACTIVATE, TRUE, g_activeFrame->GetId());
+    wxActivateEvent event(wxEVT_ACTIVATE, true, g_activeFrame->GetId());

     event.SetEventObject(g_activeFrame);
     event.SetEventObject(g_activeFrame);

-    g_activeFrame->GetEventHandler()->ProcessEvent(event);
+    g_activeFrame->HandleWindowEvent(event);

 
     return FALSE;
 }
 
     return FALSE;
 }

+}

 
 //-----------------------------------------------------------------------------
 // "focus_out_event"
 //-----------------------------------------------------------------------------
 
 
 //-----------------------------------------------------------------------------
 // "focus_out_event"
 //-----------------------------------------------------------------------------
 

-static gint gtk_frame_focus_out_callback( GtkWidget *widget, 
-                                          GdkEventFocus *WXUNUSED(gdk_event), 
-                                          wxTopLevelWindowGTK *win )
+extern "C" {
+static gint gtk_frame_focus_out_callback( GtkWidget *WXUNUSED(widget),
+                                          GdkEventFocus *WXUNUSED(gdk_event),
+                                          wxTopLevelWindowGTK *WXUNUSED(win) )

 {
     if (g_isIdle)
         wxapp_install_idle_handler();
 {
     if (g_isIdle)
         wxapp_install_idle_handler();


@@ -130,25 +181,30 @@ static gint gtk_frame_focus_out_callback( GtkWidget *widget,
     // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
     // g_sendActivateEvent to -1
     g_sendActivateEvent = 0;
     // 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") );
     // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );

-        
+

     // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
     // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );

-        
-    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;
-        
+    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;
 }
     return FALSE;
 }

+}

 
 //-----------------------------------------------------------------------------
 // "focus" from m_window
 //-----------------------------------------------------------------------------
 
 
 //-----------------------------------------------------------------------------
 // "focus" from m_window
 //-----------------------------------------------------------------------------
 

+extern "C" {

 static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
 {
     if (g_isIdle)
 static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
 {
     if (g_isIdle)


@@ -158,11 +214,13 @@ static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUS
     gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" );
     return TRUE;
 }
     gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" );
     return TRUE;
 }

+}

 
 //-----------------------------------------------------------------------------
 // "size_allocate"
 //-----------------------------------------------------------------------------
 
 
 //-----------------------------------------------------------------------------
 // "size_allocate"
 //-----------------------------------------------------------------------------
 

+extern "C" {

 static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win )
 {
     if (g_isIdle)
 static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win )
 {
     if (g_isIdle)


@@ -188,11 +246,13 @@ static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
         win->GtkUpdateSize();
     }
 }
         win->GtkUpdateSize();
     }
 }

+}

 
 //-----------------------------------------------------------------------------
 // "delete_event"
 //-----------------------------------------------------------------------------
 
 
 //-----------------------------------------------------------------------------
 // "delete_event"
 //-----------------------------------------------------------------------------
 

+extern "C" {

 static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxTopLevelWindowGTK *win )
 {
     if (g_isIdle)
 static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxTopLevelWindowGTK *win )
 {
     if (g_isIdle)


@@ -205,12 +265,14 @@ static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WX
 
     return TRUE;
 }
 
     return TRUE;
 }

+}

 
 
 //-----------------------------------------------------------------------------
 // "configure_event"
 //-----------------------------------------------------------------------------
 
 
 
 //-----------------------------------------------------------------------------
 // "configure_event"
 //-----------------------------------------------------------------------------
 

+extern "C" {

 static gint
 gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxTopLevelWindowGTK *win )
 {
 static gint
 gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxTopLevelWindowGTK *win )
 {


@@ -220,6 +282,7 @@ gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WX
     if (!win->m_hasVMT || !win->IsShown())
         return FALSE;
 
     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 );
     int x = 0;
     int y = 0;
     gdk_window_get_root_origin( win->m_widget->window, &x, &y );


@@ -228,10 +291,11 @@ gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WX
 
     wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
     mevent.SetEventObject( win );
 
     wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
     mevent.SetEventObject( win );

-    win->GetEventHandler()->ProcessEvent( mevent );
+    win->HandleWindowEvent( mevent );

 
     return FALSE;
 }
 
     return FALSE;
 }

+}

 
 //-----------------------------------------------------------------------------
 // "realize" from m_widget
 
 //-----------------------------------------------------------------------------
 // "realize" from m_widget


@@ -240,6 +304,7 @@ gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WX
 // we cannot MWM hints and icons before the widget has been realized,
 // so we do this directly after realization
 
 // 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 )
 static void
 gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
                              wxTopLevelWindowGTK *win )


@@ -262,41 +327,47 @@ gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
 
     // reset the icon
     wxIconBundle iconsOld = win->GetIcons();
 
     // reset the icon
     wxIconBundle iconsOld = win->GetIcons();

-    if ( iconsOld.GetIcon(-1).Ok() )
+    if ( !iconsOld.IsEmpty() )

     {
         win->SetIcon( wxNullIcon );
         win->SetIcons( iconsOld );
     }
 }
     {
         win->SetIcon( wxNullIcon );
         win->SetIcons( iconsOld );
     }
 }

+}

 
 //-----------------------------------------------------------------------------
 // "map_event" from m_widget
 //-----------------------------------------------------------------------------
 
 
 //-----------------------------------------------------------------------------
 // "map_event" from m_widget
 //-----------------------------------------------------------------------------
 

+extern "C" {

 static void
 gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
                         GdkEvent * WXUNUSED(event),
                         wxTopLevelWindow *win )
 {
 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
 //-----------------------------------------------------------------------------
 
 }
 
 //-----------------------------------------------------------------------------
 // "unmap_event" from m_widget
 //-----------------------------------------------------------------------------
 

+extern "C" {

 static void
 gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
                           GdkEvent * WXUNUSED(event),
                           wxTopLevelWindow *win )
 {
 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
 //-----------------------------------------------------------------------------
 
 }
 
 //-----------------------------------------------------------------------------
 // "expose_event" of m_client
 //-----------------------------------------------------------------------------
 

+extern "C" {

 static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )
 {
     GtkPizza *pizza = GTK_PIZZA(widget);
 static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )
 {
     GtkPizza *pizza = GTK_PIZZA(widget);


@@ -311,13 +382,13 @@ static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_ev
 
     return FALSE;
 }
 
     return FALSE;
 }

+}

 
 //-----------------------------------------------------------------------------
 // "draw" of m_client
 //-----------------------------------------------------------------------------
 
 
 //-----------------------------------------------------------------------------
 // "draw" of m_client
 //-----------------------------------------------------------------------------
 

-#ifndef __WXGTK20__
-
+extern "C" {

 static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win )
 {
     GtkPizza *pizza = GTK_PIZZA(widget);
 static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win )
 {
     GtkPizza *pizza = GTK_PIZZA(widget);


@@ -330,8 +401,7 @@ static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxW
                         (char *)"base",
                         0, 0, -1, -1);
 }
                         (char *)"base",
                         0, 0, -1, -1);
 }

-
-#endif // GTK+ 1.x
+}

 
 // ----------------------------------------------------------------------------
 // wxTopLevelWindowGTK itself
 
 // ----------------------------------------------------------------------------
 // wxTopLevelWindowGTK itself


@@ -382,16 +452,18 @@ static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow
 
 void wxTopLevelWindowGTK::Init()
 {
 
 void wxTopLevelWindowGTK::Init()
 {

-    m_sizeSet = FALSE;
+    m_sizeSet = false;

     m_miniEdge = 0;
     m_miniTitle = 0;
     m_miniEdge = 0;
     m_miniTitle = 0;

-    m_mainWidget = (GtkWidget*) NULL;
-    m_insertInClientArea = TRUE;
-    m_isIconized = FALSE;
-    m_fsIsShowing = FALSE;
-    m_themeEnabled = TRUE;
+    m_mainWidget = NULL;
+    m_insertInClientArea = true;
+    m_isIconized = false;
+    m_fsIsShowing = false;
+    m_themeEnabled = true;

     m_gdkDecor = m_gdkFunc = 0;
     m_gdkDecor = m_gdkFunc = 0;

-    m_grabbed = FALSE;
+    m_grabbed = false;
+
+    m_urgency_hint = -2;

 }
 
 bool wxTopLevelWindowGTK::Create( wxWindow *parent,
 }
 
 bool wxTopLevelWindowGTK::Create( wxWindow *parent,


@@ -410,13 +482,13 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
 
     wxTopLevelWindows.Append( this );
 
 
     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") );
 
     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_title = title;


@@ -427,47 +499,44 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
     //     e.g. in wxTaskBarIconAreaGTK
     if (m_widget == NULL)
     {
     //     e.g. in wxTaskBarIconAreaGTK
     if (m_widget == NULL)
     {

-        GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;
-        if (style & wxFRAME_TOOL_WINDOW)
-            win_type = GTK_WINDOW_POPUP;
-

         if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
         {
         if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
         {

-#ifdef __WXGTK20__
-            m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
-            // Tell WM that this is a dialog window and make it center
-            // on parent by default (this is what GtkDialog ctor does):
-            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_DIALOG);
             m_widget = gtk_window_new(GTK_WINDOW_DIALOG);

-#endif

         }
         else
         {
         }
         else
         {

-            m_widget = gtk_window_new(win_type);
+            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

         }
     }
 
     wxWindow *topParent = wxGetTopLevelParent(m_parent);
     if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
         }
     }
 
     wxWindow *topParent = wxGetTopLevelParent(m_parent);
     if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&

-                     (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
-                    (style & wxFRAME_FLOAT_ON_PARENT)))
+                       (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
+                       (style & wxFRAME_FLOAT_ON_PARENT)))

     {
         gtk_window_set_transient_for( GTK_WINDOW(m_widget),
                                       GTK_WINDOW(topParent->m_widget) );
     }
 
     {
         gtk_window_set_transient_for( GTK_WINDOW(m_widget),
                                       GTK_WINDOW(topParent->m_widget) );
     }
 

-#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 (!name.IsEmpty())
+    if (!name.empty())

         gtk_window_set_wmclass( GTK_WINDOW(m_widget), wxGTK_CONV( name ), wxGTK_CONV( name ) );
 
     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
         gtk_window_set_wmclass( GTK_WINDOW(m_widget), wxGTK_CONV( name ), wxGTK_CONV( name ) );
 
     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );


@@ -487,10 +556,8 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
        // For m_mainWidget themes
        gtk_signal_connect( GTK_OBJECT(m_mainWidget), "expose_event",
                 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
        // 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 );
        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 only represents the client area without toolbar and menubar


@@ -520,10 +587,6 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
     gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
                         GTK_SIGNAL_FUNC(gtk_frame_realized_callback), (gpointer) this );
 
     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 );
-

     // map and unmap for iconized state
     gtk_signal_connect( GTK_OBJECT(m_widget), "map_event",
         GTK_SIGNAL_FUNC(gtk_frame_map_callback), (gpointer)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 );


@@ -543,7 +606,7 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
         GTK_SIGNAL_FUNC(gtk_frame_focus_in_callback), (gpointer)this );
     gtk_signal_connect( GTK_OBJECT(m_widget), "focus_out_event",
         GTK_SIGNAL_FUNC(gtk_frame_focus_out_callback), (gpointer)this );
         GTK_SIGNAL_FUNC(gtk_frame_focus_in_callback), (gpointer)this );
     gtk_signal_connect( GTK_OBJECT(m_widget), "focus_out_event",
         GTK_SIGNAL_FUNC(gtk_frame_focus_out_callback), (gpointer)this );

-            
+

     // decorations
     if ((m_miniEdge > 0) || (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER))
     {
     // decorations
     if ((m_miniEdge > 0) || (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER))
     {


@@ -586,25 +649,25 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
         }
     }
 
         }
     }
 

-    return TRUE;
+    return true;

 }
 
 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
 {
     if (m_grabbed)
     {
 }
 
 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
 {
     if (m_grabbed)
     {

-        wxASSERT_MSG( FALSE, _T("Window still grabbed"));
+        wxASSERT_MSG( false, wxT("Window still grabbed"));

         RemoveGrab();
     }
 
         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 );
     }
 
     // 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)
     if (g_activeFrame == this)
         g_activeFrame = NULL;
     if (g_lastActiveFrame == this)


@@ -615,71 +678,93 @@ wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
 
 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
 {
 
 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;
 
 
     m_fsIsShowing = show;
 

-    GdkWindow *window = m_widget->window;

     wxX11FullScreenMethod method =
         wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(),
                                  (WXWindow)GDK_ROOT_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
     }
     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;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -700,9 +785,17 @@ bool wxTopLevelWindowGTK::Show( bool show )
         GtkOnSize( m_x, m_y, m_width, m_height );
     }
 
         GtkOnSize( m_x, m_y, m_width, m_height );
     }
 

+    if (show)
+        gtk_widget_set_uposition( m_widget, m_x, m_y );
+

     return wxWindow::Show( show );
 }
 
     return wxWindow::Show( show );
 }
 

+void wxTopLevelWindowGTK::Raise()
+{
+    wxWindow::Raise();
+}
+

 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
 {
     wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
 {
     wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );


@@ -718,7 +811,7 @@ void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int si
     // avoid recursions
     if (m_resizing)
         return;
     // avoid recursions
     if (m_resizing)
         return;

-    m_resizing = TRUE;
+    m_resizing = true;

 
     int old_x = m_x;
     int old_y = m_y;
 
     int old_x = m_x;
     int old_y = m_y;


@@ -765,7 +858,7 @@ void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int si
     maxWidth = -1;
     maxHeight = -1;
 #endif
     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 ((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;


@@ -789,10 +882,10 @@ void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int si
         /* 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. */
         /* 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
 }
 
 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const


@@ -828,7 +921,7 @@ void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
 
     // avoid recursions
     if (m_resizing) return;
 
     // avoid recursions
     if (m_resizing) return;

-    m_resizing = TRUE;
+    m_resizing = true;

 
     if ( m_wxwindow == NULL ) return;
 
 
     if ( m_wxwindow == NULL ) return;
 


@@ -856,7 +949,7 @@ void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
     maxWidth = -1;
     maxHeight = -1;
 #endif
     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 ((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;


@@ -897,7 +990,7 @@ void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
                             : maxHeight ;
 
         gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
                             : maxHeight ;
 
         gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),

-                                       (GtkWidget*) NULL,
+                                       NULL,

                                        &geom,
                                        (GdkWindowHints) flag );
 
                                        &geom,
                                        (GdkWindowHints) flag );
 


@@ -922,14 +1015,14 @@ void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
         // is no need to set the size or position of m_wxwindow.
     }
 
         // 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 );
 
     // send size event to frame
     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
     event.SetEventObject( this );

-    GetEventHandler()->ProcessEvent( event );
+    HandleWindowEvent( event );

 
 

-    m_resizing = FALSE;
+    m_resizing = false;

 }
 
 void wxTopLevelWindowGTK::OnInternalIdle()
 }
 
 void wxTopLevelWindowGTK::OnInternalIdle()


@@ -950,8 +1043,8 @@ void wxTopLevelWindowGTK::OnInternalIdle()
         if ( g_delayedFocus &&
              wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
         {
         if ( g_delayedFocus &&
              wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
         {

-            wxLogTrace(_T("focus"),
-                       _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
+            wxLogTrace(wxT("focus"),
+                       wxT("Setting focus from wxTLW::OnIdle() to %s(%s)"),

                        g_delayedFocus->GetClassInfo()->GetClassName(),
                        g_delayedFocus->GetLabel().c_str());
 
                        g_delayedFocus->GetClassInfo()->GetClassName(),
                        g_delayedFocus->GetLabel().c_str());
 


@@ -961,15 +1054,15 @@ void wxTopLevelWindowGTK::OnInternalIdle()
     }
 
     wxWindow::OnInternalIdle();
     }
 
     wxWindow::OnInternalIdle();

-    
+

     // Synthetize activate events.
     if ( g_sendActivateEvent != -1 )
     {
         bool activate = g_sendActivateEvent != 0;
     // Synthetize activate events.
     if ( g_sendActivateEvent != -1 )
     {
         bool activate = g_sendActivateEvent != 0;

-        
+

         // if (!activate) wxPrintf( wxT("de") );
         // wxPrintf( wxT("activate\n") );
         // if (!activate) wxPrintf( wxT("de") );
         // wxPrintf( wxT("activate\n") );

-        
+

         // do it only once
         g_sendActivateEvent = -1;
 
         // do it only once
         g_sendActivateEvent = -1;
 


@@ -985,13 +1078,12 @@ void wxTopLevelWindowGTK::SetTitle( const wxString &title )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 

+    if ( title == m_title )
+        return;
+

     m_title = title;
     m_title = title;

-    gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
-}

 
 

-void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon )
-{
-    SetIcons( wxIconBundle( icon ) );
+    gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );

 }
 
 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
 }
 
 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )


@@ -1000,101 +1092,62 @@ void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
 
     wxTopLevelWindowBase::SetIcons( icons );
 
 
     wxTopLevelWindowBase::SetIcons( icons );
 

-#ifdef __WXGTK20__
-    GList *list = NULL;
-    size_t max = icons.m_icons.GetCount();
+    if ( icons.IsEmpty() )
+        return;

 
 

-    for (size_t i = 0; i < max; i++)
-    {
-        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);
-    
-#else // !__WXGTK20__

     GdkWindow* window = m_widget->window;
     if (!window)
         return;
 
     wxIcon icon = icons.GetIcon(-1);
     GdkWindow* window = m_widget->window;
     if (!window)
         return;
 
     wxIcon icon = icons.GetIcon(-1);

-    if (icon.Ok())
+    if (icon.IsOk())

     {
         wxMask *mask = icon.GetMask();
     {
         wxMask *mask = icon.GetMask();

-        GdkBitmap *bm = (GdkBitmap *) NULL;
+        GdkBitmap *bm = NULL;

         if (mask) bm = mask->GetBitmap();
 
         if (mask) bm = mask->GetBitmap();
 

-        gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
+        gdk_window_set_icon( m_widget->window, NULL, icon.GetPixmap(), bm );

     }
 
     wxSetIconsX11( (WXDisplay*)GDK_WINDOW_XDISPLAY( window ),
                    (WXWindow)GDK_WINDOW_XWINDOW( window ), icons );
     }
 
     wxSetIconsX11( (WXDisplay*)GDK_WINDOW_XDISPLAY( window ),
                    (WXWindow)GDK_WINDOW_XWINDOW( window ), icons );

-#endif // !__WXGTK20__

 }
 
 // ----------------------------------------------------------------------------
 // frame state: maximized/iconized/normal
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // frame state: maximized/iconized/normal
 // ----------------------------------------------------------------------------
 

-void wxTopLevelWindowGTK::Maximize(bool maximize)
+void wxTopLevelWindowGTK::Maximize(bool WXUNUSED(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
+    wxFAIL_MSG( wxT("not implemented") );

 }
 
 bool wxTopLevelWindowGTK::IsMaximized() const
 {
 }
 
 bool wxTopLevelWindowGTK::IsMaximized() const
 {

-#ifdef __WXGTK20__
-    if(!m_widget->window)
-        return false;
-
-    return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
-#else
-  //    wxFAIL_MSG( _T("not implemented") );
+  //    wxFAIL_MSG( wxT("not implemented") );

 
     // This is an approximation
 
     // This is an approximation

-    return FALSE;
-#endif
+    return false;

 }
 
 void wxTopLevelWindowGTK::Restore()
 {
 }
 
 void wxTopLevelWindowGTK::Restore()
 {

-#ifdef __WXGTK20__
-    // "Present" seems similar enough to "restore"
-    gtk_window_present( GTK_WINDOW( m_widget ) );
-#else
-    wxFAIL_MSG( _T("not implemented") );
-#endif
+    wxFAIL_MSG( wxT("not implemented") );

 }
 
 void wxTopLevelWindowGTK::Iconize( bool iconize )
 {
 }
 
 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
    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") );
+       wxCHECK_RET( window, wxT("frame not created yet - can't iconize") );

 
        XIconifyWindow( GDK_WINDOW_XDISPLAY( window ),
                        GDK_WINDOW_XWINDOW( window ),
                        DefaultScreen( GDK_DISPLAY() ) );
    }
 
        XIconifyWindow( GDK_WINDOW_XDISPLAY( window ),
                        GDK_WINDOW_XWINDOW( window ),
                        DefaultScreen( GDK_DISPLAY() ) );
    }

-#endif

 }
 
 bool wxTopLevelWindowGTK::IsIconized() const
 }
 
 bool wxTopLevelWindowGTK::IsIconized() const


@@ -1115,9 +1168,9 @@ void wxTopLevelWindowGTK::AddGrab()
 {
     if (!m_grabbed)
     {
 {
     if (!m_grabbed)
     {

-        m_grabbed = TRUE;
+        m_grabbed = true;

         gtk_grab_add( m_widget );
         gtk_grab_add( m_widget );

-        gtk_main();
+        wxEventLoop().Run();

         gtk_grab_remove( m_widget );
     }
 }
         gtk_grab_remove( m_widget );
     }
 }


@@ -1127,7 +1180,7 @@ void wxTopLevelWindowGTK::RemoveGrab()
     if (m_grabbed)
     {
         gtk_main_quit();
     if (m_grabbed)
     {
         gtk_main_quit();

-        m_grabbed = FALSE;
+        m_grabbed = false;

     }
 }
 
     }
 }
 


@@ -1143,25 +1196,21 @@ static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
         }
         else
         {
         }
         else
         {

-#ifdef __WXGTK20__
-        gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
-#else
-        wxBitmap bmp = region.ConvertToBitmap();
-        bmp.SetMask(new wxMask(bmp, *wxBLACK));
-        GdkBitmap* mask = bmp.GetMask()->GetBitmap();
-        gdk_window_shape_combine_mask(window, mask, 0, 0);
-#endif
-        return TRUE;
+            wxBitmap bmp = region.ConvertToBitmap();
+            bmp.SetMask(new wxMask(bmp, *wxBLACK));
+            GdkBitmap* mask = bmp.GetMask()->GetBitmap();
+            gdk_window_shape_combine_mask(window, mask, 0, 0);
+            return true;

         }
     }
         }
     }

-    return FALSE;
+    return false;

 }
 
 
 bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
 {
 }
 
 
 bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
 {

-    wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), FALSE,
-                 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
+    wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
+                 wxT("Shaped windows must be created with the wxFRAME_SHAPED style."));

 
     GdkWindow *window = NULL;
     if (m_wxwindow)
 
     GdkWindow *window = NULL;
     if (m_wxwindow)


@@ -1178,3 +1227,39 @@ bool wxTopLevelWindowGTK::IsActive()
     return (this == (wxTopLevelWindowGTK*)g_activeFrame);
 }
 
     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)
+        gtk_timeout_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 = gtk_timeout_add(5000, (GtkFunction)gtk_frame_urgency_timer_callback, this);
+        } else {
+            m_urgency_hint = -1;
+        }
+    }
+
+    wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
+}
+
+void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
+{
+    // Process wxWindow styles. This also updates the internal variable
+    // Therefore m_windowStyle bits carry now the _new_ style values
+    wxWindow::SetWindowStyleFlag(style);
+}