X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/f6bcfd974ef26faf6f91a62cac09827e09463fd1..70050c82fe8114fc5d86591035e71751bac21cc6:/src/gtk/frame.cpp

diff --git a/src/gtk/frame.cpp b/src/gtk/frame.cpp
index 8773d721d2..18d58ae61e 100644
--- a/src/gtk/frame.cpp
+++ b/src/gtk/frame.cpp
@@ -19,6 +19,10 @@
     #pragma implementation "frame.h"
 #endif
 
+#ifdef __VMS
+#define XIconifyWindow XICONIFYWINDOW
+#endif
+
 #include "wx/frame.h"
 #include "wx/dialog.h"
 #include "wx/control.h"
@@ -60,7 +64,11 @@ extern int g_openDialogs;
 // event tables
 // ----------------------------------------------------------------------------
 
-IMPLEMENT_DYNAMIC_CLASS(wxFrame,wxWindow)
+#ifdef __WXUNIVERSAL__
+    IMPLEMENT_DYNAMIC_CLASS(wxFrameGTK, wxWindow)
+#else
+    IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
+#endif
 
 // ----------------------------------------------------------------------------
 // data
@@ -104,7 +112,7 @@ static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUS
 // "size_allocate"
 //-----------------------------------------------------------------------------
 
-static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxFrame *win )
+static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxFrameGTK *win )
 {
     if (g_isIdle)
         wxapp_install_idle_handler();
@@ -135,7 +143,7 @@ static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
 // "delete_event"
 //-----------------------------------------------------------------------------
 
-static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxFrame *win )
+static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxFrameGTK *win )
 {
     if (g_isIdle)
         wxapp_install_idle_handler();
@@ -146,11 +154,12 @@ static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WX
     return TRUE;
 }
 
+#if wxUSE_MENUS
 //-----------------------------------------------------------------------------
 // "child_attached" of menu bar
 //-----------------------------------------------------------------------------
 
-static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
+static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrameGTK *win )
 {
     if (!win->m_hasVMT) return;
 
@@ -162,20 +171,21 @@ static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *
 // "child_detached" of menu bar
 //-----------------------------------------------------------------------------
 
-static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
+static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrameGTK *win )
 {
     if (!win->m_hasVMT) return;
 
     win->m_menuBarDetached = TRUE;
     win->GtkUpdateSize();
 }
+#endif // wxUSE_MENUS
 
 #if wxUSE_TOOLBAR
 //-----------------------------------------------------------------------------
 // "child_attached" of tool bar
 //-----------------------------------------------------------------------------
 
-static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
+static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrameGTK *win )
 {
     if (!win->m_hasVMT) return;
 
@@ -188,7 +198,7 @@ static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidge
 // "child_detached" of tool bar
 //-----------------------------------------------------------------------------
 
-static void gtk_toolbar_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
+static void gtk_toolbar_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrameGTK *win )
 {
     if (g_isIdle)
         wxapp_install_idle_handler();
@@ -206,9 +216,9 @@ static void gtk_toolbar_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidge
 
 static gint
 #if (GTK_MINOR_VERSION > 0)
-gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxFrame *win )
+gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxFrameGTK *win )
 #else
-gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *event, wxFrame *win )
+gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *event, wxFrameGTK *win )
 #endif
 {
     if (g_isIdle)
@@ -242,13 +252,13 @@ gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *ev
 /* we cannot MWM hints and icons before the widget has been realized,
    so we do this directly after realization */
 
-static gint
-gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), wxFrame *win )
+static void
+gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), wxFrameGTK *win )
 {
     if (g_isIdle)
         wxapp_install_idle_handler();
 
-    if ((win->m_miniEdge > 0) || (win->HasFlag(wxSIMPLE_BORDER)))
+    if ((win->m_miniEdge > 0) || (win->HasFlag(wxSIMPLE_BORDER)) || (win->HasFlag(wxNO_BORDER)))
     {
         /* This is a mini-frame or a borderless frame. */
         gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)0 );
@@ -317,31 +327,80 @@ gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), wxFrame *win )
 
         node = node->GetNext();
     }
+}
 
-    return FALSE;
+//-----------------------------------------------------------------------------
+// "map_event" from m_widget
+//-----------------------------------------------------------------------------
+
+static void
+gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
+                        GdkEvent * WXUNUSED(event),
+                        wxFrame *win )
+{
+    win->SetIconizeState(FALSE);
+}
+
+//-----------------------------------------------------------------------------
+// "unmap_event" from m_widget
+//-----------------------------------------------------------------------------
+
+static void
+gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
+                          GdkEvent * WXUNUSED(event),
+                          wxFrame *win )
+{
+    win->SetIconizeState(TRUE);
+}
+
+//-----------------------------------------------------------------------------
+// "expose_event" of m_client
+//-----------------------------------------------------------------------------
+
+static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )
+{
+    GtkPizza *pizza = GTK_PIZZA(widget);
+
+    gtk_paint_flat_box (win->m_widget->style, pizza->bin_window, GTK_STATE_NORMAL,
+                GTK_SHADOW_NONE, &gdk_event->area, win->m_widget, "base", 0, 0, -1, -1);
+
+    return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+// "draw" of m_client
+//-----------------------------------------------------------------------------
+
+
+static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win )
+{
+    GtkPizza *pizza = GTK_PIZZA(widget);
+
+    gtk_paint_flat_box (win->m_widget->style, pizza->bin_window, GTK_STATE_NORMAL,
+                GTK_SHADOW_NONE, rect, win->m_widget, "base", 0, 0, -1, -1);
 }
 
 // ----------------------------------------------------------------------------
-// wxFrame itself
+// wxFrameGTK itself
 // ----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
-// InsertChild for wxFrame
+// InsertChild for wxFrameGTK
 //-----------------------------------------------------------------------------
 
-/* Callback for wxFrame. This very strange beast has to be used because
+/* Callback for wxFrameGTK. 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 wxInsertChildInFrame( wxFrame* parent, wxWindow* child )
+static void wxInsertChildInFrame( wxFrameGTK* parent, wxWindow* child )
 {
     wxASSERT( GTK_IS_WIDGET(child->m_widget) );
 
     if (!parent->m_insertInClientArea)
     {
         /* these are outside the client area */
-        wxFrame* frame = (wxFrame*) parent;
+        wxFrameGTK* frame = (wxFrameGTK*) parent;
         gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
                          GTK_WIDGET(child->m_widget),
                          child->m_x,
@@ -382,10 +441,10 @@ static void wxInsertChildInFrame( wxFrame* parent, wxWindow* child )
 }
 
 // ----------------------------------------------------------------------------
-// wxFrame creation
+// wxFrameGTK creation
 // ----------------------------------------------------------------------------
 
-void wxFrame::Init()
+void wxFrameGTK::Init()
 {
     m_sizeSet = FALSE;
     m_miniEdge = 0;
@@ -394,16 +453,32 @@ void wxFrame::Init()
     m_menuBarDetached = FALSE;
     m_toolBarDetached = FALSE;
     m_insertInClientArea = TRUE;
+    m_isFrame = TRUE;
+    m_isIconized = FALSE;
+    m_fsIsShowing = FALSE;
+    m_themeEnabled = TRUE;
 }
 
-bool wxFrame::Create( wxWindow *parent,
+bool wxFrameGTK::Create( wxWindow *parent,
                       wxWindowID id,
-                      const wxString &title,
-                      const wxPoint &pos,
-                      const wxSize &size,
+                      const wxString& title,
+                      const wxPoint& pos,
+                      const wxSize& sizeOrig,
                       long style,
                       const wxString &name )
 {
+    // always create a frame of some reasonable, even if arbitrary, size (at
+    // least for MSW compatibility)
+    wxSize size = sizeOrig;
+    if ( size.x == -1 || size.y == -1 )
+    {
+        wxSize sizeDpy = wxGetDisplaySize();
+        if ( size.x == -1 )
+            size.x = sizeDpy.x / 3;
+        if ( size.y == -1 )
+            size.y = sizeDpy.y / 5;
+    }
+
     wxTopLevelWindows.Append( this );
 
     m_needParent = FALSE;
@@ -411,7 +486,7 @@ bool wxFrame::Create( wxWindow *parent,
     if (!PreCreation( parent, pos, size ) ||
         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
     {
-        wxFAIL_MSG( wxT("wxFrame creation failed") );
+        wxFAIL_MSG( wxT("wxFrameGTK creation failed") );
         return FALSE;
     }
 
@@ -421,6 +496,9 @@ bool wxFrame::Create( wxWindow *parent,
 
     GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;
 
+    if (style & wxFRAME_TOOL_WINDOW)
+        win_type = GTK_WINDOW_POPUP;
+
     m_widget = gtk_window_new( win_type );
 
     if ((m_parent) && (HasFlag(wxFRAME_FLOAT_ON_PARENT)) && (GTK_IS_WINDOW(m_parent->m_widget)))
@@ -430,7 +508,7 @@ bool wxFrame::Create( wxWindow *parent,
         gtk_window_set_wmclass( GTK_WINDOW(m_widget), name.mb_str(), name.mb_str() );
 
 #ifdef __WXDEBUG__
-    debug_focus_in( m_widget, wxT("wxFrame::m_widget"), name );
+    debug_focus_in( m_widget, wxT("wxFrameGTK::m_widget"), name );
 #endif
 
     gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
@@ -445,8 +523,14 @@ bool wxFrame::Create( wxWindow *parent,
     GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
     gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
 
+    /* for m_mainWidget themes */
+    gtk_signal_connect( GTK_OBJECT(m_mainWidget), "expose_event",
+                GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
+    gtk_signal_connect( GTK_OBJECT(m_mainWidget), "draw",
+                GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
+
 #ifdef __WXDEBUG__
-    debug_focus_in( m_mainWidget, wxT("wxFrame::m_mainWidget"), name );
+    debug_focus_in( m_mainWidget, wxT("wxFrameGTK::m_mainWidget"), name );
 #endif
 
     /* m_wxwindow only represents the client area without toolbar and menubar */
@@ -455,11 +539,11 @@ bool wxFrame::Create( wxWindow *parent,
     gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
 
 #ifdef __WXDEBUG__
-    debug_focus_in( m_wxwindow, wxT("wxFrame::m_wxwindow"), name );
+    debug_focus_in( m_wxwindow, wxT("wxFrameGTK::m_wxwindow"), name );
 #endif
 
     /* we donm't allow the frame to get the focus as otherwise
-       the frame will grabit at arbitrary fcous changes. */
+       the frame will grab it at arbitrary focus changes. */
     GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
 
     if (m_parent) m_parent->AddChild( this );
@@ -483,6 +567,16 @@ bool wxFrame::Create( wxWindow *parent,
     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 );
+    gtk_signal_connect( GTK_OBJECT(m_widget), "unmap_event",
+        GTK_SIGNAL_FUNC(gtk_frame_unmap_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 );
+
     /* disable native tab traversal */
     gtk_signal_connect( GTK_OBJECT(m_widget), "focus",
         GTK_SIGNAL_FUNC(gtk_frame_focus_callback), (gpointer)this );
@@ -490,7 +584,7 @@ bool wxFrame::Create( wxWindow *parent,
     return TRUE;
 }
 
-wxFrame::~wxFrame()
+wxFrameGTK::~wxFrameGTK()
 {
     m_isBeingDeleted = TRUE;
 
@@ -508,11 +602,53 @@ wxFrame::~wxFrame()
     }
 }
 
+bool wxFrame::ShowFullScreen(bool show, long style )
+{
+    if (show == m_fsIsShowing) return FALSE; // return what?
+
+    m_fsIsShowing = show;
+
+    if (show)
+    {
+        m_fsSaveStyle = m_windowStyle;
+        m_fsSaveFlag = style;
+        GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
+        GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
+
+        gtk_widget_hide( m_widget );
+        gtk_widget_unrealize( m_widget );
+
+        m_windowStyle = wxSIMPLE_BORDER;
+
+        int x;
+        int y;
+        wxDisplaySize( &x, &y );
+        SetSize( 0, 0, x, y );
+
+        gtk_widget_realize( m_widget );
+        gtk_widget_show( m_widget );
+    }
+    else
+    {
+        gtk_widget_hide( m_widget );
+        gtk_widget_unrealize( m_widget );
+
+        m_windowStyle = m_fsSaveStyle;
+
+        SetSize( m_fsSaveFrame.x, m_fsSaveFrame.y, m_fsSaveFrame.width, m_fsSaveFrame.height );
+
+        gtk_widget_realize( m_widget );
+        gtk_widget_show( m_widget );
+    }
+
+    return TRUE;
+}
+
 // ----------------------------------------------------------------------------
 // overridden wxWindow methods
 // ----------------------------------------------------------------------------
 
-bool wxFrame::Show( bool show )
+bool wxFrameGTK::Show( bool show )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
@@ -529,16 +665,16 @@ bool wxFrame::Show( bool show )
     return wxWindow::Show( show );
 }
 
-void wxFrame::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
+void wxFrameGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
 {
-    wxFAIL_MSG( wxT("DoMoveWindow called for wxFrame") );
+    wxFAIL_MSG( wxT("DoMoveWindow called for wxFrameGTK") );
 }
 
-void wxFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
+void wxFrameGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
-    /* this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
+    /* this shouldn't happen: wxFrameGTK, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 
     /* avoid recursions */
@@ -605,13 +741,14 @@ void wxFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
     m_resizing = FALSE;
 }
 
-void wxFrame::DoGetClientSize( int *width, int *height ) const
+void wxFrameGTK::DoGetClientSize( int *width, int *height ) const
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
     wxWindow::DoGetClientSize( width, height );
     if (height)
     {
+#if wxUSE_MENUS
         /* menu bar */
         if (m_frameMenuBar)
         {
@@ -620,15 +757,16 @@ void wxFrame::DoGetClientSize( int *width, int *height ) const
             else
                 (*height) -= wxPLACE_HOLDER;
         }
+#endif // wxUSE_MENUS
 
 #if wxUSE_STATUSBAR
         /* status bar */
-        if (m_frameStatusBar) (*height) -= wxSTATUS_HEIGHT;
+        if (m_frameStatusBar && m_frameStatusBar->IsShown()) (*height) -= wxSTATUS_HEIGHT;
 #endif // wxUSE_STATUSBAR
 
 #if wxUSE_TOOLBAR
         /* tool bar */
-        if (m_frameToolBar)
+        if (m_frameToolBar && m_frameToolBar->IsShown())
         {
             if (m_toolBarDetached)
             {
@@ -659,10 +797,11 @@ void wxFrame::DoGetClientSize( int *width, int *height ) const
     }
 }
 
-void wxFrame::DoSetClientSize( int width, int height )
+void wxFrameGTK::DoSetClientSize( int width, int height )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
+#if wxUSE_MENUS
         /* menu bar */
         if (m_frameMenuBar)
         {
@@ -671,15 +810,16 @@ void wxFrame::DoSetClientSize( int width, int height )
             else
                 height += wxPLACE_HOLDER;
         }
+#endif // wxUSE_MENUS
 
 #if wxUSE_STATUSBAR
         /* status bar */
-        if (m_frameStatusBar) height += wxSTATUS_HEIGHT;
+        if (m_frameStatusBar && m_frameStatusBar->IsShown()) height += wxSTATUS_HEIGHT;
 #endif
 
 #if wxUSE_TOOLBAR
         /* tool bar */
-        if (m_frameToolBar)
+        if (m_frameToolBar && m_frameToolBar->IsShown())
         {
             if (m_toolBarDetached)
             {
@@ -704,7 +844,7 @@ void wxFrame::DoSetClientSize( int width, int height )
     DoSetSize( -1, -1, width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle, 0 );
 }
 
-void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
+void wxFrameGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
                          int width, int height )
 {
     // due to a bug in gtk, x,y are always 0
@@ -715,7 +855,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
     if (m_resizing) return;
     m_resizing = TRUE;
 
-    /* this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
+    /* this shouldn't happen: wxFrameGTK, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 
     m_width = width;
@@ -725,9 +865,9 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
     int client_area_x_offset = 0,
         client_area_y_offset = 0;
 
-    /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
+    /* wxMDIChildFrame derives from wxFrameGTK 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
+       set in wxFrameGTK::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 */
@@ -759,6 +899,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
          * 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. */
 
+#if wxUSE_MENUS
         if (m_frameMenuBar)
         {
             int xx = m_miniEdge;
@@ -775,13 +916,15 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
                                   xx, yy, ww, hh );
             client_area_y_offset += hh;
         }
+#endif // wxUSE_MENUS
 
 #if wxUSE_TOOLBAR
-        if ((m_frameToolBar) &&
+        if ((m_frameToolBar) && m_frameToolBar->IsShown() &&
             (m_frameToolBar->m_widget->parent == m_mainWidget))
         {
             int xx = m_miniEdge;
             int yy = m_miniEdge + m_miniTitle;
+#if wxUSE_MENUS
             if (m_frameMenuBar)
             {
                 if (!m_menuBarDetached)
@@ -789,6 +932,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
                 else
                     yy += wxPLACE_HOLDER;
             }
+#endif // wxUSE_MENUS
 
             m_frameToolBar->m_x = xx;
             m_frameToolBar->m_y = yy;
@@ -833,7 +977,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
     }
 
 #if wxUSE_STATUSBAR
-    if (m_frameStatusBar)
+    if (m_frameStatusBar && m_frameStatusBar->IsShown())
     {
         int xx = 0 + m_miniEdge;
         int yy = m_height - wxSTATUS_HEIGHT - m_miniEdge - client_area_y_offset;
@@ -848,7 +992,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
                             xx, yy, ww, hh );
         gtk_widget_draw( m_frameStatusBar->m_widget, (GdkRectangle*) NULL );
     }
-#endif
+#endif // wxUSE_STATUSBAR
 
     m_sizeSet = TRUE;
 
@@ -857,6 +1001,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
     event.SetEventObject( this );
     GetEventHandler()->ProcessEvent( event );
 
+#if wxUSE_STATUSBAR
     // send size event to status bar
     if (m_frameStatusBar)
     {
@@ -864,11 +1009,12 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
         event2.SetEventObject( m_frameStatusBar );
         m_frameStatusBar->GetEventHandler()->ProcessEvent( event2 );
     }
+#endif // wxUSE_STATUSBAR
 
     m_resizing = FALSE;
 }
 
-void wxFrame::MakeModal( bool modal )
+void wxFrameGTK::MakeModal( bool modal )
 {
     if (modal)
         gtk_grab_add( m_widget );
@@ -876,7 +1022,7 @@ void wxFrame::MakeModal( bool modal )
         gtk_grab_remove( m_widget );
 }
 
-void wxFrame::OnInternalIdle()
+void wxFrameGTK::OnInternalIdle()
 {
     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
     {
@@ -888,7 +1034,9 @@ void wxFrame::OnInternalIdle()
         return;
     }
 
+#if wxUSE_MENUS
     if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();
+#endif // wxUSE_MENUS
 #if wxUSE_TOOLBAR
     if (m_frameToolBar) m_frameToolBar->OnInternalIdle();
 #endif
@@ -903,7 +1051,9 @@ void wxFrame::OnInternalIdle()
 // menu/tool/status bar stuff
 // ----------------------------------------------------------------------------
 
-void wxFrame::SetMenuBar( wxMenuBar *menuBar )
+#if wxUSE_MENUS
+
+void wxFrameGTK::SetMenuBar( wxMenuBar *menuBar )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
@@ -959,8 +1109,11 @@ void wxFrame::SetMenuBar( wxMenuBar *menuBar )
     m_sizeSet = FALSE;
 }
 
+#endif // wxUSE_MENUS
+
 #if wxUSE_TOOLBAR
-wxToolBar* wxFrame::CreateToolBar( long style, wxWindowID id, const wxString& name )
+
+wxToolBar* wxFrameGTK::CreateToolBar( long style, wxWindowID id, const wxString& name )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
@@ -975,7 +1128,7 @@ wxToolBar* wxFrame::CreateToolBar( long style, wxWindowID id, const wxString& na
     return m_frameToolBar;
 }
 
-void wxFrame::SetToolBar(wxToolBar *toolbar)
+void wxFrameGTK::SetToolBar(wxToolBar *toolbar)
 {
     wxFrameBase::SetToolBar(toolbar);
 
@@ -997,7 +1150,7 @@ void wxFrame::SetToolBar(wxToolBar *toolbar)
 
 #if wxUSE_STATUSBAR
 
-wxStatusBar* wxFrame::CreateStatusBar(int number,
+wxStatusBar* wxFrameGTK::CreateStatusBar(int number,
                                       long style,
                                       wxWindowID id,
                                       const wxString& name)
@@ -1010,7 +1163,7 @@ wxStatusBar* wxFrame::CreateStatusBar(int number,
     return wxFrameBase::CreateStatusBar( number, style, id, name );
 }
 
-void wxFrame::PositionStatusBar()
+void wxFrameGTK::PositionStatusBar()
 {
     if ( !m_frameStatusBar )
         return;
@@ -1023,7 +1176,7 @@ void wxFrame::PositionStatusBar()
 // frame title/icon
 // ----------------------------------------------------------------------------
 
-void wxFrame::SetTitle( const wxString &title )
+void wxFrameGTK::SetTitle( const wxString &title )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
@@ -1031,7 +1184,7 @@ void wxFrame::SetTitle( const wxString &title )
     gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
 }
 
-void wxFrame::SetIcon( const wxIcon &icon )
+void wxFrameGTK::SetIcon( const wxIcon &icon )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
@@ -1051,23 +1204,28 @@ void wxFrame::SetIcon( const wxIcon &icon )
 }
 
 // ----------------------------------------------------------------------------
-// frame state: maximized/iconized/normal (TODO)
+// frame state: maximized/iconized/normal
 // ----------------------------------------------------------------------------
 
-void wxFrame::Maximize(bool WXUNUSED(maximize))
+void wxFrameGTK::Maximize(bool WXUNUSED(maximize))
 {
+    wxFAIL_MSG( _T("not implemented") );
 }
 
-bool wxFrame::IsMaximized() const
+bool wxFrameGTK::IsMaximized() const
 {
+  //    wxFAIL_MSG( _T("not implemented") );
+
+    // This is an approximation
     return FALSE;
 }
 
-void wxFrame::Restore()
+void wxFrameGTK::Restore()
 {
+    wxFAIL_MSG( _T("not implemented") );
 }
 
-void wxFrame::Iconize( bool iconize )
+void wxFrameGTK::Iconize( bool iconize )
 {
    if (iconize)
    {
@@ -1077,7 +1235,27 @@ void wxFrame::Iconize( bool iconize )
    }
 }
 
-bool wxFrame::IsIconized() const
+bool wxFrameGTK::IsIconized() const
 {
-    return FALSE;
+    return m_isIconized;
+}
+
+void wxFrame::SetIconizeState(bool iconize)
+{
+    if ( iconize != m_isIconized )
+    {
+        m_isIconized = iconize;
+        (void)SendIconizeEvent(iconize);
+    }
+    else
+    {
+        // this is not supposed to happen if we're called only from
+        // gtk_frame_(un)map_callback!
+        
+        // RR: I don't understand this test. Upon startup, the frame is
+        //     not iconized by default, it has just not been created
+        //     yet.
+        ///wxFAIL_MSG( _T("unexpected call to SendIconizeEvent ignored") );
+    }
 }
+