applied patch #428104 (SetSizeHints() for wxMDIChildFrame)

[wxWidgets.git] / src / gtk / frame.cpp

diff --git a/src/gtk/frame.cpp b/src/gtk/frame.cpp
index 9b7aa4a00113e5b199ec81aa442d1b21bf4f5ecf..97e19ac404cbbf06bbfa52bfba5c9188ce699c85 100644 (file)
--- a/src/gtk/frame.cpp
+++ b/src/gtk/frame.cpp
@@ -7,55 +7,74 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+

 #ifdef __GNUG__
     #pragma implementation "frame.h"
 #endif
 
 #ifdef __GNUG__
     #pragma implementation "frame.h"
 #endif
 

+#ifdef __VMS
+#define XIconifyWindow XICONIFYWINDOW
+#endif
+

 #include "wx/frame.h"
 #include "wx/dialog.h"
 #include "wx/control.h"
 #include "wx/app.h"
 #include "wx/menu.h"
 #if wxUSE_TOOLBAR
 #include "wx/frame.h"
 #include "wx/dialog.h"
 #include "wx/control.h"
 #include "wx/app.h"
 #include "wx/menu.h"
 #if wxUSE_TOOLBAR

-#include "wx/toolbar.h"
+    #include "wx/toolbar.h"

 #endif
 #if wxUSE_STATUSBAR
 #endif
 #if wxUSE_STATUSBAR

-#include "wx/statusbr.h"
+    #include "wx/statusbr.h"

 #endif
 #include "wx/dcclient.h"
 
 #endif
 #include "wx/dcclient.h"
 

-#include "glib.h"
-#include "gdk/gdk.h"
-#include "gtk/gtk.h"
+#include <glib.h>
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#include <gdk/gdkx.h>
+

 #include "wx/gtk/win_gtk.h"
 #include "wx/gtk/win_gtk.h"

-#include "gdk/gdkkeysyms.h"
-#include "gdk/gdkx.h"

 
 

-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------

 // constants
 // constants

-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------

 
 const int wxMENU_HEIGHT    = 27;
 const int wxSTATUS_HEIGHT  = 25;
 const int wxPLACE_HOLDER   = 0;
 
 
 const int wxMENU_HEIGHT    = 27;
 const int wxSTATUS_HEIGHT  = 25;
 const int wxPLACE_HOLDER   = 0;
 

-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------

 // idle system
 // idle system

-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------

 
 extern void wxapp_install_idle_handler();
 extern bool g_isIdle;
 extern int g_openDialogs;
 
 
 extern void wxapp_install_idle_handler();
 extern bool g_isIdle;
 extern int g_openDialogs;
 

-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// event tables
+// ----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxFrame,wxWindow)
+
+// ----------------------------------------------------------------------------

 // data
 // data

-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------

 
 extern wxList wxPendingDelete;
 
 
 extern wxList wxPendingDelete;
 

-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------

 // debug
 // debug

-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------

 
 #ifdef __WXDEBUG__
 
 
 #ifdef __WXDEBUG__
 


@@ -63,6 +82,28 @@ extern void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar
 
 #endif
 
 
 #endif
 

+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// GTK callbacks
+// ----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// "focus" from m_window
+//-----------------------------------------------------------------------------
+
+static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
+{
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
+    // This disables GTK's tab traversal
+    gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" );
+    return TRUE;
+}
+

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


@@ -89,7 +130,8 @@ static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
 
         win->m_width = alloc->width;
         win->m_height = alloc->height;
 
         win->m_width = alloc->width;
         win->m_height = alloc->height;

-        win->UpdateSize();
+        win->m_queuedFullRedraw = TRUE;
+        win->GtkUpdateSize();

     }
 }
 
     }
 }
 


@@ -102,7 +144,7 @@ static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WX
     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_isIdle)
         wxapp_install_idle_handler();
 

-    if (g_openDialogs == 0)
+    if ((g_openDialogs == 0) && (win->IsEnabled()))

         win->Close();
 
     return TRUE;
         win->Close();
 
     return TRUE;


@@ -117,7 +159,7 @@ static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *
     if (!win->m_hasVMT) return;
 
     win->m_menuBarDetached = FALSE;
     if (!win->m_hasVMT) return;
 
     win->m_menuBarDetached = FALSE;

-    win->UpdateSize();
+    win->GtkUpdateSize();

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


@@ -129,7 +171,7 @@ static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *
     if (!win->m_hasVMT) return;
 
     win->m_menuBarDetached = TRUE;
     if (!win->m_hasVMT) return;
 
     win->m_menuBarDetached = TRUE;

-    win->UpdateSize();
+    win->GtkUpdateSize();

 }
 
 #if wxUSE_TOOLBAR
 }
 
 #if wxUSE_TOOLBAR


@@ -143,7 +185,7 @@ static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidge
 
     win->m_toolBarDetached = FALSE;
 
 
     win->m_toolBarDetached = FALSE;
 

-    win->UpdateSize();
+    win->GtkUpdateSize();

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


@@ -158,7 +200,7 @@ static void gtk_toolbar_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidge
     if (!win->m_hasVMT) return;
 
     win->m_toolBarDetached = TRUE;
     if (!win->m_hasVMT) return;
 
     win->m_toolBarDetached = TRUE;

-    win->UpdateSize();
+    win->GtkUpdateSize();

 }
 #endif // wxUSE_TOOLBAR
 
 }
 #endif // wxUSE_TOOLBAR
 


@@ -176,9 +218,9 @@ gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *ev
     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_isIdle)
         wxapp_install_idle_handler();
 

-    if (!win->m_hasVMT) 
+    if (!win->m_hasVMT)

         return FALSE;
         return FALSE;

-       
+

 #if (GTK_MINOR_VERSION > 0)
     int x = 0;
     int y = 0;
 #if (GTK_MINOR_VERSION > 0)
     int x = 0;
     int y = 0;


@@ -204,47 +246,51 @@ 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 */
 
 /* 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 *widget, wxFrame *win )
+static void
+gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), wxFrame *win )

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

-    /* I haven't been able to set the position of
-       the dialog before it is shown, so I set the
-       position in "realize" */
-    gtk_widget_set_uposition( widget, win->m_x, win->m_y );
-
-    /* all this is for Motif Window Manager "hints" and is supposed to be
-       recognized by other WM as well. not tested. */
-    long decor = (long) GDK_DECOR_BORDER;
-    long func = (long) GDK_FUNC_MOVE;
-
-    if ((win->GetWindowStyle() & wxCAPTION) != 0)
-        decor |= GDK_DECOR_TITLE;
-    if ((win->GetWindowStyle() & wxSYSTEM_MENU) != 0)
+    if ((win->m_miniEdge > 0) || (win->HasFlag(wxSIMPLE_BORDER)) || (win->HasFlag(wxNO_BORDER)))

     {
     {

-       decor |= GDK_DECOR_MENU;
-       func |= GDK_FUNC_CLOSE;
+        /* This is a mini-frame or a borderless frame. */
+        gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)0 );
+        gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)0 );

     }
     }

-    if ((win->GetWindowStyle() & wxMINIMIZE_BOX) != 0)
-    {
-        func |= GDK_FUNC_MINIMIZE;
-        decor |= GDK_DECOR_MINIMIZE;
-    }
-    if ((win->GetWindowStyle() & wxMAXIMIZE_BOX) != 0)
-    {
-        func |= GDK_FUNC_MAXIMIZE;
-        decor |= GDK_DECOR_MAXIMIZE;
-    }
-    if ((win->GetWindowStyle() & wxRESIZE_BORDER) != 0)
+    else

     {
     {

-       func |= GDK_FUNC_RESIZE;
-       decor |= GDK_DECOR_RESIZEH;
-    }
+        /* All this is for Motif Window Manager "hints" and is supposed to be
+           recognized by other WM as well. Not tested. */
+        long decor = (long) GDK_DECOR_BORDER;
+        long func = (long) GDK_FUNC_MOVE;
+
+        if ((win->GetWindowStyle() & wxCAPTION) != 0)
+            decor |= GDK_DECOR_TITLE;
+        if ((win->GetWindowStyle() & wxSYSTEM_MENU) != 0)
+        {
+            decor |= GDK_DECOR_MENU;
+            func |= GDK_FUNC_CLOSE;
+        }
+        if ((win->GetWindowStyle() & wxMINIMIZE_BOX) != 0)
+        {
+            func |= GDK_FUNC_MINIMIZE;
+            decor |= GDK_DECOR_MINIMIZE;
+        }
+        if ((win->GetWindowStyle() & wxMAXIMIZE_BOX) != 0)
+        {
+            func |= GDK_FUNC_MAXIMIZE;
+            decor |= GDK_DECOR_MAXIMIZE;
+        }
+        if ((win->GetWindowStyle() & wxRESIZE_BORDER) != 0)
+        {
+           func |= GDK_FUNC_RESIZE;
+           decor |= GDK_DECOR_RESIZEH;
+        }

 
 

-    gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
-    gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
+        gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
+        gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
+    }

 
     /* GTK's shrinking/growing policy */
     if ((win->GetWindowStyle() & wxRESIZE_BORDER) == 0)
 
     /* GTK's shrinking/growing policy */
     if ((win->GetWindowStyle() & wxRESIZE_BORDER) == 0)


@@ -252,24 +298,12 @@ gtk_frame_realized_callback( GtkWidget *widget, wxFrame *win )
     else
         gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
 
     else
         gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
 

-    /* set size hints */
-    gint flag = 0; // GDK_HINT_POS;
-    if ((win->GetMinWidth() != -1) || (win->GetMinHeight() != -1)) flag |= GDK_HINT_MIN_SIZE;
-    if ((win->GetMaxWidth() != -1) || (win->GetMaxHeight() != -1)) flag |= GDK_HINT_MAX_SIZE;
-    if (flag)
-    {
-        gdk_window_set_hints( win->m_widget->window,
-                              win->m_x, win->m_y,
-                              win->GetMinWidth(), win->GetMinHeight(),
-                              win->GetMaxWidth(), win->GetMaxHeight(),
-                              flag );
-    }
-

     /* reset the icon */
     /* reset the icon */

-    if (win->m_icon != wxNullIcon)
+    wxIcon iconOld = win->GetIcon();
+    if ( iconOld != wxNullIcon )

     {
     {

-        wxIcon icon( win->m_icon );
-        win->m_icon = wxNullIcon;
+        wxIcon icon( iconOld );
+        win->SetIcon( wxNullIcon );

         win->SetIcon( icon );
     }
 
         win->SetIcon( icon );
     }
 


@@ -287,10 +321,63 @@ gtk_frame_realized_callback( GtkWidget *widget, wxFrame *win )
 
         node = node->GetNext();
     }
 
         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
+// ----------------------------------------------------------------------------
+

 //-----------------------------------------------------------------------------
 // InsertChild for wxFrame
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // InsertChild for wxFrame
 //-----------------------------------------------------------------------------


@@ -315,7 +402,7 @@ static void wxInsertChildInFrame( wxFrame* parent, wxWindow* child )
                          child->m_width,
                          child->m_height );
 
                          child->m_width,
                          child->m_height );
 

-#if wxUSE_TOOLBAR
+#if wxUSE_TOOLBAR_NATIVE

         /* we connect to these events for recalculating the client area
            space when the toolbar is floating */
         if (wxIS_KIND_OF(child,wxToolBar))
         /* we connect to these events for recalculating the client area
            space when the toolbar is floating */
         if (wxIS_KIND_OF(child,wxToolBar))


@@ -344,31 +431,15 @@ static void wxInsertChildInFrame( wxFrame* parent, wxWindow* child )
     }
 
     /* resize on OnInternalIdle */
     }
 
     /* resize on OnInternalIdle */

-    parent->UpdateSize();
+    parent->GtkUpdateSize();

 }
 
 }
 

-//-----------------------------------------------------------------------------
-// wxFrame
-//-----------------------------------------------------------------------------
-
-BEGIN_EVENT_TABLE(wxFrame, wxWindow)
-    EVT_SIZE(wxFrame::OnSize)
-    EVT_IDLE(wxFrame::OnIdle)
-    EVT_CLOSE(wxFrame::OnCloseWindow)
-    EVT_MENU_HIGHLIGHT_ALL(wxFrame::OnMenuHighlight)
-END_EVENT_TABLE()
-
-IMPLEMENT_DYNAMIC_CLASS(wxFrame,wxWindow)
+// ----------------------------------------------------------------------------
+// wxFrame creation
+// ----------------------------------------------------------------------------

 
 void wxFrame::Init()
 {
 
 void wxFrame::Init()
 {

-    m_frameMenuBar = (wxMenuBar *) NULL;
-#if wxUSE_STATUSBAR
-    m_frameStatusBar = (wxStatusBar *) NULL;
-#endif // wxUSE_STATUSBAR
-#if wxUSE_TOOLBAR
-    m_frameToolBar = (wxToolBar *) NULL;
-#endif // wxUSE_TOOLBAR

     m_sizeSet = FALSE;
     m_miniEdge = 0;
     m_miniTitle = 0;
     m_sizeSet = FALSE;
     m_miniEdge = 0;
     m_miniTitle = 0;


@@ -377,21 +448,31 @@ void wxFrame::Init()
     m_toolBarDetached = FALSE;
     m_insertInClientArea = TRUE;
     m_isFrame = TRUE;
     m_toolBarDetached = FALSE;
     m_insertInClientArea = TRUE;
     m_isFrame = TRUE;

+    m_isIconized = FALSE;
+    m_fsIsShowing = FALSE;
+    m_themeEnabled = TRUE;

 }
 
 }
 

-wxFrame::wxFrame( wxWindow *parent, wxWindowID id, const wxString &title,
-      const wxPoint &pos, const wxSize &size,
-      long style, const wxString &name )
+bool wxFrame::Create( wxWindow *parent,
+                      wxWindowID id,
+                      const wxString& title,
+                      const wxPoint& pos,
+                      const wxSize& sizeOrig,
+                      long style,
+                      const wxString &name )

 {
 {

-    Init();
-
-    Create( parent, id, title, pos, size, style, 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;
+    }

 
 

-bool wxFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
-      const wxPoint &pos, const wxSize &size,
-      long style, const wxString &name )
-{

     wxTopLevelWindows.Append( this );
 
     m_needParent = FALSE;
     wxTopLevelWindows.Append( this );
 
     m_needParent = FALSE;


@@ -408,10 +489,15 @@ bool wxFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
     m_insertCallback = (wxInsertChildFunction) wxInsertChildInFrame;
 
     GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;
     m_insertCallback = (wxInsertChildFunction) wxInsertChildInFrame;
 
     GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;

-    if (style & wxSIMPLE_BORDER) win_type = GTK_WINDOW_POPUP;
+
+    if (style & wxFRAME_TOOL_WINDOW)
+        win_type = GTK_WINDOW_POPUP;

 
     m_widget = gtk_window_new( win_type );
 
 
     m_widget = gtk_window_new( win_type );
 

+    if ((m_parent) && (HasFlag(wxFRAME_FLOAT_ON_PARENT)) && (GTK_IS_WINDOW(m_parent->m_widget)))
+        gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) );
+

     if (!name.IsEmpty())
         gtk_window_set_wmclass( GTK_WINDOW(m_widget), name.mb_str(), name.mb_str() );
 
     if (!name.IsEmpty())
         gtk_window_set_wmclass( GTK_WINDOW(m_widget), name.mb_str(), name.mb_str() );
 


@@ -431,6 +517,12 @@ bool wxFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
     GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
     gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
 
     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 );
 #endif
 #ifdef __WXDEBUG__
     debug_focus_in( m_mainWidget, wxT("wxFrame::m_mainWidget"), name );
 #endif


@@ -445,7 +537,7 @@ bool wxFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
 #endif
 
     /* we donm't allow the frame to get the focus as otherwise
 #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 );
     GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
 
     if (m_parent) m_parent->AddChild( this );


@@ -456,6 +548,10 @@ bool wxFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
 
     PostCreation();
 
 
     PostCreation();
 

+    if ((m_x != -1) || (m_y != -1))
+        gtk_widget_set_uposition( m_widget, m_x, m_y );
+    gtk_widget_set_usize( m_widget, m_width, m_height );
+

     /*  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",
     /*  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",


@@ -465,6 +561,20 @@ bool wxFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
     gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
         GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );
 
     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 );
+

     return TRUE;
 }
 
     return TRUE;
 }
 


@@ -472,28 +582,66 @@ wxFrame::~wxFrame()
 {
     m_isBeingDeleted = TRUE;
 
 {
     m_isBeingDeleted = TRUE;
 

-    if (m_frameMenuBar) delete m_frameMenuBar;
-    m_frameMenuBar = (wxMenuBar *) NULL;
-
-#if wxUSE_STATUSBAR
-    if (m_frameStatusBar) delete m_frameStatusBar;
-    m_frameStatusBar = (wxStatusBar *) NULL;
-#endif // wxUSE_STATUSBAR
-
-#if wxUSE_TOOLBAR
-    if (m_frameToolBar) delete m_frameToolBar;
-    m_frameToolBar = (wxToolBar *) NULL;
-#endif // wxUSE_TOOLBAR
+    DeleteAllBars();

 
     wxTopLevelWindows.DeleteObject( this );
 
     if (wxTheApp->GetTopWindow() == this)
         wxTheApp->SetTopWindow( (wxWindow*) NULL );
 
 
     wxTopLevelWindows.DeleteObject( this );
 
     if (wxTheApp->GetTopWindow() == this)
         wxTheApp->SetTopWindow( (wxWindow*) NULL );
 

-    if (wxTopLevelWindows.Number() == 0)
+    if ((wxTopLevelWindows.Number() == 0) &&
+        (wxTheApp->GetExitOnFrameDelete()))
+    {

         wxTheApp->ExitMainLoop();
         wxTheApp->ExitMainLoop();

+    }

 }
 
 }
 

+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 )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 bool wxFrame::Show( bool show )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );


@@ -511,13 +659,9 @@ bool wxFrame::Show( bool show )
     return wxWindow::Show( show );
 }
 
     return wxWindow::Show( show );
 }
 

-bool wxFrame::Destroy()
+void wxFrame::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )

 {
 {

-    wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
-
-    if (!wxPendingDelete.Member(this)) wxPendingDelete.Append(this);
-
-    return TRUE;
+    wxFAIL_MSG( wxT("DoMoveWindow called for wxFrame") );

 }
 
 void wxFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 }
 
 void wxFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )


@@ -528,7 +672,8 @@ void wxFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 
     /* avoid recursions */
     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 
     /* avoid recursions */

-    if (m_resizing) return;
+    if (m_resizing)
+        return;

     m_resizing = TRUE;
 
     int old_x = m_x;
     m_resizing = TRUE;
 
     int old_x = m_x;


@@ -579,6 +724,8 @@ void wxFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 
     if ((m_width != old_width) || (m_height != old_height))
     {
 
     if ((m_width != old_width) || (m_height != old_height))
     {

+        gtk_widget_set_usize( 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. */
         /* 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. */


@@ -588,19 +735,6 @@ void wxFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
     m_resizing = FALSE;
 }
 
     m_resizing = FALSE;
 }
 

-void wxFrame::Centre( int direction )
-{
-    wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
-
-    int x = 0;
-    int y = 0;
-
-    if ((direction & wxHORIZONTAL) == wxHORIZONTAL) x = (gdk_screen_width () - m_width) / 2;
-    if ((direction & wxVERTICAL) == wxVERTICAL) y = (gdk_screen_height () - m_height) / 2;
-
-    Move( x, y );
-}
-

 void wxFrame::DoGetClientSize( int *width, int *height ) const
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 void wxFrame::DoGetClientSize( int *width, int *height ) const
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );


@@ -619,30 +753,39 @@ void wxFrame::DoGetClientSize( int *width, int *height ) const
 
 #if wxUSE_STATUSBAR
         /* status bar */
 
 #if wxUSE_STATUSBAR
         /* status bar */

-        if (m_frameStatusBar) (*height) -= wxSTATUS_HEIGHT;
-#endif
+        if (m_frameStatusBar && m_frameStatusBar->IsShown()) (*height) -= wxSTATUS_HEIGHT;
+#endif // wxUSE_STATUSBAR

 
 #if wxUSE_TOOLBAR
         /* tool bar */
 
 #if wxUSE_TOOLBAR
         /* tool bar */

-        if (m_frameToolBar)
+        if (m_frameToolBar && m_frameToolBar->IsShown())

         {
         {

-            if (!m_toolBarDetached)
+            if (m_toolBarDetached)

             {
             {

-                int y = 0;
-                m_frameToolBar->GetSize( (int *) NULL, &y );
-                (*height) -= y;
+                *height -= wxPLACE_HOLDER;

             }
             else
             }
             else

-                (*height) -= wxPLACE_HOLDER;
+            {
+                int x, y;
+                m_frameToolBar->GetSize( &x, &y );
+                if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
+                {
+                    *width -= x;
+                }
+                else
+                {
+                    *height -= y;
+                }
+            }

         }
         }

-#endif
+#endif // wxUSE_TOOLBAR

 
         /* mini edge */
 
         /* mini edge */

-        (*height) -= m_miniEdge*2 + m_miniTitle;
+        *height -= m_miniEdge*2 + m_miniTitle;

     }
     if (width)
     {
     }
     if (width)
     {

-        (*width) -= m_miniEdge*2;
+        *width -= m_miniEdge*2;

     }
 }
 
     }
 }
 


@@ -661,28 +804,38 @@ void wxFrame::DoSetClientSize( int width, int height )
 
 #if wxUSE_STATUSBAR
         /* status bar */
 
 #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 */
 #endif
 
 #if wxUSE_TOOLBAR
         /* tool bar */

-        if (m_frameToolBar)
+        if (m_frameToolBar && m_frameToolBar->IsShown())

         {
         {

-            if (!m_toolBarDetached)
+            if (m_toolBarDetached)

             {
             {

-                int y = 0;
-                m_frameToolBar->GetSize( (int *) NULL, &y );
-                height += y;
+                height += wxPLACE_HOLDER;

             }
             else
             }
             else

-                height += wxPLACE_HOLDER;
+            {
+                int x, y;
+                m_frameToolBar->GetSize( &x, &y );
+                if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
+                {
+                    width += x;
+                }
+                else
+                {
+                    height += y;
+                }
+            }

         }
 #endif
 
     DoSetSize( -1, -1, width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle, 0 );
 }
 
         }
 #endif
 
     DoSetSize( -1, -1, width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle, 0 );
 }
 

-void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height )
+void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
+                         int width, int height )

 {
     // due to a bug in gtk, x,y are always 0
     // m_x = x;
 {
     // due to a bug in gtk, x,y are always 0
     // m_x = x;


@@ -699,7 +852,8 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
     m_height = height;
 
     /* space occupied by m_frameToolBar and m_frameMenuBar */
     m_height = height;
 
     /* space occupied by m_frameToolBar and m_frameMenuBar */

-    int client_area_y_offset = 0;
+    int client_area_x_offset = 0,
+        client_area_y_offset = 0;

 
     /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
 
     /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only


@@ -708,13 +862,26 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
        importantly) m_mainWidget */
 
        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
        importantly) m_mainWidget */
 

+    if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
+    if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
+    if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
+    if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
+

     if (m_mainWidget)
     {
     if (m_mainWidget)
     {

-        /* check if size is in legal range */
-        if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
-        if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
-        if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
-        if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
+        /* set size hints */
+        gint flag = 0; // GDK_HINT_POS;
+        if ((m_minWidth != -1) || (m_minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
+        if ((m_maxWidth != -1) || (m_maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
+        GdkGeometry geom;
+        geom.min_width = m_minWidth;
+        geom.min_height = m_minHeight;
+        geom.max_width = m_maxWidth;
+        geom.max_height = m_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
 
         /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
          * menubar, the toolbar and the client area, which is represented by


@@ -740,7 +907,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
         }
 
 #if wxUSE_TOOLBAR
         }
 
 #if wxUSE_TOOLBAR

-        if ((m_frameToolBar) &&
+        if ((m_frameToolBar) && m_frameToolBar->IsShown() &&

             (m_frameToolBar->m_widget->parent == m_mainWidget))
         {
             int xx = m_miniEdge;
             (m_frameToolBar->m_widget->parent == m_mainWidget))
         {
             int xx = m_miniEdge;


@@ -752,23 +919,38 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
                 else
                     yy += wxPLACE_HOLDER;
             }
                 else
                     yy += wxPLACE_HOLDER;
             }

-            int ww = m_width - 2*m_miniEdge;
-            int hh = m_frameToolBar->m_height;
-            if (m_toolBarDetached) hh = wxPLACE_HOLDER;
+

             m_frameToolBar->m_x = xx;
             m_frameToolBar->m_y = yy;
             m_frameToolBar->m_x = xx;
             m_frameToolBar->m_y = yy;

-            /* m_frameToolBar->m_height = hh;   don't change the toolbar's reported size
-               m_frameToolBar->m_width = ww; */
+
+            /* don't change the toolbar's reported height/width */
+            int ww, hh;
+            if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
+            {
+                ww = m_toolBarDetached ? wxPLACE_HOLDER
+                                       : m_frameToolBar->m_width;
+                hh = m_height - 2*m_miniEdge;
+
+                client_area_x_offset += ww;
+            }
+            else
+            {
+                ww = m_width - 2*m_miniEdge;
+                hh = m_toolBarDetached ? wxPLACE_HOLDER
+                                       : m_frameToolBar->m_height;
+
+                client_area_y_offset += hh;
+            }
+

             gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                                   m_frameToolBar->m_widget,
                                   xx, yy, ww, hh );
             gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                                   m_frameToolBar->m_widget,
                                   xx, yy, ww, hh );

-            client_area_y_offset += hh;

         }
         }

-#endif
+#endif // wxUSE_TOOLBAR

 
 

-        int client_x = m_miniEdge;
+        int client_x = client_area_x_offset + m_miniEdge;

         int client_y = client_area_y_offset + m_miniEdge + m_miniTitle;
         int client_y = client_area_y_offset + m_miniEdge + m_miniTitle;

-        int client_w = m_width - 2*m_miniEdge;
+        int client_w = m_width - client_area_x_offset - 2*m_miniEdge;

         int client_h = m_height - client_area_y_offset- 2*m_miniEdge - m_miniTitle;
         gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                               m_wxwindow,
         int client_h = m_height - client_area_y_offset- 2*m_miniEdge - m_miniTitle;
         gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                               m_wxwindow,


@@ -781,7 +963,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
     }
 
 #if wxUSE_STATUSBAR
     }
 
 #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;
     {
         int xx = 0 + m_miniEdge;
         int yy = m_height - wxSTATUS_HEIGHT - m_miniEdge - client_area_y_offset;


@@ -792,15 +974,12 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
         m_frameStatusBar->m_width = ww;
         m_frameStatusBar->m_height = hh;
         gtk_pizza_set_size( GTK_PIZZA(m_wxwindow),
         m_frameStatusBar->m_width = ww;
         m_frameStatusBar->m_height = hh;
         gtk_pizza_set_size( GTK_PIZZA(m_wxwindow),

-                              m_frameStatusBar->m_widget,
-                              xx, yy, ww, hh );
+                            m_frameStatusBar->m_widget,
+                            xx, yy, ww, hh );
+        gtk_widget_draw( m_frameStatusBar->m_widget, (GdkRectangle*) NULL );

     }
 #endif
 
     }
 #endif
 

-    /* we actually set the size of a frame here and no-where else */
-    gtk_widget_set_usize( m_widget, m_width, m_height );
-
-

     m_sizeSet = TRUE;
 
     // send size event to frame
     m_sizeSet = TRUE;
 
     // send size event to frame


@@ -850,55 +1029,35 @@ void wxFrame::OnInternalIdle()
     wxWindow::OnInternalIdle();
 }
 
     wxWindow::OnInternalIdle();
 }
 

-void wxFrame::OnCloseWindow( wxCloseEvent& WXUNUSED(event) )
-{
-    Destroy();
-}
+// ----------------------------------------------------------------------------
+// menu/tool/status bar stuff
+// ----------------------------------------------------------------------------

 
 

-void wxFrame::OnSize( wxSizeEvent &WXUNUSED(event) )
+void wxFrame::SetMenuBar( wxMenuBar *menuBar )

 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );

+    wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );

 
 

-#if wxUSE_CONSTRAINTS
-    if (GetAutoLayout())
-    {
-        Layout();
-    }
-    else
-#endif // wxUSE_CONSTRAINTS
+    if (menuBar == m_frameMenuBar)
+        return;
+
+    if (m_frameMenuBar)

     {
     {

-        /* do we have exactly one child? */
-        wxWindow *child = (wxWindow *)NULL;
-        for ( wxNode *node = GetChildren().First(); node; node = node->Next() )
+        m_frameMenuBar->UnsetInvokingWindow( this );
+
+        if (m_frameMenuBar->GetWindowStyle() & wxMB_DOCKABLE)

         {
         {

-            wxWindow *win = (wxWindow *)node->Data();
-            if ( !wxIS_KIND_OF(win,wxFrame) && !wxIS_KIND_OF(win,wxDialog) )
-            {
-                if (child)
-                {
-                    /* it's the second one: do nothing */
-                    return;
-                }
+            gtk_signal_disconnect_by_func( GTK_OBJECT(m_frameMenuBar->m_widget),
+                GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );

 
 

-                child = win;
-            }
+            gtk_signal_disconnect_by_func( GTK_OBJECT(m_frameMenuBar->m_widget),
+                GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );

         }
 
         }
 

-        /* no children at all? */
-        if (child)
-        {
-            /* yes: set it's size to fill all the frame */
-            int client_x, client_y;
-            DoGetClientSize( &client_x, &client_y );
-            child->SetSize( 1, 1, client_x-2, client_y-2 );
-        }
+        gtk_container_remove( GTK_CONTAINER(m_mainWidget), m_frameMenuBar->m_widget );
+        gtk_widget_ref( m_frameMenuBar->m_widget );
+        gtk_widget_unparent( m_frameMenuBar->m_widget );

     }
     }

-}
-
-void wxFrame::SetMenuBar( wxMenuBar *menuBar )
-{
-    wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
-    wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );

 
     m_frameMenuBar = menuBar;
 
 
     m_frameMenuBar = menuBar;
 


@@ -906,77 +1065,38 @@ void wxFrame::SetMenuBar( wxMenuBar *menuBar )
     {
         m_frameMenuBar->SetInvokingWindow( this );
 
     {
         m_frameMenuBar->SetInvokingWindow( this );
 

-        if (m_frameMenuBar->GetParent() != this)
-        {
-            m_frameMenuBar->SetParent(this);
-            gtk_pizza_put( GTK_PIZZA(m_mainWidget),
+        m_frameMenuBar->SetParent(this);
+        gtk_pizza_put( GTK_PIZZA(m_mainWidget),

                 m_frameMenuBar->m_widget,
                 m_frameMenuBar->m_x,
                 m_frameMenuBar->m_y,
                 m_frameMenuBar->m_width,
                 m_frameMenuBar->m_height );
 
                 m_frameMenuBar->m_widget,
                 m_frameMenuBar->m_x,
                 m_frameMenuBar->m_y,
                 m_frameMenuBar->m_width,
                 m_frameMenuBar->m_height );
 

-            if (menuBar->GetWindowStyle() & wxMB_DOCKABLE)
-            {
-                gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_attached",
-                    GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
-
-                gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",
-                    GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
-            }
+        if (menuBar->GetWindowStyle() & wxMB_DOCKABLE)
+        {
+            gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_attached",
+                GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );

 
 

-            m_frameMenuBar->Show( TRUE );
+            gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",
+                GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );

         }
         }

+
+        m_frameMenuBar->Show( TRUE );

     }
 
     /* resize window in OnInternalIdle */
     m_sizeSet = FALSE;
 }
 
     }
 
     /* resize window in OnInternalIdle */
     m_sizeSet = FALSE;
 }
 

-wxMenuBar *wxFrame::GetMenuBar() const
-{
-    return m_frameMenuBar;
-}
-
-void wxFrame::OnMenuHighlight(wxMenuEvent& event)
-{
-#if wxUSE_STATUSBAR
-    if (GetStatusBar())
-    {
-        // if no help string found, we will clear the status bar text
-        wxString helpString;
-
-        int menuId = event.GetMenuId();
-        if ( menuId != wxID_SEPARATOR && menuId != -2 /* wxID_TITLE */ )
-        {
-            wxMenuBar *menuBar = GetMenuBar();
-            if ( menuBar )
-            {
-                // it's ok if we don't find the item because it might belong to
-                // the popup menu
-                wxMenuItem *item = menuBar->FindItem(menuId);
-                if ( item )
-                    helpString = item->GetHelp();
-            }
-        }
-
-        SetStatusText(helpString);
-    }
-#endif // wxUSE_STATUSBAR
-}
-

 #if wxUSE_TOOLBAR
 wxToolBar* wxFrame::CreateToolBar( long style, wxWindowID id, const wxString& name )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
 #if wxUSE_TOOLBAR
 wxToolBar* wxFrame::CreateToolBar( long style, wxWindowID id, const wxString& name )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 

-    wxCHECK_MSG( m_frameToolBar == NULL, FALSE, wxT("recreating toolbar in wxFrame") );
-

     m_insertInClientArea = FALSE;
 
     m_insertInClientArea = FALSE;
 

-    m_frameToolBar = OnCreateToolBar( style, id, name );
-
-    if (m_frameToolBar) GetChildren().DeleteObject( m_frameToolBar );
+    m_frameToolBar = wxFrameBase::CreateToolBar( style, id, name );

 
     m_insertInClientArea = TRUE;
 
 
     m_insertInClientArea = TRUE;
 


@@ -985,14 +1105,10 @@ wxToolBar* wxFrame::CreateToolBar( long style, wxWindowID id, const wxString& na
     return m_frameToolBar;
 }
 
     return m_frameToolBar;
 }
 

-wxToolBar* wxFrame::OnCreateToolBar( long style, wxWindowID id, const wxString& name )
-{
-    return new wxToolBar( this, id, wxDefaultPosition, wxDefaultSize, style, name );
-}
-

 void wxFrame::SetToolBar(wxToolBar *toolbar)
 {
 void wxFrame::SetToolBar(wxToolBar *toolbar)
 {

-    m_frameToolBar = toolbar;
+    wxFrameBase::SetToolBar(toolbar);
+

     if (m_frameToolBar)
     {
         /* insert into toolbar area if not already there */
     if (m_frameToolBar)
     {
         /* insert into toolbar area if not already there */


@@ -1002,102 +1118,46 @@ void wxFrame::SetToolBar(wxToolBar *toolbar)
             GetChildren().DeleteObject( m_frameToolBar );
 
             gtk_widget_reparent( m_frameToolBar->m_widget, m_mainWidget );
             GetChildren().DeleteObject( m_frameToolBar );
 
             gtk_widget_reparent( m_frameToolBar->m_widget, m_mainWidget );

-            UpdateSize();
+            GtkUpdateSize();

         }
     }
 }
 
         }
     }
 }
 

-wxToolBar *wxFrame::GetToolBar() const
-{
-    return m_frameToolBar;
-}

 #endif // wxUSE_TOOLBAR
 
 #if wxUSE_STATUSBAR
 #endif // wxUSE_TOOLBAR
 
 #if wxUSE_STATUSBAR

-wxStatusBar* wxFrame::CreateStatusBar( int number, long style, wxWindowID id, const wxString& name )
-{
-    wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
-
-    wxCHECK_MSG( m_frameStatusBar == NULL, FALSE, wxT("recreating status bar in wxFrame") );
-
-    m_frameStatusBar = OnCreateStatusBar( number, style, id, name );
-
-    m_sizeSet = FALSE;

 
 

-    return m_frameStatusBar;
-}
-
-wxStatusBar *wxFrame::OnCreateStatusBar( int number, long style, wxWindowID id, const wxString& name )
-{
-    wxStatusBar *statusBar = (wxStatusBar *) NULL;
-
-    statusBar = new wxStatusBar(this, id, wxPoint(0, 0), wxSize(100, 20), style, name);
-
-    // Set the height according to the font and the border size
-    wxClientDC dc(statusBar);
-    dc.SetFont( statusBar->GetFont() );
-
-    long x, y;
-    dc.GetTextExtent( "X", &x, &y );
-
-    int height = (int)( (y  * 1.1) + 2* statusBar->GetBorderY());
-
-    statusBar->SetSize( -1, -1, 100, height );
-
-    statusBar->SetFieldsCount( number );
-    return statusBar;
-}
-
-wxStatusBar *wxFrame::GetStatusBar() const
-{
-    return m_frameStatusBar;
-}
-
-void wxFrame::SetStatusText(const wxString& text, int number)
+wxStatusBar* wxFrame::CreateStatusBar(int number,
+                                      long style,
+                                      wxWindowID id,
+                                      const wxString& name)

 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 

-    wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set text for") );
+    // because it will change when toolbar is added
+    m_sizeSet = FALSE;

 
 

-    m_frameStatusBar->SetStatusText(text, number);
+    return wxFrameBase::CreateStatusBar( number, style, id, name );

 }
 
 }
 

-void wxFrame::SetStatusWidths(int n, const int widths_field[] )
+void wxFrame::PositionStatusBar()

 {
 {

-    wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
-
-    wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set widths for") );
+    if ( !m_frameStatusBar )
+        return;

 
 

-    m_frameStatusBar->SetStatusWidths(n, widths_field);
+    m_sizeSet = FALSE;

 }
 #endif // wxUSE_STATUSBAR
 
 }
 #endif // wxUSE_STATUSBAR
 

-void wxFrame::Command( int id )
-{
-    wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, id);
-    commandEvent.SetInt( id );
-    commandEvent.SetEventObject( this );
-
-    wxMenuBar *bar = GetMenuBar();
-    if (!bar) return;
-
-    wxMenuItem *item = bar->FindItem(id) ;
-    if (item && item->IsCheckable())
-    {
-        bar->Check(id, !bar->IsChecked(id)) ;
-    }
-
-    wxEvtHandler* evtHandler = GetEventHandler();
-
-    evtHandler->ProcessEvent(commandEvent);
-}
+// ----------------------------------------------------------------------------
+// frame title/icon
+// ----------------------------------------------------------------------------

 
 void wxFrame::SetTitle( const wxString &title )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
     m_title = title;
 
 void wxFrame::SetTitle( const wxString &title )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
     m_title = title;

-    if (m_title.IsNull()) m_title = wxT("");

     gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
 }
 
     gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
 }
 


@@ -1105,10 +1165,13 @@ void wxFrame::SetIcon( const wxIcon &icon )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 

-    m_icon = icon;
-    if (!icon.Ok()) return;
+    wxFrameBase::SetIcon(icon);

 
 

-    if (!m_widget->window) return;
+    if ( !m_icon.Ok() )
+        return;
+
+    if (!m_widget->window)
+        return;

 
     wxMask *mask = icon.GetMask();
     GdkBitmap *bm = (GdkBitmap *) NULL;
 
     wxMask *mask = icon.GetMask();
     GdkBitmap *bm = (GdkBitmap *) NULL;


@@ -1117,12 +1180,26 @@ void wxFrame::SetIcon( const wxIcon &icon )
     gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
 }
 
     gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
 }
 

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

 void wxFrame::Maximize(bool WXUNUSED(maximize))
 {
 void wxFrame::Maximize(bool WXUNUSED(maximize))
 {

+    wxFAIL_MSG( _T("not implemented") );
+}
+
+bool wxFrame::IsMaximized() const
+{
+  //    wxFAIL_MSG( _T("not implemented") );
+
+    // This is an approximation
+    return FALSE;

 }
 
 void wxFrame::Restore()
 {
 }
 
 void wxFrame::Restore()
 {

+    wxFAIL_MSG( _T("not implemented") );

 }
 
 void wxFrame::Iconize( bool iconize )
 }
 
 void wxFrame::Iconize( bool iconize )


@@ -1137,5 +1214,25 @@ void wxFrame::Iconize( bool iconize )
 
 bool wxFrame::IsIconized() const
 {
 
 bool wxFrame::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") );
+    }
+}
+