X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/15f7c30516facfb272fc116aec4d3f9c3a9de085..9ef1ad0d2ccb6dee00b1adc495ce055edd27844b:/src/common/sizer.cpp diff --git a/src/common/sizer.cpp b/src/common/sizer.cpp index 3b18a56b59..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)); } @@ -274,68 +308,68 @@ wxSize wxSizerItem::GetSize() const 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; - } - } - + // 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(); + 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; - } - } - } - + + // 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; } @@ -522,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: @@ -834,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 ) @@ -846,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 ) @@ -899,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. + + const wxSize clientSize = ComputeFittingClientSize(window); - window->SetSizeHints( size.x, - size.y, - window->GetMaxWidth(), - window->GetMaxHeight() ); + 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) ) @@ -1381,7 +1412,7 @@ wxSize wxGridSizer::CalcMin() node = node->GetNext(); } - // In case we have a nested sizer with a two step algo , give it + // 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; @@ -1389,10 +1420,10 @@ wxSize wxGridSizer::CalcMin() { wxSizerItem *item = node->GetData(); didChangeMinSize |= item->InformFirstDirection( wxHORIZONTAL, w, -1 ); - + node = node->GetNext(); } - + // And redo iteration in case min size changed if( didChangeMinSize ) { @@ -1407,9 +1438,9 @@ wxSize wxGridSizer::CalcMin() h = wxMax( h, sz.y ); node = node->GetNext(); - } + } } - + return wxSize( ncols * w + (ncols-1) * m_hgap, nrows * h + (nrows-1) * m_vgap ); } @@ -1571,7 +1602,7 @@ void wxFlexGridSizer::FindWidthsAndHeights(int nrows, int ncols) wxSizerItem * const item = *i; if ( item->IsShown() ) { - // NOTE: Not doing the calculation here, this is just + // NOTE: Not doing the calculation here, this is just // for finding max values. const wxSize sz(item->GetMinSizeWithBorder()); @@ -1622,7 +1653,7 @@ wxSize wxFlexGridSizer::CalcMin() } } - // The stage of looking for max values in each row/column has been + // 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); @@ -1752,13 +1783,13 @@ void wxFlexGridSizer::AdjustForGrowables(const wxSize& sz) 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. + + // 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(); @@ -1769,7 +1800,7 @@ void wxFlexGridSizer::AdjustForGrowables(const wxSize& sz) didAdjustMinSize |= (*i)->InformFirstDirection(wxHORIZONTAL, m_colWidths[col], sz.y - m_calculatedMinSize.y); } - // Only redo if info was actually used + // Only redo if info was actually used if( didAdjustMinSize ) { DoAdjustForGrowables @@ -1848,17 +1879,18 @@ void wxBoxSizer::RecalcSizes() if ( m_children.empty() ) return; - const wxCoord totalMinorSize = SizeInMinorDir(m_size); + 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; - for ( wxSizerItemList::const_iterator i = m_children.begin(); + wxSizerItemList::const_iterator i ; + for ( i = m_children.begin(); i != m_children.end(); ++i ) { @@ -1870,27 +1902,27 @@ void wxBoxSizer::RecalcSizes() wxSize szMinPrev = item->GetMinSizeWithBorder(); item->InformFirstDirection(m_orient^wxBOTH,totalMinorSize,delta); wxSize szMin = item->GetMinSizeWithBorder(); - int deltaChange = SizeInMajorDir(szMin-szMinPrev); + int deltaChange = GetSizeInMajorDir(szMin-szMinPrev); if( deltaChange ) { - // Since we passed available space along to the item, it should not - // take too much ,so delat should not become negative. - delta -= 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 += SizeInMajorDir(item->GetMinSizeWithBorder()); + majorMinSum += GetSizeInMajorDir(item->GetMinSizeWithBorder()); } // And update our min size SizeInMajorDir(m_minSize) = majorMinSum; // might have a new delta now - delta = SizeInMajorDir(m_size) - SizeInMajorDir(m_minSize); - + delta = GetSizeInMajorDir(m_size) - GetSizeInMajorDir(m_minSize); + // the position at which we put the next child wxPoint pt(m_position); int totalProportion = m_totalProportion; - for ( wxSizerItemList::const_iterator i = m_children.begin(); + for ( i = m_children.begin(); i != m_children.end(); ++i ) { @@ -1898,17 +1930,11 @@ void wxBoxSizer::RecalcSizes() if ( !item->IsShown() ) continue; - -#ifndef __DMC__ - // DMC doesn't distinguish between - // int SizeInMajorDir(const wxSize& sz) const - // and int& SizeInMajorDir(wxSize& sz) - const -#endif - wxSize sizeThis(item->GetMinSizeWithBorder()); + + 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 ) { @@ -1924,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) ) { @@ -1974,14 +2000,11 @@ wxSize wxBoxSizer::CalcMin() if ( !item->IsShown() ) continue; -#ifndef __DMC__ - const // see __DMC__ above -#endif - wxSize sizeMinThis = item->CalcMin(); - SizeInMajorDir(m_minSize) += SizeInMajorDir(sizeMinThis); - if ( SizeInMinorDir(sizeMinThis) > SizeInMinorDir(m_minSize) ) - SizeInMinorDir(m_minSize) = SizeInMinorDir(sizeMinThis); + const wxSize sizeMinThis = item->CalcMin(); + SizeInMajorDir(m_minSize) += GetSizeInMajorDir(sizeMinThis); + if ( GetSizeInMinorDir(sizeMinThis) > GetSizeInMinorDir(m_minSize) ) + SizeInMinorDir(m_minSize) = GetSizeInMinorDir(sizeMinThis); m_totalProportion += item->GetProportion(); } @@ -1993,15 +2016,15 @@ wxSize wxBoxSizer::CalcMin() // wxWrapSizer //--------------------------------------------------------------------------- -#define wxDEFAULT_PROPORTION_LAST 1000000 - -// User data to hold old proportion for last item on line +#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; }; @@ -2009,8 +2032,8 @@ struct wxPropHolder : public wxObject IMPLEMENT_DYNAMIC_CLASS(wxWrapSizer, wxBoxSizer); wxWrapSizer::wxWrapSizer( int orient, int flags ) - : wxBoxSizer(orient), - m_prim_size_last( -1 ), + : wxBoxSizer(orient), + m_prim_size_last( -1 ), m_rows(orient^wxBOTH), m_flags(flags) { @@ -2033,17 +2056,17 @@ bool wxWrapSizer::InformFirstDirection( int direction, int size, int WXUNUSED(av { if( !direction ) { - // Better to keep value, then CalcMin will work better - //m_prim_size_last = -1; + // 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; + m_prim_size_last = size; return true; } - else + else return false; } @@ -2053,9 +2076,9 @@ void wxWrapSizer::AdjustPropLastItem(wxSizer *psz, wxSizerItem *itemLast) wxSizerItem *psi = m_rows.GetItem(psz); wxASSERT(psi); wxPropHolder *pph = (wxPropHolder*)psi->GetUserData(); - if ( !pph ) + if ( !pph ) psi->SetUserData( pph=new wxPropHolder ); - + pph->Init( itemLast, itemLast->GetProportion() ); itemLast->SetProportion( wxDEFAULT_PROPORTION_LAST ); } @@ -2066,39 +2089,39 @@ void wxWrapSizer::RecalcSizes() 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. + // 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 + // 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); - + 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 = SizeInMajorDir(m_size); - + int majorSize = GetSizeInMajorDir(m_size); + // Make sure we have at least one child sizer m_n_line = 1; - if( !m_rows.GetChildren().GetCount() ) + 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; @@ -2107,11 +2130,11 @@ void wxWrapSizer::RecalcSizes() item = node->GetData(); if ( item->IsShown() ) { - wxSize minSz = item->GetMinSize(); - int minSzMajor = SizeInMajorDir(minSz); - + wxSize minSz = item->GetMinSize(); + int minSzMajor = GetSizeInMajorDir(minSz); + // More space on this line? - if( !lineSumMajor || lineSumMajor+minSzMajor<=majorSize ) + if( !lineSumMajor || lineSumMajor+minSzMajor<=majorSize ) { lineSumMajor += minSzMajor; } @@ -2121,38 +2144,38 @@ void wxWrapSizer::RecalcSizes() // 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 + + // 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); - + AdjustPropLastItem(psz,itemLast); + // The sizer where to insert items in psz = m_rows.GetItem(m_n_line++)->GetSizer(); } - itemLast = item; + 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 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 ); + item->GetWindow()->SetContainingSizer( this ); } node = node->GetNext(); } - // If we have extend-last-on-each-line mode, then do so now + // 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 + + // 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 = SizeInMajorDir(m_size); + m_prim_size_last = GetSizeInMajorDir(m_size); } @@ -2163,15 +2186,15 @@ wxSize wxWrapSizer::CalcMin() // Algorithm for calculating min size: (assuming horizontal orientation) // X: Max width of all members - // Y: Based on last X, calculate how many lines needed + // 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) @@ -2180,15 +2203,15 @@ wxSize wxWrapSizer::CalcMin() if ( item->IsShown() ) { wxSize minSz = item->CalcMin(); - int szMajor = SizeInMajorDir(minSz); - int szMinor = SizeInMinorDir(minSz); + 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 ) + if( m_prim_size_last<0 || !lineSumMajor || + lineSumMajor+szMajor<=m_prim_size_last ) { lineSumMajor += szMajor; - if( szMinor>lineMaxMinor ) + if( szMinor>lineMaxMinor ) lineMaxMinor = szMinor; } else @@ -2203,8 +2226,8 @@ wxSize wxWrapSizer::CalcMin() } minorSum += lineMaxMinor; // Add height of highest item on last line - m_minSize = SizeFromMajorMinor(maxMajor, minorSum); - return m_minSize; + m_minSize = SizeFromMajorMinor(maxMajor, minorSum); + return m_minSize; } //---------------------------------------------------------------------------