diff options
Diffstat (limited to 'src/gui/kernel/qboxlayout.cpp')
| -rw-r--r-- | src/gui/kernel/qboxlayout.cpp | 1550 |
1 files changed, 1550 insertions, 0 deletions
diff --git a/src/gui/kernel/qboxlayout.cpp b/src/gui/kernel/qboxlayout.cpp new file mode 100644 index 0000000000..6946f9bd27 --- /dev/null +++ b/src/gui/kernel/qboxlayout.cpp @@ -0,0 +1,1550 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qboxlayout.h" +#include "qapplication.h" +#include "qwidget.h" +#include "qlist.h" +#include "qsizepolicy.h" +#include "qvector.h" + +#include "qlayoutengine_p.h" +#include "qlayout_p.h" + +QT_BEGIN_NAMESPACE + +/* + Returns true if the \a widget can be added to the \a layout; + otherwise returns false. +*/ +static bool checkWidget(QLayout *layout, QWidget *widget) +{ + if (!widget) { + qWarning("QLayout: Cannot add null widget to %s/%s", layout->metaObject()->className(), + layout->objectName().toLocal8Bit().data()); + return false; + } + return true; +} + +struct QBoxLayoutItem +{ + QBoxLayoutItem(QLayoutItem *it, int stretch_ = 0) + : item(it), stretch(stretch_), magic(false) { } + ~QBoxLayoutItem() { delete item; } + + int hfw(int w) { + if (item->hasHeightForWidth()) { + return item->heightForWidth(w); + } else { + return item->sizeHint().height(); + } + } + int mhfw(int w) { + if (item->hasHeightForWidth()) { + return item->heightForWidth(w); + } else { + return item->minimumSize().height(); + } + } + int hStretch() { + if (stretch == 0 && item->widget()) { + return item->widget()->sizePolicy().horizontalStretch(); + } else { + return stretch; + } + } + int vStretch() { + if (stretch == 0 && item->widget()) { + return item->widget()->sizePolicy().verticalStretch(); + } else { + return stretch; + } + } + + QLayoutItem *item; + int stretch; + bool magic; +}; + +class QBoxLayoutPrivate : public QLayoutPrivate +{ + Q_DECLARE_PUBLIC(QBoxLayout) +public: + QBoxLayoutPrivate() : hfwWidth(-1), dirty(true), spacing(-1) { } + ~QBoxLayoutPrivate(); + + void setDirty() { + geomArray.clear(); + hfwWidth = -1; + hfwHeight = -1; + dirty = true; + } + + QList<QBoxLayoutItem *> list; + QVector<QLayoutStruct> geomArray; + int hfwWidth; + int hfwHeight; + int hfwMinHeight; + QSize sizeHint; + QSize minSize; + QSize maxSize; + int leftMargin, topMargin, rightMargin, bottomMargin; + Qt::Orientations expanding; + uint hasHfw : 1; + uint dirty : 1; + QBoxLayout::Direction dir; + int spacing; + + inline void deleteAll() { while (!list.isEmpty()) delete list.takeFirst(); } + + void setupGeom(); + void calcHfw(int); + + void effectiveMargins(int *left, int *top, int *right, int *bottom) const; +}; + +QBoxLayoutPrivate::~QBoxLayoutPrivate() +{ +} + +static inline bool horz(QBoxLayout::Direction dir) +{ + return dir == QBoxLayout::RightToLeft || dir == QBoxLayout::LeftToRight; +} + +/** + * The purpose of this function is to make sure that widgets are not laid out outside its layout. + * E.g. the layoutItemRect margins are only meant to take of the surrounding margins/spacings. + * However, if the margin is 0, it can easily cover the area of a widget above it. + */ +void QBoxLayoutPrivate::effectiveMargins(int *left, int *top, int *right, int *bottom) const +{ + int l = leftMargin; + int t = topMargin; + int r = rightMargin; + int b = bottomMargin; +#ifdef Q_WS_MAC + Q_Q(const QBoxLayout); + if (horz(dir)) { + QBoxLayoutItem *leftBox = 0; + QBoxLayoutItem *rightBox = 0; + + if (left || right) { + leftBox = list.value(0); + rightBox = list.value(list.count() - 1); + if (dir == QBoxLayout::RightToLeft) + qSwap(leftBox, rightBox); + + int leftDelta = 0; + int rightDelta = 0; + if (leftBox) { + QLayoutItem *itm = leftBox->item; + if (QWidget *w = itm->widget()) + leftDelta = itm->geometry().left() - w->geometry().left(); + } + if (rightBox) { + QLayoutItem *itm = rightBox->item; + if (QWidget *w = itm->widget()) + rightDelta = w->geometry().right() - itm->geometry().right(); + } + QWidget *w = q->parentWidget(); + Qt::LayoutDirection layoutDirection = w ? w->layoutDirection() : QApplication::layoutDirection(); + if (layoutDirection == Qt::RightToLeft) + qSwap(leftDelta, rightDelta); + + l = qMax(l, leftDelta); + r = qMax(r, rightDelta); + } + + int count = top || bottom ? list.count() : 0; + for (int i = 0; i < count; ++i) { + QBoxLayoutItem *box = list.at(i); + QLayoutItem *itm = box->item; + QWidget *w = itm->widget(); + if (w) { + QRect lir = itm->geometry(); + QRect wr = w->geometry(); + if (top) + t = qMax(t, lir.top() - wr.top()); + if (bottom) + b = qMax(b, wr.bottom() - lir.bottom()); + } + } + } else { // vertical layout + QBoxLayoutItem *topBox = 0; + QBoxLayoutItem *bottomBox = 0; + + if (top || bottom) { + topBox = list.value(0); + bottomBox = list.value(list.count() - 1); + if (dir == QBoxLayout::BottomToTop) { + qSwap(topBox, bottomBox); + } + + if (top && topBox) { + QLayoutItem *itm = topBox->item; + QWidget *w = itm->widget(); + if (w) + t = qMax(t, itm->geometry().top() - w->geometry().top()); + } + + if (bottom && bottomBox) { + QLayoutItem *itm = bottomBox->item; + QWidget *w = itm->widget(); + if (w) + b = qMax(b, w->geometry().bottom() - itm->geometry().bottom()); + } + } + + int count = left || right ? list.count() : 0; + for (int i = 0; i < count; ++i) { + QBoxLayoutItem *box = list.at(i); + QLayoutItem *itm = box->item; + QWidget *w = itm->widget(); + if (w) { + QRect lir = itm->geometry(); + QRect wr = w->geometry(); + if (left) + l = qMax(l, lir.left() - wr.left()); + if (right) + r = qMax(r, wr.right() - lir.right()); + } + } + } +#endif + if (left) + *left = l; + if (top) + *top = t; + if (right) + *right = r; + if (bottom) + *bottom = b; +} + + +/* + Initializes the data structure needed by qGeomCalc and + recalculates max/min and size hint. +*/ +void QBoxLayoutPrivate::setupGeom() +{ + if (!dirty) + return; + + Q_Q(QBoxLayout); + int maxw = horz(dir) ? 0 : QLAYOUTSIZE_MAX; + int maxh = horz(dir) ? QLAYOUTSIZE_MAX : 0; + int minw = 0; + int minh = 0; + int hintw = 0; + int hinth = 0; + + bool horexp = false; + bool verexp = false; + + hasHfw = false; + + int n = list.count(); + geomArray.clear(); + QVector<QLayoutStruct> a(n); + + QSizePolicy::ControlTypes controlTypes1; + QSizePolicy::ControlTypes controlTypes2; + int fixedSpacing = q->spacing(); + int previousNonEmptyIndex = -1; + + QStyle *style = 0; + if (fixedSpacing < 0) { + if (QWidget *parentWidget = q->parentWidget()) + style = parentWidget->style(); + } + + for (int i = 0; i < n; i++) { + QBoxLayoutItem *box = list.at(i); + QSize max = box->item->maximumSize(); + QSize min = box->item->minimumSize(); + QSize hint = box->item->sizeHint(); + Qt::Orientations exp = box->item->expandingDirections(); + bool empty = box->item->isEmpty(); + int spacing = 0; + + if (!empty) { + if (fixedSpacing >= 0) { + spacing = (previousNonEmptyIndex >= 0) ? fixedSpacing : 0; +#ifdef Q_WS_MAC + if (!horz(dir) && previousNonEmptyIndex >= 0) { + QBoxLayoutItem *sibling = (dir == QBoxLayout::TopToBottom ? box : list.at(previousNonEmptyIndex)); + if (sibling) { + QWidget *wid = sibling->item->widget(); + if (wid) + spacing = qMax(spacing, sibling->item->geometry().top() - wid->geometry().top()); + } + } +#endif + } else { + controlTypes1 = controlTypes2; + controlTypes2 = box->item->controlTypes(); + if (previousNonEmptyIndex >= 0) { + QSizePolicy::ControlTypes actual1 = controlTypes1; + QSizePolicy::ControlTypes actual2 = controlTypes2; + if (dir == QBoxLayout::RightToLeft || dir == QBoxLayout::BottomToTop) + qSwap(actual1, actual2); + + if (style) { + spacing = style->combinedLayoutSpacing(actual1, actual2, + horz(dir) ? Qt::Horizontal : Qt::Vertical, + 0, q->parentWidget()); + if (spacing < 0) + spacing = 0; + } + } + } + + if (previousNonEmptyIndex >= 0) + a[previousNonEmptyIndex].spacing = spacing; + previousNonEmptyIndex = i; + } + + bool ignore = empty && box->item->widget(); // ignore hidden widgets + bool dummy = true; + if (horz(dir)) { + bool expand = (exp & Qt::Horizontal || box->stretch > 0); + horexp = horexp || expand; + maxw += spacing + max.width(); + minw += spacing + min.width(); + hintw += spacing + hint.width(); + if (!ignore) + qMaxExpCalc(maxh, verexp, dummy, + max.height(), exp & Qt::Vertical, box->item->isEmpty()); + minh = qMax(minh, min.height()); + hinth = qMax(hinth, hint.height()); + + a[i].sizeHint = hint.width(); + a[i].maximumSize = max.width(); + a[i].minimumSize = min.width(); + a[i].expansive = expand; + a[i].stretch = box->stretch ? box->stretch : box->hStretch(); + } else { + bool expand = (exp & Qt::Vertical || box->stretch > 0); + verexp = verexp || expand; + maxh += spacing + max.height(); + minh += spacing + min.height(); + hinth += spacing + hint.height(); + if (!ignore) + qMaxExpCalc(maxw, horexp, dummy, + max.width(), exp & Qt::Horizontal, box->item->isEmpty()); + minw = qMax(minw, min.width()); + hintw = qMax(hintw, hint.width()); + + a[i].sizeHint = hint.height(); + a[i].maximumSize = max.height(); + a[i].minimumSize = min.height(); + a[i].expansive = expand; + a[i].stretch = box->stretch ? box->stretch : box->vStretch(); + } + + a[i].empty = empty; + a[i].spacing = 0; // might be be initialized with a non-zero value in a later iteration + hasHfw = hasHfw || box->item->hasHeightForWidth(); + } + + geomArray = a; + + expanding = (Qt::Orientations) + ((horexp ? Qt::Horizontal : 0) + | (verexp ? Qt::Vertical : 0)); + + minSize = QSize(minw, minh); + maxSize = QSize(maxw, maxh).expandedTo(minSize); + sizeHint = QSize(hintw, hinth).expandedTo(minSize).boundedTo(maxSize); + + q->getContentsMargins(&leftMargin, &topMargin, &rightMargin, &bottomMargin); + int left, top, right, bottom; + effectiveMargins(&left, &top, &right, &bottom); + QSize extra(left + right, top + bottom); + + minSize += extra; + maxSize += extra; + sizeHint += extra; + + dirty = false; +} + +/* + Calculates and stores the preferred height given the width \a w. +*/ +void QBoxLayoutPrivate::calcHfw(int w) +{ + QVector<QLayoutStruct> &a = geomArray; + int n = a.count(); + int h = 0; + int mh = 0; + + Q_ASSERT(n == list.size()); + + if (horz(dir)) { + qGeomCalc(a, 0, n, 0, w); + for (int i = 0; i < n; i++) { + QBoxLayoutItem *box = list.at(i); + h = qMax(h, box->hfw(a.at(i).size)); + mh = qMax(mh, box->mhfw(a.at(i).size)); + } + } else { + for (int i = 0; i < n; ++i) { + QBoxLayoutItem *box = list.at(i); + int spacing = a.at(i).spacing; + h += box->hfw(w); + mh += box->mhfw(w); + h += spacing; + mh += spacing; + } + } + hfwWidth = w; + hfwHeight = h; + hfwMinHeight = mh; +} + + +/*! + \class QBoxLayout + + \brief The QBoxLayout class lines up child widgets horizontally or + vertically. + + \ingroup geomanagement + + QBoxLayout takes the space it gets (from its parent layout or from + the parentWidget()), divides it up into a row of boxes, and makes + each managed widget fill one box. + + \image qhboxlayout-with-5-children.png Horizontal box layout with five child widgets + + If the QBoxLayout's orientation is Qt::Horizontal the boxes are + placed in a row, with suitable sizes. Each widget (or other box) + will get at least its minimum size and at most its maximum size. + Any excess space is shared according to the stretch factors (more + about that below). + + \image qvboxlayout-with-5-children.png Vertical box layout with five child widgets + + If the QBoxLayout's orientation is Qt::Vertical, the boxes are + placed in a column, again with suitable sizes. + + The easiest way to create a QBoxLayout is to use one of the + convenience classes, e.g. QHBoxLayout (for Qt::Horizontal boxes) + or QVBoxLayout (for Qt::Vertical boxes). You can also use the + QBoxLayout constructor directly, specifying its direction as + LeftToRight, RightToLeft, TopToBottom, or BottomToTop. + + If the QBoxLayout is not the top-level layout (i.e. it is not + managing all of the widget's area and children), you must add it + to its parent layout before you can do anything with it. The + normal way to add a layout is by calling + parentLayout-\>addLayout(). + + Once you have done this, you can add boxes to the QBoxLayout using + one of four functions: + + \list + \o addWidget() to add a widget to the QBoxLayout and set the + widget's stretch factor. (The stretch factor is along the row of + boxes.) + + \o addSpacing() to create an empty box; this is one of the + functions you use to create nice and spacious dialogs. See below + for ways to set margins. + + \o addStretch() to create an empty, stretchable box. + + \o addLayout() to add a box containing another QLayout to the row + and set that layout's stretch factor. + \endlist + + Use insertWidget(), insertSpacing(), insertStretch() or + insertLayout() to insert a box at a specified position in the + layout. + + QBoxLayout also includes two margin widths: + + \list + \o setContentsMargins() sets the width of the outer border on + each side of the widget. This is the width of the reserved space + along each of the QBoxLayout's four sides. + \o setSpacing() sets the width between neighboring boxes. (You + can use addSpacing() to get more space at a particular spot.) + \endlist + + The margin default is provided by the style. The default margin + most Qt styles specify is 9 for child widgets and 11 for windows. + The spacing defaults to the same as the margin width for a + top-level layout, or to the same as the parent layout. + + To remove a widget from a layout, call removeWidget(). Calling + QWidget::hide() on a widget also effectively removes the widget + from the layout until QWidget::show() is called. + + You will almost always want to use QVBoxLayout and QHBoxLayout + rather than QBoxLayout because of their convenient constructors. + + \sa QGridLayout, QStackedLayout, {Layout Management} +*/ + +/*! + \enum QBoxLayout::Direction + + This type is used to determine the direction of a box layout. + + \value LeftToRight Horizontal from left to right. + \value RightToLeft Horizontal from right to left. + \value TopToBottom Vertical from top to bottom. + \value BottomToTop Vertical from bottom to top. + + \omitvalue Down + \omitvalue Up +*/ + +/*! + Constructs a new QBoxLayout with direction \a dir and parent widget \a + parent. + + \sa direction() +*/ +QBoxLayout::QBoxLayout(Direction dir, QWidget *parent) + : QLayout(*new QBoxLayoutPrivate, 0, parent) +{ + Q_D(QBoxLayout); + d->dir = dir; +} + +#ifdef QT3_SUPPORT +/*! + Constructs a new QBoxLayout with direction \a dir and main widget \a + parent. \a parent may not be 0. + + The \a margin is the number of pixels between the edge of the + widget and its managed children. The \a spacing is the default + number of pixels between neighboring children. If \a spacing is -1 + the value of \a margin is used for \a spacing. + + \a name is the internal object name. + + \sa direction() +*/ +QBoxLayout::QBoxLayout(QWidget *parent, Direction dir, + int margin, int spacing, const char *name) + : QLayout(*new QBoxLayoutPrivate, 0, parent) +{ + Q_D(QBoxLayout); + d->dir = dir; + setMargin(margin); + setObjectName(QString::fromAscii(name)); + setSpacing(spacing<0 ? margin : spacing); +} + +/*! + Constructs a new QBoxLayout called \a name, with direction \a dir, + and inserts it into \a parentLayout. + + The \a spacing is the default number of pixels between neighboring + children. If \a spacing is -1, the layout will inherit its + parent's spacing(). +*/ +QBoxLayout::QBoxLayout(QLayout *parentLayout, Direction dir, int spacing, + const char *name) + : QLayout(*new QBoxLayoutPrivate, parentLayout, 0) +{ + Q_D(QBoxLayout); + d->dir = dir; + setObjectName(QString::fromAscii(name)); + setSpacing(spacing); +} + +/*! + Constructs a new QBoxLayout called \a name, with direction \a dir. + + If \a spacing is -1, the layout will inherit its parent's + spacing(); otherwise \a spacing is used. + + You must insert this box into another layout. +*/ +QBoxLayout::QBoxLayout(Direction dir, int spacing, const char *name) + : QLayout(*new QBoxLayoutPrivate,0, 0) +{ + Q_D(QBoxLayout); + d->dir = dir; + setObjectName(QString::fromAscii(name)); + setSpacing(spacing); +} +#endif // QT3_SUPPORT + + +/*! + Destroys this box layout. + + The layout's widgets aren't destroyed. +*/ +QBoxLayout::~QBoxLayout() +{ + Q_D(QBoxLayout); + d->deleteAll(); // must do it before QObject deletes children, so can't be in ~QBoxLayoutPrivate +} + +/*! + Reimplements QLayout::spacing(). If the spacing property is + valid, that value is returned. Otherwise, a value for the spacing + property is computed and returned. Since layout spacing in a widget + is style dependent, if the parent is a widget, it queries the style + for the (horizontal or vertical) spacing of the layout. Otherwise, + the parent is a layout, and it queries the parent layout for the + spacing(). + + \sa QLayout::spacing(), setSpacing() + */ +int QBoxLayout::spacing() const +{ + Q_D(const QBoxLayout); + if (d->spacing >=0) { + return d->spacing; + } else { + return qSmartSpacing(this, d->dir == LeftToRight || d->dir == RightToLeft + ? QStyle::PM_LayoutHorizontalSpacing + : QStyle::PM_LayoutVerticalSpacing); + } +} + +/*! + Reimplements QLayout::setSpacing(). Sets the spacing + property to \a spacing. + + \sa QLayout::setSpacing(), spacing() + */ +void QBoxLayout::setSpacing(int spacing) +{ + Q_D(QBoxLayout); + d->spacing = spacing; + invalidate(); +} + +/*! + \reimp +*/ +QSize QBoxLayout::sizeHint() const +{ + Q_D(const QBoxLayout); + if (d->dirty) + const_cast<QBoxLayout*>(this)->d_func()->setupGeom(); + return d->sizeHint; +} + +/*! + \reimp +*/ +QSize QBoxLayout::minimumSize() const +{ + Q_D(const QBoxLayout); + if (d->dirty) + const_cast<QBoxLayout*>(this)->d_func()->setupGeom(); + return d->minSize; +} + +/*! + \reimp +*/ +QSize QBoxLayout::maximumSize() const +{ + Q_D(const QBoxLayout); + if (d->dirty) + const_cast<QBoxLayout*>(this)->d_func()->setupGeom(); + + QSize s = d->maxSize.boundedTo(QSize(QLAYOUTSIZE_MAX, QLAYOUTSIZE_MAX)); + + if (alignment() & Qt::AlignHorizontal_Mask) + s.setWidth(QLAYOUTSIZE_MAX); + if (alignment() & Qt::AlignVertical_Mask) + s.setHeight(QLAYOUTSIZE_MAX); + return s; +} + +/*! + \reimp +*/ +bool QBoxLayout::hasHeightForWidth() const +{ + Q_D(const QBoxLayout); + if (d->dirty) + const_cast<QBoxLayout*>(this)->d_func()->setupGeom(); + return d->hasHfw; +} + +/*! + \reimp +*/ +int QBoxLayout::heightForWidth(int w) const +{ + Q_D(const QBoxLayout); + if (!hasHeightForWidth()) + return -1; + + int left, top, right, bottom; + d->effectiveMargins(&left, &top, &right, &bottom); + + w -= left + right; + if (w != d->hfwWidth) + const_cast<QBoxLayout*>(this)->d_func()->calcHfw(w); + + return d->hfwHeight + top + bottom; +} + +/*! + \reimp +*/ +int QBoxLayout::minimumHeightForWidth(int w) const +{ + Q_D(const QBoxLayout); + (void) heightForWidth(w); + int top, bottom; + d->effectiveMargins(0, &top, 0, &bottom); + return d->hasHfw ? (d->hfwMinHeight + top + bottom) : -1; +} + +/*! + Resets cached information. +*/ +void QBoxLayout::invalidate() +{ + Q_D(QBoxLayout); + d->setDirty(); + QLayout::invalidate(); +} + +/*! + \reimp +*/ +int QBoxLayout::count() const +{ + Q_D(const QBoxLayout); + return d->list.count(); +} + +/*! + \reimp +*/ +QLayoutItem *QBoxLayout::itemAt(int index) const +{ + Q_D(const QBoxLayout); + return index >= 0 && index < d->list.count() ? d->list.at(index)->item : 0; +} + +/*! + \reimp +*/ +QLayoutItem *QBoxLayout::takeAt(int index) +{ + Q_D(QBoxLayout); + if (index < 0 || index >= d->list.count()) + return 0; + QBoxLayoutItem *b = d->list.takeAt(index); + QLayoutItem *item = b->item; + b->item = 0; + delete b; + + invalidate(); + return item; +} + + +/*! + \reimp +*/ +Qt::Orientations QBoxLayout::expandingDirections() const +{ + Q_D(const QBoxLayout); + if (d->dirty) + const_cast<QBoxLayout*>(this)->d_func()->setupGeom(); + return d->expanding; +} + +/*! + \reimp +*/ +void QBoxLayout::setGeometry(const QRect &r) +{ + Q_D(QBoxLayout); + if (d->dirty || r != geometry()) { + QRect oldRect = geometry(); + QLayout::setGeometry(r); + if (d->dirty) + d->setupGeom(); + QRect cr = alignment() ? alignmentRect(r) : r; + + int left, top, right, bottom; + d->effectiveMargins(&left, &top, &right, &bottom); + QRect s(cr.x() + left, cr.y() + top, + cr.width() - (left + right), + cr.height() - (top + bottom)); + + QVector<QLayoutStruct> a = d->geomArray; + int pos = horz(d->dir) ? s.x() : s.y(); + int space = horz(d->dir) ? s.width() : s.height(); + int n = a.count(); + if (d->hasHfw && !horz(d->dir)) { + for (int i = 0; i < n; i++) { + QBoxLayoutItem *box = d->list.at(i); + if (box->item->hasHeightForWidth()) { + int width = qBound(box->item->minimumSize().width(), s.width(), box->item->maximumSize().width()); + a[i].sizeHint = a[i].minimumSize = + box->item->heightForWidth(width); + } + } + } + + Direction visualDir = d->dir; + QWidget *parent = parentWidget(); + if (parent && parent->isRightToLeft()) { + if (d->dir == LeftToRight) + visualDir = RightToLeft; + else if (d->dir == RightToLeft) + visualDir = LeftToRight; + } + + qGeomCalc(a, 0, n, pos, space); + + bool reverse = (horz(visualDir) + ? ((r.right() > oldRect.right()) != (visualDir == RightToLeft)) + : r.bottom() > oldRect.bottom()); + for (int j = 0; j < n; j++) { + int i = reverse ? n-j-1 : j; + QBoxLayoutItem *box = d->list.at(i); + + switch (visualDir) { + case LeftToRight: + box->item->setGeometry(QRect(a.at(i).pos, s.y(), a.at(i).size, s.height())); + break; + case RightToLeft: + box->item->setGeometry(QRect(s.left() + s.right() - a.at(i).pos - a.at(i).size + 1, + s.y(), a.at(i).size, s.height())); + break; + case TopToBottom: + box->item->setGeometry(QRect(s.x(), a.at(i).pos, s.width(), a.at(i).size)); + break; + case BottomToTop: + box->item->setGeometry(QRect(s.x(), + s.top() + s.bottom() - a.at(i).pos - a.at(i).size + 1, + s.width(), a.at(i).size)); + } + } + } +} + +/*! + \reimp +*/ +void QBoxLayout::addItem(QLayoutItem *item) +{ + Q_D(QBoxLayout); + QBoxLayoutItem *it = new QBoxLayoutItem(item); + d->list.append(it); + invalidate(); +} + +/*! + Inserts \a item into this box layout at position \a index. If \a + index is negative, the item is added at the end. + + \sa addItem(), insertWidget(), insertLayout(), insertStretch(), + insertSpacing() +*/ +void QBoxLayout::insertItem(int index, QLayoutItem *item) +{ + Q_D(QBoxLayout); + if (index < 0) // append + index = d->list.count(); + + QBoxLayoutItem *it = new QBoxLayoutItem(item); + d->list.insert(index, it); + invalidate(); +} + +/*! + Inserts a non-stretchable space (a QSpacerItem) at position \a index, with + size \a size. If \a index is negative the space is added at the end. + + The box layout has default margin and spacing. This function adds + additional space. + + \sa addSpacing(), insertItem(), QSpacerItem +*/ +void QBoxLayout::insertSpacing(int index, int size) +{ + Q_D(QBoxLayout); + if (index < 0) // append + index = d->list.count(); + + QLayoutItem *b; + if (horz(d->dir)) + b = QLayoutPrivate::createSpacerItem(this, size, 0, QSizePolicy::Fixed, QSizePolicy::Minimum); + else + b = QLayoutPrivate::createSpacerItem(this, 0, size, QSizePolicy::Minimum, QSizePolicy::Fixed); + + QT_TRY { + QBoxLayoutItem *it = new QBoxLayoutItem(b); + it->magic = true; + d->list.insert(index, it); + + } QT_CATCH(...) { + delete b; + QT_RETHROW; + } + invalidate(); +} + +/*! + Inserts a stretchable space (a QSpacerItem) at position \a + index, with zero minimum size and stretch factor \a stretch. If \a + index is negative the space is added at the end. + + \sa addStretch(), insertItem(), QSpacerItem +*/ +void QBoxLayout::insertStretch(int index, int stretch) +{ + Q_D(QBoxLayout); + if (index < 0) // append + index = d->list.count(); + + QLayoutItem *b; + if (horz(d->dir)) + b = QLayoutPrivate::createSpacerItem(this, 0, 0, QSizePolicy::Expanding, QSizePolicy::Minimum); + else + b = QLayoutPrivate::createSpacerItem(this, 0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding); + + QBoxLayoutItem *it = new QBoxLayoutItem(b, stretch); + it->magic = true; + d->list.insert(index, it); + invalidate(); +} + +/*! + \since 4.4 + + Inserts \a spacerItem at position \a index, with zero minimum + size and stretch factor. If \a index is negative the + space is added at the end. + + \sa addSpacerItem(), insertStretch(), insertSpacing() +*/ +void QBoxLayout::insertSpacerItem(int index, QSpacerItem *spacerItem) +{ + Q_D(QBoxLayout); + if (index < 0) // append + index = d->list.count(); + + QBoxLayoutItem *it = new QBoxLayoutItem(spacerItem); + it->magic = true; + d->list.insert(index, it); + invalidate(); +} + +/*! + Inserts \a layout at position \a index, with stretch factor \a + stretch. If \a index is negative, the layout is added at the end. + + \a layout becomes a child of the box layout. + + \sa addLayout(), insertItem() +*/ +void QBoxLayout::insertLayout(int index, QLayout *layout, int stretch) +{ + Q_D(QBoxLayout); + addChildLayout(layout); + if (index < 0) // append + index = d->list.count(); + QBoxLayoutItem *it = new QBoxLayoutItem(layout, stretch); + d->list.insert(index, it); + invalidate(); +} + +/*! + Inserts \a widget at position \a index, with stretch factor \a + stretch and alignment \a alignment. If \a index is negative, the + widget is added at the end. + + The stretch factor applies only in the \l{direction()}{direction} + of the QBoxLayout, and is relative to the other boxes and widgets + in this QBoxLayout. Widgets and boxes with higher stretch factors + grow more. + + If the stretch factor is 0 and nothing else in the QBoxLayout has + a stretch factor greater than zero, the space is distributed + according to the QWidget:sizePolicy() of each widget that's + involved. + + The alignment is specified by \a alignment. The default alignment + is 0, which means that the widget fills the entire cell. + + \sa addWidget(), insertItem() +*/ +void QBoxLayout::insertWidget(int index, QWidget *widget, int stretch, + Qt::Alignment alignment) +{ + Q_D(QBoxLayout); + if (!checkWidget(this, widget)) + return; + addChildWidget(widget); + if (index < 0) // append + index = d->list.count(); + QWidgetItem *b = QLayoutPrivate::createWidgetItem(this, widget); + b->setAlignment(alignment); + + QBoxLayoutItem *it; + QT_TRY{ + it = new QBoxLayoutItem(b, stretch); + } QT_CATCH(...) { + delete b; + QT_RETHROW; + } + + QT_TRY{ + d->list.insert(index, it); + } QT_CATCH(...) { + delete it; + QT_RETHROW; + } + invalidate(); +} + +/*! + Adds a non-stretchable space (a QSpacerItem) with size \a size + to the end of this box layout. QBoxLayout provides default margin + and spacing. This function adds additional space. + + \sa insertSpacing(), addItem(), QSpacerItem +*/ +void QBoxLayout::addSpacing(int size) +{ + insertSpacing(-1, size); +} + +/*! + Adds a stretchable space (a QSpacerItem) with zero minimum + size and stretch factor \a stretch to the end of this box layout. + + \sa insertStretch(), addItem(), QSpacerItem +*/ +void QBoxLayout::addStretch(int stretch) +{ + insertStretch(-1, stretch); +} + +/*! + \since 4.4 + + Adds \a spacerItem to the end of this box layout. + + \sa addSpacing(), addStretch() +*/ +void QBoxLayout::addSpacerItem(QSpacerItem *spacerItem) +{ + insertSpacerItem(-1, spacerItem); +} + +/*! + Adds \a widget to the end of this box layout, with a stretch + factor of \a stretch and alignment \a alignment. + + The stretch factor applies only in the \l{direction()}{direction} + of the QBoxLayout, and is relative to the other boxes and widgets + in this QBoxLayout. Widgets and boxes with higher stretch factors + grow more. + + If the stretch factor is 0 and nothing else in the QBoxLayout has + a stretch factor greater than zero, the space is distributed + according to the QWidget:sizePolicy() of each widget that's + involved. + + The alignment is specified by \a alignment. The default + alignment is 0, which means that the widget fills the entire cell. + + \sa insertWidget(), addItem(), addLayout(), addStretch(), + addSpacing(), addStrut() +*/ +void QBoxLayout::addWidget(QWidget *widget, int stretch, Qt::Alignment alignment) +{ + insertWidget(-1, widget, stretch, alignment); +} + +/*! + Adds \a layout to the end of the box, with serial stretch factor + \a stretch. + + \sa insertLayout(), addItem(), addWidget() +*/ +void QBoxLayout::addLayout(QLayout *layout, int stretch) +{ + insertLayout(-1, layout, stretch); +} + +/*! + Limits the perpendicular dimension of the box (e.g. height if the + box is \l LeftToRight) to a minimum of \a size. Other constraints + may increase the limit. + + \sa addItem() +*/ +void QBoxLayout::addStrut(int size) +{ + Q_D(QBoxLayout); + QLayoutItem *b; + if (horz(d->dir)) + b = QLayoutPrivate::createSpacerItem(this, 0, size, QSizePolicy::Fixed, QSizePolicy::Minimum); + else + b = QLayoutPrivate::createSpacerItem(this, size, 0, QSizePolicy::Minimum, QSizePolicy::Fixed); + + QBoxLayoutItem *it = new QBoxLayoutItem(b); + it->magic = true; + d->list.append(it); + invalidate(); +} + +/*! + \fn int QBoxLayout::findWidget(QWidget *widget) + + Use indexOf(\a widget) instead. +*/ + +/*! + Sets the stretch factor for \a widget to \a stretch and returns + true if \a widget is found in this layout (not including child + layouts); otherwise returns false. + + \sa setAlignment() +*/ +bool QBoxLayout::setStretchFactor(QWidget *widget, int stretch) +{ + Q_D(QBoxLayout); + if (!widget) + return false; + for (int i = 0; i < d->list.size(); ++i) { + QBoxLayoutItem *box = d->list.at(i); + if (box->item->widget() == widget) { + box->stretch = stretch; + invalidate(); + return true; + } + } + return false; +} + +/*! + \overload + + Sets the stretch factor for the layout \a layout to \a stretch and + returns true if \a layout is found in this layout (not including + child layouts); otherwise returns false. +*/ +bool QBoxLayout::setStretchFactor(QLayout *layout, int stretch) +{ + Q_D(QBoxLayout); + for (int i = 0; i < d->list.size(); ++i) { + QBoxLayoutItem *box = d->list.at(i); + if (box->item->layout() == layout) { + if (box->stretch != stretch) { + box->stretch = stretch; + invalidate(); + } + return true; + } + } + return false; +} + +/*! + Sets the stretch factor at position \a index. to \a stretch. + + \since 4.5 +*/ + +void QBoxLayout::setStretch(int index, int stretch) +{ + Q_D(QBoxLayout); + if (index >= 0 && index < d->list.size()) { + QBoxLayoutItem *box = d->list.at(index); + if (box->stretch != stretch) { + box->stretch = stretch; + invalidate(); + } + } +} + +/*! + Returns the stretch factor at position \a index. + + \since 4.5 +*/ + +int QBoxLayout::stretch(int index) const +{ + Q_D(const QBoxLayout); + if (index >= 0 && index < d->list.size()) + return d->list.at(index)->stretch; + return -1; +} + +/*! + Sets the direction of this layout to \a direction. +*/ +void QBoxLayout::setDirection(Direction direction) +{ + Q_D(QBoxLayout); + if (d->dir == direction) + return; + if (horz(d->dir) != horz(direction)) { + //swap around the spacers (the "magic" bits) + //#### a bit yucky, knows too much. + //#### probably best to add access functions to spacerItem + //#### or even a QSpacerItem::flip() + for (int i = 0; i < d->list.size(); ++i) { + QBoxLayoutItem *box = d->list.at(i); + if (box->magic) { + QSpacerItem *sp = box->item->spacerItem(); + if (sp) { + if (sp->expandingDirections() == Qt::Orientations(0) /*No Direction*/) { + //spacing or strut + QSize s = sp->sizeHint(); + sp->changeSize(s.height(), s.width(), + horz(direction) ? QSizePolicy::Fixed:QSizePolicy::Minimum, + horz(direction) ? QSizePolicy::Minimum:QSizePolicy::Fixed); + + } else { + //stretch + if (horz(direction)) + sp->changeSize(0, 0, QSizePolicy::Expanding, + QSizePolicy::Minimum); + else + sp->changeSize(0, 0, QSizePolicy::Minimum, + QSizePolicy::Expanding); + } + } + } + } + } + d->dir = direction; + invalidate(); +} + +/*! + \fn QBoxLayout::Direction QBoxLayout::direction() const + + Returns the direction of the box. addWidget() and addSpacing() + work in this direction; the stretch stretches in this direction. + + \sa QBoxLayout::Direction addWidget() addSpacing() +*/ + +QBoxLayout::Direction QBoxLayout::direction() const +{ + Q_D(const QBoxLayout); + return d->dir; +} + +/*! + \class QHBoxLayout + \brief The QHBoxLayout class lines up widgets horizontally. + + \ingroup geomanagement + + This class is used to construct horizontal box layout objects. See + QBoxLayout for details. + + The simplest use of the class is like this: + + \snippet doc/src/snippets/layouts/layouts.cpp 0 + \snippet doc/src/snippets/layouts/layouts.cpp 1 + \snippet doc/src/snippets/layouts/layouts.cpp 2 + \codeline + \snippet doc/src/snippets/layouts/layouts.cpp 3 + \snippet doc/src/snippets/layouts/layouts.cpp 4 + \snippet doc/src/snippets/layouts/layouts.cpp 5 + + First, we create the widgets we want in the layout. Then, we + create the QHBoxLayout object and add the widgets into the + layout. Finally, we call QWidget::setLayout() to install the + QHBoxLayout object onto the widget. At that point, the widgets in + the layout are reparented to have \c window as their parent. + + \image qhboxlayout-with-5-children.png Horizontal box layout with five child widgets + + \sa QVBoxLayout, QGridLayout, QStackedLayout, {Layout Management}, {Basic Layouts Example} +*/ + + +/*! + Constructs a new top-level horizontal box with + parent \a parent. +*/ +QHBoxLayout::QHBoxLayout(QWidget *parent) + : QBoxLayout(LeftToRight, parent) +{ +} + +/*! + Constructs a new horizontal box. You must add + it to another layout. +*/ +QHBoxLayout::QHBoxLayout() + : QBoxLayout(LeftToRight) +{ +} + + + +#ifdef QT3_SUPPORT +/*! + Constructs a new top-level horizontal box called \a name, with + parent \a parent. + + The \a margin is the number of pixels between the edge of the + widget and its managed children. The \a spacing is the default + number of pixels between neighboring children. If \a spacing is -1 + the value of \a margin is used for \a spacing. +*/ +QHBoxLayout::QHBoxLayout(QWidget *parent, int margin, + int spacing, const char *name) + : QBoxLayout(LeftToRight, parent) +{ + setMargin(margin); + setSpacing(spacing<0 ? margin : spacing); + setObjectName(QString::fromAscii(name)); +} + +/*! + Constructs a new horizontal box called name \a name and adds it to + \a parentLayout. + + The \a spacing is the default number of pixels between neighboring + children. If \a spacing is -1, this QHBoxLayout will inherit its + parent's spacing(). +*/ +QHBoxLayout::QHBoxLayout(QLayout *parentLayout, int spacing, + const char *name) + : QBoxLayout(LeftToRight) +{ + setSpacing(spacing); + setObjectName(QString::fromAscii(name)); + if (parentLayout) { + setParent(parentLayout); + parentLayout->addItem(this); + } +} + +/*! + Constructs a new horizontal box called name \a name. You must add + it to another layout. + + The \a spacing is the default number of pixels between neighboring + children. If \a spacing is -1, this QHBoxLayout will inherit its + parent's spacing(). +*/ +QHBoxLayout::QHBoxLayout(int spacing, const char *name) + : QBoxLayout(LeftToRight) +{ + setSpacing(spacing); + setObjectName(QString::fromAscii(name)); +} +#endif + + +/*! + Destroys this box layout. + + The layout's widgets aren't destroyed. +*/ +QHBoxLayout::~QHBoxLayout() +{ +} + +/*! + \class QVBoxLayout + \brief The QVBoxLayout class lines up widgets vertically. + + \ingroup geomanagement + + This class is used to construct vertical box layout objects. See + QBoxLayout for details. + + The simplest use of the class is like this: + + \snippet doc/src/snippets/layouts/layouts.cpp 6 + \snippet doc/src/snippets/layouts/layouts.cpp 7 + \snippet doc/src/snippets/layouts/layouts.cpp 8 + \codeline + \snippet doc/src/snippets/layouts/layouts.cpp 9 + \snippet doc/src/snippets/layouts/layouts.cpp 10 + \snippet doc/src/snippets/layouts/layouts.cpp 11 + + First, we create the widgets we want in the layout. Then, we + create the QVBoxLayout object and add the widgets into the + layout. Finally, we call QWidget::setLayout() to install the + QVBoxLayout object onto the widget. At that point, the widgets in + the layout are reparented to have \c window as their parent. + + \image qvboxlayout-with-5-children.png Horizontal box layout with five child widgets + + \sa QHBoxLayout, QGridLayout, QStackedLayout, {Layout Management}, {Basic Layouts Example} +*/ + +/*! + Constructs a new top-level vertical box with + parent \a parent. +*/ +QVBoxLayout::QVBoxLayout(QWidget *parent) + : QBoxLayout(TopToBottom, parent) +{ +} + +/*! + Constructs a new vertical box. You must add + it to another layout. + +*/ +QVBoxLayout::QVBoxLayout() + : QBoxLayout(TopToBottom) +{ +} + +#ifdef QT3_SUPPORT +/*! + Constructs a new top-level vertical box called \a name, with + parent \a parent. + + The \a margin is the number of pixels between the edge of the + widget and its managed children. The \a spacing is the default + number of pixels between neighboring children. If \a spacing is -1 + the value of \a margin is used for \a spacing. +*/ +QVBoxLayout::QVBoxLayout(QWidget *parent, int margin, int spacing, + const char *name) + : QBoxLayout(TopToBottom, parent) +{ + setMargin(margin); + setSpacing(spacing<0 ? margin : spacing); + setObjectName(QString::fromAscii(name)); +} + +/*! + Constructs a new vertical box called name \a name and adds it to + \a parentLayout. + + The \a spacing is the default number of pixels between neighboring + children. If \a spacing is -1, this QVBoxLayout will inherit its + parent's spacing(). +*/ +QVBoxLayout::QVBoxLayout(QLayout *parentLayout, int spacing, + const char *name) + : QBoxLayout(TopToBottom) +{ + setSpacing(spacing); + setObjectName(QString::fromAscii(name)); + if (parentLayout) { + setParent(parentLayout); + parentLayout->addItem(this); + } +} + +/*! + Constructs a new vertical box called name \a name. You must add + it to another layout. + + The \a spacing is the default number of pixels between neighboring + children. If \a spacing is -1, this QVBoxLayout will inherit its + parent's spacing(). +*/ +QVBoxLayout::QVBoxLayout(int spacing, const char *name) + : QBoxLayout(TopToBottom) +{ + setSpacing(spacing); + setObjectName(QString::fromAscii(name)); +} + + +#endif + +/*! + Destroys this box layout. + + The layout's widgets aren't destroyed. +*/ +QVBoxLayout::~QVBoxLayout() +{ +} + +/*! + \fn QWidget *QLayout::mainWidget() const + + Use parentWidget() instead. +*/ + +/*! + \fn void QLayout::remove(QWidget *widget) + + Use removeWidget(\a widget) instead. +*/ + +/*! + \fn void QLayout::add(QWidget *widget) + + Use addWidget(\a widget) instead. +*/ + +/*! + \fn QLayoutIterator QLayout::iterator() + + Use a QLayoutIterator() constructor instead. +*/ + +/*! + \fn int QLayout::defaultBorder() const + + Use spacing() instead. +*/ + +QT_END_NAMESPACE |