Updated list of subprojects.
[wxWidgets.git] / src / common / sizer.cpp
index a9bcc42f0400c2d5eebdb09211d830bfb0c127a7..a691f6431c5af175f8741d922e325819d515c421 100644 (file)
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        sizer.cpp
+// Name:        src/common/sizer.cpp
 // Purpose:     provide new wxSizer class for layout
 // Author:      Robert Roebling and Robin Dunn, contributions by
 //              Dirk Holtwick, Ron Lee
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "sizer.h"
-#endif
-
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #endif
 
 #include "wx/sizer.h"
-#include "wx/utils.h"
-#include "wx/statbox.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/string.h"
+    #include "wx/intl.h"
+    #include "wx/math.h"
+    #include "wx/utils.h"
+    #include "wx/settings.h"
+    #include "wx/button.h"
+    #include "wx/statbox.h"
+    #include "wx/toplevel.h"
+#endif // WX_PRECOMP
+
 #include "wx/listimpl.cpp"
+
 #if WXWIN_COMPATIBILITY_2_4
     #include "wx/notebook.h"
 #endif
 
-#ifdef __WXMAC__
-#   include "wx/mac/uma.h"
-#endif
-
 //---------------------------------------------------------------------------
 
 IMPLEMENT_CLASS(wxSizerItem, wxObject)
@@ -43,8 +46,11 @@ IMPLEMENT_CLASS(wxBoxSizer, wxSizer)
 #if wxUSE_STATBOX
 IMPLEMENT_CLASS(wxStaticBoxSizer, wxBoxSizer)
 #endif
+#if wxUSE_BUTTON
+IMPLEMENT_CLASS(wxStdDialogButtonSizer, wxBoxSizer)
+#endif
 
-WX_DEFINE_EXPORTED_LIST( wxSizerItemList );
+WX_DEFINE_EXPORTED_LIST( wxSizerItemList )
 
 /*
     TODO PROPERTIES
@@ -78,93 +84,170 @@ WX_DEFINE_EXPORTED_LIST( wxSizerItemList );
        growablecols
     minsize
 */
-//---------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
 // wxSizerItem
-//---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+void wxSizerItem::Init(const wxSizerFlags& flags)
+{
+    Init();
+
+    m_proportion = flags.GetProportion();
+    m_flag = flags.GetFlags();
+    m_border = flags.GetBorderInPixels();
+}
+
+wxSizerItem::wxSizerItem()
+{
+    Init();
+
+    m_proportion = 0;
+    m_border = 0;
+    m_flag = 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_proportion( proportion )
-    , m_border( border )
-    , m_flag( flag )
-    , m_show( true )
-    , m_userData( userData )
-{
-    SetRatio( m_size );
-}
-
-wxSizerItem::wxSizerItem( wxWindow *window, int proportion, int flag, int border, wxObject* userData )
-    : m_window( window )
-    , m_sizer( NULL )
-    , m_proportion( proportion )
-    , m_border( border )
-    , m_flag( flag )
-    , m_show( true )
-    , m_userData( userData )
-{
-    if (flag & wxFIXED_MINSIZE)
-        window->SetMinSize(window->GetSize());
+    m_kind = Item_None;
+}
+
+// window item
+void wxSizerItem::SetWindow(wxWindow *window)
+{
+    wxCHECK_RET( window, _T("NULL window in wxSizerItem::SetWindow()") );
+
+    m_kind = Item_Window;
+    m_window = window;
+
+    // window doesn't become smaller than its initial size, whatever happens
     m_minSize = window->GetSize();
 
+    if ( m_flag & wxFIXED_MINSIZE )
+        window->SetMinSize(m_minSize);
+
     // aspect ratio calculated from initial size
-    SetRatio( m_minSize );
+    SetRatio(m_minSize);
+}
 
-    // m_size is calculated later
+wxSizerItem::wxSizerItem(wxWindow *window,
+                         int proportion,
+                         int flag,
+                         int border,
+                         wxObject* userData)
+           : m_proportion(proportion),
+             m_border(border),
+             m_flag(flag),
+             m_userData(userData)
+{
+    SetWindow(window);
 }
 
-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 )
+// sizer item
+void wxSizerItem::SetSizer(wxSizer *sizer)
 {
-    // m_minSize is calculated later
-    // m_size is calculated later
+    m_kind = Item_Sizer;
+    m_sizer = sizer;
 }
 
-wxSizerItem::wxSizerItem()
-    : m_window( NULL )
-    , m_sizer( NULL )
-    , m_proportion( 0 )
-    , m_border( 0 )
-    , m_flag( 0 )
-    , m_show( true )
-    , m_ratio( 0.0 )
-    , m_userData( NULL )
+wxSizerItem::wxSizerItem(wxSizer *sizer,
+                         int proportion,
+                         int flag,
+                         int border,
+                         wxObject* userData)
+           : m_proportion(proportion),
+             m_border(border),
+             m_flag(flag),
+             m_ratio(0.0),
+             m_userData(userData)
+{
+    SetSizer(sizer);
+
+    // m_minSize is set later
+}
+
+// spacer item
+void wxSizerItem::SetSpacer(const wxSize& size)
+{
+    m_kind = Item_Spacer;
+    m_spacer = new wxSizerSpacer(size);
+    m_minSize = size;
+    SetRatio(size);
+}
+
+wxSizerItem::wxSizerItem(int width,
+                         int height,
+                         int proportion,
+                         int flag,
+                         int border,
+                         wxObject* userData)
+           : m_minSize(width, height), // minimal size is the initial size
+             m_proportion(proportion),
+             m_border(border),
+             m_flag(flag),
+             m_userData(userData)
 {
+    SetSpacer(width, height);
 }
 
 wxSizerItem::~wxSizerItem()
 {
     delete m_userData;
 
-    if ( m_window )
+    switch ( m_kind )
     {
-        m_window->SetContainingSizer(NULL);
-    }
-    else // we must be a sizer
-    {
-        delete m_sizer;
+        case Item_None:
+            break;
+
+        case Item_Window:
+            m_window->SetContainingSizer(NULL);
+            break;
+
+        case Item_Sizer:
+            delete m_sizer;
+            break;
+
+        case Item_Spacer:
+            delete m_spacer;
+            break;
+
+        case Item_Max:
+        default:
+            wxFAIL_MSG( _T("unexpected wxSizerItem::m_kind") );
     }
 }
 
+wxSize wxSizerItem::GetSpacer() const
+{
+    wxSize size;
+    if ( m_kind == Item_Spacer )
+        size = m_spacer->GetSize();
+
+    return size;
+}
+
 
 wxSize wxSizerItem::GetSize() const
 {
     wxSize ret;
-    if (IsSizer())
-        ret = m_sizer->GetSize();
-    else
-    if (IsWindow())
-        ret = m_window->GetSize();
-    else ret = m_size;
+    switch ( m_kind )
+    {
+        case Item_None:
+            break;
+
+        case Item_Window:
+            ret = m_window->GetSize();
+            break;
+
+        case Item_Sizer:
+            ret = m_sizer->GetSize();
+            break;
+
+        case Item_Spacer:
+            ret = m_spacer->GetSize();
+            break;
+
+        case Item_Max:
+        default:
+            wxFAIL_MSG( _T("unexpected wxSizerItem::m_kind") );
+    }
 
     if (m_flag & wxWEST)
         ret.x += m_border;
@@ -186,7 +269,7 @@ wxSize wxSizerItem::CalcMin()
 
         // 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)
+        if ( (m_flag & wxSHAPED) && wxIsNullDouble(m_ratio) )
             SetRatio(m_minSize);
     }
     else if ( IsWindow() )
@@ -216,8 +299,10 @@ wxSize wxSizerItem::GetMinSizeWithBorder() const
 }
 
 
-void wxSizerItem::SetDimension( wxPoint pos, wxSize size )
+void wxSizerItem::SetDimension( const wxPoint& pos_, const wxSize& size_ )
 {
+    wxPoint pos = pos_;
+    wxSize size = size_;
     if (m_flag & wxSHAPED)
     {
         // adjust aspect ratio
@@ -269,54 +354,134 @@ void wxSizerItem::SetDimension( wxPoint pos, wxSize size )
         size.y -= m_border;
     }
 
-    if (IsSizer())
-        m_sizer->SetDimension( pos.x, pos.y, size.x, size.y );
+    if (size.x < 0)
+        size.x = 0;
+    if (size.y < 0)
+        size.y = 0;
 
-    if (IsWindow())
-        m_window->SetSize( pos.x, pos.y, size.x, size.y, wxSIZE_ALLOW_MINUS_ONE );
+    m_rect = wxRect(pos, size);
 
-    m_size = size;
+    switch ( m_kind )
+    {
+        case Item_None:
+            wxFAIL_MSG( _T("can't set size of uninitialized sizer item") );
+            break;
+
+        case Item_Window:
+            m_window->SetSize(pos.x, pos.y, size.x, size.y,
+                              wxSIZE_ALLOW_MINUS_ONE);
+            break;
+
+        case Item_Sizer:
+            m_sizer->SetDimension(pos.x, pos.y, size.x, size.y);
+            break;
+
+        case Item_Spacer:
+            m_spacer->SetSize(size);
+            break;
+
+        case Item_Max:
+        default:
+            wxFAIL_MSG( _T("unexpected wxSizerItem::m_kind") );
+    }
 }
 
 void wxSizerItem::DeleteWindows()
 {
-    if (m_window)
+    switch ( m_kind )
     {
-         m_window->Destroy();
-         m_window = NULL;
+        case Item_None:
+        case Item_Spacer:
+            break;
+
+        case Item_Window:
+            //We are deleting the window from this sizer - normally
+            //the window destroys the sizer associated with it,
+            //which might destroy this, which we don't want
+            m_window->SetContainingSizer(NULL);
+            m_window->Destroy();
+            //Putting this after the switch will result in a spacer
+            //not being deleted properly on destruction
+            m_kind = Item_None;
+            break;
+
+        case Item_Sizer:
+            m_sizer->DeleteWindows();
+            break;
+
+        case Item_Max:
+        default:
+            wxFAIL_MSG( _T("unexpected wxSizerItem::m_kind") );
     }
 
-    if (m_sizer)
-        m_sizer->DeleteWindows();
 }
 
-bool wxSizerItem::IsWindow() const
+void wxSizerItem::Show( bool show )
 {
-    return (m_window != NULL);
-}
+    switch ( m_kind )
+    {
+        case Item_None:
+            wxFAIL_MSG( _T("can't show uninitialized sizer item") );
+            break;
 
-bool wxSizerItem::IsSizer() const
-{
-    return (m_sizer != NULL);
-}
+        case Item_Window:
+            m_window->Show(show);
+            break;
 
-bool wxSizerItem::IsSpacer() const
-{
-    return (m_window == NULL) && (m_sizer == NULL);
+        case Item_Sizer:
+            m_sizer->Show(show);
+            break;
+
+        case Item_Spacer:
+            m_spacer->Show(show);
+            break;
+
+        case Item_Max:
+        default:
+            wxFAIL_MSG( _T("unexpected wxSizerItem::m_kind") );
+    }
 }
 
-void wxSizerItem::Show( bool show )
+bool wxSizerItem::IsShown() const
 {
-    m_show = show;
+    switch ( m_kind )
+    {
+        case Item_None:
+            // we may be called from CalcMin(), just return false so that we're
+            // not used
+            break;
+
+        case Item_Window:
+            return m_window->IsShown();
+
+        case Item_Sizer:
+            // arbitrarily decide that if at least one of our elements is
+            // shown, so are we (this arbitrariness is the reason for
+            // deprecating this function)
+            {
+                for ( wxSizerItemList::compatibility_iterator
+                        node = m_sizer->GetChildren().GetFirst();
+                      node;
+                      node = node->GetNext() )
+                {
+                    if ( node->GetData()->IsShown() )
+                        return true;
+                }
+            }
+            return false;
+
+        case Item_Spacer:
+            return m_spacer->IsShown();
 
-    if( IsWindow() )
-        m_window->Show( show );
-    else if( IsSizer() )
-        m_sizer->ShowItems( show );
+        case Item_Max:
+        default:
+            wxFAIL_MSG( _T("unexpected wxSizerItem::m_kind") );
+    }
 
-    // ... nothing else to do to hide/show spacers
+    return false;
 }
 
+#if WXWIN_COMPATIBILITY_2_6
 void wxSizerItem::SetOption( int option )
 {
     SetProportion( option );
@@ -326,147 +491,57 @@ int wxSizerItem::GetOption() const
 {
     return GetProportion();
 }
+#endif // WXWIN_COMPATIBILITY_2_6
 
 
 //---------------------------------------------------------------------------
 // wxSizer
 //---------------------------------------------------------------------------
 
-wxSizer::wxSizer()
-    : m_minSize( wxSize( 0, 0 ) )
-{
-}
-
 wxSizer::~wxSizer()
 {
     WX_CLEAR_LIST(wxSizerItemList, m_children);
 }
 
-void wxSizer::Add( wxWindow *window, int proportion, int flag, int border, wxObject* userData )
-{
-    m_children.Append( new wxSizerItem( window, proportion, flag, border, userData ) );
-    window->SetContainingSizer( this );
-}
-
-void wxSizer::Add( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData )
-{
-    m_children.Append( new wxSizerItem( sizer, proportion, flag, border, userData ) );
-}
-
-void wxSizer::Add( int width, int height, int proportion, int flag, int border, wxObject* userData )
+wxSizerItem* wxSizer::Insert( size_t index, wxSizerItem *item )
 {
-    m_children.Append( new wxSizerItem( width, height, proportion, flag, border, userData ) );
-}
-
-void wxSizer::Add( wxSizerItem *item )
-{
-    m_children.Append( item );
-
-    if( item->GetWindow() )
-        item->GetWindow()->SetContainingSizer( this );
-}
-
-void wxSizer::AddSpacer(int size)
-{
-    Add(size, size);
-}
-
-void wxSizer::AddStretchSpacer(int prop)
-{
-    Add(0, 0, prop);
-}
-
-void wxSizer::Prepend( wxWindow *window, int proportion, int flag, int border, wxObject* userData )
-{
-    m_children.Insert( new wxSizerItem( window, proportion, flag, border, userData ) );
-    window->SetContainingSizer( this );
-}
-
-void wxSizer::Prepend( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData )
-{
-    m_children.Insert( new wxSizerItem( sizer, proportion, flag, border, userData ) );
-}
-
-void wxSizer::Prepend( int width, int height, int proportion, int flag, int border, wxObject* userData )
-{
-    m_children.Insert( new wxSizerItem( width, height, proportion, flag, border, userData ) );
-}
-
-void wxSizer::Prepend( wxSizerItem *item )
-{
-    m_children.Insert( item );
+    m_children.Insert( index, item );
 
-    if( item->GetWindow() )
+    if ( item->GetWindow() )
         item->GetWindow()->SetContainingSizer( this );
-}
-
-void wxSizer::PrependSpacer(int size)
-{
-    Prepend(size, size);
-}
-
-void wxSizer::PrependStretchSpacer(int prop)
-{
-    Prepend(0, 0, prop);
-}
-
-void wxSizer::Insert( size_t index,
-                      wxWindow *window,
-                      int proportion,
-                      int flag,
-                      int border,
-                      wxObject* 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 ) );
+    return item;
 }
 
-void wxSizer::Insert( size_t index, wxSizerItem *item )
+void wxSizer::SetContainingWindow(wxWindow *win)
 {
-    m_children.Insert( index, item );
+    if ( win == m_containingWindow )
+        return;
 
-    if( item->GetWindow() )
-        item->GetWindow()->SetContainingSizer( this );
-}
+    m_containingWindow = win;
 
-void wxSizer::InsertSpacer(size_t index, int size)
-{
-    Insert(index, size, size);
-}
+    // set the same window for all nested sizers as well, they also are in the
+    // same window
+    for ( wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
+          node;
+          node = node->GetNext() )
+    {
+        wxSizerItem *const item = node->GetData();
+        wxSizer *const sizer = item->GetSizer();
 
-void wxSizer::InsertStretchSpacer(size_t index, int prop)
-{
-    Insert(index, 0, 0, prop);
+        if ( sizer )
+        {
+            sizer->SetContainingWindow(win);
+        }
+    }
 }
 
+#if WXWIN_COMPATIBILITY_2_6
 bool wxSizer::Remove( wxWindow *window )
 {
     return Detach( window );
 }
+#endif // WXWIN_COMPATIBILITY_2_6
 
 bool wxSizer::Remove( wxSizer *sizer )
 {
@@ -502,7 +577,7 @@ bool wxSizer::Remove( int index )
 
     wxSizerItem *item = node->GetData();
 
-    if( item->IsWindow() )
+    if ( item->IsWindow() )
         item->GetWindow()->SetContainingSizer( NULL );
 
     delete item;
@@ -566,9 +641,9 @@ bool wxSizer::Detach( int index )
 
     wxSizerItem *item = node->GetData();
 
-    if( item->IsSizer() )
+    if ( item->IsSizer() )
         item->DetachSizer();
-    else if( item->IsWindow() )
+    else if ( item->IsWindow() )
         item->GetWindow()->SetContainingSizer( NULL );
 
     delete item;
@@ -576,6 +651,80 @@ bool wxSizer::Detach( int index )
     return true;
 }
 
+bool wxSizer::Replace( wxWindow *oldwin, wxWindow *newwin, bool recursive )
+{
+    wxASSERT_MSG( oldwin, _T("Replacing NULL window") );
+    wxASSERT_MSG( newwin, _T("Replacing with NULL window") );
+
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
+    while (node)
+    {
+        wxSizerItem     *item = node->GetData();
+
+        if (item->GetWindow() == oldwin)
+        {
+            item->GetWindow()->SetContainingSizer( NULL );
+            item->SetWindow(newwin);
+            newwin->SetContainingSizer( this );
+            return true;
+        }
+        else if (recursive && item->IsSizer())
+        {
+            if (item->GetSizer()->Replace( oldwin, newwin, true ))
+                return true;
+        }
+
+        node = node->GetNext();
+    }
+
+    return false;
+}
+
+bool wxSizer::Replace( wxSizer *oldsz, wxSizer *newsz, bool recursive )
+{
+    wxASSERT_MSG( oldsz, _T("Replacing NULL sizer") );
+    wxASSERT_MSG( newsz, _T("Replacing with NULL sizer") );
+
+    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
+    while (node)
+    {
+        wxSizerItem     *item = node->GetData();
+
+        if (item->GetSizer() == oldsz)
+        {
+            wxSizer *old = item->GetSizer();
+            item->SetSizer(newsz);
+            delete old;
+            return true;
+        }
+        else if (recursive && item->IsSizer())
+        {
+            if (item->GetSizer()->Replace( oldsz, newsz, true ))
+                return true;
+        }
+
+        node = node->GetNext();
+    }
+
+    return false;
+}
+
+bool wxSizer::Replace( size_t old, wxSizerItem *newitem )
+{
+    wxCHECK_MSG( old < m_children.GetCount(), false, _T("Replace index is out of range") );
+    wxASSERT_MSG( newitem, _T("Replacing with NULL item") );
+
+    wxSizerItemList::compatibility_iterator node = m_children.Item( old );
+
+    wxCHECK_MSG( node, false, _T("Failed to find child node") );
+
+    wxSizerItem *item = node->GetData();
+    node->SetData(newitem);
+    delete item;
+
+    return true;
+}
+
 void wxSizer::Clear( bool delete_windows )
 {
     // First clear the ContainingSizer pointers
@@ -688,14 +837,23 @@ wxSize wxSizer::GetMinWindowSize( wxWindow *window )
 // Return a window size that will fit within the screens dimensions
 wxSize wxSizer::FitSize( wxWindow *window )
 {
+    if ( window->IsTopLevel() )
+    {
+        wxTopLevelWindow *tlw = wxDynamicCast(window, wxTopLevelWindow);
+        if ( tlw && tlw->IsAlwaysMaximized() )
+        {
+            return tlw->GetClientSize();
+        }
+    }
+
     wxSize size     = GetMinWindowSize( window );
     wxSize sizeMax  = GetMaxWindowSize( window );
 
     // Limit the size if sizeMax != wxDefaultSize
 
-    if ( size.x > sizeMax.x && sizeMax.x != -1 )
+    if ( size.x > sizeMax.x && sizeMax.x != wxDefaultCoord )
         size.x = sizeMax.x;
-    if ( size.y > sizeMax.y && sizeMax.y != -1 )
+    if ( size.y > sizeMax.y && sizeMax.y != wxDefaultCoord )
         size.y = sizeMax.y;
 
     return size;
@@ -705,7 +863,7 @@ wxSize wxSizer::GetMaxClientSize( wxWindow *window ) const
 {
     wxSize maxSize( window->GetMaxSize() );
 
-    if( maxSize != wxDefaultSize )
+    if ( maxSize != wxDefaultSize )
     {
         wxSize size( window->GetSize() );
         wxSize client_size( window->GetClientSize() );
@@ -729,9 +887,9 @@ wxSize wxSizer::VirtualFitSize( wxWindow *window )
 
     // Limit the size if sizeMax != wxDefaultSize
 
-    if ( size.x > sizeMax.x && sizeMax.x != -1 )
+    if ( size.x > sizeMax.x && sizeMax.x != wxDefaultCoord )
         size.x = sizeMax.x;
-    if ( size.y > sizeMax.y && sizeMax.y != -1 )
+    if ( size.y > sizeMax.y && sizeMax.y != wxDefaultCoord )
         size.y = sizeMax.y;
 
     return size;
@@ -858,9 +1016,9 @@ bool wxSizer::DoSetItemMinSize( size_t index, int width, int height )
     return true;
 }
 
-bool wxSizer::Show( wxWindow *window, bool show, bool recursive )
+wxSizerItem* wxSizer::GetItem( wxWindow *window, bool recursive )
 {
-    wxASSERT_MSG( window, _T("Show for NULL window") );
+    wxASSERT_MSG( window, _T("GetItem for NULL window") );
 
     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
     while (node)
@@ -869,58 +1027,93 @@ bool wxSizer::Show( wxWindow *window, bool show, bool recursive )
 
         if (item->GetWindow() == window)
         {
-            item->Show( show );
-
-            return true;
+            return item;
         }
         else if (recursive && item->IsSizer())
         {
-            if (item->GetSizer()->Show(window, show, recursive))
-                return true;
+            wxSizerItem *subitem = item->GetSizer()->GetItem( window, true );
+            if (subitem)
+                return subitem;
         }
 
         node = node->GetNext();
     }
 
-    return false;
+    return NULL;
 }
 
-bool wxSizer::Show( wxSizer *sizer, bool show, bool recursive )
+wxSizerItem* wxSizer::GetItem( wxSizer *sizer, bool recursive )
 {
-    wxASSERT_MSG( sizer, _T("Show for NULL sizer") );
+    wxASSERT_MSG( sizer, _T("GetItem for NULL sizer") );
 
     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
     while (node)
     {
-        wxSizerItem     *item = node->GetData();
+        wxSizerItem *item = node->GetData();
 
         if (item->GetSizer() == sizer)
         {
-            item->Show( show );
-
-            return true;
+            return item;
         }
         else if (recursive && item->IsSizer())
         {
-            if (item->GetSizer()->Show(sizer, show, recursive))
-                return true;
+            wxSizerItem *subitem = item->GetSizer()->GetItem( sizer, true );
+            if (subitem)
+                return subitem;
         }
 
         node = node->GetNext();
     }
 
+    return NULL;
+}
+
+wxSizerItem* wxSizer::GetItem( size_t index )
+{
+    wxCHECK_MSG( index < m_children.GetCount(),
+                 NULL,
+                 _T("GetItem index is out of range") );
+
+    return m_children.Item( index )->GetData();
+}
+
+bool wxSizer::Show( wxWindow *window, bool show, bool recursive )
+{
+    wxSizerItem *item = GetItem( window, recursive );
+
+    if ( item )
+    {
+         item->Show( show );
+         return true;
+    }
+
+    return false;
+}
+
+bool wxSizer::Show( wxSizer *sizer, bool show, bool recursive )
+{
+    wxSizerItem *item = GetItem( sizer, recursive );
+
+    if ( item )
+    {
+         item->Show( show );
+         return true;
+    }
+
     return false;
 }
 
 bool wxSizer::Show( size_t index, bool show)
 {
-    wxCHECK_MSG( index < m_children.GetCount(),
-                 false,
-                 _T("Show index is out of range") );
+    wxSizerItem *item = GetItem( index );
 
-    m_children.Item( index )->GetData()->Show( show );
+    if ( item )
+    {
+         item->Show( show );
+         return true;
+    }
 
-    return true;
+    return false;
 }
 
 void wxSizer::ShowItems( bool show )
@@ -986,23 +1179,19 @@ bool wxSizer::IsShown( size_t index ) const
 //---------------------------------------------------------------------------
 
 wxGridSizer::wxGridSizer( int rows, int cols, int vgap, int hgap )
-    : m_rows( rows )
+    : m_rows( ( cols == 0 && rows == 0 ) ? 1 : rows )
     , m_cols( cols )
     , m_vgap( vgap )
     , m_hgap( hgap )
 {
-    if (m_rows == 0 && m_cols == 0)
-        m_rows = 1;
 }
 
 wxGridSizer::wxGridSizer( int cols, int vgap, int hgap )
-    : m_rows( 0 )
+    : m_rows( cols == 0 ? 1 : 0 )
     , m_cols( cols )
     , m_vgap( vgap )
     , m_hgap( hgap )
 {
-    if (m_rows == 0 && m_cols == 0)
-        m_rows = 1;
 }
 
 int wxGridSizer::CalcRowsCols(int& nrows, int& ncols) const
@@ -1068,7 +1257,7 @@ wxSize wxGridSizer::CalcMin()
 {
     int nrows, ncols;
     if ( CalcRowsCols(nrows, ncols) == 0 )
-        return wxSize(10, 10);
+        return wxSize();
 
     // Find the max width and height for any component
     int w = 0;
@@ -1177,9 +1366,11 @@ void wxFlexGridSizer::RecalcSizes()
 
                 SetItemBounds( node->GetData(), x, y, w, h);
             }
-            y = y + m_rowHeights[r] + m_vgap;
+            if (m_rowHeights[r] != -1)
+                y = y + m_rowHeights[r] + m_vgap;
         }
-        x = x + m_colWidths[c] + m_hgap;
+        if (m_colWidths[c] != -1)
+            x = x + m_colWidths[c] + m_hgap;
     }
 }
 
@@ -1191,7 +1382,7 @@ wxSize wxFlexGridSizer::CalcMin()
 
     // Number of rows/columns can change as items are added or removed.
     if ( !CalcRowsCols(nrows, ncols) )
-        return wxSize(10, 10);
+        return wxSize();
 
     m_rowHeights.SetCount(nrows);
     m_colWidths.SetCount(ncols);
@@ -1233,12 +1424,16 @@ wxSize wxFlexGridSizer::CalcMin()
     int width = 0;
     for (int col = 0; col < ncols; col++)
         if ( m_colWidths[ col ] != -1 )
-            width += m_colWidths[ col ] + ( col == ncols-1 ? 0 : m_hgap );
+            width += m_colWidths[ col ] + m_hgap;
+    if (width > 0)
+        width -= m_hgap;
 
     int height = 0;
     for (int row = 0; row < nrows; row++)
         if ( m_rowHeights[ row ] != -1 )
-            height += m_rowHeights[ row ] + ( row == nrows-1 ? 0 : m_vgap );
+            height += m_rowHeights[ row ] + m_vgap;
+    if (height > 0)
+        height -= m_vgap;
 
     m_calculatedMinSize = wxSize( width, height );
     return m_calculatedMinSize;
@@ -1255,10 +1450,12 @@ void wxFlexGridSizer::AdjustForFlexDirection()
         wxArrayInt& array = m_flexDirection == wxVERTICAL ? m_colWidths
                                                           : m_rowHeights;
 
-        const int count = array.GetCount();
+        const size_t count = array.GetCount();
 
         // find the largest value in this array
-        int n, largest = 0;
+        size_t n;
+        int largest = 0;
+
         for ( n = 0; n < count; ++n )
         {
             if ( array[n] > largest )
@@ -1388,20 +1585,38 @@ void wxFlexGridSizer::AddGrowableRow( size_t idx, int proportion )
     m_growableRowsProportions.Add( proportion );
 }
 
-void wxFlexGridSizer::RemoveGrowableRow( size_t idx )
-{
-    m_growableRows.Remove( idx );
-}
-
 void wxFlexGridSizer::AddGrowableCol( size_t idx, int proportion )
 {
     m_growableCols.Add( idx );
     m_growableColsProportions.Add( proportion );
 }
 
+// helper function for RemoveGrowableCol/Row()
+static void
+DoRemoveFromArrays(size_t idx, wxArrayInt& items, wxArrayInt& proportions)
+{
+    const size_t count = items.size();
+    for ( size_t n = 0; n < count; n++ )
+    {
+        if ( (size_t)items[n] == idx )
+        {
+            items.RemoveAt(n);
+            proportions.RemoveAt(n);
+            return;
+        }
+    }
+
+    wxFAIL_MSG( _T("column/row is already not growable") );
+}
+
 void wxFlexGridSizer::RemoveGrowableCol( size_t idx )
 {
-    m_growableCols.Remove( idx );
+    DoRemoveFromArrays(idx, m_growableCols, m_growableColsProportions);
+}
+
+void wxFlexGridSizer::RemoveGrowableRow( size_t idx )
+{
+    DoRemoveFromArrays(idx, m_growableRows, m_growableRowsProportions);
 }
 
 //---------------------------------------------------------------------------
@@ -1449,7 +1664,7 @@ void wxBoxSizer::RecalcSizes()
                 }
 
                 wxPoint child_pos( pt );
-                wxSize  child_size( wxSize( size.x, height) );
+                wxSize  child_size( size.x, height );
 
                 if (item->GetFlag() & (wxEXPAND | wxSHAPED))
                     child_size.x = m_size.x;
@@ -1475,7 +1690,7 @@ void wxBoxSizer::RecalcSizes()
                 }
 
                 wxPoint child_pos( pt );
-                wxSize  child_size( wxSize(width, size.y) );
+                wxSize  child_size( width, size.y );
 
                 if (item->GetFlag() & (wxEXPAND | wxSHAPED))
                     child_size.y = m_size.y;
@@ -1486,6 +1701,16 @@ void wxBoxSizer::RecalcSizes()
                 //     wxALIGN_CENTER should be used in new code
                     child_pos.y += (m_size.y - size.y) / 2;
 
+                if ( m_containingWindow )
+                {
+                    child_pos.x = m_containingWindow->AdjustForLayoutDirection
+                                                      (
+                                                        child_pos.x,
+                                                        width,
+                                                        m_size.x
+                                                      );
+                }
+
                 item->SetDimension( child_pos, child_size );
 
                 pt.x += width;
@@ -1499,7 +1724,7 @@ void wxBoxSizer::RecalcSizes()
 wxSize wxBoxSizer::CalcMin()
 {
     if (m_children.GetCount() == 0)
-        return wxSize(10,10);
+        return wxSize();
 
     m_stretchable = 0;
     m_minWidth = 0;
@@ -1513,11 +1738,12 @@ wxSize wxBoxSizer::CalcMin()
     {
         wxSizerItem *item = node->GetData();
 
-        if (item->IsShown())
+        if ( item->IsShown() )
+        {
             item->CalcMin();  // result is stored in the item
 
-        if (item->IsShown() && item->GetProportion() != 0)
             m_stretchable += item->GetProportion();
+        }
 
         node = node->GetNext();
     }
@@ -1604,10 +1830,27 @@ wxSize wxBoxSizer::CalcMin()
 #if wxUSE_STATBOX
 
 wxStaticBoxSizer::wxStaticBoxSizer( wxStaticBox *box, int orient )
-    : wxBoxSizer( orient )
-    , m_staticBox( box )
+    : wxBoxSizer( orient ),
+      m_staticBox( box )
 {
     wxASSERT_MSG( box, wxT("wxStaticBoxSizer needs a static box") );
+
+    // do this so that our Detach() is called if the static box is destroyed
+    // before we are
+    m_staticBox->SetContainingSizer(this);
+}
+
+wxStaticBoxSizer::wxStaticBoxSizer(int orient, wxWindow *win, const wxString& s)
+                : wxBoxSizer(orient),
+                  m_staticBox(new wxStaticBox(win, wxID_ANY, s))
+{
+    // same as above
+    m_staticBox->SetContainingSizer(this);
+}
+
+wxStaticBoxSizer::~wxStaticBoxSizer()
+{
+    delete m_staticBox;
 }
 
 static void GetStaticBoxBorders( wxStaticBox *box,
@@ -1616,43 +1859,7 @@ static void GetStaticBoxBorders( wxStaticBox *box,
 {
     // 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);
-#elif defined(__WXMAC__)
-
-    static int extraTop = -1; // Uninitted
-    static int other = 5;
-
-    if ( extraTop == -1 )
-    {
-        // The minimal border used for the top. Later on the staticbox'
-        // font height is added to this.
-        extraTop = 0;
-
-        if ( UMAGetSystemVersion() >= 0x1030 /*Panther*/ )
-        {
-            // As indicated by the HIG, Panther needs an extra border of 11
-            // pixels (otherwise overlapping occurs at the top). The "other"
-            // border has to be 11.
-            extraTop = 11;
-            other = 11;
-        }
-
-    }
-
-    *borderTop = extraTop + box->GetCharHeight();
-    *borderOther = other;
-
-#else
-#ifdef __WXGTK__
-    if ( box->GetLabel().IsEmpty() )
-        *borderTop = 5;
-    else
-#endif // __WXGTK__
-        *borderTop = box->GetCharHeight();
-
-    *borderOther = 5;
-#endif // __WXCOCOA__
+    box->GetBordersForSizer(borderTop, borderOther);
 }
 
 void wxStaticBoxSizer::RecalcSizes()
@@ -1693,8 +1900,204 @@ void wxStaticBoxSizer::ShowItems( bool show )
     wxBoxSizer::ShowItems( show );
 }
 
+bool wxStaticBoxSizer::Detach( wxWindow *window )
+{
+    // avoid deleting m_staticBox in our dtor if it's being detached from the
+    // sizer (which can happen because it's being already destroyed for
+    // example)
+    if ( window == m_staticBox )
+    {
+        m_staticBox = NULL;
+        return true;
+    }
+
+    return wxSizer::Detach( window );
+}
+
 #endif // wxUSE_STATBOX
 
+#if wxUSE_BUTTON
+
+wxStdDialogButtonSizer::wxStdDialogButtonSizer()
+    : wxBoxSizer(wxHORIZONTAL)
+{
+    // Vertical buttons with lots of space on either side
+    // looks rubbish on WinCE, so let's not do this for now.
+    // If we are going to use vertical buttons, we should
+    // put the sizer to the right of other controls in the dialog,
+    // and that's beyond the scope of this sizer.
+#ifndef __WXWINCE__
+    bool is_pda = (wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA);
+    // If we have a PDA screen, put yes/no button over
+    // all other buttons, otherwise on the left side.
+    if (is_pda)
+        m_orient = wxVERTICAL;
+#endif
+
+    m_buttonAffirmative = NULL;
+    m_buttonApply = NULL;
+    m_buttonNegative = NULL;
+    m_buttonCancel = NULL;
+    m_buttonHelp = NULL;
+}
+
+void wxStdDialogButtonSizer::AddButton(wxButton *mybutton)
+{
+    switch (mybutton->GetId())
+    {
+        case wxID_OK:
+        case wxID_YES:
+        case wxID_SAVE:
+            m_buttonAffirmative = mybutton;
+            break;
+        case wxID_APPLY:
+            m_buttonApply = mybutton;
+            break;
+        case wxID_NO:
+            m_buttonNegative = mybutton;
+            break;
+        case wxID_CANCEL:
+            m_buttonCancel = mybutton;
+            break;
+        case wxID_HELP:
+        case wxID_CONTEXT_HELP:
+            m_buttonHelp = mybutton;
+            break;
+        default:
+            break;
+    }
+}
+
+void wxStdDialogButtonSizer::SetAffirmativeButton( wxButton *button )
+{
+    m_buttonAffirmative = button;
+}
+
+void wxStdDialogButtonSizer::SetNegativeButton( wxButton *button )
+{
+    m_buttonNegative = button;
+}
+
+void wxStdDialogButtonSizer::SetCancelButton( wxButton *button )
+{
+    m_buttonCancel = button;
+}
+
+void wxStdDialogButtonSizer::Realize()
+{
+#ifdef __WXMAC__
+        Add(0, 0, 0, wxLEFT, 6);
+        if (m_buttonHelp)
+            Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
+
+        if (m_buttonNegative){
+            // HIG POLICE BULLETIN - destructive buttons need extra padding
+            // 24 pixels on either side
+            Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 12);
+        }
+
+        // extra whitespace between help/negative and cancel/ok buttons
+        Add(0, 0, 1, wxEXPAND, 0);
+
+        if (m_buttonCancel){
+            Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
+            // Cancel or help should be default
+            // m_buttonCancel->SetDefaultButton();
+        }
+
+        // Ugh, Mac doesn't really have apply dialogs, so I'll just
+        // figure the best place is between Cancel and OK
+        if (m_buttonApply)
+            Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
+
+        if (m_buttonAffirmative){
+            Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT, 6);
+
+            if (m_buttonAffirmative->GetId() == wxID_SAVE){
+                // these buttons have set labels under Mac so we should use them
+                m_buttonAffirmative->SetLabel(_("Save"));
+                m_buttonNegative->SetLabel(_("Don't Save"));
+            }
+        }
+
+        // Extra space around and at the right
+        Add(12, 24);
+#elif defined(__WXGTK20__)
+        Add(0, 0, 0, wxLEFT, 9);
+        if (m_buttonHelp)
+            Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
+
+        // extra whitespace between help and cancel/ok buttons
+        Add(0, 0, 1, wxEXPAND, 0);
+
+        if (m_buttonNegative){
+            Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
+        }
+
+        if (m_buttonCancel){
+            Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
+            // Cancel or help should be default
+            // m_buttonCancel->SetDefaultButton();
+        }
+
+        if (m_buttonApply)
+            Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
+
+        if (m_buttonAffirmative)
+            Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT, 6);
+#elif defined(__WXMSW__)
+        // Windows
+
+        // right-justify buttons
+        Add(0, 0, 1, wxEXPAND, 0);
+
+        if (m_buttonAffirmative){
+            Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonAffirmative->ConvertDialogToPixels(wxSize(2, 0)).x);
+        }
+
+        if (m_buttonNegative){
+            Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonNegative->ConvertDialogToPixels(wxSize(2, 0)).x);
+        }
+
+        if (m_buttonCancel){
+            Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonCancel->ConvertDialogToPixels(wxSize(2, 0)).x);
+        }
+        if (m_buttonApply)
+            Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonApply->ConvertDialogToPixels(wxSize(2, 0)).x);
+
+        if (m_buttonHelp)
+            Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonHelp->ConvertDialogToPixels(wxSize(2, 0)).x);
+#else
+        // GTK+1 and any other platform
+
+        // Add(0, 0, 0, wxLEFT, 5); // Not sure what this was for but it unbalances the dialog
+        if (m_buttonHelp)
+            Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonHelp->ConvertDialogToPixels(wxSize(4, 0)).x);
+
+        // extra whitespace between help and cancel/ok buttons
+        Add(0, 0, 1, wxEXPAND, 0);
+
+        if (m_buttonApply)
+            Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonApply->ConvertDialogToPixels(wxSize(4, 0)).x);
+
+        if (m_buttonAffirmative){
+            Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonAffirmative->ConvertDialogToPixels(wxSize(4, 0)).x);
+        }
+
+        if (m_buttonNegative){
+            Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonNegative->ConvertDialogToPixels(wxSize(4, 0)).x);
+        }
+
+        if (m_buttonCancel){
+            Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonCancel->ConvertDialogToPixels(wxSize(4, 0)).x);
+            // Cancel or help should be default
+            // m_buttonCancel->SetDefaultButton();
+        }
+
+#endif
+}
+
+#endif // wxUSE_BUTTON
 
 #if WXWIN_COMPATIBILITY_2_4
 
@@ -1711,12 +2114,16 @@ IMPLEMENT_CLASS(wxNotebookSizer, wxBookCtrlSizer)
 
 #if wxUSE_BOOKCTRL
 
-wxBookCtrlSizer::wxBookCtrlSizer(wxBookCtrl *bookctrl)
+#if WXWIN_COMPATIBILITY_2_6
+
+wxBookCtrlSizer::wxBookCtrlSizer(wxBookCtrlBase *bookctrl)
                : m_bookctrl(bookctrl)
 {
     wxASSERT_MSG( bookctrl, wxT("wxBookCtrlSizer needs a control") );
 }
 
+#endif // WXWIN_COMPATIBILITY_2_6
+
 void wxBookCtrlSizer::RecalcSizes()
 {
     m_bookctrl->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );
@@ -1724,7 +2131,7 @@ void wxBookCtrlSizer::RecalcSizes()
 
 wxSize wxBookCtrlSizer::CalcMin()
 {
-    wxSize sizeBorder = m_bookctrl->CalcSizeFromPage(wxSize(0, 0));
+    wxSize sizeBorder = m_bookctrl->CalcSizeFromPage(wxSize(0,0));
 
     sizeBorder.x += 5;
     sizeBorder.y += 5;
@@ -1762,12 +2169,16 @@ wxSize wxBookCtrlSizer::CalcMin()
 
 #if wxUSE_NOTEBOOK
 
+#if WXWIN_COMPATIBILITY_2_6
+
 wxNotebookSizer::wxNotebookSizer(wxNotebook *nb)
 {
     wxASSERT_MSG( nb, wxT("wxNotebookSizer needs a control") );
     m_bookctrl = nb;
 }
 
+#endif // WXWIN_COMPATIBILITY_2_6
+
 #endif // wxUSE_NOTEBOOOK
 #endif // wxUSE_BOOKCTRL