X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/3ed6c6f4acbb69db8711446912bc563b58c148ab..4b5d2be39657bb364c9111c4d13b1eecb8f3b69f:/src/common/sizer.cpp diff --git a/src/common/sizer.cpp b/src/common/sizer.cpp index 364b173dc1..071ee21039 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" @@ -31,10 +32,6 @@ #include "wx/toplevel.h" #endif // WX_PRECOMP -#if wxUSE_SYSTEM_OPTIONS -#include "wx/sysopt.h" -#endif - #include "wx/listimpl.cpp" @@ -91,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(); @@ -98,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() @@ -140,6 +164,8 @@ wxSizerItem::wxSizerItem(wxWindow *window, m_id(wxID_NONE), m_userData(userData) { + ASSERT_VALID_SIZER_FLAGS( m_flag ); + DoSetWindow(window); } @@ -164,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 @@ -193,6 +221,8 @@ wxSizerItem::wxSizerItem(int width, m_id(wxID_NONE), m_userData(userData) { + ASSERT_VALID_SIZER_FLAGS( m_flag ); + DoSetSpacer(wxSize(width, height)); } @@ -276,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()) @@ -388,7 +485,7 @@ void wxSizerItem::SetDimension( const wxPoint& pos_, const wxSize& size_ ) break; case Item_Sizer: - m_sizer->SetDimension(pos.x, pos.y, size.x, size.y); + m_sizer->SetDimension(pos, size); break; case Item_Spacer: @@ -459,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: @@ -771,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 ) @@ -783,38 +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 ) { - // 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; - } + // or, if we don't know which one it is, of the main one + disp = 0; + } - sizeMax = wxDisplay(disp).GetClientArea().GetSize(); + sizeMax = wxDisplay(disp).GetClientArea().GetSize(); -#if wxUSE_SYSTEM_OPTIONS - int marginX = wxSystemOptions::GetOptionInt(wxT("sizer.desktopmargin.x")); - int marginY = wxSystemOptions::GetOptionInt(wxT("sizer.desktopmargin.y")); - sizeMax.x -= marginX; - sizeMax.y -= marginY; -#endif - } + // 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; +} + +wxSize wxSizer::ComputeFittingWindowSize(wxWindow *window) +{ + wxCHECK_MSG( window, wxDefaultSize, "window can't be NULL" ); - window->SetSize( size ); + return window->ClientToWindowSize(ComputeFittingClientSize(window)); +} - return size; +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 ) @@ -843,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) ) @@ -918,15 +1005,6 @@ wxSize wxSizer::VirtualFitSize( wxWindow *window ) return size; } -void wxSizer::SetDimension( int x, int y, int width, int height ) -{ - m_position.x = x; - m_position.y = y; - m_size.x = width; - m_size.y = height; - Layout(); -} - wxSize wxSizer::GetMinSize() { wxSize ret( CalcMin() ); @@ -1325,6 +1403,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 ); } @@ -1467,16 +1574,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 @@ -1494,7 +1593,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; @@ -1510,6 +1611,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; } @@ -1627,21 +1764,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 ( @@ -1654,15 +1805,43 @@ 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 + ); + } +} + +bool wxFlexGridSizer::IsRowGrowable( size_t idx ) +{ + return m_growableRows.Index( idx ) != wxNOT_FOUND; +} + +bool wxFlexGridSizer::IsColGrowable( size_t idx ) +{ + return m_growableCols.Index( idx ) != wxNOT_FOUND; +} void wxFlexGridSizer::AddGrowableRow( size_t idx, int proportion ) { + wxASSERT_MSG( !IsRowGrowable( idx ), + "AddGrowableRow() called for growable row" ); m_growableRows.Add( idx ); m_growableRowsProportions.Add( proportion ); } void wxFlexGridSizer::AddGrowableCol( size_t idx, int proportion ) { + wxASSERT_MSG( !IsColGrowable( idx ), + "AddGrowableCol() called for growable column" ); m_growableCols.Add( idx ); m_growableColsProportions.Add( proportion ); } @@ -1704,17 +1883,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 ) { @@ -1722,17 +1934,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 ) { @@ -1748,7 +1954,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) ) { @@ -1798,14 +2004,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(); }