set transiency relation so that the WM can do better job of positioning the window

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

diff --git a/src/gtk/frame.cpp b/src/gtk/frame.cpp
index f3022f5c0e5763c773c17c5e361d7faf98a05054..b6abf6f26b6fabf6cc7ee3b7efa601db7b77ac90 100644 (file)
--- a/src/gtk/frame.cpp
+++ b/src/gtk/frame.cpp
@@ -15,10 +15,13 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

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

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

 #include "wx/defs.h"
 
 #include "wx/dialog.h"
 #include "wx/defs.h"
 
 #include "wx/dialog.h"


@@ -34,8 +37,8 @@
 #include "wx/dcclient.h"
 
 #include <glib.h>
 #include "wx/dcclient.h"
 
 #include <glib.h>

-#include <gdk/gdk.h>
-#include <gtk/gtk.h>
+#include "wx/gtk/private.h"
+

 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
 
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
 


@@ -45,7 +48,6 @@
 // constants
 // ----------------------------------------------------------------------------
 
 // constants
 // ----------------------------------------------------------------------------
 

-const int wxMENU_HEIGHT    = 27;

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


@@ -61,9 +63,7 @@ extern int g_openDialogs;
 // event tables
 // ----------------------------------------------------------------------------
 
 // event tables
 // ----------------------------------------------------------------------------
 

-#ifndef __WXUNIVERSAL__
-    IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxTopLevelWindow)
-#endif
+IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxTopLevelWindow)

 
 // ============================================================================
 // implementation
 
 // ============================================================================
 // implementation


@@ -79,7 +79,7 @@ extern int g_openDialogs;
 // "child_attached" of menu bar
 //-----------------------------------------------------------------------------
 
 // "child_attached" of menu bar
 //-----------------------------------------------------------------------------
 

-static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrameGTK *win )
+static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )

 {
     if (!win->m_hasVMT) return;
 
 {
     if (!win->m_hasVMT) return;
 


@@ -91,10 +91,16 @@ static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *
 // "child_detached" of menu bar
 //-----------------------------------------------------------------------------
 
 // "child_detached" of menu bar
 //-----------------------------------------------------------------------------
 

-static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrameGTK *win )
+static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )

 {
 {

+    if (g_isIdle)
+        wxapp_install_idle_handler();
+

     if (!win->m_hasVMT) return;
 
     if (!win->m_hasVMT) return;
 

+    // Raise the client area area
+    gdk_window_raise( win->m_wxwindow->window );
+

     win->m_menuBarDetached = TRUE;
     win->GtkUpdateSize();
 }
     win->m_menuBarDetached = TRUE;
     win->GtkUpdateSize();
 }


@@ -106,12 +112,11 @@ static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *
 // "child_attached" of tool bar
 //-----------------------------------------------------------------------------
 
 // "child_attached" of tool bar
 //-----------------------------------------------------------------------------
 

-static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrameGTK *win )
+static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )

 {
     if (!win->m_hasVMT) return;
 
     win->m_toolBarDetached = FALSE;
 {
     if (!win->m_hasVMT) return;
 
     win->m_toolBarDetached = FALSE;

-

     win->GtkUpdateSize();
 }
 
     win->GtkUpdateSize();
 }
 


@@ -119,13 +124,16 @@ static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidge
 // "child_detached" of tool bar
 //-----------------------------------------------------------------------------
 
 // "child_detached" of tool bar
 //-----------------------------------------------------------------------------
 

-static void gtk_toolbar_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrameGTK *win )
+static void gtk_toolbar_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )

 {
     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return;
 
 {
     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return;
 

+    // Raise the client area area
+    gdk_window_raise( win->m_wxwindow->window );
+

     win->m_toolBarDetached = TRUE;
     win->GtkUpdateSize();
 }
     win->m_toolBarDetached = TRUE;
     win->GtkUpdateSize();
 }


@@ -133,36 +141,36 @@ static void gtk_toolbar_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidge
 
 
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------

-// wxFrameGTK itself
+// wxFrame itself

 // ----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------

-// InsertChild for wxFrameGTK
+// InsertChild for wxFrame

 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 

-/* Callback for wxFrameGTK. This very strange beast has to be used because
+/* Callback for wxFrame. This very strange beast has to be used because

  * C++ has no virtual methods in a constructor. We have to emulate a
  * C++ has no virtual methods in a constructor. We have to emulate a

- * virtual function here as wxWindows requires different ways to insert
+ * virtual function here as wxWidgets requires different ways to insert

  * a child in container classes. */
 
  * a child in container classes. */
 

-static void wxInsertChildInFrame( wxFrameGTK* parent, wxWindow* child )
+static void wxInsertChildInFrame( wxFrame* parent, wxWindow* child )

 {
     wxASSERT( GTK_IS_WIDGET(child->m_widget) );
 
     if (!parent->m_insertInClientArea)
     {
 {
     wxASSERT( GTK_IS_WIDGET(child->m_widget) );
 
     if (!parent->m_insertInClientArea)
     {

-        /* these are outside the client area */
-        wxFrameGTK* frame = (wxFrameGTK*) parent;
+        // These are outside the client area
+        wxFrame* frame = (wxFrame*) parent;

         gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
                          GTK_WIDGET(child->m_widget),
                          child->m_x,
                          child->m_y,
                          child->m_width,
                          child->m_height );
         gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
                          GTK_WIDGET(child->m_widget),
                          child->m_x,
                          child->m_y,
                          child->m_width,
                          child->m_height );

-
+                         

 #if wxUSE_TOOLBAR_NATIVE
 #if wxUSE_TOOLBAR_NATIVE

-        /* we connect to these events for recalculating the client area
-           space when the toolbar is floating */
+        // We connect to these events for recalculating the client area
+        // space when the toolbar is floating

         if (wxIS_KIND_OF(child,wxToolBar))
         {
             wxToolBar *toolBar = (wxToolBar*) child;
         if (wxIS_KIND_OF(child,wxToolBar))
         {
             wxToolBar *toolBar = (wxToolBar*) child;


@@ -179,7 +187,7 @@ static void wxInsertChildInFrame( wxFrameGTK* parent, wxWindow* child )
     }
     else
     {
     }
     else
     {

-        /* these are inside the client area */
+        // These are inside the client area

         gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
                          GTK_WIDGET(child->m_widget),
                          child->m_x,
         gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
                          GTK_WIDGET(child->m_widget),
                          child->m_x,


@@ -187,22 +195,23 @@ static void wxInsertChildInFrame( wxFrameGTK* parent, wxWindow* child )
                          child->m_width,
                          child->m_height );
     }
                          child->m_width,
                          child->m_height );
     }

-
-    /* resize on OnInternalIdle */
+    
+    // Resize on OnInternalIdle

     parent->GtkUpdateSize();
 }
 
 // ----------------------------------------------------------------------------
     parent->GtkUpdateSize();
 }
 
 // ----------------------------------------------------------------------------

-// wxFrameGTK creation
+// wxFrame creation

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-void wxFrameGTK::Init()
+void wxFrame::Init()

 {
     m_menuBarDetached = FALSE;
     m_toolBarDetached = FALSE;
 {
     m_menuBarDetached = FALSE;
     m_toolBarDetached = FALSE;

+    m_menuBarHeight = 2;

 }
 
 }
 

-bool wxFrameGTK::Create( wxWindow *parent,
+bool wxFrame::Create( wxWindow *parent,

                       wxWindowID id,
                       const wxString& title,
                       const wxPoint& pos,
                       wxWindowID id,
                       const wxString& title,
                       const wxPoint& pos,


@@ -210,13 +219,14 @@ bool wxFrameGTK::Create( wxWindow *parent,
                       long style,
                       const wxString &name )
 {
                       long style,
                       const wxString &name )
 {

-    bool rt = wxTopLevelWindow::Create(parent, id, title, pos, sizeOrig, 
+    bool rt = wxTopLevelWindow::Create(parent, id, title, pos, sizeOrig,

                                        style, name);
     m_insertCallback = (wxInsertChildFunction) wxInsertChildInFrame;
                                        style, name);
     m_insertCallback = (wxInsertChildFunction) wxInsertChildInFrame;

+    

     return rt;
 }
 
     return rt;
 }
 

-wxFrameGTK::~wxFrameGTK()
+wxFrame::~wxFrame()

 {
     m_isBeingDeleted = TRUE;
     DeleteAllBars();
 {
     m_isBeingDeleted = TRUE;
     DeleteAllBars();


@@ -226,33 +236,33 @@ wxFrameGTK::~wxFrameGTK()
 // overridden wxWindow methods
 // ----------------------------------------------------------------------------
 
 // overridden wxWindow methods
 // ----------------------------------------------------------------------------
 

-void wxFrameGTK::DoGetClientSize( int *width, int *height ) const
+void wxFrame::DoGetClientSize( int *width, int *height ) const

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

-    
+

     wxTopLevelWindow::DoGetClientSize( width, height );
 
     if (height)
     {
 #if wxUSE_MENUS_NATIVE
     wxTopLevelWindow::DoGetClientSize( width, height );
 
     if (height)
     {
 #if wxUSE_MENUS_NATIVE

-        /* menu bar */
+        // menu bar

         if (m_frameMenuBar)
         {
             if (!m_menuBarDetached)
         if (m_frameMenuBar)
         {
             if (!m_menuBarDetached)

-                (*height) -= wxMENU_HEIGHT;
+                (*height) -= m_menuBarHeight;

             else
                 (*height) -= wxPLACE_HOLDER;
         }
 #endif // wxUSE_MENUS_NATIVE
 
 #if wxUSE_STATUSBAR
             else
                 (*height) -= wxPLACE_HOLDER;
         }
 #endif // wxUSE_MENUS_NATIVE
 
 #if wxUSE_STATUSBAR

-        /* status bar */
-        if (m_frameStatusBar && m_frameStatusBar->IsShown()) 
+        // status bar
+        if (m_frameStatusBar && m_frameStatusBar->IsShown())

             (*height) -= wxSTATUS_HEIGHT;
 #endif // wxUSE_STATUSBAR
 
 #if wxUSE_TOOLBAR
             (*height) -= wxSTATUS_HEIGHT;
 #endif // wxUSE_STATUSBAR
 
 #if wxUSE_TOOLBAR

-        /* tool bar */
+        // tool bar

         if (m_frameToolBar && m_frameToolBar->IsShown())
         {
             if (m_toolBarDetached)
         if (m_frameToolBar && m_frameToolBar->IsShown())
         {
             if (m_toolBarDetached)


@@ -277,28 +287,28 @@ void wxFrameGTK::DoGetClientSize( int *width, int *height ) const
     }
 }
 
     }
 }
 

-void wxFrameGTK::DoSetClientSize( int width, int height )
+void wxFrame::DoSetClientSize( int width, int height )

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

-        /* menu bar */
+        // menu bar

         if (m_frameMenuBar)
         {
             if (!m_menuBarDetached)
         if (m_frameMenuBar)
         {
             if (!m_menuBarDetached)

-                height += wxMENU_HEIGHT;
+                height += m_menuBarHeight;

             else
                 height += wxPLACE_HOLDER;
         }
 #endif // wxUSE_MENUS_NATIVE
 
 #if wxUSE_STATUSBAR
             else
                 height += wxPLACE_HOLDER;
         }
 #endif // wxUSE_MENUS_NATIVE
 
 #if wxUSE_STATUSBAR

-        /* status bar */
+        // status bar

         if (m_frameStatusBar && m_frameStatusBar->IsShown()) height += wxSTATUS_HEIGHT;
 #endif
 
 #if wxUSE_TOOLBAR
         if (m_frameStatusBar && m_frameStatusBar->IsShown()) height += wxSTATUS_HEIGHT;
 #endif
 
 #if wxUSE_TOOLBAR

-        /* tool bar */
+        // tool bar

         if (m_frameToolBar && m_frameToolBar->IsShown())
         {
             if (m_toolBarDetached)
         if (m_frameToolBar && m_frameToolBar->IsShown())
         {
             if (m_toolBarDetached)


@@ -324,60 +334,65 @@ void wxFrameGTK::DoSetClientSize( int width, int height )
     wxTopLevelWindow::DoSetClientSize( width, height );
 }
 
     wxTopLevelWindow::DoSetClientSize( width, height );
 }
 

-void wxFrameGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
+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;
     // m_y = y;
 
                          int width, int height )
 {
     // due to a bug in gtk, x,y are always 0
     // m_x = x;
     // m_y = y;
 

-    /* avoid recursions */
+    // avoid recursions

     if (m_resizing) return;
     m_resizing = TRUE;
 
     if (m_resizing) return;
     m_resizing = TRUE;
 

-    /* this shouldn't happen: wxFrameGTK, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
+    // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow

     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 
     m_width = width;
     m_height = height;
 
     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 
     m_width = width;
     m_height = height;
 

-    /* space occupied by m_frameToolBar and m_frameMenuBar */
+    // space occupied by m_frameToolBar and m_frameMenuBar

     int client_area_x_offset = 0,
         client_area_y_offset = 0;
 
     int client_area_x_offset = 0,
         client_area_y_offset = 0;
 

-    /* wxMDIChildFrame derives from wxFrameGTK but it _is_ a wxWindow as it uses
+    /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses

        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only

-       set in wxFrameGTK::Create so it is used to check what kind of frame we
+       set in wxFrame::Create so it is used to check what kind of frame we

        have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
        importantly) m_mainWidget */
 
        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 */
 

-    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;
+    int minWidth = GetMinWidth(),
+        minHeight = GetMinHeight(),
+        maxWidth = GetMaxWidth(),
+        maxHeight = GetMaxHeight();
+
+    if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
+    if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
+    if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
+    if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;

 
     if (m_mainWidget)
     {
 
     if (m_mainWidget)
     {

-        /* set size hints */
+        // set size hints

         gint flag = 0; // GDK_HINT_POS;
         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;
+        if ((minWidth != -1) || (minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
+        if ((maxWidth != -1) || (maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;

         GdkGeometry geom;
         GdkGeometry geom;

-        geom.min_width = m_minWidth;
-        geom.min_height = m_minHeight;
-        geom.max_width = m_maxWidth;
-        geom.max_height = m_maxHeight;
+        geom.min_width = minWidth;
+        geom.min_height = minHeight;
+        geom.max_width = maxWidth;
+        geom.max_height = maxHeight;

         gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
                                        (GtkWidget*) NULL,
                                        &geom,
                                        (GdkWindowHints) flag );
 
         gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
                                        (GtkWidget*) NULL,
                                        &geom,
                                        (GdkWindowHints) flag );
 

-        /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
-         * menubar, the toolbar and the client area, which is represented by
-         * m_wxwindow.
-         * this hurts in the eye, but I don't want to call SetSize()
-         * because I don't want to call any non-native functions here. */
+        // I revert back to wxGTK's original behaviour. m_mainWidget holds
+        // the menubar, the toolbar and the client area, which is represented
+        // by m_wxwindow.
+        // This hurts in the eye, but I don't want to call SetSize()
+        // because I don't want to call any non-native functions here.

 
 #if wxUSE_MENUS_NATIVE
         if (m_frameMenuBar)
 
 #if wxUSE_MENUS_NATIVE
         if (m_frameMenuBar)


@@ -385,7 +400,7 @@ void wxFrameGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
             int xx = m_miniEdge;
             int yy = m_miniEdge + m_miniTitle;
             int ww = m_width  - 2*m_miniEdge;
             int xx = m_miniEdge;
             int yy = m_miniEdge + m_miniTitle;
             int ww = m_width  - 2*m_miniEdge;

-            int hh = wxMENU_HEIGHT;
+            int hh = m_menuBarHeight;

             if (m_menuBarDetached) hh = wxPLACE_HOLDER;
             m_frameMenuBar->m_x = xx;
             m_frameMenuBar->m_y = yy;
             if (m_menuBarDetached) hh = wxPLACE_HOLDER;
             m_frameMenuBar->m_x = xx;
             m_frameMenuBar->m_y = yy;


@@ -408,7 +423,7 @@ void wxFrameGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
             if (m_frameMenuBar)
             {
                 if (!m_menuBarDetached)
             if (m_frameMenuBar)
             {
                 if (!m_menuBarDetached)

-                    yy += wxMENU_HEIGHT;
+                    yy += m_menuBarHeight;

                 else
                     yy += wxPLACE_HOLDER;
             }
                 else
                     yy += wxPLACE_HOLDER;
             }


@@ -417,7 +432,7 @@ void wxFrameGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
             m_frameToolBar->m_x = xx;
             m_frameToolBar->m_y = yy;
 
             m_frameToolBar->m_x = xx;
             m_frameToolBar->m_y = yy;
 

-            /* don't change the toolbar's reported height/width */
+            // don't change the toolbar's reported height/width

             int ww, hh;
             if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
             {
             int ww, hh;
             if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
             {


@@ -452,8 +467,8 @@ void wxFrameGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
     }
     else
     {
     }
     else
     {

-        /* if there is no m_mainWidget between m_widget and m_wxwindow there
-           is no need to set the size or position of m_wxwindow. */
+        // If there is no m_mainWidget between m_widget and m_wxwindow there
+        // is no need to set the size or position of m_wxwindow.

     }
 
 #if wxUSE_STATUSBAR
     }
 
 #if wxUSE_STATUSBAR


@@ -494,9 +509,9 @@ void wxFrameGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
     m_resizing = FALSE;
 }
 
     m_resizing = FALSE;
 }
 

-void wxFrameGTK::OnInternalIdle()
+void wxFrame::OnInternalIdle()

 {
 {

-    wxTopLevelWindow::OnInternalIdle();
+    wxFrameBase::OnInternalIdle();

 
 #if wxUSE_MENUS_NATIVE
     if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();
 
 #if wxUSE_MENUS_NATIVE
     if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();


@@ -515,7 +530,7 @@ void wxFrameGTK::OnInternalIdle()
 
 #if wxUSE_MENUS_NATIVE
 
 
 #if wxUSE_MENUS_NATIVE
 

-void wxFrameGTK::DetachMenuBar()
+void wxFrame::DetachMenuBar()

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


@@ -533,15 +548,15 @@ void wxFrameGTK::DetachMenuBar()
                 GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
         }
 
                 GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
         }
 

-        gtk_container_remove( GTK_CONTAINER(m_mainWidget), m_frameMenuBar->m_widget );

         gtk_widget_ref( m_frameMenuBar->m_widget );
         gtk_widget_ref( m_frameMenuBar->m_widget );

-        gtk_widget_unparent( m_frameMenuBar->m_widget );
+
+        gtk_container_remove( GTK_CONTAINER(m_mainWidget), m_frameMenuBar->m_widget );

     }
 
     wxFrameBase::DetachMenuBar();
 }
 
     }
 
     wxFrameBase::DetachMenuBar();
 }
 

-void wxFrameGTK::AttachMenuBar( wxMenuBar *menuBar )
+void wxFrame::AttachMenuBar( wxMenuBar *menuBar )

 {
     wxFrameBase::AttachMenuBar(menuBar);
 
 {
     wxFrameBase::AttachMenuBar(menuBar);
 


@@ -565,19 +580,42 @@ void wxFrameGTK::AttachMenuBar( wxMenuBar *menuBar )
             gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",
                 GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
         }
             gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",
                 GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
         }

+        
+        gtk_widget_show( m_frameMenuBar->m_widget );

 
 

-        m_frameMenuBar->Show( TRUE );
+        UpdateMenuBarSize();

     }
     }

+    else
+    {
+        m_menuBarHeight = 2;
+        GtkUpdateSize();        // resize window in OnInternalIdle
+    }
+}
+
+void wxFrame::UpdateMenuBarSize()
+{
+    wxASSERT_MSG( m_frameMenuBar, _T("Updating non existant menubar?") );
+
+    GtkRequisition  req;

 
 

-    /* resize window in OnInternalIdle */
-    m_sizeSet = FALSE;
+    req.width = 2;
+    req.height = 2;
+
+    (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(m_frameMenuBar->m_widget) )->size_request )
+        (m_frameMenuBar->m_widget, &req );
+
+    m_menuBarHeight = req.height;
+
+        // resize window in OnInternalIdle
+
+    GtkUpdateSize();

 }
 
 #endif // wxUSE_MENUS_NATIVE
 
 #if wxUSE_TOOLBAR
 
 }
 
 #endif // wxUSE_MENUS_NATIVE
 
 #if wxUSE_TOOLBAR
 

-wxToolBar* wxFrameGTK::CreateToolBar( long style, wxWindowID id, const wxString& name )
+wxToolBar* wxFrame::CreateToolBar( long style, wxWindowID id, const wxString& name )

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


@@ -587,18 +625,20 @@ wxToolBar* wxFrameGTK::CreateToolBar( long style, wxWindowID id, const wxString&
 
     m_insertInClientArea = TRUE;
 
 
     m_insertInClientArea = TRUE;
 

-    m_sizeSet = FALSE;
+    GtkUpdateSize();

 
     return m_frameToolBar;
 }
 
 
     return m_frameToolBar;
 }
 

-void wxFrameGTK::SetToolBar(wxToolBar *toolbar)
+void wxFrame::SetToolBar(wxToolBar *toolbar)

 {
 {

+    bool hadTbar = m_frameToolBar != NULL;
+

     wxFrameBase::SetToolBar(toolbar);
 
     wxFrameBase::SetToolBar(toolbar);
 

-    if (m_frameToolBar)
+    if ( m_frameToolBar )

     {
     {

-        /* insert into toolbar area if not already there */
+        // insert into toolbar area if not already there

         if ((m_frameToolBar->m_widget->parent) &&
             (m_frameToolBar->m_widget->parent != m_mainWidget))
         {
         if ((m_frameToolBar->m_widget->parent) &&
             (m_frameToolBar->m_widget->parent != m_mainWidget))
         {


@@ -608,13 +648,21 @@ void wxFrameGTK::SetToolBar(wxToolBar *toolbar)
             GtkUpdateSize();
         }
     }
             GtkUpdateSize();
         }
     }

+    else // toolbar unset
+    {
+        // still need to update size if it had been there before
+        if ( hadTbar )
+        {
+            GtkUpdateSize();
+        }
+    }

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

-wxStatusBar* wxFrameGTK::CreateStatusBar(int number,
+wxStatusBar* wxFrame::CreateStatusBar(int number,

                                       long style,
                                       wxWindowID id,
                                       const wxString& name)
                                       long style,
                                       wxWindowID id,
                                       const wxString& name)


@@ -622,17 +670,27 @@ wxStatusBar* wxFrameGTK::CreateStatusBar(int number,
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
     // because it will change when toolbar is added
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
     // because it will change when toolbar is added

-    m_sizeSet = FALSE;
+    GtkUpdateSize();

 
     return wxFrameBase::CreateStatusBar( number, style, id, name );
 }
 
 
     return wxFrameBase::CreateStatusBar( number, style, id, name );
 }
 

-void wxFrameGTK::PositionStatusBar()
+void wxFrame::SetStatusBar(wxStatusBar *statbar)
+{
+    bool hadStatBar = m_frameStatusBar != NULL;
+    
+    wxFrameBase::SetStatusBar(statbar);
+    
+    if (hadStatBar && !m_frameToolBar) 
+        GtkUpdateSize();
+}
+
+void wxFrame::PositionStatusBar()

 {
     if ( !m_frameStatusBar )
         return;
 
 {
     if ( !m_frameStatusBar )
         return;
 

-    m_sizeSet = FALSE;
+    GtkUpdateSize();

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