X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/74ab5f5b9df928c75c119a2c00b0d2092caa49f1..8ef9a526cea6ecc3853f327a76da14561b36f82a:/src/common/sizer.cpp diff --git a/src/common/sizer.cpp b/src/common/sizer.cpp index 9dde5b581b..930aa061bb 100644 --- a/src/common/sizer.cpp +++ b/src/common/sizer.cpp @@ -19,6 +19,7 @@ #include "wx/display.h" #include "wx/sizer.h" +#include "wx/private/flagscheck.h" #ifndef WX_PRECOMP #include "wx/string.h" @@ -87,6 +88,31 @@ WX_DEFINE_EXPORTED_LIST( wxSizerItemList ) // wxSizerItem // ---------------------------------------------------------------------------- +// check for flags conflicts +static const int SIZER_FLAGS_MASK = + wxADD_FLAG(wxCENTRE, + wxADD_FLAG(wxHORIZONTAL, + wxADD_FLAG(wxVERTICAL, + wxADD_FLAG(wxLEFT, + wxADD_FLAG(wxRIGHT, + wxADD_FLAG(wxUP, + wxADD_FLAG(wxDOWN, + wxADD_FLAG(wxALIGN_NOT, + wxADD_FLAG(wxALIGN_CENTER_HORIZONTAL, + wxADD_FLAG(wxALIGN_RIGHT, + wxADD_FLAG(wxALIGN_BOTTOM, + wxADD_FLAG(wxALIGN_CENTER_VERTICAL, + wxADD_FLAG(wxFIXED_MINSIZE, + wxADD_FLAG(wxRESERVE_SPACE_EVEN_IF_HIDDEN, + wxADD_FLAG(wxSTRETCH_NOT, + wxADD_FLAG(wxSHRINK, + wxADD_FLAG(wxGROW, + wxADD_FLAG(wxSHAPED, + 0)))))))))))))))))); + +#define ASSERT_VALID_SIZER_FLAGS(f) wxASSERT_VALID_FLAGS(f, SIZER_FLAGS_MASK) + + void wxSizerItem::Init(const wxSizerFlags& flags) { Init(); @@ -94,6 +120,8 @@ void wxSizerItem::Init(const wxSizerFlags& flags) m_proportion = flags.GetProportion(); m_flag = flags.GetFlags(); m_border = flags.GetBorderInPixels(); + + ASSERT_VALID_SIZER_FLAGS( m_flag ); } wxSizerItem::wxSizerItem() @@ -136,6 +164,8 @@ wxSizerItem::wxSizerItem(wxWindow *window, m_id(wxID_NONE), m_userData(userData) { + ASSERT_VALID_SIZER_FLAGS( m_flag ); + DoSetWindow(window); } @@ -160,6 +190,8 @@ wxSizerItem::wxSizerItem(wxSizer *sizer, m_ratio(0.0), m_userData(userData) { + ASSERT_VALID_SIZER_FLAGS( m_flag ); + DoSetSizer(sizer); // m_minSize is set later @@ -189,6 +221,8 @@ wxSizerItem::wxSizerItem(int width, m_id(wxID_NONE), m_userData(userData) { + ASSERT_VALID_SIZER_FLAGS( m_flag ); + DoSetSpacer(wxSize(width, height)); } @@ -272,6 +306,73 @@ wxSize wxSizerItem::GetSize() const return ret; } +bool wxSizerItem::InformFirstDirection(int direction, int size, int availableOtherDir) +{ + // The size that come here will be including borders. Child items should get it + // without borders. + if( size>0 ) + { + if( direction==wxHORIZONTAL ) + { + if (m_flag & wxWEST) + size -= m_border; + if (m_flag & wxEAST) + size -= m_border; + } + else if( direction==wxVERTICAL ) + { + if (m_flag & wxNORTH) + size -= m_border; + if (m_flag & wxSOUTH) + size -= m_border; + } + } + + bool didUse = false; + // Pass the information along to the held object + if (IsSizer()) + { + didUse = GetSizer()->InformFirstDirection(direction,size,availableOtherDir); + if (didUse) + m_minSize = GetSizer()->CalcMin(); + } + else if (IsWindow()) + { + didUse = GetWindow()->InformFirstDirection(direction,size,availableOtherDir); + if (didUse) + m_minSize = m_window->GetEffectiveMinSize(); + + // This information is useful for items with wxSHAPED flag, since + // we can request an optimal min size for such an item. Even if + // we overwrite the m_minSize member here, we can read it back from + // the owned window (happens automatically). + if( (m_flag & wxSHAPED) && (m_flag & wxEXPAND) && direction ) + { + if( !wxIsNullDouble(m_ratio) ) + { + wxCHECK_MSG( (m_proportion==0), false, _T("Shaped item, non-zero proportion in wxSizerItem::InformFirstDirection()") ); + if( direction==wxHORIZONTAL && !wxIsNullDouble(m_ratio) ) + { + // Clip size so that we don't take too much + if( availableOtherDir>=0 && int(size/m_ratio)-m_minSize.y>availableOtherDir ) + size = int((availableOtherDir+m_minSize.y)*m_ratio); + m_minSize = wxSize(size,int(size/m_ratio)); + } + else if( direction==wxVERTICAL ) + { + // Clip size so that we don't take too much + if( availableOtherDir>=0 && int(size*m_ratio)-m_minSize.x>availableOtherDir ) + size = int((availableOtherDir+m_minSize.x)/m_ratio); + m_minSize = wxSize(int(size*m_ratio),size); + } + didUse = true; + } + } + } + + return didUse; +} + wxSize wxSizerItem::CalcMin() { if (IsSizer()) @@ -455,6 +556,9 @@ void wxSizerItem::Show( bool show ) bool wxSizerItem::IsShown() const { + if ( m_flag & wxRESERVE_SPACE_EVEN_IF_HIDDEN ) + return true; + switch ( m_kind ) { case Item_None: @@ -767,11 +871,13 @@ void wxSizer::DeleteWindows() } } -wxSize wxSizer::Fit( wxWindow *window ) +wxSize wxSizer::ComputeFittingClientSize(wxWindow *window) { + wxCHECK_MSG( window, wxDefaultSize, "window can't be NULL" ); + // take the min size by default and limit it by max size - wxSize size = GetMinWindowSize(window); - wxSize sizeMax = GetMaxWindowSize(window); + wxSize size = GetMinClientSize(window); + wxSize sizeMax; wxTopLevelWindow *tlw = wxDynamicCast(window, wxTopLevelWindow); if ( tlw ) @@ -779,31 +885,51 @@ wxSize wxSizer::Fit( wxWindow *window ) // hack for small screen devices where TLWs are always full screen if ( tlw->IsAlwaysMaximized() ) { - size = tlw->GetSize(); + return tlw->GetClientSize(); } - else // normal situation - { - // limit the window to the size of the display it is on - int disp = wxDisplay::GetFromWindow(window); - if ( disp == wxNOT_FOUND ) - { - // or, if we don't know which one it is, of the main one - disp = 0; - } - sizeMax = wxDisplay(disp).GetClientArea().GetSize(); + // limit the window to the size of the display it is on + int disp = wxDisplay::GetFromWindow(window); + if ( disp == wxNOT_FOUND ) + { + // or, if we don't know which one it is, of the main one + disp = 0; } + + sizeMax = wxDisplay(disp).GetClientArea().GetSize(); + + // space for decorations and toolbars etc. + sizeMax = tlw->WindowToClientSize(sizeMax); + } + else + { + sizeMax = GetMaxClientSize(window); } if ( sizeMax.x != wxDefaultCoord && size.x > sizeMax.x ) - size.x = sizeMax.x; + size.x = sizeMax.x; if ( sizeMax.y != wxDefaultCoord && size.y > sizeMax.y ) - size.y = sizeMax.y; + size.y = sizeMax.y; + return size; +} - window->SetSize( size ); +wxSize wxSizer::ComputeFittingWindowSize(wxWindow *window) +{ + wxCHECK_MSG( window, wxDefaultSize, "window can't be NULL" ); - return size; + return window->ClientToWindowSize(ComputeFittingClientSize(window)); +} + +wxSize wxSizer::Fit( wxWindow *window ) +{ + wxCHECK_MSG( window, wxDefaultSize, "window can't be NULL" ); + + // set client size + window->SetClientSize(ComputeFittingClientSize(window)); + + // return entire size + return window->GetSize(); } void wxSizer::FitInside( wxWindow *window ) @@ -832,59 +958,31 @@ void wxSizer::SetSizeHints( wxWindow *window ) // Preserve the window's max size hints, but set the // lower bound according to the sizer calculations. - wxSize size = Fit( window ); + // This is equivalent to calling Fit(), except that we need to set + // the size hints _in between_ the two steps performed by Fit + // (1. ComputeFittingClientSize, 2. SetClientSize). That's because + // otherwise SetClientSize() could have no effect if there already are + // size hints in effect that forbid requested client size. - window->SetSizeHints( size.x, - size.y, - window->GetMaxWidth(), - window->GetMaxHeight() ); + const wxSize clientSize = ComputeFittingClientSize(window); + + window->SetMinClientSize(clientSize); + window->SetClientSize(clientSize); } +#if WXWIN_COMPATIBILITY_2_8 void wxSizer::SetVirtualSizeHints( wxWindow *window ) { - // Preserve the window's max size hints, but set the - // lower bound according to the sizer calculations. - FitInside( window ); - wxSize size( window->GetVirtualSize() ); - window->SetVirtualSizeHints( size.x, - size.y, - window->GetMaxWidth(), - window->GetMaxHeight() ); -} - -wxSize wxSizer::GetMaxWindowSize( wxWindow *window ) const -{ - return window->GetMaxSize(); -} - -wxSize wxSizer::GetMinWindowSize( wxWindow *window ) -{ - wxSize 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 ); } +#endif // WXWIN_COMPATIBILITY_2_8 // TODO on mac we need a function that determines how much free space this // min size contains, in order to make sure that we have 20 pixels of free // space around the controls wxSize wxSizer::GetMaxClientSize( wxWindow *window ) const { - wxSize maxSize( window->GetMaxSize() ); - - if ( maxSize != wxDefaultSize ) - { - wxSize size( window->GetSize() ); - wxSize client_size( window->GetClientSize() ); - - return wxSize( maxSize.x + client_size.x - size.x, - maxSize.y + client_size.y - size.y ); - } - else - return wxDefaultSize; + return window->WindowToClientSize(window->GetMaxSize()); } wxSize wxSizer::GetMinClientSize( wxWindow *WXUNUSED(window) ) @@ -1314,6 +1412,35 @@ wxSize wxGridSizer::CalcMin() node = node->GetNext(); } + // In case we have a nested sizer with a two step algo , give it + // a chance to adjust to that (we give it width component) + node = m_children.GetFirst(); + bool didChangeMinSize = false; + while (node) + { + wxSizerItem *item = node->GetData(); + didChangeMinSize |= item->InformFirstDirection( wxHORIZONTAL, w, -1 ); + + node = node->GetNext(); + } + + // And redo iteration in case min size changed + if( didChangeMinSize ) + { + node = m_children.GetFirst(); + w = h = 0; + while (node) + { + wxSizerItem *item = node->GetData(); + wxSize sz( item->GetMinSizeWithBorder() ); + + w = wxMax( w, sz.x ); + h = wxMax( h, sz.y ); + + node = node->GetNext(); + } + } + return wxSize( ncols * w + (ncols-1) * m_hgap, nrows * h + (nrows-1) * m_vgap ); } @@ -1456,16 +1583,8 @@ static int SumArraySizes(const wxArrayInt& sizes, int gap) return total; } -wxSize wxFlexGridSizer::CalcMin() +void wxFlexGridSizer::FindWidthsAndHeights(int nrows, int ncols) { - int nrows, - ncols; - - // Number of rows/columns can change as items are added or removed. - if ( !CalcRowsCols(nrows, ncols) ) - return wxSize(); - - // We have to recalculate the sizes in case the item minimum size has // changed since the previous layout, or the item has been hidden using // wxSizer::Show(). If all the items in a row/column are hidden, the final @@ -1483,7 +1602,9 @@ wxSize wxFlexGridSizer::CalcMin() wxSizerItem * const item = *i; if ( item->IsShown() ) { - const wxSize sz(item->CalcMin()); + // NOTE: Not doing the calculation here, this is just + // for finding max values. + const wxSize sz(item->GetMinSizeWithBorder()); const int row = n / ncols; const int col = n % ncols; @@ -1499,6 +1620,42 @@ wxSize wxFlexGridSizer::CalcMin() m_calculatedMinSize = wxSize(SumArraySizes(m_colWidths, m_hgap), SumArraySizes(m_rowHeights, m_vgap)); +} + +wxSize wxFlexGridSizer::CalcMin() +{ + int nrows, + ncols; + + // Number of rows/columns can change as items are added or removed. + if ( !CalcRowsCols(nrows, ncols) ) + return wxSize(); + + + // We have to recalculate the sizes in case the item minimum size has + // changed since the previous layout, or the item has been hidden using + // wxSizer::Show(). If all the items in a row/column are hidden, the final + // dimension of the row/column will be -1, indicating that the column + // itself is hidden. + m_rowHeights.assign(nrows, -1); + m_colWidths.assign(ncols, -1); + + // n is the index of the item in left-to-right top-to-bottom order + size_t n = 0; + for ( wxSizerItemList::iterator i = m_children.begin(); + i != m_children.end(); + ++i, ++n ) + { + wxSizerItem * const item = *i; + if ( item->IsShown() ) + { + item->CalcMin(); + } + } + + // The stage of looking for max values in each row/column has been + // made a separate function, since it's reused in AdjustForGrowables. + FindWidthsAndHeights(nrows,ncols); return m_calculatedMinSize; } @@ -1616,21 +1773,35 @@ DoAdjustForGrowables(int delta, void wxFlexGridSizer::AdjustForGrowables(const wxSize& sz) { - if ( (m_flexDirection & wxVERTICAL) || (m_growMode != wxFLEX_GROWMODE_NONE) ) + if ( (m_flexDirection & wxHORIZONTAL) || (m_growMode != wxFLEX_GROWMODE_NONE) ) { - // pass NULL instead of proportions if the grow mode is ALL as we - // should treat all rows as having proportion of 1 then DoAdjustForGrowables ( - sz.y - m_calculatedMinSize.y, - m_growableRows, - m_rowHeights, - m_growMode == wxFLEX_GROWMODE_SPECIFIED ? &m_growableRowsProportions + sz.x - m_calculatedMinSize.x, + m_growableCols, + m_colWidths, + m_growMode == wxFLEX_GROWMODE_SPECIFIED ? &m_growableColsProportions : NULL ); + + // This gives nested objects that benefit from knowing one size + // component in advance the chance to use that. + bool didAdjustMinSize = false; + int nrows, ncols; + CalcRowsCols(nrows, ncols); + + // Iterate over all items and inform about column width + size_t n = 0; + for ( wxSizerItemList::iterator i = m_children.begin(); + i != m_children.end(); + ++i, ++n ) + { + const int col = n % ncols; + didAdjustMinSize |= (*i)->InformFirstDirection(wxHORIZONTAL, m_colWidths[col], sz.y - m_calculatedMinSize.y); } - if ( (m_flexDirection & wxHORIZONTAL) || (m_growMode != wxFLEX_GROWMODE_NONE) ) + // Only redo if info was actually used + if( didAdjustMinSize ) { DoAdjustForGrowables ( @@ -1643,6 +1814,21 @@ void wxFlexGridSizer::AdjustForGrowables(const wxSize& sz) } } + if ( (m_flexDirection & wxVERTICAL) || (m_growMode != wxFLEX_GROWMODE_NONE) ) + { + // pass NULL instead of proportions if the grow mode is ALL as we + // should treat all rows as having proportion of 1 then + DoAdjustForGrowables + ( + sz.y - m_calculatedMinSize.y, + m_growableRows, + m_rowHeights, + m_growMode == wxFLEX_GROWMODE_SPECIFIED ? &m_growableRowsProportions + : NULL + ); + } +} + void wxFlexGridSizer::AddGrowableRow( size_t idx, int proportion ) { @@ -1693,17 +1879,50 @@ void wxBoxSizer::RecalcSizes() if ( m_children.empty() ) return; + const wxCoord totalMinorSize = GetSizeInMinorDir(m_size); + // the amount of free space which we should redistribute among the // stretchable items (i.e. those with non zero proportion) - int delta = SizeInMajorDir(m_size) - SizeInMajorDir(m_minSize); + int delta = GetSizeInMajorDir(m_size) - GetSizeInMajorDir(m_minSize); + + + // Inform child items about the size in minor direction, that can + // change how much free space we have in major dir and how to distribute it. + int majorMinSum = 0; + wxSizerItemList::const_iterator i ; + for ( i = m_children.begin(); + i != m_children.end(); + ++i ) + { + wxSizerItem * const item = *i; + + if ( !item->IsShown() ) + continue; + + wxSize szMinPrev = item->GetMinSizeWithBorder(); + item->InformFirstDirection(m_orient^wxBOTH,totalMinorSize,delta); + wxSize szMin = item->GetMinSizeWithBorder(); + int deltaChange = GetSizeInMajorDir(szMin-szMinPrev); + if( deltaChange ) + { + // Since we passed available space along to the item, it should not + // take too much, so delta should not become negative. + delta -= deltaChange; + } + majorMinSum += GetSizeInMajorDir(item->GetMinSizeWithBorder()); + } + // And update our min size + SizeInMajorDir(m_minSize) = majorMinSum; + + + // might have a new delta now + delta = GetSizeInMajorDir(m_size) - GetSizeInMajorDir(m_minSize); // the position at which we put the next child wxPoint pt(m_position); - const wxCoord totalMinorSize = SizeInMinorDir(m_size); - int totalProportion = m_totalProportion; - for ( wxSizerItemList::const_iterator i = m_children.begin(); + for ( i = m_children.begin(); i != m_children.end(); ++i ) { @@ -1714,9 +1933,8 @@ void wxBoxSizer::RecalcSizes() const wxSize sizeThis(item->GetMinSizeWithBorder()); - // adjust the size in the major direction using the proportion - wxCoord majorSize = SizeInMajorDir(sizeThis); + wxCoord majorSize = GetSizeInMajorDir(sizeThis); const int propItem = item->GetProportion(); if ( propItem ) { @@ -1732,7 +1950,7 @@ void wxBoxSizer::RecalcSizes() // apply the alignment in the minor direction wxPoint posChild(pt); - wxCoord minorSize = SizeInMinorDir(sizeThis); + wxCoord minorSize = GetSizeInMinorDir(sizeThis); const int flag = item->GetFlag(); if ( flag & (wxEXPAND | wxSHAPED) ) { @@ -1784,10 +2002,9 @@ wxSize wxBoxSizer::CalcMin() continue; const wxSize sizeMinThis = item->CalcMin(); - - SizeInMajorDir(m_minSize) += SizeInMajorDir(sizeMinThis); - if ( SizeInMinorDir(sizeMinThis) > SizeInMinorDir(m_minSize) ) - SizeInMinorDir(m_minSize) = SizeInMinorDir(sizeMinThis); + SizeInMajorDir(m_minSize) += GetSizeInMajorDir(sizeMinThis); + if ( GetSizeInMinorDir(sizeMinThis) > GetSizeInMinorDir(m_minSize) ) + SizeInMinorDir(m_minSize) = GetSizeInMinorDir(sizeMinThis); m_totalProportion += item->GetProportion(); } @@ -1795,6 +2012,224 @@ wxSize wxBoxSizer::CalcMin() return m_minSize; } +//--------------------------------------------------------------------------- +// wxWrapSizer +//--------------------------------------------------------------------------- + +#define wxDEFAULT_PROPORTION_LAST 1000000 + +// User data to hold old proportion for last item on line +// (which might be extended) +struct wxPropHolder : public wxObject +{ + wxPropHolder( ) : m_item(0), m_propOld(0) { } + void Init( wxSizerItem *item, int propOld ) { m_item=item; m_propOld=propOld; } + + wxSizerItem *m_item; + int m_propOld; +}; + +IMPLEMENT_DYNAMIC_CLASS(wxWrapSizer, wxBoxSizer); + +wxWrapSizer::wxWrapSizer( int orient, int flags ) + : wxBoxSizer(orient), + m_prim_size_last( -1 ), + m_rows(orient^wxBOTH), + m_flags(flags) +{ +} + +wxWrapSizer::~wxWrapSizer() +{ + // Have to clear grand child items so that they're not deleted twice + for( int ix=m_rows.GetChildren().GetCount()-1; ix>=0; ix-- ) + { + wxSizer *psz = m_rows.GetItem((size_t)ix)->GetSizer(); + wxSizerItemList &sl = psz->GetChildren(); + while( sl.GetLast() ) + sl.Erase( sl.GetLast() ); + } +} + + +bool wxWrapSizer::InformFirstDirection( int direction, int size, int WXUNUSED(availableOtherDir) ) +{ + if( !direction ) + { + // Better to keep value, then CalcMin will work better + //m_prim_size_last = -1; + return false; + } + if( direction==m_orient ) + { + // The direction is same as our primary, so we can make use of it + m_prim_size_last = size; + return true; + } + else + return false; +} + + +void wxWrapSizer::AdjustPropLastItem(wxSizer *psz, wxSizerItem *itemLast) +{ + wxSizerItem *psi = m_rows.GetItem(psz); + wxASSERT(psi); + wxPropHolder *pph = (wxPropHolder*)psi->GetUserData(); + if ( !pph ) + psi->SetUserData( pph=new wxPropHolder ); + + pph->Init( itemLast, itemLast->GetProportion() ); + itemLast->SetProportion( wxDEFAULT_PROPORTION_LAST ); +} + +void wxWrapSizer::RecalcSizes() +{ + wxASSERT( m_orient&wxBOTH ); + if (m_children.GetCount() == 0) + return; + + // What we do here is to put our items into child box sizers, + // as many of them as we have lines. + + // Empty all items in all rows in owned sizer. + // We have to access the list directly, since we don't want to + // destroy the wxSizerItems. + for( int ix=m_rows.GetChildren().GetCount()-1; ix>=0; ix-- ){ + wxSizerItem *psi = m_rows.GetItem( (size_t)ix ); + + // Restore proportion for last item on line (if item has not been deleted) + wxPropHolder *pph = (wxPropHolder*)psi->GetUserData(); + if( pph && GetChildren().Find(pph->m_item) ) + pph->m_item->SetProportion(pph->m_propOld); + + wxSizer *psz = psi->GetSizer(); + wxASSERT( psz ); + wxSizerItemList &sl = psz->GetChildren(); + while( sl.GetLast() ) + sl.Erase( sl.GetLast() ); + } + + int lineSumMajor = 0; + int majorSize = GetSizeInMajorDir(m_size); + + // Make sure we have at least one child sizer + m_n_line = 1; + if( !m_rows.GetChildren().GetCount() ) + m_rows.Add( new wxBoxSizer(GetOrientation()), 1, wxEXPAND ); + + // The sizer where to insert items in + wxSizer *psz = m_rows.GetItem((size_t)0)->GetSizer(); + wxASSERT( psz ); + + // Now put our child items into child sizers instead + wxSizerItemList::compatibility_iterator node = m_children.GetFirst(); + wxSizerItem *item = NULL, *itemLast=NULL; + while (node) + { + item = node->GetData(); + if ( item->IsShown() ) + { + wxSize minSz = item->GetMinSize(); + int minSzMajor = GetSizeInMajorDir(minSz); + + // More space on this line? + if( !lineSumMajor || lineSumMajor+minSzMajor<=majorSize ) + { + lineSumMajor += minSzMajor; + } + else + { + lineSumMajor = minSzMajor; + // Get a new empty sizer to insert into + if( (int)m_rows.GetChildren().GetCount()<=m_n_line ) + m_rows.Add( new wxBoxSizer(GetOrientation()), 1, wxEXPAND ); + + // If we have extend-last-on-each-line mode, then do so now + // Note: We must store old proportion value then. + if( m_flags&wxEXTEND_LAST_ON_EACH_LINE ) + AdjustPropLastItem(psz,itemLast); + + // The sizer where to insert items in + psz = m_rows.GetItem(m_n_line++)->GetSizer(); + } + itemLast = item; + psz->Add( item ); + // If item is a window, it now has a pointer to the child sizer, + // which is wrong. Set it to point to us. + if( item->GetWindow() ) + item->GetWindow()->SetContainingSizer( this ); + } + node = node->GetNext(); + } + + // If we have extend-last-on-each-line mode, then do so now + if( m_flags&wxEXTEND_LAST_ON_EACH_LINE ) + AdjustPropLastItem(psz,itemLast); + + // If we have more sizers than lines, remove them + while( (int)m_rows.GetChildren().GetCount()>m_n_line ) + m_rows.Remove( m_n_line ); + + // Now do layout on row sizer + m_rows.SetDimension( m_position.x, m_position.y, m_size.x, m_size.y ); + + // Remember this to next time (will be overridden by InformFirstDirection if used) + m_prim_size_last = GetSizeInMajorDir(m_size); +} + + +wxSize wxWrapSizer::CalcMin() +{ + if (m_children.GetCount() == 0) + return wxSize(); + + // Algorithm for calculating min size: (assuming horizontal orientation) + // X: Max width of all members + // Y: Based on last X, calculate how many lines needed + // First time around, assume all items fits on one line + + int maxMajor = 0; + int minorSum = 0; + int lineMaxMinor = 0; + int lineSumMajor = 0; + m_n_line = 0; + + // precalc item minsizes and fit on lines (preliminary) + wxSizerItemList::compatibility_iterator node = m_children.GetFirst(); + while (node) + { + wxSizerItem *item = node->GetData(); + if ( item->IsShown() ) + { + wxSize minSz = item->CalcMin(); + int szMajor = GetSizeInMajorDir(minSz); + int szMinor = GetSizeInMinorDir(minSz); + if( szMajor>maxMajor ) maxMajor = szMajor; + // More space on this line? + if( m_prim_size_last<0 || !lineSumMajor || + lineSumMajor+szMajor<=m_prim_size_last ) + { + lineSumMajor += szMajor; + if( szMinor>lineMaxMinor ) + lineMaxMinor = szMinor; + } + else + { + minorSum += lineMaxMinor; // Add height of highest item on last line + m_n_line++; + lineMaxMinor = szMinor; + lineSumMajor = szMajor; + } + } + node = node->GetNext(); + } + minorSum += lineMaxMinor; // Add height of highest item on last line + + m_minSize = SizeFromMajorMinor(maxMajor, minorSum); + return m_minSize; +} + //--------------------------------------------------------------------------- // wxStaticBoxSizer //---------------------------------------------------------------------------