#endif // WX_PRECOMP
#include "wx/display.h"
+#include "wx/vector.h"
#include "wx/listimpl.cpp"
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() )
{
- // Some apps (such as dialog editors) depend on an empty sizer still
- // being laid out correctly and reporting the correct size and position.
- if (m_sizer->GetChildren().GetCount() == 0)
+ if ( node->GetData()->IsShown() )
return true;
-
- for ( wxSizerItemList::compatibility_iterator
- node = m_sizer->GetChildren().GetFirst();
- node;
- node = node->GetNext() )
- {
- if ( node->GetData()->IsShown() )
- return true;
- }
}
return false;
+ }
case Item_Spacer:
return m_spacer->IsShown();
wxSizerItem *item = node->GetData();
node->SetData(newitem);
+
+ if (item->IsWindow() && item->GetWindow())
+ item->GetWindow()->SetContainingSizer(NULL);
+
delete item;
return true;
m_vgap( vgap ),
m_hgap( hgap )
{
+ wxASSERT(cols >= 0);
}
wxGridSizer::wxGridSizer( int cols, const wxSize& gap )
m_vgap( gap.GetHeight() ),
m_hgap( gap.GetWidth() )
{
+ wxASSERT(cols >= 0);
}
wxGridSizer::wxGridSizer( int rows, int cols, int vgap, int hgap )
m_vgap( vgap ),
m_hgap( hgap )
{
+ wxASSERT(rows >= 0 && cols >= 0);
}
wxGridSizer::wxGridSizer( int rows, int cols, const wxSize& gap )
m_vgap( gap.GetHeight() ),
m_hgap( gap.GetWidth() )
{
+ wxASSERT(rows >= 0 && cols >= 0);
}
wxSizerItem *wxGridSizer::DoInsert(size_t index, wxSizerItem *item)
return IsVertical() ? Add(0, size) : Add(size, 0);
}
+namespace
+{
+
+/*
+ Helper of RecalcSizes(): checks if there is enough remaining space for the
+ min size of the given item and returns its min size or the entire remaining
+ space depending on which one is greater.
+
+ This function updates the remaining space parameter to account for the size
+ effectively allocated to the item.
+ */
+int
+GetMinOrRemainingSize(int orient, const wxSizerItem *item, int *remainingSpace_)
+{
+ int& remainingSpace = *remainingSpace_;
+
+ wxCoord size;
+ if ( remainingSpace > 0 )
+ {
+ const wxSize sizeMin = item->GetMinSizeWithBorder();
+ size = orient == wxHORIZONTAL ? sizeMin.x : sizeMin.y;
+
+ if ( size >= remainingSpace )
+ {
+ // truncate the item to fit in the remaining space, this is better
+ // than showing it only partially in general, even if both choices
+ // are bad -- but there is nothing else we can do
+ size = remainingSpace;
+ }
+
+ remainingSpace -= size;
+ }
+ else // no remaining space
+ {
+ // no space at all left, no need to even query the item for its min
+ // size as we can't give it to it anyhow
+ size = 0;
+ }
+
+ return size;
+}
+
+} // anonymous namespace
+
void wxBoxSizer::RecalcSizes()
{
if ( m_children.empty() )
return;
const wxCoord totalMinorSize = GetSizeInMinorDir(m_size);
+ const wxCoord totalMajorSize = GetSizeInMajorDir(m_size);
// the amount of free space which we should redistribute among the
// stretchable items (i.e. those with non zero proportion)
- int delta = GetSizeInMajorDir(m_size) - GetSizeInMajorDir(m_minSize);
+ int delta = totalMajorSize - GetSizeInMajorDir(m_minSize);
+ // declare loop variables used below:
+ wxSizerItemList::const_iterator i; // iterator in m_children list
+ unsigned n = 0; // item index in majorSizes array
- // 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 )
+
+ // First, inform item about the available size in minor direction as this
+ // can change their size in the major direction. Also compute the number of
+ // visible items and sum of their min sizes in major direction.
+
+ int minMajorSize = 0;
+ for ( i = m_children.begin(); i != m_children.end(); ++i )
{
wxSizerItem * const item = *i;
// take too much, so delta should not become negative.
delta -= deltaChange;
}
- majorMinSum += GetSizeInMajorDir(item->GetMinSizeWithBorder());
+ minMajorSize += GetSizeInMajorDir(item->GetMinSizeWithBorder());
}
- // And update our min size
- SizeInMajorDir(m_minSize) = majorMinSum;
+ // update our min size and delta which may have changed
+ SizeInMajorDir(m_minSize) = minMajorSize;
+ delta = totalMajorSize - minMajorSize;
- // 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);
+ // space and sum of proportions for the remaining items, both may change
+ // below
+ wxCoord remaining = totalMajorSize;
int totalProportion = m_totalProportion;
- for ( i = m_children.begin();
- i != m_children.end();
- ++i )
+
+ // size of the (visible) items in major direction, -1 means "not fixed yet"
+ wxVector<int> majorSizes(GetItemCount(), wxDefaultCoord);
+
+
+ // Check for the degenerated case when we don't have enough space for even
+ // the min sizes of all the items: in this case we really can't do much
+ // more than to allocate the min size to as many of fixed size items as
+ // possible (on the assumption that variable size items such as text zones
+ // or list boxes may use scrollbars to show their content even if their
+ // size is less than min size but that fixed size items such as buttons
+ // will suffer even more if we don't give them their min size)
+ if ( totalMajorSize < minMajorSize )
{
- wxSizerItem * const item = *i;
+ // Second degenerated case pass: allocate min size to all fixed size
+ // items.
+ for ( i = m_children.begin(), n = 0; i != m_children.end(); ++i, ++n )
+ {
+ wxSizerItem * const item = *i;
- if ( !item->IsShown() )
- continue;
+ if ( !item->IsShown() )
+ continue;
- const wxSize sizeThis(item->GetMinSizeWithBorder());
+ // deal with fixed size items only during this pass
+ if ( item->GetProportion() )
+ continue;
- // adjust the size in the major direction using the proportion
- wxCoord majorSize = GetSizeInMajorDir(sizeThis);
+ majorSizes[n] = GetMinOrRemainingSize(m_orient, item, &remaining);
+ }
+
+
+ // Third degenerated case pass: allocate min size to all the remaining,
+ // i.e. non-fixed size, items.
+ for ( i = m_children.begin(), n = 0; i != m_children.end(); ++i, ++n )
+ {
+ wxSizerItem * const item = *i;
+
+ if ( !item->IsShown() )
+ continue;
+
+ // we've already dealt with fixed size items above
+ if ( !item->GetProportion() )
+ continue;
- // if there is not enough space, don't try to distribute negative space
- // among the children, this would result in overlapping windows which
- // we don't want
- if ( delta > 0 )
+ majorSizes[n] = GetMinOrRemainingSize(m_orient, item, &remaining);
+ }
+ }
+ else // we do have enough space to give at least min sizes to all items
+ {
+ // Second and maybe more passes in the non-degenerated case: deal with
+ // fixed size items and items whose min size is greater than what we
+ // would allocate to them taking their proportion into account. For
+ // both of them, we will just use their min size, but for the latter we
+ // also need to reexamine all the items as the items which fitted
+ // before we adjusted their size upwards might not fit any more. This
+ // does make for a quadratic algorithm but it's not obvious how to
+ // avoid it and hopefully it's not a huge problem in practice as the
+ // sizers don't have many items usually (and, of course, the algorithm
+ // still reduces into a linear one if there is enough space for all the
+ // min sizes).
+ bool nonFixedSpaceChanged = false;
+ for ( i = m_children.begin(), n = 0; ; ++i, ++n )
{
+ if ( nonFixedSpaceChanged )
+ {
+ i = m_children.begin();
+ n = 0;
+ nonFixedSpaceChanged = false;
+ }
+
+ // check for the end of the loop only after the check above as
+ // otherwise we wouldn't do another pass if the last child resulted
+ // in non fixed space reduction
+ if ( i == m_children.end() )
+ break;
+
+ wxSizerItem * const item = *i;
+
+ if ( !item->IsShown() )
+ continue;
+
+ // don't check the item which we had already dealt with during a
+ // previous pass (this is more than an optimization, the code
+ // wouldn't work correctly if we kept adjusting for the same item
+ // over and over again)
+ if ( majorSizes[n] != wxDefaultCoord )
+ continue;
+
+ wxCoord minMajor = GetSizeInMajorDir(item->GetMinSizeWithBorder());
+
+ // it doesn't make sense for min size to be negative but right now
+ // it's possible to create e.g. a spacer with (-1, 10) as size and
+ // people do it in their code apparently (see #11842) so ensure
+ // that we don't use this -1 as real min size as it conflicts with
+ // the meaning we use for it here and negative min sizes just don't
+ // make sense anyhow (which is why it might be a better idea to
+ // deal with them at wxSizerItem level in the future but for now
+ // this is the minimal fix for the bug)
+ if ( minMajor < 0 )
+ minMajor = 0;
+
const int propItem = item->GetProportion();
if ( propItem )
{
- const int deltaItem = (delta * propItem) / totalProportion;
+ // is the desired size of this item big enough?
+ if ( (remaining*propItem)/totalProportion >= minMajor )
+ {
+ // yes, it is, we'll determine the real size of this
+ // item later, for now just leave it as wxDefaultCoord
+ continue;
+ }
+
+ // the proportion of this item won't count, it has
+ // effectively become fixed
+ totalProportion -= propItem;
+ }
+
+ // we can already allocate space for this item
+ majorSizes[n] = minMajor;
+
+ // change the amount of the space remaining to the other items,
+ // as this can result in not being able to satisfy their
+ // proportions any more we will need to redo another loop
+ // iteration
+ remaining -= minMajor;
- majorSize += deltaItem;
+ nonFixedSpaceChanged = true;
+ }
+
+
+ // Last by one pass: distribute the remaining space among the non-fixed
+ // items whose size weren't fixed yet according to their proportions.
+ for ( i = m_children.begin(), n = 0; i != m_children.end(); ++i, ++n )
+ {
+ wxSizerItem * const item = *i;
+
+ if ( !item->IsShown() )
+ continue;
+
+ if ( majorSizes[n] == wxDefaultCoord )
+ {
+ const int propItem = item->GetProportion();
+ majorSizes[n] = (remaining*propItem)/totalProportion;
- delta -= deltaItem;
+ remaining -= majorSizes[n];
totalProportion -= propItem;
}
}
+ }
+
+ // the position at which we put the next child
+ wxPoint pt(m_position);
+
+
+ // Final pass: finally do position the items correctly using their sizes as
+ // determined above.
+ for ( i = m_children.begin(), n = 0; i != m_children.end(); ++i, ++n )
+ {
+ wxSizerItem * const item = *i;
+
+ if ( !item->IsShown() )
+ continue;
+
+ const int majorSize = majorSizes[n];
+
+ const wxSize sizeThis(item->GetMinSizeWithBorder());
// apply the alignment in the minor direction
wxPoint posChild(pt);
wxCoord minorSize = GetSizeInMinorDir(sizeThis);
const int flag = item->GetFlag();
- if ( flag & (wxEXPAND | wxSHAPED) )
+ if ( (flag & (wxEXPAND | wxSHAPED)) || (minorSize > totalMinorSize) )
{
+ // occupy all the available space if wxEXPAND was given and also if
+ // the item is too big to fit -- in this case we truncate it below
+ // its minimal size which is bad but better than not showing parts
+ // of the window at all
minorSize = totalMinorSize;
}
else if ( flag & (IsVertical() ? wxALIGN_RIGHT : wxALIGN_BOTTOM) )
}
// NB: wxCENTRE is used here only for backwards compatibility,
// wxALIGN_CENTRE should be used in new code
- else if ( flag & (wxCENTER | (IsVertical() ? wxALIGN_CENTRE_HORIZONTAL : wxALIGN_CENTRE_VERTICAL)))
+ else if ( flag & (wxCENTER | (IsVertical() ? wxALIGN_CENTRE_HORIZONTAL
+ : wxALIGN_CENTRE_VERTICAL)) )
{
PosInMinorDir(posChild) += (totalMinorSize - minorSize) / 2;
}
m_totalProportion = 0;
m_minSize = wxSize(0, 0);
- // calculate the minimal sizes for all items and count sum of proportions
+ // The minimal size for the sizer should be big enough to allocate its
+ // element at least its minimal size but also, and this is the non trivial
+ // part, to respect the children proportion. To satisfy the latter
+ // condition we must find the greatest min-size-to-proportion ratio for all
+ // elements with non-zero proportion.
+ float maxMinSizeToProp = 0.;
for ( wxSizerItemList::const_iterator i = m_children.begin();
i != m_children.end();
++i )
continue;
const wxSize sizeMinThis = item->CalcMin();
- SizeInMajorDir(m_minSize) += GetSizeInMajorDir(sizeMinThis);
+ if ( const int propThis = item->GetProportion() )
+ {
+ float minSizeToProp = GetSizeInMajorDir(sizeMinThis);
+ minSizeToProp /= propThis;
+
+ if ( minSizeToProp > maxMinSizeToProp )
+ maxMinSizeToProp = minSizeToProp;
+
+ m_totalProportion += item->GetProportion();
+ }
+ else // fixed size item
+ {
+ // Just account for its size directly
+ SizeInMajorDir(m_minSize) += GetSizeInMajorDir(sizeMinThis);
+ }
+
+ // In the transversal direction we just need to find the maximum.
if ( GetSizeInMinorDir(sizeMinThis) > GetSizeInMinorDir(m_minSize) )
SizeInMinorDir(m_minSize) = GetSizeInMinorDir(sizeMinThis);
-
- m_totalProportion += item->GetProportion();
}
+ // Using the max ratio ensures that the min size is big enough for all
+ // items to have their min size and satisfy the proportions among them.
+ SizeInMajorDir(m_minSize) += (int)(maxMinSizeToProp*m_totalProportion);
+
return m_minSize;
}
// in the wxBoxSizer::RecalcSizes() call below using coordinates relative
// to the top-left corner of the staticbox:
m_position.x = m_position.y = 0;
+#elif defined(__WXOSX__) && wxOSX_USE_COCOA
+ // the distance from the 'inner' content view to the embedded controls
+ m_position.x = m_position.y = 10;
#else
// if the wxStaticBox has childrens, then these windows must be placed
// by the wxBoxSizer::RecalcSizes() call below using coordinates relative
// Extra space around and at the right
Add(12, 40);
#elif defined(__WXGTK20__)
- Add(0, 0, 0, wxLEFT, 9);
+ // http://library.gnome.org/devel/hig-book/stable/windows-alert.html.en
+ // says that the correct button order is
+ //
+ // [Help] [Alternative] [Cancel] [Affirmative]
+
+ // Flags ensuring that margins between the buttons are 6 pixels.
+ const wxSizerFlags
+ flagsBtn = wxSizerFlags().Centre().Border(wxLEFT | wxRIGHT, 3);
+
+ // Margin around the entire sizer button should be 12.
+ AddSpacer(9);
+
if (m_buttonHelp)
- Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
+ Add(m_buttonHelp, flagsBtn);
- // extra whitespace between help and cancel/ok buttons
- Add(0, 0, 1, wxEXPAND, 0);
+ // Align the rest of the buttons to the right.
+ AddStretchSpacer();
- if (m_buttonNegative){
- Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
- }
+ if (m_buttonNegative)
+ Add(m_buttonNegative, flagsBtn);
- // according to HIG, in explicit apply windows the order is:
- // [ Help Apply Cancel OK ]
if (m_buttonApply)
- Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
+ Add(m_buttonApply, flagsBtn);
- if (m_buttonCancel){
- Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
- // Cancel or help should be default
- // m_buttonCancel->SetDefaultButton();
- }
+ if (m_buttonCancel)
+ Add(m_buttonCancel, flagsBtn);
if (m_buttonAffirmative)
- Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT, 6);
+ Add(m_buttonAffirmative, flagsBtn);
+
+ // Ensure that the right margin is 12 as well.
+ AddSpacer(9);
#elif defined(__WXMSW__)
// Windows
projects / wxWidgets.git / blobdiff