]> 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
use wxART_MISSING_IMAGE in wxHTML
[wxWidgets.git] / src / common / sizer.cpp
diff --git a/src/common/sizer.cpp b/src/common/sizer.cpp
index f227e41b17932f2a70158d8cb14ef43e2e03170e..44d9630a629bda8e9929de73ce13421edbee318c 100644 (file)
--- a/src/common/sizer.cpp
+++ b/src/common/sizer.cpp
@@ -6,6 +6,7 @@
 // Created:
 // RCS-ID:      $Id$
 // Copyright:   (c) Robin Dunn, Dirk Holtwick and Robert Roebling
 // Created:
 // RCS-ID:      $Id$
 // Copyright:   (c) Robin Dunn, Dirk Holtwick and Robert Roebling
+//              (c) 2003, Ron Lee
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
@@ -24,49 +25,51 @@
 #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_CLASS(wxSizerItem, wxObject)
+IMPLEMENT_CLASS(wxSizer, wxObject)
+IMPLEMENT_CLASS(wxGridSizer, wxSizer)
+IMPLEMENT_CLASS(wxFlexGridSizer, wxGridSizer)
+IMPLEMENT_CLASS(wxBoxSizer, wxSizer)
 #if wxUSE_STATBOX
 #if wxUSE_STATBOX
-IMPLEMENT_ABSTRACT_CLASS(wxStaticBoxSizer, wxBoxSizer)
+IMPLEMENT_CLASS(wxStaticBoxSizer, wxBoxSizer)
 #endif
 #if wxUSE_NOTEBOOK
 #endif
 #if wxUSE_NOTEBOOK
-IMPLEMENT_ABSTRACT_CLASS(wxNotebookSizer, wxSizer)
+IMPLEMENT_CLASS(wxNotebookSizer, wxSizer)
 #endif
 
 #endif
 
+WX_DEFINE_EXPORTED_LIST( wxSizerItemList );
+
+
 //---------------------------------------------------------------------------
 // wxSizerItem
 //---------------------------------------------------------------------------
 
 //---------------------------------------------------------------------------
 // wxSizerItem
 //---------------------------------------------------------------------------
 
-wxSizerItem::wxSizerItem( int width, int height, int option, int flag, int border, wxObject* userData )
-    : m_window( 0 )
-    , m_sizer( 0 )
+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_size( wxSize( width, height ) ) // size is set directly
     , m_minSize( m_size )               // minimal size is the initial size
-    , m_option( option )
+    , m_proportion( proportion )
     , m_border( border )
     , m_flag( flag )
     , m_border( border )
     , m_flag( flag )
-    , m_show( TRUE )                    // Cannot be changed
-    , m_deleteItem( FALSE )             // unused for spacer
+    , m_show( true )
     , m_userData( userData )
 {
     SetRatio( m_size );
 }
 
     , m_userData( userData )
 {
     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_window( window )
-    , m_sizer( 0 )
+    , m_sizer( NULL )
     , m_minSize( window->GetSize() )    // minimal size is the initial size
     , m_minSize( window->GetSize() )    // minimal size is the initial size
-    , m_option( option )
+    , m_proportion( proportion )
     , m_border( border )
     , m_flag( flag )
     , m_border( border )
     , m_flag( flag )
-    , m_show( TRUE )
-    , m_deleteItem( FALSE )             // currently unused for window
+    , m_show( true )
     , m_userData( userData )
 {
     // aspect ratio calculated from initial size
     , m_userData( userData )
 {
     // aspect ratio calculated from initial size
@@ -75,15 +78,14 @@ wxSizerItem::wxSizerItem( wxWindow *window, int option, int flag, int border, wx
     // m_size is calculated later
 }
 
     // m_size is calculated later
 }
 
-wxSizerItem::wxSizerItem( wxSizer *sizer, int option, int flag, int border, wxObject* userData )
-    : m_window( 0 )
+wxSizerItem::wxSizerItem( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData )
+    : m_window( NULL )
     , m_sizer( sizer )
     , m_sizer( sizer )
-    , m_option( option )
+    , m_proportion( proportion )
     , m_border( border )
     , m_flag( flag )
     , m_border( border )
     , m_flag( flag )
-    , m_show( TRUE )
-    , m_ratio( 0 )
-    , m_deleteItem( TRUE )              // we delete sizer items by default.
+    , m_show( true )
+    , m_ratio( 0.0 )
     , m_userData( userData )
 {
     // m_minSize is calculated later
     , m_userData( userData )
 {
     // m_minSize is calculated later
@@ -92,17 +94,14 @@ wxSizerItem::wxSizerItem( wxSizer *sizer, int option, int flag, int border, wxOb
 
 wxSizerItem::~wxSizerItem()
 {
 
 wxSizerItem::~wxSizerItem()
 {
-    // User data is bound to the sizeritem, always delete it.
     if (m_userData)
         delete m_userData;
     if (m_userData)
         delete m_userData;
-
-    // To be able to Detach a sizer, we must be able to veto its deletion here.
-    if (m_deleteItem && m_sizer)
+    if (m_sizer)
         delete m_sizer;
 }
 
 
         delete m_sizer;
 }
 
 
-wxSize wxSizerItem::GetSize()
+wxSize wxSizerItem::GetSize() const
 {
     wxSize ret;
     if (IsSizer())
 {
     wxSize ret;
     if (IsSizer())
@@ -233,30 +232,52 @@ void wxSizerItem::DeleteWindows()
         m_sizer->DeleteWindows();
 }
 
         m_sizer->DeleteWindows();
 }
 
-bool wxSizerItem::IsWindow()
+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;
+    m_children.DeleteContents( true );
 }
 
 wxSizer::~wxSizer()
 }
 
 wxSizer::~wxSizer()
@@ -264,148 +285,209 @@ wxSizer::~wxSizer()
     Clear();
 }
 
     Clear();
 }
 
-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 ) );
-    window->SetContainingSizer(this);
+    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 ) );
-    window->SetContainingSizer(this);
+    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 ) );
-    window->SetContainingSizer(this);
+    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 );
 }
 
 }
 
-bool wxSizer::Remove( wxWindow *window )
+void wxSizer::Insert( size_t index,
+                      wxSizer *sizer,
+                      int proportion,
+                      int flag,
+                      int border,
+                      wxObject* userData )
 {
 {
-    wxASSERT( window );
+    m_children.Insert( index,
+                       new wxSizerItem( sizer, proportion, flag, border, userData ) );
+}
 
 
-    wxNode *node = m_children.First();
-    while (node)
-    {
-        wxSizerItem *item = (wxSizerItem*)node->Data();
-        if (item->GetWindow() == window)
-        {
-            item->GetWindow()->SetContainingSizer(NULL);
-            m_children.DeleteNode( node );
-            return TRUE;
-        }
-        node = node->Next();
-    }
+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 );
+}
 
 
-    return FALSE;
+bool wxSizer::Remove( wxWindow *window )
+{
+    return Detach( window );
 }
 
 bool wxSizer::Remove( wxSizer *sizer )
 {
 }
 
 bool wxSizer::Remove( wxSizer *sizer )
 {
-    wxASSERT( sizer );
+    wxASSERT_MSG( sizer, _T("Removing NULL sizer") );
 
 
-    wxNode *node = m_children.First();
+    wxSizerItemList::Node   *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;
-        }
-        node = node->Next();
+            return m_children.DeleteNode( node );
+
+        node = node->GetNext();
     }
 
     }
 
-    return FALSE;
+    return false;
 }
 
 }
 
-bool wxSizer::Remove( int pos )
+bool wxSizer::Remove( size_t index )
 {
 {
-    if ((size_t)pos >= m_children.GetCount())
-        return FALSE;
-    wxNode *node = m_children.Nth( pos );
-    if (!node) return FALSE;
+    wxCHECK_MSG( index < m_children.GetCount(),
+                 false,
+                 _T("Remove index is out of range") );
+
+    wxSizerItemList::Node   *node = m_children.Item( index );
 
 
-    m_children.DeleteNode( node );
+    wxCHECK_MSG( node, false, _T("Failed to find child node") );
 
 
-    return TRUE;
+    wxSizerItem     *item = node->GetData();
+
+    if( item->IsWindow() )
+        item->GetWindow()->SetContainingSizer( NULL );
+
+    return m_children.DeleteNode( node );
 }
 
 bool wxSizer::Detach( wxSizer *sizer )
 {
 }
 
 bool wxSizer::Detach( wxSizer *sizer )
 {
-    wxASSERT( sizer );
+    wxASSERT_MSG( sizer, _T("Detaching NULL sizer") );
 
 
-    wxNode *node = m_children.First();
+    wxSizerItemList::Node   *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)
         {
-            item->SetDeleteItem( FALSE );
-            m_children.DeleteNode( node );
-            return TRUE;
+            item->DetachSizer();
+            return m_children.DeleteNode( node );
+        }
+        node = node->GetNext();
+    }
+
+    return false;
+}
+
+bool wxSizer::Detach( wxWindow *window )
+{
+    wxASSERT_MSG( window, _T("Detaching NULL window") );
+
+    wxSizerItemList::Node   *node = m_children.GetFirst();
+    while (node)
+    {
+        wxSizerItem     *item = node->GetData();
+
+        if (item->GetWindow() == window)
+        {
+            item->GetWindow()->SetContainingSizer( NULL );
+            return m_children.DeleteNode( node );
         }
         }
-        node = node->Next();
+        node = node->GetNext();
     }
 
     }
 
-    return FALSE;
+    return false;
 }
 
 }
 
-bool wxSizer::Detach( int pos )
+bool wxSizer::Detach( size_t index )
 {
 {
-    if ((size_t)pos >= m_children.GetCount())
-        return FALSE;
-    wxNode *node = m_children.Nth( pos );
-    if (!node) return FALSE;
+    wxCHECK_MSG( index < m_children.GetCount(),
+                 false,
+                 _T("Detach index is out of range") );
+
+    wxSizerItemList::Node   *node = m_children.Item( index );
+
+    wxCHECK_MSG( node, false, _T("Failed to find child node") );
+
+    wxSizerItem     *item = node->GetData();
 
 
-    ( (wxSizerItem*)node->Data() )->SetDeleteItem( FALSE );
-    m_children.DeleteNode( node );
+    if( item->IsSizer() )
+        item->DetachSizer();
+    else if( item->IsWindow() )
+        item->GetWindow()->SetContainingSizer( NULL );
 
 
-    return TRUE;
+    return m_children.DeleteNode( node );
 }
 
 void wxSizer::Clear( bool delete_windows )
 {
     // First clear the ContainingSizer pointers
 }
 
 void wxSizer::Clear( bool delete_windows )
 {
     // First clear the ContainingSizer pointers
-    wxNode *node = m_children.First();
+    wxSizerItemList::Node   *node = m_children.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*)node->Data();
+        wxSizerItem     *item = node->GetData();
+
         if (item->IsWindow())
         if (item->IsWindow())
-            item->GetWindow()->SetContainingSizer(NULL);
-        node = node->Next();
+            item->GetWindow()->SetContainingSizer( NULL );
+        node = node->GetNext();
     }
 
     // Destroy the windows if needed
     }
 
     // Destroy the windows if needed
@@ -418,12 +500,13 @@ void wxSizer::Clear( bool delete_windows )
 
 void wxSizer::DeleteWindows()
 {
 
 void wxSizer::DeleteWindows()
 {
-    wxNode *node = m_children.First();
+    wxSizerItemList::Node   *node = m_children.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*)node->Data();
+        wxSizerItem     *item = node->GetData();
+
         item->DeleteWindows();
         item->DeleteWindows();
-        node = node->Next();
+        node = node->GetNext();
     }
 }
 
     }
 }
 
@@ -483,16 +566,17 @@ void wxSizer::SetVirtualSizeHints( wxWindow *window )
                                  window->GetMaxHeight() );
 }
 
                                  window->GetMaxHeight() );
 }
 
-wxSize wxSizer::GetMaxWindowSize( wxWindow *window )
+wxSize wxSizer::GetMaxWindowSize( wxWindow *window ) const
 {
     return window->GetMaxSize();
 }
 
 wxSize wxSizer::GetMinWindowSize( wxWindow *window )
 {
 {
     return window->GetMaxSize();
 }
 
 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 );
 }
@@ -513,7 +597,7 @@ wxSize wxSizer::FitSize( wxWindow *window )
     return size;
 }
 
     return size;
 }
 
-wxSize wxSizer::GetMaxClientSize( wxWindow *window )
+wxSize wxSizer::GetMaxClientSize( wxWindow *window ) const
 {
     wxSize maxSize( window->GetMaxSize() );
 
 {
     wxSize maxSize( window->GetMaxSize() );
 
@@ -574,80 +658,88 @@ 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::Node   *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::Node   *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::Node   *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())
     {
         // Sizers contains the minimal size in them, if not calculated ...
     if (item->GetSizer())
     {
         // Sizers contains the minimal size in them, if not calculated ...
@@ -659,111 +751,129 @@ bool wxSizer::DoSetItemMinSize( int pos, int width, int height )
         item->SetInitSize( width, height );
     }
 
         item->SetInitSize( width, height );
     }
 
-    return TRUE;
+    return true;
 }
 
 }
 
-void wxSizer::Show(wxWindow *window, bool show)
+void wxSizer::Show( wxWindow *window, bool show )
 {
 {
-    wxNode *node = m_children.GetFirst();
+    wxASSERT_MSG( window, _T("Show for NULL window") );
+
+    wxSizerItemList::Node   *node = m_children.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*) node->Data();
+        wxSizerItem     *item = node->GetData();
 
 
-        if (item->IsWindow() && item->GetWindow() == window)
+        if (item->GetWindow() == window)
         {
         {
-            item->Show(show);
-            window->Show(show);
-            return;
+            item->Show( show );
+            break;
         }
         }
-        node = node->Next();
+        node = node->GetNext();
     }
 }
 
     }
 }
 
-void wxSizer::Show(wxSizer *sizer, bool show)
+void wxSizer::Show( wxSizer *sizer, bool show )
 {
 {
-    wxNode *node = m_children.GetFirst();
+    wxASSERT_MSG( sizer, _T("Show for NULL sizer") );
+
+    wxSizerItemList::Node   *node = m_children.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*) node->Data();
+        wxSizerItem     *item = node->GetData();
 
 
-        if (item->IsSizer() && item->GetSizer() == sizer)
+        if (item->GetSizer() == sizer)
         {
         {
-            item->Show(show);
-            sizer->ShowItems(show);
-            return;
+            item->Show( show );
+            break;
         }
         }
-        node = node->Next();
+        node = node->GetNext();
     }
 }
 
     }
 }
 
-void wxSizer::ShowItems (bool show)
+void wxSizer::Show( size_t index, bool show )
 {
 {
-    wxNode *node = m_children.GetFirst();
-    while (node)
-    {
-        wxSizerItem *item = (wxSizerItem*) node->Data();
+    wxCHECK_RET( index < m_children.GetCount(),
+                 _T("Show index is out of range") );
 
 
-        if (item->IsWindow())
-            item->GetWindow()->Show (show);
-        else if (item->IsSizer())
-            item->GetSizer()->ShowItems (show);
+    m_children.Item( index )->GetData()->Show( show );
+}
 
 
-        node = node->Next();
+void wxSizer::ShowItems( bool show )
+{
+    wxSizerItemList::Node   *node = m_children.GetFirst();
+    while (node)
+    {
+        node->GetData()->Show( show );
+        node = node->GetNext();
     }
 }
 
     }
 }
 
-bool wxSizer::IsShown (wxWindow *window)
+bool wxSizer::IsShown( wxWindow *window ) const
 {
 {
-    wxNode *node = m_children.GetFirst();
+    wxSizerItemList::Node   *node = m_children.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*) node->Data();
+        wxSizerItem     *item = node->GetData();
         
         
-        if (item->IsWindow() && item->GetWindow() == window)
+        if (item->GetWindow() == window)
         {
             return item->IsShown();
         }
         {
             return item->IsShown();
         }
-        node = node->Next();
+        node = node->GetNext();
     }
 
     }
 
-    return FALSE;
+    wxFAIL_MSG( _T("IsShown failed to find sizer item") );
+
+    return false;
 }
 
 }
 
-bool wxSizer::IsShown (wxSizer *sizer)
+bool wxSizer::IsShown( wxSizer *sizer ) const
 {
 {
-    wxNode *node = m_children.GetFirst();
+    wxSizerItemList::Node   *node = m_children.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*) node->Data();
+        wxSizerItem     *item = node->GetData();
 
 
-        if (item->IsSizer() && item->GetSizer() == sizer)
+        if (item->GetSizer() == sizer)
         {
             return item->IsShown();
         }
         {
             return item->IsShown();
         }
-        node = node->Next();
+        node = node->GetNext();
     }
 
     }
 
-    return FALSE;
+    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;
 }
 
 int wxGridSizer::CalcRowsCols(int& nrows, int& ncols) const
 }
 
 int wxGridSizer::CalcRowsCols(int& nrows, int& ncols) const
@@ -813,10 +923,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::Node   *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;
         }
@@ -834,19 +945,20 @@ wxSize wxGridSizer::CalcMin()
     int w = 0;
     int h = 0;
 
     int w = 0;
     int h = 0;
 
-    wxNode *node = m_children.First();
+    wxSizerItemList::Node   *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 )
@@ -889,16 +1001,16 @@ void wxGridSizer::SetItemBounds( wxSizerItem *item, int x, int y, int w, int h )
 
 wxFlexGridSizer::wxFlexGridSizer( int rows, int cols, int vgap, int hgap )
    : wxGridSizer( rows, cols, vgap, hgap )
 
 wxFlexGridSizer::wxFlexGridSizer( int rows, int cols, int vgap, int hgap )
    : wxGridSizer( rows, cols, vgap, hgap )
+   , m_rowHeights( NULL )
+   , m_colWidths( NULL )
 {
 {
-    m_rowHeights = (int*) NULL;
-    m_colWidths = (int*) NULL;
 }
 
 wxFlexGridSizer::wxFlexGridSizer( int cols, int vgap, int hgap )
    : wxGridSizer( cols, vgap, hgap )
 }
 
 wxFlexGridSizer::wxFlexGridSizer( int cols, int vgap, int hgap )
    : wxGridSizer( cols, vgap, hgap )
+   , m_rowHeights( NULL )
+   , m_colWidths( NULL )
 {
 {
-    m_rowHeights = (int*) NULL;
-    m_colWidths = (int*) NULL;
 }
 
 wxFlexGridSizer::~wxFlexGridSizer()
 }
 
 wxFlexGridSizer::~wxFlexGridSizer()
@@ -985,13 +1097,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::Node   *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;
         }
@@ -1007,18 +1120,20 @@ wxSize wxFlexGridSizer::CalcMin()
 
     CreateArrays();
 
 
     CreateArrays();
 
-    int i = 0;
-    wxNode *node = m_children.First();
+    int                      i = 0;
+    wxSizerItemList::Node   *node = m_children.GetFirst();
+
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*)node->Data();
-        wxSize sz( item->CalcMin() );
-        int row = i / ncols;
-        int col = i % ncols;
+        wxSizerItem    *item = node->GetData();
+        wxSize          sz( item->CalcMin() );
+        int             row = i / ncols;
+        int             col = i % ncols;
+
         m_rowHeights[ row ] = wxMax( sz.y, m_rowHeights[ row ] );
         m_colWidths[ col ] = wxMax( sz.x, m_colWidths[ col ] );
 
         m_rowHeights[ row ] = wxMax( sz.y, m_rowHeights[ row ] );
         m_colWidths[ col ] = wxMax( sz.x, m_colWidths[ col ] );
 
-        node = node->Next();
+        node = node->GetNext();
         i++;
     }
 
         i++;
     }
 
@@ -1057,8 +1172,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()
@@ -1084,22 +1199,23 @@ void wxBoxSizer::RecalcSizes()
 
     wxPoint pt( m_position );
 
 
     wxPoint pt( m_position );
 
-    wxNode *node = m_children.GetFirst();
+    wxSizerItemList::Node   *node = m_children.GetFirst();
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*) node->Data();
+        wxSizerItem     *item = node->GetData();
+
         if (item->IsShown())
         {
             int weight = 1;
         if (item->IsShown())
         {
             int weight = 1;
-            if (item->GetOption())
-                weight = item->GetOption();
+            if (item->GetProportion())
+                weight = item->GetProportion();
 
             wxSize size( item->CalcMin() );
 
             if (m_orient == wxVERTICAL)
             {
                 wxCoord height = size.y;
 
             wxSize size( item->CalcMin() );
 
             if (m_orient == wxVERTICAL)
             {
                 wxCoord height = size.y;
-                if (item->GetOption())
+                if (item->GetProportion())
                 {
                     height = (delta * weight) + extra;
                     extra = 0; // only the first item will get the remainder as extra size
                 {
                     height = (delta * weight) + extra;
                     extra = 0; // only the first item will get the remainder as extra size
@@ -1124,7 +1240,7 @@ void wxBoxSizer::RecalcSizes()
             else
             {
                 wxCoord width = size.x;
             else
             {
                 wxCoord width = size.x;
-                if (item->GetOption())
+                if (item->GetProportion())
                 {
                     width = (delta * weight) + extra;
                     extra = 0; // only the first item will get the remainder as extra size
                 {
                     width = (delta * weight) + extra;
                     extra = 0; // only the first item will get the remainder as extra size
@@ -1148,7 +1264,7 @@ void wxBoxSizer::RecalcSizes()
             }
         }
 
             }
         }
 
-        node = node->Next();
+        node = node->GetNext();
     }
 }
 
     }
 }
 
@@ -1164,14 +1280,16 @@ wxSize wxBoxSizer::CalcMin()
     m_fixedHeight = 0;
 
     // Find how long each stretch unit needs to be
     m_fixedHeight = 0;
 
     // Find how long each stretch unit needs to be
-    int stretchSize = 1;
-    wxNode *node = m_children.GetFirst();
+    int                      stretchSize = 1;
+    wxSizerItemList::Node   *node = m_children.GetFirst();
+
     while (node)
     {
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*) node->Data();
-        if (item->IsShown() && item->GetOption() != 0)
+        wxSizerItem     *item = node->GetData();
+
+        if (item->IsShown() && item->GetProportion() != 0)
         {
         {
-            int stretch = item->GetOption();
+            int stretch = item->GetProportion();
             wxSize size( item->CalcMin() );
             int sizePerStretch;
             // Integer division rounded up is (a + b - 1) / b
             wxSize size( item->CalcMin() );
             int sizePerStretch;
             // Integer division rounded up is (a + b - 1) / b
@@ -1182,24 +1300,26 @@ wxSize wxBoxSizer::CalcMin()
             if (sizePerStretch > stretchSize)
                 stretchSize = sizePerStretch;
         }
             if (sizePerStretch > stretchSize)
                 stretchSize = sizePerStretch;
         }
-        node = node->Next();
+        node = node->GetNext();
     }
     }
+
     // Calculate overall minimum size
     node = m_children.GetFirst();
     while (node)
     {
     // Calculate overall minimum size
     node = m_children.GetFirst();
     while (node)
     {
-        wxSizerItem *item = (wxSizerItem*) node->Data();
+        wxSizerItem     *item = node->GetData();
+
         if (item->IsShown())
         {
         if (item->IsShown())
         {
-            m_stretchable += item->GetOption();
+            m_stretchable += item->GetProportion();
 
             wxSize size( item->CalcMin() );
 
             wxSize size( item->CalcMin() );
-            if (item->GetOption() != 0)
+            if (item->GetProportion() != 0)
             {
                 if (m_orient == wxHORIZONTAL)
             {
                 if (m_orient == wxHORIZONTAL)
-                    size.x = stretchSize * item->GetOption();
+                    size.x = stretchSize * item->GetProportion();
                 else
                 else
-                    size.y = stretchSize * item->GetOption();
+                    size.y = stretchSize * item->GetProportion();
             }
 
             if (m_orient == wxHORIZONTAL)
             }
 
             if (m_orient == wxHORIZONTAL)
@@ -1213,7 +1333,7 @@ wxSize wxBoxSizer::CalcMin()
                 m_minWidth = wxMax( m_minWidth, size.x );
             }
 
                 m_minWidth = wxMax( m_minWidth, size.x );
             }
 
-            if (item->GetOption() == 0)
+            if (item->GetProportion() == 0)
             {
                 if (m_orient == wxVERTICAL)
                 {
             {
                 if (m_orient == wxVERTICAL)
                 {
@@ -1227,7 +1347,7 @@ wxSize wxBoxSizer::CalcMin()
                 }
             }
         }
                 }
             }
         }
-        node = node->Next();
+        node = node->GetNext();
     }
 
     return wxSize( m_minWidth, m_minHeight );
     }
 
     return wxSize( m_minWidth, m_minHeight );
@@ -1240,15 +1360,15 @@ wxSize wxBoxSizer::CalcMin()
 #if wxUSE_STATBOX
 
 wxStaticBoxSizer::wxStaticBoxSizer( wxStaticBox *box, int orient )
 #if wxUSE_STATBOX
 
 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") );
-
-    m_staticBox = box;
 }
 
 }
 
-static void GetStaticBoxBorders(wxStaticBox *box,
-                                int *borderTop, int *borderOther)
+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
 {
     // this has to be done platform by platform as there is no way to
     // guess the thickness of a wxStaticBox border
@@ -1303,10 +1423,9 @@ wxSize wxStaticBoxSizer::CalcMin()
 #if wxUSE_NOTEBOOK
 
 wxNotebookSizer::wxNotebookSizer( wxNotebook *nb )
 #if wxUSE_NOTEBOOK
 
 wxNotebookSizer::wxNotebookSizer( wxNotebook *nb )
+    : m_notebook( nb )
 {
     wxASSERT_MSG( nb, wxT("wxNotebookSizer needs a notebook") );
 {
     wxASSERT_MSG( nb, wxT("wxNotebookSizer needs a notebook") );
-
-    m_notebook = nb;
 }
 
 void wxNotebookSizer::RecalcSizes()
 }
 
 void wxNotebookSizer::RecalcSizes()
wxWidgets (Impactor)