avoid conflict between wxBookCtrlBase::DoSetSelection() and the derived classes;...

[wxWidgets.git] / src / common / sizer.cpp

diff --git a/src/common/sizer.cpp b/src/common/sizer.cpp
index 93d8ed970968378ee83a691398d7112bccf03099..a691f6431c5af175f8741d922e325819d515c421 100644 (file)
--- a/src/common/sizer.cpp
+++ b/src/common/sizer.cpp
@@ -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
 // Purpose:     provide new wxSizer class for layout
 // Author:      Robert Roebling and Robin Dunn, contributions by
 //              Dirk Holtwick, Ron Lee


@@ -10,10 +10,6 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // 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"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -21,25 +17,25 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

+#include "wx/sizer.h"
+

 #ifndef WX_PRECOMP
     #include "wx/string.h"
     #include "wx/intl.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
 
 #endif // WX_PRECOMP
 

-#include "wx/sizer.h"
-#include "wx/utils.h"
-#include "wx/statbox.h"
-#include "wx/settings.h"

 #include "wx/listimpl.cpp"
 #include "wx/listimpl.cpp"

-#include "wx/intl.h"
+

 #if WXWIN_COMPATIBILITY_2_4
     #include "wx/notebook.h"
 #endif
 
 #if WXWIN_COMPATIBILITY_2_4
     #include "wx/notebook.h"
 #endif
 

-#ifdef __WXMAC__
-#   include "wx/mac/uma.h"
-#endif
-

 //---------------------------------------------------------------------------
 
 IMPLEMENT_CLASS(wxSizerItem, wxObject)
 //---------------------------------------------------------------------------
 
 IMPLEMENT_CLASS(wxSizerItem, wxObject)


@@ -54,7 +50,7 @@ IMPLEMENT_CLASS(wxStaticBoxSizer, wxBoxSizer)
 IMPLEMENT_CLASS(wxStdDialogButtonSizer, wxBoxSizer)
 #endif
 
 IMPLEMENT_CLASS(wxStdDialogButtonSizer, wxBoxSizer)
 #endif
 

-WX_DEFINE_EXPORTED_LIST( wxSizerItemList );
+WX_DEFINE_EXPORTED_LIST( wxSizerItemList )

 
 /*
     TODO PROPERTIES
 
 /*
     TODO PROPERTIES


@@ -89,18 +85,9 @@ WX_DEFINE_EXPORTED_LIST( wxSizerItemList );
     minsize
 */
 
     minsize
 */
 

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

 // wxSizerItem
 // wxSizerItem

-//---------------------------------------------------------------------------
-
-void wxSizerItem::Init()
-{
-    m_window = NULL;
-    m_sizer = NULL;
-    m_show = true;
-    m_userData = NULL;
-    m_zoneRect = wxRect( 0, 0, 0, 0 );
-}
+// ----------------------------------------------------------------------------

 
 void wxSizerItem::Init(const wxSizerFlags& flags)
 {
 
 void wxSizerItem::Init(const wxSizerFlags& flags)
 {


@@ -111,89 +98,156 @@ void wxSizerItem::Init(const wxSizerFlags& flags)
     m_border = flags.GetBorderInPixels();
 }
 
     m_border = flags.GetBorderInPixels();
 }
 

-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_zoneRect( 0, 0, 0, 0 )
-    , 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_zoneRect( 0, 0, 0, 0 )
-    , m_show( true )
-    , m_userData( userData )
-{
-    if (flag & wxFIXED_MINSIZE)
-        window->SetMinSize(window->GetSize());
+wxSizerItem::wxSizerItem()
+{
+    Init();
+
+    m_proportion = 0;
+    m_border = 0;
+    m_flag = 0;
+
+    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();
 
     m_minSize = window->GetSize();
 

+    if ( m_flag & wxFIXED_MINSIZE )
+        window->SetMinSize(m_minSize);
+

     // aspect ratio calculated from initial size
     // 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_zoneRect( 0, 0, 0, 0 )
-    , 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()
+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)

 {
 {

-    Init();
+    SetSizer(sizer);

 
 

-    m_proportion = 0;
-    m_border = 0;
-    m_flag = 0;
+    // 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;
 
 }
 
 wxSizerItem::~wxSizerItem()
 {
     delete m_userData;
 

-    if ( m_window )
-    {
-        m_window->SetContainingSizer(NULL);
-    }
-    else // we must be a sizer
+    switch ( m_kind )

     {
     {

-        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;
 
 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;
 
     if (m_flag & wxWEST)
         ret.x += m_border;


@@ -215,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 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() )
             SetRatio(m_minSize);
     }
     else if ( IsWindow() )


@@ -245,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
     if (m_flag & wxSHAPED)
     {
         // adjust aspect ratio


@@ -298,55 +354,134 @@ void wxSizerItem::SetDimension( wxPoint pos, wxSize size )
         size.y -= m_border;
     }
 
         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;
+
+    m_rect = wxRect(pos, size);

 
 

-    m_zoneRect = wxRect(pos, size);
-    if (IsWindow())
-        m_window->SetSize( pos.x, pos.y, size.x, size.y, wxSIZE_ALLOW_MINUS_ONE );
+    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;

 
 

-    m_size = size;
+        case Item_Max:
+        default:
+            wxFAIL_MSG( _T("unexpected wxSizerItem::m_kind") );
+    }

 }
 
 void wxSizerItem::DeleteWindows()
 {
 }
 
 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;

 
 

-    if( IsWindow() )
-        m_window->Show( show );
-    else if( IsSizer() )
-        m_sizer->ShowItems( show );
+        case Item_Spacer:
+            return m_spacer->IsShown();

 
 

-    // ... nothing else to do to hide/show spacers
+        case Item_Max:
+        default:
+            wxFAIL_MSG( _T("unexpected wxSizerItem::m_kind") );
+    }
+
+    return false;

 }
 
 }
 

+#if WXWIN_COMPATIBILITY_2_6

 void wxSizerItem::SetOption( int option )
 {
     SetProportion( option );
 void wxSizerItem::SetOption( int option )
 {
     SetProportion( option );


@@ -356,17 +491,13 @@ int wxSizerItem::GetOption() const
 {
     return GetProportion();
 }
 {
     return GetProportion();
 }

+#endif // WXWIN_COMPATIBILITY_2_6

 
 
 //---------------------------------------------------------------------------
 // wxSizer
 //---------------------------------------------------------------------------
 
 
 
 //---------------------------------------------------------------------------
 // wxSizer
 //---------------------------------------------------------------------------
 

-wxSizer::wxSizer()
-    : m_minSize( wxSize( 0, 0 ) )
-{
-}
-

 wxSizer::~wxSizer()
 {
     WX_CLEAR_LIST(wxSizerItemList, m_children);
 wxSizer::~wxSizer()
 {
     WX_CLEAR_LIST(wxSizerItemList, m_children);


@@ -376,16 +507,41 @@ wxSizerItem* wxSizer::Insert( size_t index, wxSizerItem *item )
 {
     m_children.Insert( index, item );
 
 {
     m_children.Insert( index, item );
 

-    if( item->GetWindow() )
+    if ( item->GetWindow() )

         item->GetWindow()->SetContainingSizer( this );
 
     return item;
 }
 
         item->GetWindow()->SetContainingSizer( this );
 
     return item;
 }
 

+void wxSizer::SetContainingWindow(wxWindow *win)
+{
+    if ( win == m_containingWindow )
+        return;
+
+    m_containingWindow = win;
+
+    // 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();
+
+        if ( sizer )
+        {
+            sizer->SetContainingWindow(win);
+        }
+    }
+}
+
+#if WXWIN_COMPATIBILITY_2_6

 bool wxSizer::Remove( wxWindow *window )
 {
     return Detach( window );
 }
 bool wxSizer::Remove( wxWindow *window )
 {
     return Detach( window );
 }

+#endif // WXWIN_COMPATIBILITY_2_6

 
 bool wxSizer::Remove( wxSizer *sizer )
 {
 
 bool wxSizer::Remove( wxSizer *sizer )
 {


@@ -421,7 +577,7 @@ bool wxSizer::Remove( int index )
 
     wxSizerItem *item = node->GetData();
 
 
     wxSizerItem *item = node->GetData();
 

-    if( item->IsWindow() )
+    if ( item->IsWindow() )

         item->GetWindow()->SetContainingSizer( NULL );
 
     delete item;
         item->GetWindow()->SetContainingSizer( NULL );
 
     delete item;


@@ -485,9 +641,9 @@ bool wxSizer::Detach( int index )
 
     wxSizerItem *item = node->GetData();
 
 
     wxSizerItem *item = node->GetData();
 

-    if( item->IsSizer() )
+    if ( item->IsSizer() )

         item->DetachSizer();
         item->DetachSizer();

-    else if( item->IsWindow() )
+    else if ( item->IsWindow() )

         item->GetWindow()->SetContainingSizer( NULL );
 
     delete item;
         item->GetWindow()->SetContainingSizer( NULL );
 
     delete item;


@@ -495,6 +651,80 @@ bool wxSizer::Detach( int index )
     return true;
 }
 
     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
 void wxSizer::Clear( bool delete_windows )
 {
     // First clear the ContainingSizer pointers


@@ -607,6 +837,15 @@ wxSize wxSizer::GetMinWindowSize( wxWindow *window )
 // Return a window size that will fit within the screens dimensions
 wxSize wxSizer::FitSize( 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 );
 
     wxSize size     = GetMinWindowSize( window );
     wxSize sizeMax  = GetMaxWindowSize( window );
 


@@ -624,7 +863,7 @@ wxSize wxSizer::GetMaxClientSize( wxWindow *window ) const
 {
     wxSize maxSize( window->GetMaxSize() );
 
 {
     wxSize maxSize( window->GetMaxSize() );
 

-    if( maxSize != wxDefaultSize )
+    if ( maxSize != wxDefaultSize )

     {
         wxSize size( window->GetSize() );
         wxSize client_size( window->GetClientSize() );
     {
         wxSize size( window->GetSize() );
         wxSize client_size( window->GetClientSize() );


@@ -940,23 +1179,19 @@ bool wxSizer::IsShown( size_t index ) const
 //---------------------------------------------------------------------------
 
 wxGridSizer::wxGridSizer( int rows, int cols, int vgap, int hgap )
 //---------------------------------------------------------------------------
 
 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 )
 {
     , 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 )
 }
 
 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 )
 {
     , 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
 }
 
 int wxGridSizer::CalcRowsCols(int& nrows, int& ncols) const


@@ -1022,7 +1257,7 @@ wxSize wxGridSizer::CalcMin()
 {
     int nrows, ncols;
     if ( CalcRowsCols(nrows, ncols) == 0 )
 {
     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;
 
     // Find the max width and height for any component
     int w = 0;


@@ -1131,9 +1366,11 @@ void wxFlexGridSizer::RecalcSizes()
 
                 SetItemBounds( node->GetData(), x, y, w, h);
             }
 
                 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;

     }
 }
 
     }
 }
 


@@ -1145,7 +1382,7 @@ wxSize wxFlexGridSizer::CalcMin()
 
     // Number of rows/columns can change as items are added or removed.
     if ( !CalcRowsCols(nrows, ncols) )
 
     // 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);
 
     m_rowHeights.SetCount(nrows);
     m_colWidths.SetCount(ncols);


@@ -1187,12 +1424,16 @@ wxSize wxFlexGridSizer::CalcMin()
     int width = 0;
     for (int col = 0; col < ncols; col++)
         if ( m_colWidths[ col ] != -1 )
     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 )
 
     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;
 
     m_calculatedMinSize = wxSize( width, height );
     return m_calculatedMinSize;


@@ -1209,10 +1450,12 @@ void wxFlexGridSizer::AdjustForFlexDirection()
         wxArrayInt& array = m_flexDirection == wxVERTICAL ? m_colWidths
                                                           : m_rowHeights;
 
         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
 
         // 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 )
         for ( n = 0; n < count; ++n )
         {
             if ( array[n] > largest )


@@ -1342,20 +1585,38 @@ void wxFlexGridSizer::AddGrowableRow( size_t idx, int proportion )
     m_growableRowsProportions.Add( 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 );
 }
 
 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 )
 {
 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);

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


@@ -1440,6 +1701,16 @@ void wxBoxSizer::RecalcSizes()
                 //     wxALIGN_CENTER should be used in new code
                     child_pos.y += (m_size.y - size.y) / 2;
 
                 //     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;
                 item->SetDimension( child_pos, child_size );
 
                 pt.x += width;


@@ -1453,7 +1724,7 @@ void wxBoxSizer::RecalcSizes()
 wxSize wxBoxSizer::CalcMin()
 {
     if (m_children.GetCount() == 0)
 wxSize wxBoxSizer::CalcMin()
 {
     if (m_children.GetCount() == 0)

-        return wxSize(10,10);
+        return wxSize();

 
     m_stretchable = 0;
     m_minWidth = 0;
 
     m_stretchable = 0;
     m_minWidth = 0;


@@ -1467,11 +1738,12 @@ wxSize wxBoxSizer::CalcMin()
     {
         wxSizerItem *item = node->GetData();
 
     {
         wxSizerItem *item = node->GetData();
 

-        if (item->IsShown())
+        if ( item->IsShown() )
+        {

             item->CalcMin();  // result is stored in the item
 
             item->CalcMin();  // result is stored in the item
 

-        if (item->IsShown() && item->GetProportion() != 0)

             m_stretchable += item->GetProportion();
             m_stretchable += item->GetProportion();

+        }

 
         node = node->GetNext();
     }
 
         node = node->GetNext();
     }


@@ -1558,10 +1830,27 @@ wxSize wxBoxSizer::CalcMin()
 #if wxUSE_STATBOX
 
 wxStaticBoxSizer::wxStaticBoxSizer( wxStaticBox *box, int orient )
 #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") );
 {
     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,
 }
 
 static void GetStaticBoxBorders( wxStaticBox *box,


@@ -1570,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
 {
     // 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().empty() )
-        *borderTop = 5;
-    else
-#endif // __WXGTK__
-        *borderTop = box->GetCharHeight();
-
-    *borderOther = 5;
-#endif // __WXCOCOA__
+    box->GetBordersForSizer(borderTop, borderOther);

 }
 
 void wxStaticBoxSizer::RecalcSizes()
 }
 
 void wxStaticBoxSizer::RecalcSizes()


@@ -1647,6 +1900,20 @@ void wxStaticBoxSizer::ShowItems( bool show )
     wxBoxSizer::ShowItems( 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
 #endif // wxUSE_STATBOX
 
 #if wxUSE_BUTTON


@@ -1654,12 +1921,18 @@ void wxStaticBoxSizer::ShowItems( bool show )
 wxStdDialogButtonSizer::wxStdDialogButtonSizer()
     : wxBoxSizer(wxHORIZONTAL)
 {
 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);
     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;
     // 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_buttonAffirmative = NULL;
     m_buttonApply = NULL;


@@ -1687,6 +1960,7 @@ void wxStdDialogButtonSizer::AddButton(wxButton *mybutton)
             m_buttonCancel = mybutton;
             break;
         case wxID_HELP:
             m_buttonCancel = mybutton;
             break;
         case wxID_HELP:

+        case wxID_CONTEXT_HELP:

             m_buttonHelp = mybutton;
             break;
         default:
             m_buttonHelp = mybutton;
             break;
         default:


@@ -1709,7 +1983,7 @@ void wxStdDialogButtonSizer::SetCancelButton( wxButton *button )
     m_buttonCancel = button;
 }
 
     m_buttonCancel = button;
 }
 

-void wxStdDialogButtonSizer::Finalise()
+void wxStdDialogButtonSizer::Realize()

 {
 #ifdef __WXMAC__
         Add(0, 0, 0, wxLEFT, 6);
 {
 #ifdef __WXMAC__
         Add(0, 0, 0, wxLEFT, 6);


@@ -1771,11 +2045,32 @@ void wxStdDialogButtonSizer::Finalise()
 
         if (m_buttonAffirmative)
             Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT, 6);
 
         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
 #else

-    // do the same thing for GTK1 and Windows platforms
-    // and assume any platform not accounted for here will use
-    // Windows style
-        Add(0, 0, 0, wxLEFT, 9);
+        // 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);
 
         if (m_buttonHelp)
             Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonHelp->ConvertDialogToPixels(wxSize(4, 0)).x);
 


@@ -1794,7 +2089,7 @@ void wxStdDialogButtonSizer::Finalise()
         }
 
         if (m_buttonCancel){
         }
 
         if (m_buttonCancel){

-            Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT, m_buttonCancel->ConvertDialogToPixels(wxSize(4, 0)).x);
+            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();
         }
             // Cancel or help should be default
             // m_buttonCancel->SetDefaultButton();
         }


@@ -1819,12 +2114,16 @@ IMPLEMENT_CLASS(wxNotebookSizer, wxBookCtrlSizer)
 
 #if wxUSE_BOOKCTRL
 
 
 #if wxUSE_BOOKCTRL
 

+#if WXWIN_COMPATIBILITY_2_6
+

 wxBookCtrlSizer::wxBookCtrlSizer(wxBookCtrlBase *bookctrl)
                : m_bookctrl(bookctrl)
 {
     wxASSERT_MSG( bookctrl, wxT("wxBookCtrlSizer needs a control") );
 }
 
 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 );
 void wxBookCtrlSizer::RecalcSizes()
 {
     m_bookctrl->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );


@@ -1832,7 +2131,7 @@ void wxBookCtrlSizer::RecalcSizes()
 
 wxSize wxBookCtrlSizer::CalcMin()
 {
 
 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;
 
     sizeBorder.x += 5;
     sizeBorder.y += 5;


@@ -1870,12 +2169,16 @@ wxSize wxBookCtrlSizer::CalcMin()
 
 #if wxUSE_NOTEBOOK
 
 
 #if wxUSE_NOTEBOOK
 

+#if WXWIN_COMPATIBILITY_2_6
+

 wxNotebookSizer::wxNotebookSizer(wxNotebook *nb)
 {
     wxASSERT_MSG( nb, wxT("wxNotebookSizer needs a control") );
     m_bookctrl = nb;
 }
 
 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
 
 #endif // wxUSE_NOTEBOOOK
 #endif // wxUSE_BOOKCTRL