]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/sizer.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
fix gcc warnings
[wxWidgets.git] / src / common / sizer.cpp
diff --git a/src/common/sizer.cpp b/src/common/sizer.cpp
index a41263744895ad26306f145f00f30160586bca7a..e121731de814863e0a75c781f9a4f726776b268f 100644 (file)
--- a/src/common/sizer.cpp
+++ b/src/common/sizer.cpp
@@ -1,15 +1,16 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        sizer.cpp
 // Purpose:     provide new wxSizer class for layout
 /////////////////////////////////////////////////////////////////////////////
 // Name:        sizer.cpp
 // Purpose:     provide new wxSizer class for layout
-// Author:      Robert Roebling and Robin Dunn
-// Modified by:
+// Author:      Robert Roebling and Robin Dunn, contributions by
+//              Dirk Holtwick, Ron Lee
+// Modified by: Ron Lee
 // Created:
 // RCS-ID:      $Id$
 // Created:
 // RCS-ID:      $Id$
-// Copyright:   (c) Robin Dunn, Dirk Holtwick and Robert Roebling
+// Copyright:   (c) Robin Dunn, Robert Roebling
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
 #pragma implementation "sizer.h"
 #endif
 
 #pragma implementation "sizer.h"
 #endif
 
@@ -24,88 +25,123 @@
 #include "wx/utils.h"
 #include "wx/statbox.h"
 #include "wx/notebook.h"
 #include "wx/utils.h"
 #include "wx/statbox.h"
 #include "wx/notebook.h"
+#include <wx/listimpl.cpp>
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 
-IMPLEMENT_ABSTRACT_CLASS(wxSizerItem, wxObject);
-IMPLEMENT_ABSTRACT_CLASS(wxSizer, wxObject);
-IMPLEMENT_ABSTRACT_CLASS(wxGridSizer, wxSizer);
-IMPLEMENT_ABSTRACT_CLASS(wxFlexGridSizer, wxGridSizer);
-IMPLEMENT_ABSTRACT_CLASS(wxBoxSizer, wxSizer);
-IMPLEMENT_ABSTRACT_CLASS(wxStaticBoxSizer, wxBoxSizer);
-#if wxUSE_NOTEBOOK
-IMPLEMENT_ABSTRACT_CLASS(wxNotebookSizer, wxSizer);
+IMPLEMENT_CLASS(wxSizerItem, wxObject)
+IMPLEMENT_CLASS(wxSizer, wxObject)
+IMPLEMENT_CLASS(wxGridSizer, wxSizer)
+IMPLEMENT_CLASS(wxFlexGridSizer, wxGridSizer)
+IMPLEMENT_CLASS(wxBoxSizer, wxSizer)
+#if wxUSE_STATBOX
+IMPLEMENT_CLASS(wxStaticBoxSizer, wxBoxSizer)
 #endif
 #endif
+#if wxUSE_BOOKCTRL
+IMPLEMENT_CLASS(wxBookCtrlSizer, wxSizer)
+#if wxUSE_NOTEBOOK
+IMPLEMENT_CLASS(wxNotebookSizer, wxBookCtrlSizer)
+#endif // wxUSE_NOTEBOOK
+#endif // wxUSE_BOOKCTRL
+
+WX_DEFINE_EXPORTED_LIST( wxSizerItemList );
 
 
+/*
+       TODO PROPERTIES
+         sizeritem
+           object
+               object_ref
+                 minsize
+                 option
+                 flag
+                 border
+     spacer
+               option
+               flag
+               borfder
+       boxsizer
+          orient
+    staticboxsizer
+          orient
+          label
+       gridsizer
+          rows
+          cols
+          vgap
+          hgap
+       flexgridsizer
+          rows
+          cols
+          vgap
+          hgap
+          growablerows
+          growablecols
+    minsize
+*/
 //---------------------------------------------------------------------------
 // wxSizerItem
 //---------------------------------------------------------------------------
 
 //---------------------------------------------------------------------------
 // wxSizerItem
 //---------------------------------------------------------------------------
 
-wxSizerItem::wxSizerItem( int width, int height, int option, int flag, int border, wxObject* userData )
+wxSizerItem::wxSizerItem( int width, int height, int proportion, int flag, int border, wxObject* userData )
+    : m_window( NULL )
+    , m_sizer( NULL )
+    , m_size( wxSize( width, height ) ) // size is set directly
+    , m_minSize( m_size )               // minimal size is the initial size
+    , m_proportion( proportion )
+    , m_border( border )
+    , m_flag( flag )
+    , m_show( true )
+    , m_userData( userData )
 {
 {
-    m_window = (wxWindow *) NULL;
-    m_sizer = (wxSizer *) NULL;
-    m_option = option;
-    m_border = border;
-    m_flag = flag;
-    m_userData = userData;
-
-    // minimal size is the initial size
-    m_minSize.x = width;
-    m_minSize.y = height;
-
-    SetRatio(width, height);
-
-    // size is set directly
-    m_size = m_minSize;
+    SetRatio( m_size );
 }
 
 }
 
-wxSizerItem::wxSizerItem( wxWindow *window, int option, int flag, int border, wxObject* userData )
+wxSizerItem::wxSizerItem( wxWindow *window, int proportion, int flag, int border, wxObject* userData )
+    : m_window( window )
+    , m_sizer( NULL )
+    , m_minSize( window->GetSize() )    // minimal size is the initial size
+    , m_proportion( proportion )
+    , m_border( border )
+    , m_flag( flag )
+    , m_show( true )
+    , m_userData( userData )
 {
 {
-    m_window = window;
-    m_sizer = (wxSizer *) NULL;
-    m_option = option;
-    m_border = border;
-    m_flag = flag;
-    m_userData = userData;
-
-    // minimal size is the initial size
-    m_minSize = window->GetSize();
-
     // aspect ratio calculated from initial size
     // aspect ratio calculated from initial size
-    SetRatio(m_minSize);
+    SetRatio( m_minSize );
 
 
-    // size is calculated later
-    // m_size = ...
+    // m_size is calculated later
 }
 
 }
 
-wxSizerItem::wxSizerItem( wxSizer *sizer, int option, int flag, int border, wxObject* userData )
+wxSizerItem::wxSizerItem( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData )
+    : m_window( NULL )
+    , m_sizer( sizer )
+    , m_proportion( proportion )
+    , m_border( border )
+    , m_flag( flag )
+    , m_show( true )
+    , m_ratio( 0.0 )
+    , m_userData( userData )
 {
 {
-    m_window = (wxWindow *) NULL;
-    m_sizer = sizer;
-    m_option = option;
-    m_border = border;
-    m_flag = flag;
-    m_userData = userData;
-
-    // minimal size is calculated later
-    // m_minSize = ...
-    m_ratio = 0;
-
-    // size is calculated later
-    // m_size = ...
+    // m_minSize is calculated later
+    // m_size is calculated later
 }
 
 wxSizerItem::~wxSizerItem()
 {
 }
 
 wxSizerItem::~wxSizerItem()
 {
-    if (m_userData)
-        delete m_userData;
-    if (m_sizer)
+    delete m_userData;
+
+    if ( m_window )
+    {
+        m_window->SetContainingSizer(NULL);
+    }
+    else // we must be a sizer
+    {
         delete m_sizer;
         delete m_sizer;
+    }
 }
 
 
 }
 
 
-wxSize wxSizerItem::GetSize()
+wxSize wxSizerItem::GetSize() const
 {
     wxSize ret;
     if (IsSizer())
 {
     wxSize ret;
     if (IsSizer())
@@ -133,21 +169,25 @@ wxSize wxSizerItem::CalcMin()
     if (IsSizer())
     {
         ret = m_sizer->GetMinSize();
     if (IsSizer())
     {
         ret = m_sizer->GetMinSize();
+
         // if we have to preserve aspect ratio _AND_ this is
         // the first-time calculation, consider ret to be initial size
         // if we have to preserve aspect ratio _AND_ this is
         // the first-time calculation, consider ret to be initial size
-        if ((m_flag & wxSHAPED) && !m_ratio) SetRatio(ret);
+        if ((m_flag & wxSHAPED) && !m_ratio)
+            SetRatio(ret);
     }
     }
-
-/*
-    The minimum size of a window should be the
-    initial size, as saved in m_minSize, not the
-    current size.
-
     else
     else
-    if (IsWindow())
-        ret = m_window->GetSize();
-*/
-    else ret = m_minSize;
+    {
+        if ( IsWindow() && (m_flag & wxADJUST_MINSIZE) )
+        {
+            // By user request, keep the minimal size for this item
+            // in sync with the largest of BestSize and any user supplied
+            // minimum size hint.  Useful in cases where the item is
+            // changeable -- static text labels, etc.
+            m_minSize = m_window->GetAdjustedBestSize();
+        }
+
+        ret = m_minSize;
+    }
 
     if (m_flag & wxWEST)
         ret.x += m_border;
 
     if (m_flag & wxWEST)
         ret.x += m_border;
@@ -163,30 +203,12 @@ wxSize wxSizerItem::CalcMin()
 
 void wxSizerItem::SetDimension( wxPoint pos, wxSize size )
 {
 
 void wxSizerItem::SetDimension( wxPoint pos, wxSize size )
 {
-    m_pos = pos;
-
-    if (m_flag & wxWEST)
+    if (m_flag & wxSHAPED)
     {
     {
-        pos.x += m_border;
-        size.x -= m_border;
-    }
-    if (m_flag & wxEAST)
-    {
-        size.x -= m_border;
-    }
-    if (m_flag & wxNORTH)
-    {
-        pos.y += m_border;
-        size.y -= m_border;
-    }
-    if (m_flag & wxSOUTH)
-    {
-        size.y -= m_border;
-    }
-    if (m_flag & wxSHAPED) {
         // adjust aspect ratio
         int rwidth = (int) (size.y * m_ratio);
         // adjust aspect ratio
         int rwidth = (int) (size.y * m_ratio);
-        if (rwidth > size.x) {
+        if (rwidth > size.x)
+        {
             // fit horizontally
             int rheight = (int) (size.x / m_ratio);
             // add vertical space
             // fit horizontally
             int rheight = (int) (size.x / m_ratio);
             // add vertical space
@@ -196,7 +218,9 @@ void wxSizerItem::SetDimension( wxPoint pos, wxSize size )
                 pos.y += (size.y - rheight);
             // use reduced dimensions
             size.y =rheight;
                 pos.y += (size.y - rheight);
             // use reduced dimensions
             size.y =rheight;
-        } else if (rwidth < size.x) {
+        }
+        else if (rwidth < size.x)
+        {
             // add horizontal space
             if (m_flag & wxALIGN_CENTER_HORIZONTAL)
                 pos.x += (size.x - rwidth) / 2;
             // add horizontal space
             if (m_flag & wxALIGN_CENTER_HORIZONTAL)
                 pos.x += (size.x - rwidth) / 2;
@@ -206,6 +230,30 @@ void wxSizerItem::SetDimension( wxPoint pos, wxSize size )
         }
     }
 
         }
     }
 
+    // This is what GetPosition() returns. Since we calculate
+    // borders afterwards, GetPosition() will be the left/top
+    // corner of the surrounding border.
+    m_pos = pos;
+
+    if (m_flag & wxWEST)
+    {
+        pos.x += m_border;
+        size.x -= m_border;
+    }
+    if (m_flag & wxEAST)
+    {
+        size.x -= m_border;
+    }
+    if (m_flag & wxNORTH)
+    {
+        pos.y += m_border;
+        size.y -= m_border;
+    }
+    if (m_flag & wxSOUTH)
+    {
+        size.y -= m_border;
+    }
+
     if (IsSizer())
         m_sizer->SetDimension( pos.x, pos.y, size.x, size.y );
 
     if (IsSizer())
         m_sizer->SetDimension( pos.x, pos.y, size.x, size.y );
 
@@ -215,132 +263,326 @@ void wxSizerItem::SetDimension( wxPoint pos, wxSize size )
     m_size = size;
 }
 
     m_size = size;
 }
 
-bool wxSizerItem::IsWindow()
+void wxSizerItem::DeleteWindows()
+{
+    if (m_window)
+         m_window->Destroy();
+
+    if (m_sizer)
+        m_sizer->DeleteWindows();
+}
+
+bool wxSizerItem::IsWindow() const
 {
     return (m_window != NULL);
 }
 
 {
     return (m_window != NULL);
 }
 
-bool wxSizerItem::IsSizer()
+bool wxSizerItem::IsSizer() const
 {
     return (m_sizer != NULL);
 }
 
 {
     return (m_sizer != NULL);
 }
 
-bool wxSizerItem::IsSpacer()
+bool wxSizerItem::IsSpacer() const
 {
     return (m_window == NULL) && (m_sizer == NULL);
 }
 
 {
     return (m_window == NULL) && (m_sizer == NULL);
 }
 
+void wxSizerItem::Show( bool show )
+{
+    m_show = show;
+
+    if( IsWindow() )
+        m_window->Show( show );
+    else if( IsSizer() )
+        m_sizer->ShowItems( show );
+
+    // ... nothing else to do to hide/show spacers
+}
+
+void wxSizerItem::SetOption( int option )
+{
+    SetProportion( option );
+}
+
+int wxSizerItem::GetOption() const
+{
+    return GetProportion();
+}
+
+
 //---------------------------------------------------------------------------
 // wxSizer
 //---------------------------------------------------------------------------
 
 wxSizer::wxSizer()
 //---------------------------------------------------------------------------
 // wxSizer
 //---------------------------------------------------------------------------
 
 wxSizer::wxSizer()
+    : m_minSize( wxSize( 0, 0 ) )
 {
 {
-    m_children.DeleteContents( TRUE );
-    m_minSize.x = 0;
-    m_minSize.y = 0;
 }
 
 wxSizer::~wxSizer()
 {
 }
 
 wxSizer::~wxSizer()
 {
+    WX_CLEAR_LIST(wxSizerItemList, m_children);
 }
 
 }
 
-void wxSizer::Add( wxWindow *window, int option, int flag, int border, wxObject* userData )
+void wxSizer::Add( wxWindow *window, int proportion, int flag, int border, wxObject* userData )
 {
 {
-    m_children.Append( new wxSizerItem( window, option, flag, border, userData ) );
+    m_children.Append( new wxSizerItem( window, proportion, flag, border, userData ) );
+    window->SetContainingSizer( this );
 }
 
 }
 
-void wxSizer::Add( wxSizer *sizer, int option, int flag, int border, wxObject* userData )
+void wxSizer::Add( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData )
 {
 {
-    m_children.Append( new wxSizerItem( sizer, option, flag, border, userData ) );
+    m_children.Append( new wxSizerItem( sizer, proportion, flag, border, userData ) );
 }
 
 }
 
-void wxSizer::Add( int width, int height, int option, int flag, int border, wxObject* userData )
+void wxSizer::Add( int width, int height, int proportion, int flag, int border, wxObject* userData )
 {
 {
-    m_children.Append( new wxSizerItem( width, height, option, flag, border, userData ) );
+    m_children.Append( new wxSizerItem( width, height, proportion, flag, border, userData ) );
 }
 
 }
 
-void wxSizer::Prepend( wxWindow *window, int option, int flag, int border, wxObject* userData )
+void wxSizer::Add( wxSizerItem *item )
 {
 {
-    m_children.Insert( new wxSizerItem( window, option, flag, border, userData ) );
+    m_children.Append( item );
+
+    if( item->GetWindow() )
+        item->GetWindow()->SetContainingSizer( this );
 }
 
 }
 
-void wxSizer::Prepend( wxSizer *sizer, int option, int flag, int border, wxObject* userData )
+void wxSizer::Prepend( wxWindow *window, int proportion, int flag, int border, wxObject* userData )
 {
 {
-    m_children.Insert( new wxSizerItem( sizer, option, flag, border, userData ) );
+    m_children.Insert( new wxSizerItem( window, proportion, flag, border, userData ) );
+    window->SetContainingSizer( this );
 }
 
 }
 
-void wxSizer::Prepend( int width, int height, int option, int flag, int border, wxObject* userData )
+void wxSizer::Prepend( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData )
 {
 {
-    m_children.Insert( new wxSizerItem( width, height, option, flag, border, userData ) );
+    m_children.Insert( new wxSizerItem( sizer, proportion, flag, border, userData ) );
 }
 
 }
 
-void wxSizer::Insert( int before, wxWindow *window, int option, int flag, int border, wxObject* userData )
+void wxSizer::Prepend( int width, int height, int proportion, int flag, int border, wxObject* userData )
 {
 {
-    m_children.Insert( before, new wxSizerItem( window, option, flag, border, userData ) );
+    m_children.Insert( new wxSizerItem( width, height, proportion, flag, border, userData ) );
 }
 
 }
 
-void wxSizer::Insert( int before, wxSizer *sizer, int option, int flag, int border, wxObject* userData )
+void wxSizer::Prepend( wxSizerItem *item )
 {
 {
-    m_children.Insert( before, new wxSizerItem( sizer, option, flag, border, userData ) );
+    m_children.Insert( item );
+
+    if( item->GetWindow() )
+        item->GetWindow()->SetContainingSizer( this );
 }
 
 }
 
-void wxSizer::Insert( int before, int width, int height, int option, int flag, int border, wxObject* userData )
+void wxSizer::Insert( size_t index,
+                      wxWindow *window,
+                      int proportion,
+                      int flag,
+                      int border,
+                      wxObject* userData )
 {
 {
-    m_children.Insert( before, new wxSizerItem( width, height, option, flag, border, userData ) );
+    m_children.Insert( index,
+                       new wxSizerItem( window, proportion, flag, border, userData ) );
+    window->SetContainingSizer( this );
+}
+
+void wxSizer::Insert( size_t index,
+                      wxSizer *sizer,
+                      int proportion,
+                      int flag,
+                      int border,
+                      wxObject* userData )
+{
+    m_children.Insert( index,
+                       new wxSizerItem( sizer, proportion, flag, border, userData ) );
+}
+
+void wxSizer::Insert( size_t index,
+                      int width,
+                      int height,
+                      int proportion,
+                      int flag,
+                      int border,
+                      wxObject* userData )
+{
+    m_children.Insert( index,
+                       new wxSizerItem( width, height, proportion, flag, border, userData ) );
+}
+
+void wxSizer::Insert( size_t index, wxSizerItem *item )
+{
+    m_children.Insert( index, item );
+
+    if( item->GetWindow() )
+        item->GetWindow()->SetContainingSizer( this );
 }
 
 bool wxSizer::Remove( wxWindow *window )
 {
 }
 
 bool wxSizer::Remove( wxWindow *window )
 {
-    wxASSERT( window );
+    return Detach( window );
+}
+
+bool wxSizer::Remove( wxSizer *sizer )
+{
+    wxASSERT_MSG( sizer, _T("Removing NULL sizer") );
 
 
-    wxNode *node = m_children.First();
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*)node->Data();
-        if (item->GetWindow() == window)
+        wxSizerItem     *item = node->GetData();
+
+        if (item->GetSizer() == sizer)
         {
         {
-            m_children.DeleteNode( node );
-            return TRUE;
+            delete item;
+            m_children.Erase( node );
+            return true;
         }
         }
-        node = node->Next();
+
+        node = node->GetNext();
     }
 
     }
 
-    return FALSE;
+    return false;
 }
 
 }
 
-bool wxSizer::Remove( wxSizer *sizer )
+bool wxSizer::Remove( int index )
+{
+    wxCHECK_MSG( index >= 0 && (size_t)index < m_children.GetCount(),
+                 false,
+                 _T("Remove index is out of range") );
+
+    wxSizerItemList::compatibility_iterator node = m_children.Item( index );
+
+    wxCHECK_MSG( node, false, _T("Failed to find child node") );
+
+    wxSizerItem *item = node->GetData();
+
+    if( item->IsWindow() )
+        item->GetWindow()->SetContainingSizer( NULL );
+
+    delete item;
+    m_children.Erase( node );
+    return true;
+}
+
+bool wxSizer::Detach( wxSizer *sizer )
 {
 {
-    wxASSERT( sizer );
+    wxASSERT_MSG( sizer, _T("Detaching NULL sizer") );
 
 
-    wxNode *node = m_children.First();
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*)node->Data();
+        wxSizerItem     *item = node->GetData();
+
         if (item->GetSizer() == sizer)
         {
         if (item->GetSizer() == sizer)
         {
-            m_children.DeleteNode( node );
-            return TRUE;
+            item->DetachSizer();
+            delete item;
+            m_children.Erase( node );
+            return true;
         }
         }
-        node = node->Next();
+        node = node->GetNext();
     }
 
     }
 
-    return FALSE;
+    return false;
 }
 
 }
 
-bool wxSizer::Remove( int pos )
+bool wxSizer::Detach( wxWindow *window )
 {
 {
-    wxNode *node = m_children.Nth( pos );
-    if (!node) return FALSE;
+    wxASSERT_MSG( window, _T("Detaching NULL window") );
 
 
-    m_children.DeleteNode( node );
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
+    while (node)
+    {
+        wxSizerItem     *item = node->GetData();
+
+        if (item->GetWindow() == window)
+        {
+            item->GetWindow()->SetContainingSizer( NULL );
+            delete item;
+            m_children.Erase( node );
+            return true;
+        }
+        node = node->GetNext();
+    }
 
 
-    return TRUE;
+    return false;
 }
 
 }
 
-void wxSizer::Fit( wxWindow *window )
+bool wxSizer::Detach( int index )
 {
 {
-    window->SetSize( GetMinWindowSize( window ) );
+    wxCHECK_MSG( index >= 0 && (size_t)index < m_children.GetCount(),
+                 false,
+                 _T("Detach index is out of range") );
+
+    wxSizerItemList::compatibility_iterator node = m_children.Item( index );
+
+    wxCHECK_MSG( node, false, _T("Failed to find child node") );
+
+    wxSizerItem *item = node->GetData();
+
+    if( item->IsSizer() )
+        item->DetachSizer();
+    else if( item->IsWindow() )
+        item->GetWindow()->SetContainingSizer( NULL );
+
+    delete item;
+    m_children.Erase( node );
+    return true;
+}
+
+void wxSizer::Clear( bool delete_windows )
+{
+    // First clear the ContainingSizer pointers
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
+    while (node)
+    {
+        wxSizerItem     *item = node->GetData();
+
+        if (item->IsWindow())
+            item->GetWindow()->SetContainingSizer( NULL );
+        node = node->GetNext();
+    }
+
+    // Destroy the windows if needed
+    if (delete_windows)
+        DeleteWindows();
+
+    // Now empty the list
+    WX_CLEAR_LIST(wxSizerItemList, m_children);
+}
+
+void wxSizer::DeleteWindows()
+{
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
+    while (node)
+    {
+        wxSizerItem     *item = node->GetData();
+
+        item->DeleteWindows();
+        node = node->GetNext();
+    }
+}
+
+wxSize wxSizer::Fit( wxWindow *window )
+{
+    wxSize size;
+    if (window->IsTopLevel())
+        size = FitSize( window );
+    else
+        size = GetMinWindowSize( window );
+
+    window->SetSize( size );
+
+    return size;
+}
+
+void wxSizer::FitInside( wxWindow *window )
+{
+    wxSize size;
+    if (window->IsTopLevel())
+        size = VirtualFitSize( window );
+    else
+        size = GetMinClientSize( window );
+
+    window->SetVirtualSize( size );
 }
 
 void wxSizer::Layout()
 }
 
 void wxSizer::Layout()
@@ -351,27 +593,104 @@ void wxSizer::Layout()
 
 void wxSizer::SetSizeHints( wxWindow *window )
 {
 
 void wxSizer::SetSizeHints( wxWindow *window )
 {
-    wxSize size( GetMinWindowSize( window ) );
-    window->SetSizeHints( size.x, size.y );
+    // Preserve the window's max size hints, but set the
+    // lower bound according to the sizer calculations.
+
+    wxSize size = Fit( window );
+
+    window->SetSizeHints( size.x,
+                          size.y,
+                          window->GetMaxWidth(),
+                          window->GetMaxHeight() );
+}
+
+void wxSizer::SetVirtualSizeHints( wxWindow *window )
+{
+    // Preserve the window's max size hints, but set the
+    // lower bound according to the sizer calculations.
+
+    FitInside( window );
+    wxSize size( window->GetVirtualSize() );
+    window->SetVirtualSizeHints( size.x,
+                                 size.y,
+                                 window->GetMaxWidth(),
+                                 window->GetMaxHeight() );
+}
+
+wxSize wxSizer::GetMaxWindowSize( wxWindow *window ) const
+{
+    return window->GetMaxSize();
 }
 
 wxSize wxSizer::GetMinWindowSize( wxWindow *window )
 {
 }
 
 wxSize wxSizer::GetMinWindowSize( wxWindow *window )
 {
-    wxSize minSize( GetMinSize() );
-    wxSize size( window->GetSize() );
-    wxSize client_size( window->GetClientSize() );
+    wxSize      minSize( GetMinSize() );
+    wxSize      size( window->GetSize() );
+    wxSize      client_size( window->GetClientSize() );
+
     return wxSize( minSize.x+size.x-client_size.x,
                    minSize.y+size.y-client_size.y );
 }
 
     return wxSize( minSize.x+size.x-client_size.x,
                    minSize.y+size.y-client_size.y );
 }
 
+// Return a window size that will fit within the screens dimensions
+wxSize wxSizer::FitSize( wxWindow *window )
+{
+    wxSize size     = GetMinWindowSize( window );
+    wxSize sizeMax  = GetMaxWindowSize( window );
+
+    // Limit the size if sizeMax != wxDefaultSize
+
+    if ( size.x > sizeMax.x && sizeMax.x != -1 )
+        size.x = sizeMax.x;
+    if ( size.y > sizeMax.y && sizeMax.y != -1 )
+        size.y = sizeMax.y;
+
+    return size;
+}
+
+wxSize wxSizer::GetMaxClientSize( wxWindow *window ) const
+{
+    wxSize maxSize( window->GetMaxSize() );
+
+    if( maxSize != wxDefaultSize )
+    {
+        wxSize size( window->GetSize() );
+        wxSize client_size( window->GetClientSize() );
+
+        return wxSize( maxSize.x + client_size.x - size.x,
+                       maxSize.y + client_size.y - size.y );
+    }
+    else
+        return wxDefaultSize;
+}
+
+wxSize wxSizer::GetMinClientSize( wxWindow *WXUNUSED(window) )
+{
+    return GetMinSize();  // Already returns client size.
+}
+
+wxSize wxSizer::VirtualFitSize( wxWindow *window )
+{
+    wxSize size     = GetMinClientSize( window );
+    wxSize sizeMax  = GetMaxClientSize( window );
+
+    // Limit the size if sizeMax != wxDefaultSize
+
+    if ( size.x > sizeMax.x && sizeMax.x != -1 )
+        size.x = sizeMax.x;
+    if ( size.y > sizeMax.y && sizeMax.y != -1 )
+        size.y = sizeMax.y;
+
+    return size;
+}
+
 void wxSizer::SetDimension( int x, int y, int width, int height )
 {
     m_position.x = x;
     m_position.y = y;
     m_size.x = width;
     m_size.y = height;
 void wxSizer::SetDimension( int x, int y, int width, int height )
 {
     m_position.x = x;
     m_position.y = y;
     m_size.x = width;
     m_size.y = height;
-    CalcMin();
-    RecalcSizes();
+    Layout();
 }
 
 wxSize wxSizer::GetMinSize()
 }
 
 wxSize wxSizer::GetMinSize()
@@ -390,128 +709,255 @@ void wxSizer::DoSetMinSize( int width, int height )
 
 bool wxSizer::DoSetItemMinSize( wxWindow *window, int width, int height )
 {
 
 bool wxSizer::DoSetItemMinSize( wxWindow *window, int width, int height )
 {
-    wxASSERT( window );
+    wxASSERT_MSG( window, _T("SetMinSize for NULL window") );
+
+    // Is it our immediate child?
 
 
-    wxNode *node = m_children.First();
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*)node->Data();
+        wxSizerItem     *item = node->GetData();
+
         if (item->GetWindow() == window)
         {
             item->SetInitSize( width, height );
         if (item->GetWindow() == window)
         {
             item->SetInitSize( width, height );
-            return TRUE;
+            return true;
         }
         }
-        node = node->Next();
+        node = node->GetNext();
     }
 
     }
 
-    node = m_children.First();
+    // No?  Search any subsizers we own then
+
+    node = m_children.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*)node->Data();
-        if (item->GetSizer())
+        wxSizerItem     *item = node->GetData();
+
+        if ( item->GetSizer() &&
+             item->GetSizer()->DoSetItemMinSize( window, width, height ) )
         {
         {
-            /* It's a sizer, so lets search recursively. */
-            if (item->GetSizer()->DoSetItemMinSize( window, width, height ))
-            {
-                /* A child sizer found the requested windw, exit. */
-                return TRUE;
-            }
+            // A child sizer found the requested windw, exit.
+            return true;
         }
         }
-        node = node->Next();
+        node = node->GetNext();
     }
 
     }
 
-    return FALSE;
+    return false;
 }
 
 bool wxSizer::DoSetItemMinSize( wxSizer *sizer, int width, int height )
 {
 }
 
 bool wxSizer::DoSetItemMinSize( wxSizer *sizer, int width, int height )
 {
-    wxASSERT( sizer );
+    wxASSERT_MSG( sizer, _T("SetMinSize for NULL sizer") );
 
 
-    wxNode *node = m_children.First();
+    // Is it our immediate child?
+
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*)node->Data();
+        wxSizerItem     *item = node->GetData();
+
         if (item->GetSizer() == sizer)
         {
             item->GetSizer()->DoSetMinSize( width, height );
         if (item->GetSizer() == sizer)
         {
             item->GetSizer()->DoSetMinSize( width, height );
-            return TRUE;
+            return true;
         }
         }
-        node = node->Next();
+        node = node->GetNext();
     }
 
     }
 
-    node = m_children.First();
+    // No?  Search any subsizers we own then
+
+    node = m_children.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*)node->Data();
-        if (item->GetSizer())
+        wxSizerItem     *item = node->GetData();
+
+        if ( item->GetSizer() &&
+             item->GetSizer()->DoSetItemMinSize( sizer, width, height ) )
         {
         {
-            /* It's a sizer, so lets search recursively. */
-            if (item->GetSizer()->DoSetItemMinSize( sizer, width, height ))
-            {
-                /* A child sizer found the requested windw, exit. */
-                return TRUE;
-            }
+            // A child found the requested sizer, exit.
+            return true;
         }
         }
-        node = node->Next();
+        node = node->GetNext();
     }
 
     }
 
-    return FALSE;
+    return false;
 }
 
 }
 
-bool wxSizer::DoSetItemMinSize( int pos, int width, int height )
+bool wxSizer::DoSetItemMinSize( size_t index, int width, int height )
 {
 {
-    wxNode *node = m_children.Nth( pos );
-    if (!node) return FALSE;
+    wxSizerItemList::compatibility_iterator node = m_children.Item( index );
+
+    wxCHECK_MSG( node, false, _T("Failed to find child node") );
+
+    wxSizerItem     *item = node->GetData();
 
 
-    wxSizerItem *item = (wxSizerItem*) node->Data();
     if (item->GetSizer())
     {
     if (item->GetSizer())
     {
-        /* Sizers contains the minimal size in them, if not calculated ... */
+        // Sizers contains the minimal size in them, if not calculated ...
         item->GetSizer()->DoSetMinSize( width, height );
     }
     else
     {
         item->GetSizer()->DoSetMinSize( width, height );
     }
     else
     {
-        /* ... whereas the minimal size of spacers and windows in stored
-           in the item */
+        // ... but the minimal size of spacers and windows in stored in them
         item->SetInitSize( width, height );
     }
 
         item->SetInitSize( width, height );
     }
 
-    return TRUE;
+    return true;
+}
+
+void wxSizer::Show( wxWindow *window, bool show )
+{
+    wxASSERT_MSG( window, _T("Show for NULL window") );
+
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
+    while (node)
+    {
+        wxSizerItem     *item = node->GetData();
+
+        if (item->GetWindow() == window)
+        {
+            item->Show( show );
+            break;
+        }
+        node = node->GetNext();
+    }
+}
+
+void wxSizer::Show( wxSizer *sizer, bool show )
+{
+    wxASSERT_MSG( sizer, _T("Show for NULL sizer") );
+
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
+    while (node)
+    {
+        wxSizerItem     *item = node->GetData();
+
+        if (item->GetSizer() == sizer)
+        {
+            item->Show( show );
+            break;
+        }
+        node = node->GetNext();
+    }
 }
 
 }
 
+void wxSizer::Show( size_t index, bool show )
+{
+    wxCHECK_RET( index < m_children.GetCount(),
+                 _T("Show index is out of range") );
+
+    m_children.Item( index )->GetData()->Show( show );
+}
+
+void wxSizer::ShowItems( bool show )
+{
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
+    while (node)
+    {
+        node->GetData()->Show( show );
+        node = node->GetNext();
+    }
+}
+
+bool wxSizer::IsShown( wxWindow *window ) const
+{
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
+    while (node)
+    {
+        wxSizerItem     *item = node->GetData();
+
+        if (item->GetWindow() == window)
+        {
+            return item->IsShown();
+        }
+        node = node->GetNext();
+    }
+
+    wxFAIL_MSG( _T("IsShown failed to find sizer item") );
+
+    return false;
+}
+
+bool wxSizer::IsShown( wxSizer *sizer ) const
+{
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
+    while (node)
+    {
+        wxSizerItem     *item = node->GetData();
+
+        if (item->GetSizer() == sizer)
+        {
+            return item->IsShown();
+        }
+        node = node->GetNext();
+    }
+
+    wxFAIL_MSG( _T("IsShown failed to find sizer item") );
+
+    return false;
+}
+
+bool wxSizer::IsShown( size_t index ) const
+{
+    wxCHECK_MSG( index < m_children.GetCount(),
+                 false,
+                 _T("IsShown index is out of range") );
+
+    return m_children.Item( index )->GetData()->IsShown();
+}
+
+
 //---------------------------------------------------------------------------
 // wxGridSizer
 //---------------------------------------------------------------------------
 
 wxGridSizer::wxGridSizer( int rows, int cols, int vgap, int hgap )
 //---------------------------------------------------------------------------
 // wxGridSizer
 //---------------------------------------------------------------------------
 
 wxGridSizer::wxGridSizer( int rows, int cols, int vgap, int hgap )
+    : m_rows( rows )
+    , m_cols( cols )
+    , m_vgap( vgap )
+    , m_hgap( hgap )
 {
 {
-    m_rows = rows;
-    m_cols = cols;
-    m_vgap = vgap;
-    m_hgap = hgap;
 }
 
 wxGridSizer::wxGridSizer( int cols, int vgap, int hgap )
 }
 
 wxGridSizer::wxGridSizer( int cols, int vgap, int hgap )
+    : m_rows( 0 )
+    , m_cols( cols )
+    , m_vgap( vgap )
+    , m_hgap( hgap )
 {
 {
-    m_rows = 0;
-    m_cols = cols;
-    m_vgap = vgap;
-    m_hgap = hgap;
 }
 
 }
 
-void wxGridSizer::RecalcSizes()
+int wxGridSizer::CalcRowsCols(int& nrows, int& ncols) const
 {
 {
-    if (m_children.GetCount() == 0)
-        return;
-
     int nitems = m_children.GetCount();
     int nitems = m_children.GetCount();
-    int nrows = m_rows;
-    int ncols = m_cols;
+    if ( nitems)
+    {
+        if ( m_cols )
+        {
+            ncols = m_cols;
+            nrows = (nitems + m_cols - 1) / m_cols;
+        }
+        else if ( m_rows )
+        {
+            ncols = (nitems + m_rows - 1) / m_rows;
+            nrows = m_rows;
+        }
+        else // 0 columns, 0 rows?
+        {
+            wxFAIL_MSG( _T("grid sizer must have either rows or columns fixed") );
 
 
-    if (ncols > 0)
-        nrows = (nitems + ncols-1) / ncols;
-    else
-        ncols = (nitems + nrows-1) / nrows;
+            nrows = ncols = 0;
+        }
+    }
+
+    return nitems;
+}
+
+void wxGridSizer::RecalcSizes()
+{
+    int nitems, nrows, ncols;
+    if ( (nitems = CalcRowsCols(nrows, ncols)) == 0 )
+        return;
 
     wxSize sz( GetSize() );
     wxPoint pt( GetPosition() );
 
     wxSize sz( GetSize() );
     wxPoint pt( GetPosition() );
@@ -528,10 +974,11 @@ void wxGridSizer::RecalcSizes()
             int i = r * ncols + c;
             if (i < nitems)
             {
             int i = r * ncols + c;
             if (i < nitems)
             {
-                wxNode *node = m_children.Nth( i );
-                wxASSERT( node );
+                wxSizerItemList::compatibility_iterator node = m_children.Item( i );
 
 
-                SetItemBounds( (wxSizerItem*) node->Data(), x, y, w, h);
+                wxASSERT_MSG( node, _T("Failed to find SizerItemList node") );
+
+                SetItemBounds( node->GetData(), x, y, w, h);
             }
             y = y + h + m_vgap;
         }
             }
             y = y + h + m_vgap;
         }
@@ -541,35 +988,28 @@ void wxGridSizer::RecalcSizes()
 
 wxSize wxGridSizer::CalcMin()
 {
 
 wxSize wxGridSizer::CalcMin()
 {
-    if (m_children.GetCount() == 0)
-        return wxSize(10,10);
+    int nrows, ncols;
+    if ( CalcRowsCols(nrows, ncols) == 0 )
+        return wxSize(10, 10);
 
 
-    int nitems = m_children.GetCount();
-    int nrows = m_rows;
-    int ncols = m_cols;
-
-    if (ncols > 0)
-        nrows = (nitems + ncols-1) / ncols;
-    else
-        ncols = (nitems + nrows-1) / nrows;
-
-    /* Find the max width and height for any component */
+    // Find the max width and height for any component
     int w = 0;
     int h = 0;
 
     int w = 0;
     int h = 0;
 
-    wxNode *node = m_children.First();
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*)node->Data();
-        wxSize sz( item->CalcMin() );
+        wxSizerItem     *item = node->GetData();
+        wxSize           sz( item->CalcMin() );
+
         w = wxMax( w, sz.x );
         h = wxMax( h, sz.y );
 
         w = wxMax( w, sz.x );
         h = wxMax( h, sz.y );
 
-        node = node->Next();
+        node = node->GetNext();
     }
 
     }
 
-    return wxSize(ncols * w + (ncols-1) * m_hgap,
-                  nrows * h + (nrows-1) * m_vgap);
+    return wxSize( ncols * w + (ncols-1) * m_hgap,
+                   nrows * h + (nrows-1) * m_vgap );
 }
 
 void wxGridSizer::SetItemBounds( wxSizerItem *item, int x, int y, int w, int h )
 }
 
 void wxGridSizer::SetItemBounds( wxSizerItem *item, int x, int y, int w, int h )
@@ -611,87 +1051,129 @@ void wxGridSizer::SetItemBounds( wxSizerItem *item, int x, int y, int w, int h )
 //---------------------------------------------------------------------------
 
 wxFlexGridSizer::wxFlexGridSizer( int rows, int cols, int vgap, int hgap )
 //---------------------------------------------------------------------------
 
 wxFlexGridSizer::wxFlexGridSizer( int rows, int cols, int vgap, int hgap )
-   : wxGridSizer( rows, cols, vgap, hgap )
+               : wxGridSizer( rows, cols, vgap, hgap ),
+                 m_flexDirection(wxBOTH),
+                 m_growMode(wxFLEX_GROWMODE_SPECIFIED)
 {
 {
-    m_rowHeights = (int*) NULL;
-    m_colWidths = (int*) NULL;
 }
 
 wxFlexGridSizer::wxFlexGridSizer( int cols, int vgap, int hgap )
 }
 
 wxFlexGridSizer::wxFlexGridSizer( int cols, int vgap, int hgap )
-   : wxGridSizer( cols, vgap, hgap )
+               : wxGridSizer( cols, vgap, hgap ),
+                 m_flexDirection(wxBOTH),
+                 m_growMode(wxFLEX_GROWMODE_SPECIFIED)
 {
 {
-    m_rowHeights = (int*) NULL;
-    m_colWidths = (int*) NULL;
 }
 
 wxFlexGridSizer::~wxFlexGridSizer()
 {
 }
 
 wxFlexGridSizer::~wxFlexGridSizer()
 {
-    if (m_rowHeights)
-        delete[] m_rowHeights;
-    if (m_colWidths)
-        delete[] m_colWidths;
-}
-
-void wxFlexGridSizer::CreateArrays()
-{
-    if (m_rowHeights)
-        delete[] m_rowHeights;
-    if (m_colWidths)
-        delete[] m_colWidths;
-
-    if (m_children.GetCount() == 0)
-        return;
-
-    int nitems = m_children.GetCount();
-    int nrows = m_rows;
-    int ncols = m_cols;
-
-    if (ncols > 0)
-        nrows = (nitems + ncols-1) / ncols;
-    else
-        ncols = (nitems + nrows-1) / nrows;
-
-    m_rowHeights = new int[nrows];
-    m_colWidths = new int[ncols];
-
-    for (int col = 0; col < ncols; col++)
-        m_colWidths[ col ] = 0;
-    for (int row = 0; row < nrows; row++)
-        m_rowHeights[ row ] = 0;
 }
 
 void wxFlexGridSizer::RecalcSizes()
 {
 }
 
 void wxFlexGridSizer::RecalcSizes()
 {
-    if (m_children.GetCount() == 0)
+    int nitems, nrows, ncols;
+    if ( (nitems = CalcRowsCols(nrows, ncols)) == 0 )
         return;
 
         return;
 
-    int nitems = m_children.GetCount();
-    int nrows = m_rows;
-    int ncols = m_cols;
-
-    if (ncols > 0)
-        nrows = (nitems + ncols-1) / ncols;
-    else
-        ncols = (nitems + nrows-1) / nrows;
-
     wxSize sz( GetSize() );
     wxSize minsz( CalcMin() );
     wxPoint pt( GetPosition() );
     wxSize sz( GetSize() );
     wxSize minsz( CalcMin() );
     wxPoint pt( GetPosition() );
-    int    delta;
-    size_t idx;
 
 
-    if ((m_growableRows.GetCount() > 0) && (sz.y > minsz.y))
+    // what to do with the rows? by default, resize them proportionally
+    if ( sz.y > minsz.y && ( (m_flexDirection & wxVERTICAL) || (m_growMode == wxFLEX_GROWMODE_SPECIFIED) ) )
     {
     {
-        delta = (sz.y - minsz.y) / m_growableRows.GetCount();
+        int sum_proportions = 0;
+        int growable_space = 0;
+        int num = 0;
+        size_t idx;
         for (idx = 0; idx < m_growableRows.GetCount(); idx++)
         for (idx = 0; idx < m_growableRows.GetCount(); idx++)
-            m_rowHeights[ m_growableRows[idx] ] += delta;
+        {
+            // Since the number of rows/columns can change as items are inserted/deleted, we need
+            // to verify at runtime that the requested growable rows/columns are still valid.
+            if (m_growableRows[idx] >= nrows)
+                continue;
+            // If all items in a row/column are hidden, that row/column will have a dimension of -1.
+            // This causes the row/column to be hidden completely.
+            if (m_rowHeights[ m_growableRows[idx] ] == -1)
+                continue;
+            sum_proportions += m_growableRowsProportions[idx];
+            growable_space += m_rowHeights[ m_growableRows[idx] ];
+            num++;
+        }
+
+        if (num > 0)
+        {
+            for (idx = 0; idx < m_growableRows.GetCount(); idx++)
+            {
+                if (m_growableRows[idx] >= nrows )
+                    continue;
+                if (m_rowHeights[ m_growableRows[idx] ] == -1)
+                    m_rowHeights[ m_growableRows[idx] ] = 0;
+                else
+                {
+                    int delta = (sz.y - minsz.y);
+                    if (sum_proportions == 0)
+                        delta = (delta/num) + m_rowHeights[ m_growableRows[idx] ];
+                    else
+                        delta = ((delta+growable_space)*m_growableRowsProportions[idx]) / sum_proportions;
+                    m_rowHeights[ m_growableRows[idx] ] = delta;
+                }
+            }
+        }
+    }
+    else if ( (m_growMode == wxFLEX_GROWMODE_ALL) && (sz.y > minsz.y) )
+    {
+        // rounding problem?
+        for ( int row = 0; row < nrows; ++row )
+            m_rowHeights[ row ] = sz.y / nrows;
     }
 
     }
 
-    if ((m_growableCols.GetCount() > 0) && (sz.x > minsz.x))
+    // the same logic as above but for the columns
+    if ( sz.x > minsz.x && ( (m_flexDirection & wxHORIZONTAL) || (m_growMode == wxFLEX_GROWMODE_SPECIFIED) ) )
     {
     {
-        delta = (sz.x - minsz.x) / m_growableCols.GetCount();
+        int sum_proportions = 0;
+        int growable_space = 0;
+        int num = 0;
+        size_t idx;
         for (idx = 0; idx < m_growableCols.GetCount(); idx++)
         for (idx = 0; idx < m_growableCols.GetCount(); idx++)
-            m_colWidths[ m_growableCols[idx] ] += delta;
+        {
+            // Since the number of rows/columns can change as items are inserted/deleted, we need
+            // to verify at runtime that the requested growable rows/columns are still valid.
+            if (m_growableCols[idx] >= ncols)
+                continue;
+            // If all items in a row/column are hidden, that row/column will have a dimension of -1.
+            // This causes the column to be hidden completely.
+            if (m_colWidths[ m_growableCols[idx] ] == -1)
+                continue;
+            sum_proportions += m_growableColsProportions[idx];
+            // wtb 5/12/02 bugfix - was m_ColWidths[idx]!!
+            growable_space += m_colWidths[ m_growableCols[idx] ];
+            num++;
+        }
+
+        if (num > 0)
+        {
+            for (idx = 0; idx < m_growableCols.GetCount(); idx++)
+            {
+                if (m_growableCols[idx] >= ncols )
+                    continue;
+                if (m_colWidths[ m_growableCols[idx] ] == -1)
+                    m_colWidths[ m_growableCols[idx] ] = 0;
+                else
+                {
+                    int delta = (sz.x - minsz.x);
+                    if (sum_proportions == 0)
+                        delta = (delta/num) + m_colWidths[ m_growableCols[idx] ];
+                    else
+                        delta = ((delta+growable_space)*m_growableColsProportions[idx])/sum_proportions;
+                    m_colWidths[ m_growableCols[idx] ] = delta;
+                }
+            }
+        }
+    }
+    else if ( (m_growMode == wxFLEX_GROWMODE_ALL) && (sz.x > minsz.x) )
+    {
+        for ( int col=0; col < ncols; ++col )
+            m_colWidths[ col ] = sz.x / ncols;
     }
 
     sz = wxSize( pt.x + sz.x, pt.y + sz.y );
     }
 
     sz = wxSize( pt.x + sz.x, pt.y + sz.y );
@@ -705,13 +1187,14 @@ void wxFlexGridSizer::RecalcSizes()
             int i = r * ncols + c;
             if (i < nitems)
             {
             int i = r * ncols + c;
             if (i < nitems)
             {
-                wxNode *node = m_children.Nth( i );
-                wxASSERT( node );
+                wxSizerItemList::compatibility_iterator node = m_children.Item( i );
+
+                wxASSERT_MSG( node, _T("Failed to find node") );
 
                 int w = wxMax( 0, wxMin( m_colWidths[c], sz.x - x ) );
                 int h = wxMax( 0, wxMin( m_rowHeights[r], sz.y - y ) );
 
 
                 int w = wxMax( 0, wxMin( m_colWidths[c], sz.x - x ) );
                 int h = wxMax( 0, wxMin( m_rowHeights[r], sz.y - y ) );
 
-                SetItemBounds( (wxSizerItem*) node->Data(), x, y, w, h);
+                SetItemBounds( node->GetData(), x, y, w, h);
             }
             y = y + m_rowHeights[r] + m_vgap;
         }
             }
             y = y + m_rowHeights[r] + m_vgap;
         }
@@ -721,62 +1204,101 @@ void wxFlexGridSizer::RecalcSizes()
 
 wxSize wxFlexGridSizer::CalcMin()
 {
 
 wxSize wxFlexGridSizer::CalcMin()
 {
-    if (m_children.GetCount() == 0)
-        return wxSize(10,10);
+    int     nrows,
+            ncols;
+    size_t  i, s;
 
 
-    int nitems = m_children.GetCount();
-    int nrows = m_rows;
-    int ncols = m_cols;
+    // Number of rows/columns can change as items are added or removed.
+    if ( !CalcRowsCols(nrows, ncols) )
+        return wxSize(10, 10);
 
 
-    if (ncols > 0)
-        nrows = (nitems + ncols-1) / ncols;
-    else
-        ncols = (nitems + nrows-1) / nrows;
+    m_rowHeights.SetCount(nrows);
+    m_colWidths.SetCount(ncols);
 
 
-    CreateArrays();
+    // We have to recalcuate the sizes in case an item has wxADJUST_MINSIZE, has changed
+    // minimum size since the previous layout, or has been hidden using wxSizer::Show().
+    // If all the items in a row/column are hidden, the final dimension of the row/column
+    // will be -1, indicating that the column itself is hidden.
+    for( s = m_rowHeights.GetCount(), i = 0; i < s; ++i )
+        m_rowHeights[ i ] = -1;
+    for( s = m_colWidths.GetCount(), i = 0; i < s; ++i )
+        m_colWidths[ i ] = -1;
 
 
-    int col;
-    int row;
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
 
 
-    int i = 0;
-    wxNode *node = m_children.First();
+    i = 0;
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*)node->Data();
-        wxSize sz( item->CalcMin() );
-        row = i / ncols;
-        col = i % ncols;
-        m_rowHeights[ row ] = wxMax( sz.y, m_rowHeights[ row ] );
-        m_colWidths[ col ] = wxMax( sz.x, m_colWidths[ col ] );
-
-        node = node->Next();
+        wxSizerItem    *item = node->GetData();
+        if ( item->IsShown() )
+        {
+            wxSize sz( item->CalcMin() );
+            int row = i / ncols;
+            int col = i % ncols;
+
+            m_rowHeights[ row ] = wxMax( wxMax( 0, sz.y ), m_rowHeights[ row ] );
+            m_colWidths[ col ] = wxMax( wxMax( 0, sz.x ), m_colWidths[ col ] );
+        }
+
+        node = node->GetNext();
         i++;
     }
 
         i++;
     }
 
+    // the logic above works when we resize flexibly in both directions but
+    // maybe this is not the case
+    if ( m_flexDirection != wxBOTH )
+    {
+        // select the array corresponding to the direction in which we do *not*
+        // resize flexibly
+        wxArrayInt& array = m_flexDirection == wxVERTICAL ? m_colWidths
+                                                          : m_rowHeights;
+
+        const int count = array.GetCount();
+
+        // find the largest value in this array
+        int n, largest = 0;
+        for ( n = 0; n < count; ++n )
+        {
+            if ( array[n] > largest )
+                largest = array[n];
+        }
+
+        // and now fill it with the largest value
+        for ( n = 0; n < count; ++n )
+        {
+            array[n] = largest;
+        }
+    }
+
+    // Sum total minimum size, including gaps between rows/columns.
+    // -1 is used as a magic number meaning empty column.
     int width = 0;
     int width = 0;
-    for (col = 0; col < ncols; col++)
-        width += m_colWidths[ col ];
+    for (int col = 0; col < ncols; col++)
+        if ( m_colWidths[ col ] != -1 )
+            width += m_colWidths[ col ] + ( col == ncols-1 ? 0 : m_hgap );
 
     int height = 0;
 
     int height = 0;
-    for (row = 0; row < nrows; row++)
-        height += m_rowHeights[ row ];
+    for (int row = 0; row < nrows; row++)
+        if ( m_rowHeights[ row ] != -1 )
+            height += m_rowHeights[ row ] + ( row == nrows-1 ? 0 : m_vgap );
 
 
-    return wxSize( width +  (ncols-1) * m_hgap,
-                   height + (nrows-1) * m_vgap);
+    return wxSize( width, height );
 }
 
 }
 
-void wxFlexGridSizer::AddGrowableRow( size_t idx )
+void wxFlexGridSizer::AddGrowableRow( size_t idx, int proportion )
 {
     m_growableRows.Add( idx );
 {
     m_growableRows.Add( idx );
+    m_growableRowsProportions.Add( proportion );
 }
 
 void wxFlexGridSizer::RemoveGrowableRow( size_t WXUNUSED(idx) )
 {
 }
 
 }
 
 void wxFlexGridSizer::RemoveGrowableRow( size_t WXUNUSED(idx) )
 {
 }
 
-void wxFlexGridSizer::AddGrowableCol( size_t idx )
+void wxFlexGridSizer::AddGrowableCol( size_t idx, int proportion )
 {
     m_growableCols.Add( idx );
 {
     m_growableCols.Add( idx );
+    m_growableColsProportions.Add( proportion );
 }
 
 void wxFlexGridSizer::RemoveGrowableCol( size_t WXUNUSED(idx) )
 }
 
 void wxFlexGridSizer::RemoveGrowableCol( size_t WXUNUSED(idx) )
@@ -788,8 +1310,8 @@ void wxFlexGridSizer::RemoveGrowableCol( size_t WXUNUSED(idx) )
 //---------------------------------------------------------------------------
 
 wxBoxSizer::wxBoxSizer( int orient )
 //---------------------------------------------------------------------------
 
 wxBoxSizer::wxBoxSizer( int orient )
+    : m_orient( orient )
 {
 {
-    m_orient = orient;
 }
 
 void wxBoxSizer::RecalcSizes()
 }
 
 void wxBoxSizer::RecalcSizes()
@@ -815,69 +1337,72 @@ void wxBoxSizer::RecalcSizes()
 
     wxPoint pt( m_position );
 
 
     wxPoint pt( m_position );
 
-    wxNode *node = m_children.GetFirst();
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*) node->Data();
+        wxSizerItem     *item = node->GetData();
 
 
-        int weight = 1;
-        if (item->GetOption())
-            weight = item->GetOption();
+        if (item->IsShown())
+        {
+            int weight = 1;
+            if (item->GetProportion())
+                weight = item->GetProportion();
 
 
-        wxSize size( item->CalcMin() );
+            wxSize size( item->CalcMin() );
 
 
-        if (m_orient == wxVERTICAL)
-        {
-            wxCoord height = size.y;
-            if (item->GetOption())
+            if (m_orient == wxVERTICAL)
             {
             {
-                height = (delta * weight) + extra;
-                extra = 0; // only the first item will get the remainder as extra size
+                wxCoord height = size.y;
+                if (item->GetProportion())
+                {
+                    height = (delta * weight) + extra;
+                    extra = 0; // only the first item will get the remainder as extra size
+                }
+
+                wxPoint child_pos( pt );
+                wxSize  child_size( wxSize( size.x, height) );
+
+                if (item->GetFlag() & (wxEXPAND | wxSHAPED))
+                    child_size.x = m_size.x;
+                else if (item->GetFlag() & wxALIGN_RIGHT)
+                    child_pos.x += m_size.x - size.x;
+                else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_HORIZONTAL))
+                // XXX wxCENTER is added for backward compatibility;
+                //     wxALIGN_CENTER should be used in new code
+                    child_pos.x += (m_size.x - size.x) / 2;
+
+                item->SetDimension( child_pos, child_size );
+
+                pt.y += height;
             }
             }
-
-            wxPoint child_pos( pt );
-            wxSize  child_size( wxSize( size.x, height) );
-
-            if (item->GetFlag() & (wxEXPAND | wxSHAPED))
-                child_size.x = m_size.x;
-            else if (item->GetFlag() & wxALIGN_RIGHT)
-                child_pos.x += m_size.x - size.x;
-            else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_HORIZONTAL))
-            // XXX wxCENTER is added for backward compatibility;
-            //     wxALIGN_CENTER should be used in new code
-                child_pos.x += (m_size.x - size.x) / 2;
-
-            item->SetDimension( child_pos, child_size );
-
-            pt.y += height;
-        }
-        else
-        {
-            wxCoord width = size.x;
-            if (item->GetOption())
+            else
             {
             {
-                width = (delta * weight) + extra;
-                extra = 0; // only the first item will get the remainder as extra size
+                wxCoord width = size.x;
+                if (item->GetProportion())
+                {
+                    width = (delta * weight) + extra;
+                    extra = 0; // only the first item will get the remainder as extra size
+                }
+
+                wxPoint child_pos( pt );
+                wxSize  child_size( wxSize(width, size.y) );
+
+                if (item->GetFlag() & (wxEXPAND | wxSHAPED))
+                    child_size.y = m_size.y;
+                else if (item->GetFlag() & wxALIGN_BOTTOM)
+                    child_pos.y += m_size.y - size.y;
+                else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_VERTICAL))
+                // XXX wxCENTER is added for backward compatibility;
+                //     wxALIGN_CENTER should be used in new code
+                    child_pos.y += (m_size.y - size.y) / 2;
+
+                item->SetDimension( child_pos, child_size );
+
+                pt.x += width;
             }
             }
-
-            wxPoint child_pos( pt );
-            wxSize  child_size( wxSize(width, size.y) );
-
-            if (item->GetFlag() & (wxEXPAND | wxSHAPED))
-                child_size.y = m_size.y;
-            else if (item->GetFlag() & wxALIGN_BOTTOM)
-                child_pos.y += m_size.y - size.y;
-            else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_VERTICAL))
-            // XXX wxCENTER is added for backward compatibility;
-            //     wxALIGN_CENTER should be used in new code
-                child_pos.y += (m_size.y - size.y) / 2;
-
-            item->SetDimension( child_pos, child_size );
-
-            pt.x += width;
         }
 
         }
 
-        node = node->Next();
+        node = node->GetNext();
     }
 }
 
     }
 }
 
@@ -892,41 +1417,75 @@ wxSize wxBoxSizer::CalcMin()
     m_fixedWidth = 0;
     m_fixedHeight = 0;
 
     m_fixedWidth = 0;
     m_fixedHeight = 0;
 
-    wxNode *node = m_children.GetFirst();
+    // Find how long each stretch unit needs to be
+    int                      stretchSize = 1;
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
+
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*) node->Data();
-
-        m_stretchable += item->GetOption();
-        
-        wxSize size( item->CalcMin() );
+        wxSizerItem     *item = node->GetData();
 
 
-        if (m_orient == wxHORIZONTAL)
+        if (item->IsShown() && item->GetProportion() != 0)
         {
         {
-            m_minWidth += size.x;
-            m_minHeight = wxMax( m_minHeight, size.y );
-        }
-        else
-        {
-            m_minHeight += size.y;
-            m_minWidth = wxMax( m_minWidth, size.x );
+            int stretch = item->GetProportion();
+            wxSize size( item->CalcMin() );
+            int sizePerStretch;
+            // Integer division rounded up is (a + b - 1) / b
+            if (m_orient == wxHORIZONTAL)
+                sizePerStretch = ( size.x + stretch - 1 ) / stretch;
+            else
+                sizePerStretch = ( size.y + stretch - 1 ) / stretch;
+            if (sizePerStretch > stretchSize)
+                stretchSize = sizePerStretch;
         }
         }
+        node = node->GetNext();
+    }
 
 
-        if (item->GetOption() == 0)
+    // Calculate overall minimum size
+    node = m_children.GetFirst();
+    while (node)
+    {
+        wxSizerItem     *item = node->GetData();
+
+        if (item->IsShown())
         {
         {
-            if (m_orient == wxVERTICAL)
+            m_stretchable += item->GetProportion();
+
+            wxSize size( item->CalcMin() );
+            if (item->GetProportion() != 0)
             {
             {
-                m_fixedHeight += size.y;
-                m_fixedWidth = wxMax( m_fixedWidth, size.x );
+                if (m_orient == wxHORIZONTAL)
+                    size.x = stretchSize * item->GetProportion();
+                else
+                    size.y = stretchSize * item->GetProportion();
+            }
+
+            if (m_orient == wxHORIZONTAL)
+            {
+                m_minWidth += size.x;
+                m_minHeight = wxMax( m_minHeight, size.y );
             }
             else
             }
             else
-            { 
-                m_fixedWidth += size.x;
-                m_fixedHeight = wxMax( m_fixedHeight, size.y );
+            {
+                m_minHeight += size.y;
+                m_minWidth = wxMax( m_minWidth, size.x );
             }
             }
-        }
 
 
-        node = node->Next();
+            if (item->GetProportion() == 0)
+            {
+                if (m_orient == wxVERTICAL)
+                {
+                    m_fixedHeight += size.y;
+                    m_fixedWidth = wxMax( m_fixedWidth, size.x );
+                }
+                else
+                {
+                    m_fixedWidth += size.x;
+                    m_fixedHeight = wxMax( m_fixedHeight, size.y );
+                }
+            }
+        }
+        node = node->GetNext();
     }
 
     return wxSize( m_minWidth, m_minHeight );
     }
 
     return wxSize( m_minWidth, m_minHeight );
@@ -936,22 +1495,39 @@ wxSize wxBoxSizer::CalcMin()
 // wxStaticBoxSizer
 //---------------------------------------------------------------------------
 
 // wxStaticBoxSizer
 //---------------------------------------------------------------------------
 
+#if wxUSE_STATBOX
+
 wxStaticBoxSizer::wxStaticBoxSizer( wxStaticBox *box, int orient )
 wxStaticBoxSizer::wxStaticBoxSizer( wxStaticBox *box, int orient )
-  : wxBoxSizer( orient )
+    : wxBoxSizer( orient )
+    , m_staticBox( box )
 {
     wxASSERT_MSG( box, wxT("wxStaticBoxSizer needs a static box") );
 {
     wxASSERT_MSG( box, wxT("wxStaticBoxSizer needs a static box") );
+}
+
+static void GetStaticBoxBorders( wxStaticBox *box,
+                                 int *borderTop,
+                                 int *borderOther)
+{
+    // this has to be done platform by platform as there is no way to
+    // guess the thickness of a wxStaticBox border
+#ifdef __WXCOCOA__
+    box->GetBordersForSizer(borderTop,borderOther);
+#else // __WXCOCOA__
+#ifdef __WXGTK__
+    if ( box->GetLabel().IsEmpty() )
+        *borderTop = 5;
+    else
+#endif // __WXGTK__
+        *borderTop = box->GetCharHeight();
 
 
-    m_staticBox = box;
+    *borderOther = 5;
+#endif // __WXCOCOA__
 }
 
 void wxStaticBoxSizer::RecalcSizes()
 {
 }
 
 void wxStaticBoxSizer::RecalcSizes()
 {
-    // this will have to be done platform by platform
-    // as there is no way to guess the thickness of
-    // a wxStaticBox border
-    int top_border = 15;
-    if (m_staticBox->GetLabel().IsEmpty()) top_border = 5;
-    int other_border = 5;
+    int top_border, other_border;
+    GetStaticBoxBorders(m_staticBox, &top_border, &other_border);
 
     m_staticBox->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );
 
 
     m_staticBox->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );
 
@@ -970,13 +1546,8 @@ void wxStaticBoxSizer::RecalcSizes()
 
 wxSize wxStaticBoxSizer::CalcMin()
 {
 
 wxSize wxStaticBoxSizer::CalcMin()
 {
-    // This will have to be done platform by platform
-    // as there is no way to guess the thickness of
-    // a wxStaticBox border.
-
-    int top_border = 15;
-    if (m_staticBox->GetLabel().IsEmpty()) top_border = 5;
-    int other_border = 5;
+    int top_border, other_border;
+    GetStaticBoxBorders(m_staticBox, &top_border, &other_border);
 
     wxSize ret( wxBoxSizer::CalcMin() );
     ret.x += 2*other_border;
 
     wxSize ret( wxBoxSizer::CalcMin() );
     ret.x += 2*other_border;
@@ -985,49 +1556,42 @@ wxSize wxStaticBoxSizer::CalcMin()
     return ret;
 }
 
     return ret;
 }
 
-//---------------------------------------------------------------------------
+#endif // wxUSE_STATBOX
+
+// ----------------------------------------------------------------------------
 // wxNotebookSizer
 // wxNotebookSizer
-//---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 
-#if wxUSE_NOTEBOOK
+#if wxUSE_BOOKCTRL
 
 
-wxNotebookSizer::wxNotebookSizer( wxNotebook *nb )
+wxBookCtrlSizer::wxBookCtrlSizer(wxBookCtrl *bookctrl)
+               : m_bookctrl(bookctrl)
 {
 {
-    wxASSERT_MSG( nb, wxT("wxNotebookSizer needs a notebook") );
-
-    m_notebook = nb;
+    wxASSERT_MSG( bookctrl, wxT("wxBookCtrlSizer needs a control") );
 }
 
 }
 
-void wxNotebookSizer::RecalcSizes()
+void wxBookCtrlSizer::RecalcSizes()
 {
 {
-    m_notebook->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );
+    m_bookctrl->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );
 }
 
 }
 
-wxSize wxNotebookSizer::CalcMin()
+wxSize wxBookCtrlSizer::CalcMin()
 {
 {
-    // This will have to be done platform by platform
-    // as there is no way to guess the thickness of
-    // the wxNotebook tabs and border.
+    wxSize sizeBorder = m_bookctrl->CalcSizeFromPage(wxSize(0, 0));
 
 
-    int borderX = 5;
-    int borderY = 5;
-    if ((m_notebook->HasFlag(wxNB_RIGHT)) ||
-        (m_notebook->HasFlag(wxNB_LEFT)))
-    {
-        borderX += 90; // improvements later..
-    }
-    else
+    sizeBorder.x += 5;
+    sizeBorder.y += 5;
+
+    if ( m_bookctrl->GetPageCount() == 0 )
     {
     {
-        borderY += 40; // improvements later..
+        return wxSize(sizeBorder.x + 10, sizeBorder.y + 10);
     }
 
     }
 
-    if (m_notebook->GetChildren().GetCount() == 0)
-        return wxSize(borderX + 10, borderY + 10);
-
     int maxX = 0;
     int maxY = 0;
 
     int maxX = 0;
     int maxY = 0;
 
-    wxWindowList::Node *node = m_notebook->GetChildren().GetFirst();
+    wxWindowList::compatibility_iterator
+        node = m_bookctrl->GetChildren().GetFirst();
     while (node)
     {
         wxWindow *item = node->GetData();
     while (node)
     {
         wxWindow *item = node->GetData();
@@ -1037,14 +1601,26 @@ wxSize wxNotebookSizer::CalcMin()
         {
             wxSize subsize( itemsizer->CalcMin() );
 
         {
             wxSize subsize( itemsizer->CalcMin() );
 
-            if (subsize.x > maxX) maxX = subsize.x;
-            if (subsize.y > maxY) maxY = subsize.y;
+            if (subsize.x > maxX)
+                maxX = subsize.x;
+            if (subsize.y > maxY)
+                maxY = subsize.y;
         }
 
         node = node->GetNext();
     }
 
         }
 
         node = node->GetNext();
     }
 
-    return wxSize( borderX + maxX, borderY + maxY );
+    return wxSize( maxX, maxY ) + sizeBorder;
 }
 
 }
 
-#endif // wxUSE_NOTEBOOK
+
+#if wxUSE_NOTEBOOK
+
+wxNotebookSizer::wxNotebookSizer(wxNotebook *nb)
+    : wxBookCtrlSizer(nb)
+{
+}
+
+#endif // wxUSE_NOTEBOOOK
+#endif // wxUSE_BOOKCTRL
+
wxWidgets (Impactor)