--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/gui/widgets/qsplitter.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,1839 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 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 "qsplitter.h"
+#ifndef QT_NO_SPLITTER
+
+#include "qapplication.h"
+#include "qcursor.h"
+#include "qdrawutil.h"
+#include "qevent.h"
+#include "qlayout.h"
+#include "qlist.h"
+#include "qpainter.h"
+#include "qrubberband.h"
+#include "qstyle.h"
+#include "qstyleoption.h"
+#include "qtextstream.h"
+#include "qvarlengtharray.h"
+#include "qvector.h"
+#include "private/qlayoutengine_p.h"
+#include "private/qsplitter_p.h"
+#include "qtimer.h"
+#include "qdebug.h"
+
+#include <ctype.h>
+
+QT_BEGIN_NAMESPACE
+
+//#define QSPLITTER_DEBUG
+
+/*!
+ \class QSplitterHandle
+ \brief The QSplitterHandle class provides handle functionality of the splitter.
+
+ \ingroup organizers
+
+ QSplitterHandle is typically what people think about when they think about
+ a splitter. It is the handle that is used to resize the widgets.
+
+ A typical developer using QSplitter will never have to worry about
+ QSplitterHandle. It is provided for developers who want splitter handles
+ that provide extra features, such as popup menus.
+
+ The typical way one would create splitter handles is to subclass QSplitter then
+ reimplement QSplitter::createHandle() to instantiate the custom splitter
+ handle. For example, a minimum QSplitter subclass might look like this:
+
+ \snippet doc/src/snippets/splitterhandle/splitter.h 0
+
+ The \l{QSplitter::}{createHandle()} implementation simply constructs a
+ custom splitter handle, called \c Splitter in this example:
+
+ \snippet doc/src/snippets/splitterhandle/splitter.cpp 1
+
+ Information about a given handle can be obtained using functions like
+ orientation() and opaqueResize(), and is retrieved from its parent splitter.
+ Details like these can be used to give custom handles different appearances
+ depending on the splitter's orientation.
+
+ The complexity of a custom handle subclass depends on the tasks that it
+ needs to perform. A simple subclass might only provide a paintEvent()
+ implementation:
+
+ \snippet doc/src/snippets/splitterhandle/splitter.cpp 0
+
+ In this example, a predefined gradient is set up differently depending on
+ the orientation of the handle. QSplitterHandle provides a reasonable
+ size hint for the handle, so the subclass does not need to provide a
+ reimplementation of sizeHint() unless the handle has special size
+ requirements.
+
+ \sa QSplitter
+*/
+
+/*!
+ Creates a QSplitter handle with the given \a orientation and
+ QSplitter \a parent.
+*/
+QSplitterHandle::QSplitterHandle(Qt::Orientation orientation, QSplitter *parent)
+ : QWidget(*new QSplitterHandlePrivate, parent, 0)
+{
+ Q_D(QSplitterHandle);
+ d->s = parent;
+ setOrientation(orientation);
+}
+
+/*!
+ Sets the orientation of the splitter handle to \a orientation.
+ This is usually propogated from the QSplitter.
+
+ \sa QSplitter::setOrientation()
+*/
+void QSplitterHandle::setOrientation(Qt::Orientation orientation)
+{
+ Q_D(QSplitterHandle);
+ d->orient = orientation;
+#ifndef QT_NO_CURSOR
+ setCursor(orientation == Qt::Horizontal ? Qt::SplitHCursor : Qt::SplitVCursor);
+#endif
+}
+
+/*!
+ Returns the handle's orientation. This is usually propagated from the QSplitter.
+
+ \sa QSplitter::orientation()
+*/
+Qt::Orientation QSplitterHandle::orientation() const
+{
+ Q_D(const QSplitterHandle);
+ return d->orient;
+}
+
+
+/*!
+ Returns true if widgets are resized dynamically (opaquely), otherwise
+ returns false. This value is controlled by the QSplitter.
+
+ \sa QSplitter::opaqueResize()
+
+*/
+bool QSplitterHandle::opaqueResize() const
+{
+ Q_D(const QSplitterHandle);
+ return d->s->opaqueResize();
+}
+
+
+/*!
+ Returns the splitter associated with this splitter handle.
+
+ \sa QSplitter::handle()
+*/
+QSplitter *QSplitterHandle::splitter() const
+{
+ return d_func()->s;
+}
+
+/*!
+ Tells the splitter to move this handle to position \a pos, which is
+ the distance from the left or top edge of the widget.
+
+ Note that \a pos is also measured from the left (or top) for
+ right-to-left languages. This function will map \a pos to the
+ appropriate position before calling QSplitter::moveSplitter().
+
+ \sa QSplitter::moveSplitter() closestLegalPosition()
+*/
+void QSplitterHandle::moveSplitter(int pos)
+{
+ Q_D(QSplitterHandle);
+ if (d->s->isRightToLeft() && d->orient == Qt::Horizontal)
+ pos = d->s->contentsRect().width() - pos;
+ d->s->moveSplitter(pos, d->s->indexOf(this));
+}
+
+/*!
+ Returns the closest legal position to \a pos of the splitter
+ handle. The positions are measured from the left or top edge of
+ the splitter, even for right-to-left languages.
+
+ \sa QSplitter::closestLegalPosition(), moveSplitter()
+*/
+
+int QSplitterHandle::closestLegalPosition(int pos)
+{
+ Q_D(QSplitterHandle);
+ QSplitter *s = d->s;
+ if (s->isRightToLeft() && d->orient == Qt::Horizontal) {
+ int w = s->contentsRect().width();
+ return w - s->closestLegalPosition(w - pos, s->indexOf(this));
+ }
+ return s->closestLegalPosition(pos, s->indexOf(this));
+}
+
+/*!
+ \reimp
+*/
+QSize QSplitterHandle::sizeHint() const
+{
+ Q_D(const QSplitterHandle);
+ int hw = d->s->handleWidth();
+ QStyleOption opt(0);
+ opt.init(d->s);
+ opt.state = QStyle::State_None;
+ return parentWidget()->style()->sizeFromContents(QStyle::CT_Splitter, &opt, QSize(hw, hw), d->s)
+ .expandedTo(QApplication::globalStrut());
+}
+
+/*!
+ \reimp
+*/
+bool QSplitterHandle::event(QEvent *event)
+{
+ Q_D(QSplitterHandle);
+ switch(event->type()) {
+ case QEvent::HoverEnter:
+ d->hover = true;
+ update();
+ break;
+ case QEvent::HoverLeave:
+ d->hover = false;
+ update();
+ break;
+ default:
+ break;
+ }
+ return QWidget::event(event);
+}
+
+/*!
+ \reimp
+*/
+void QSplitterHandle::mouseMoveEvent(QMouseEvent *e)
+{
+ Q_D(QSplitterHandle);
+ if (!(e->buttons() & Qt::LeftButton))
+ return;
+ int pos = d->pick(parentWidget()->mapFromGlobal(e->globalPos()))
+ - d->mouseOffset;
+ if (opaqueResize()) {
+ moveSplitter(pos);
+ } else {
+ d->s->setRubberBand(closestLegalPosition(pos));
+ }
+}
+
+/*!
+ \reimp
+*/
+void QSplitterHandle::mousePressEvent(QMouseEvent *e)
+{
+ Q_D(QSplitterHandle);
+ if (e->button() == Qt::LeftButton) {
+ d->mouseOffset = d->pick(e->pos());
+ d->pressed = true;
+ update();
+ }
+}
+
+/*!
+ \reimp
+*/
+void QSplitterHandle::mouseReleaseEvent(QMouseEvent *e)
+{
+ Q_D(QSplitterHandle);
+ if (!opaqueResize() && e->button() == Qt::LeftButton) {
+ int pos = d->pick(parentWidget()->mapFromGlobal(e->globalPos()))
+ - d->mouseOffset;
+ d->s->setRubberBand(-1);
+ moveSplitter(pos);
+ }
+ if (e->button() == Qt::LeftButton) {
+ d->pressed = false;
+ update();
+ }
+}
+
+/*!
+ \reimp
+*/
+void QSplitterHandle::paintEvent(QPaintEvent *)
+{
+ Q_D(QSplitterHandle);
+ QPainter p(this);
+ QStyleOption opt(0);
+ opt.rect = rect();
+ opt.palette = palette();
+ if (orientation() == Qt::Horizontal)
+ opt.state = QStyle::State_Horizontal;
+ else
+ opt.state = QStyle::State_None;
+ if (d->hover)
+ opt.state |= QStyle::State_MouseOver;
+ if (d->pressed)
+ opt.state |= QStyle::State_Sunken;
+ if (isEnabled())
+ opt.state |= QStyle::State_Enabled;
+ parentWidget()->style()->drawControl(QStyle::CE_Splitter, &opt, &p, d->s);
+}
+
+
+int QSplitterLayoutStruct::getWidgetSize(Qt::Orientation orient)
+{
+ if (sizer == -1) {
+ QSize s = widget->sizeHint();
+ const int presizer = pick(s, orient);
+ const int realsize = pick(widget->size(), orient);
+ if (!s.isValid() || (widget->testAttribute(Qt::WA_Resized) && (realsize > presizer))) {
+ sizer = pick(widget->size(), orient);
+ } else {
+ sizer = presizer;
+ }
+ QSizePolicy p = widget->sizePolicy();
+ int sf = (orient == Qt::Horizontal) ? p.horizontalStretch() : p.verticalStretch();
+ if (sf > 1)
+ sizer *= sf;
+ }
+ return sizer;
+}
+
+int QSplitterLayoutStruct::getHandleSize(Qt::Orientation orient)
+{
+ return pick(handle->sizeHint(), orient);
+}
+
+void QSplitterPrivate::init()
+{
+ Q_Q(QSplitter);
+ QSizePolicy sp(QSizePolicy::Expanding, QSizePolicy::Preferred);
+ if (orient == Qt::Vertical)
+ sp.transpose();
+ q->setSizePolicy(sp);
+ q->setAttribute(Qt::WA_WState_OwnSizePolicy, false);
+}
+
+void QSplitterPrivate::recalc(bool update)
+{
+ Q_Q(QSplitter);
+ int n = list.count();
+ /*
+ Splitter handles before the first visible widget or right
+ before a hidden widget must be hidden.
+ */
+ bool first = true;
+ for (int i = 0; i < n ; ++i) {
+ QSplitterLayoutStruct *s = list.at(i);
+ s->handle->setHidden(first || s->widget->isHidden());
+ if (!s->widget->isHidden())
+ first = false;
+ }
+
+ int fi = 2 * q->frameWidth();
+ int maxl = fi;
+ int minl = fi;
+ int maxt = QWIDGETSIZE_MAX;
+ int mint = fi;
+ /*
+ calculate min/max sizes for the whole splitter
+ */
+ bool empty = true;
+ for (int j = 0; j < n; j++) {
+ QSplitterLayoutStruct *s = list.at(j);
+
+ if (!s->widget->isHidden()) {
+ empty = false;
+ if (!s->handle->isHidden()) {
+ minl += s->getHandleSize(orient);
+ maxl += s->getHandleSize(orient);
+ }
+
+ QSize minS = qSmartMinSize(s->widget);
+ minl += pick(minS);
+ maxl += pick(s->widget->maximumSize());
+ mint = qMax(mint, trans(minS));
+ int tm = trans(s->widget->maximumSize());
+ if (tm > 0)
+ maxt = qMin(maxt, tm);
+ }
+ }
+
+ if (empty) {
+ if (qobject_cast<QSplitter *>(parent)) {
+ // nested splitters; be nice
+ maxl = maxt = 0;
+ } else {
+ // QSplitter with no children yet
+ maxl = QWIDGETSIZE_MAX;
+ }
+ } else {
+ maxl = qMin<int>(maxl, QWIDGETSIZE_MAX);
+ }
+ if (maxt < mint)
+ maxt = mint;
+
+ if (update) {
+ if (orient == Qt::Horizontal) {
+ q->setMaximumSize(maxl, maxt);
+ if (q->isWindow())
+ q->setMinimumSize(minl,mint);
+ } else {
+ q->setMaximumSize(maxt, maxl);
+ if (q->isWindow())
+ q->setMinimumSize(mint,minl);
+ }
+ doResize();
+ q->updateGeometry();
+ } else {
+ firstShow = true;
+ }
+}
+
+void QSplitterPrivate::doResize()
+{
+ Q_Q(QSplitter);
+ QRect r = q->contentsRect();
+ int n = list.count();
+ QVector<QLayoutStruct> a(n*2);
+ int i;
+
+ bool noStretchFactorsSet = true;
+ for (i = 0; i < n; ++i) {
+ QSizePolicy p = list.at(i)->widget->sizePolicy();
+ int sf = orient == Qt::Horizontal ? p.horizontalStretch() : p.verticalStretch();
+ if (sf != 0) {
+ noStretchFactorsSet = false;
+ break;
+ }
+ }
+
+ int j=0;
+ for (i = 0; i < n; ++i) {
+ QSplitterLayoutStruct *s = list.at(i);
+#ifdef QSPLITTER_DEBUG
+ qDebug("widget %d hidden: %d collapsed: %d handle hidden: %d", i, s->widget->isHidden(),
+ s->collapsed, s->handle->isHidden());
+#endif
+
+ a[j].init();
+ if (s->handle->isHidden()) {
+ a[j].maximumSize = 0;
+ } else {
+ a[j].sizeHint = a[j].minimumSize = a[j].maximumSize = s->getHandleSize(orient);
+ a[j].empty = false;
+ }
+ ++j;
+
+ a[j].init();
+ if (s->widget->isHidden() || s->collapsed) {
+ a[j].maximumSize = 0;
+ } else {
+ a[j].minimumSize = pick(qSmartMinSize(s->widget));
+ a[j].maximumSize = pick(s->widget->maximumSize());
+ a[j].empty = false;
+
+ bool stretch = noStretchFactorsSet;
+ if (!stretch) {
+ QSizePolicy p = s->widget->sizePolicy();
+ int sf = orient == Qt::Horizontal ? p.horizontalStretch() : p.verticalStretch();
+ stretch = (sf != 0);
+ }
+ if (stretch) {
+ a[j].stretch = s->getWidgetSize(orient);
+ a[j].sizeHint = a[j].minimumSize;
+ a[j].expansive = true;
+ } else {
+ a[j].sizeHint = qMax(s->getWidgetSize(orient), a[j].minimumSize);
+ }
+ }
+ ++j;
+ }
+
+ qGeomCalc(a, 0, n*2, pick(r.topLeft()), pick(r.size()), 0);
+
+#ifdef QSPLITTER_DEBUG
+ for (i = 0; i < n*2; ++i) {
+ qDebug("%*s%d: stretch %d, sh %d, minS %d, maxS %d, exp %d, emp %d -> %d, %d",
+ i, "", i,
+ a[i].stretch,
+ a[i].sizeHint,
+ a[i].minimumSize,
+ a[i].maximumSize,
+ a[i].expansive,
+ a[i].empty,
+ a[i].pos,
+ a[i].size);
+ }
+#endif
+
+ for (i = 0; i < n; ++i) {
+ QSplitterLayoutStruct *s = list.at(i);
+ setGeo(s, a[i*2+1].pos, a[i*2+1].size, false);
+ }
+}
+
+void QSplitterPrivate::storeSizes()
+{
+ for (int i = 0; i < list.size(); ++i) {
+ QSplitterLayoutStruct *sls = list.at(i);
+ sls->sizer = pick(sls->rect.size());
+ }
+}
+
+void QSplitterPrivate::addContribution(int index, int *min, int *max, bool mayCollapse) const
+{
+ QSplitterLayoutStruct *s = list.at(index);
+ if (!s->widget->isHidden()) {
+ if (!s->handle->isHidden()) {
+ *min += s->getHandleSize(orient);
+ *max += s->getHandleSize(orient);
+ }
+ if (mayCollapse || !s->collapsed)
+ *min += pick(qSmartMinSize(s->widget));
+
+ *max += pick(s->widget->maximumSize());
+ }
+}
+
+int QSplitterPrivate::findWidgetJustBeforeOrJustAfter(int index, int delta, int &collapsibleSize) const
+{
+ if (delta < 0)
+ index += delta;
+ do {
+ QWidget *w = list.at(index)->widget;
+ if (!w->isHidden()) {
+ if (collapsible(list.at(index)))
+ collapsibleSize = pick(qSmartMinSize(w));
+ return index;
+ }
+ index += delta;
+ } while (index >= 0 && index < list.count());
+
+ return -1;
+}
+
+/*
+ For the splitter handle with index \a index, \a min and \a max give the range without collapsing any widgets,
+ and \a farMin and farMax give the range with collapsing included.
+*/
+void QSplitterPrivate::getRange(int index, int *farMin, int *min, int *max, int *farMax) const
+{
+ Q_Q(const QSplitter);
+ int n = list.count();
+ if (index <= 0 || index >= n)
+ return;
+
+ int collapsibleSizeBefore = 0;
+ int idJustBefore = findWidgetJustBeforeOrJustAfter(index, -1, collapsibleSizeBefore);
+
+ int collapsibleSizeAfter = 0;
+ int idJustAfter = findWidgetJustBeforeOrJustAfter(index, +1, collapsibleSizeAfter);
+
+ int minBefore = 0;
+ int minAfter = 0;
+ int maxBefore = 0;
+ int maxAfter = 0;
+ int i;
+
+ for (i = 0; i < index; ++i)
+ addContribution(i, &minBefore, &maxBefore, i == idJustBefore);
+ for (i = index; i < n; ++i)
+ addContribution(i, &minAfter, &maxAfter, i == idJustAfter);
+
+ QRect r = q->contentsRect();
+ int farMinVal;
+ int minVal;
+ int maxVal;
+ int farMaxVal;
+
+ int smartMinBefore = qMax(minBefore, pick(r.size()) - maxAfter);
+ int smartMaxBefore = qMin(maxBefore, pick(r.size()) - minAfter);
+
+ minVal = pick(r.topLeft()) + smartMinBefore;
+ maxVal = pick(r.topLeft()) + smartMaxBefore;
+
+ farMinVal = minVal;
+ if (minBefore - collapsibleSizeBefore >= pick(r.size()) - maxAfter)
+ farMinVal -= collapsibleSizeBefore;
+ farMaxVal = maxVal;
+ if (pick(r.size()) - (minAfter - collapsibleSizeAfter) <= maxBefore)
+ farMaxVal += collapsibleSizeAfter;
+
+ if (farMin)
+ *farMin = farMinVal;
+ if (min)
+ *min = minVal;
+ if (max)
+ *max = maxVal;
+ if (farMax)
+ *farMax = farMaxVal;
+}
+
+int QSplitterPrivate::adjustPos(int pos, int index, int *farMin, int *min, int *max, int *farMax) const
+{
+ const int Threshold = 40;
+
+ getRange(index, farMin, min, max, farMax);
+
+ if (pos >= *min) {
+ if (pos <= *max) {
+ return pos;
+ } else {
+ int delta = pos - *max;
+ int width = *farMax - *max;
+
+ if (delta > width / 2 && delta >= qMin(Threshold, width)) {
+ return *farMax;
+ } else {
+ return *max;
+ }
+ }
+ } else {
+ int delta = *min - pos;
+ int width = *min - *farMin;
+
+ if (delta > width / 2 && delta >= qMin(Threshold, width)) {
+ return *farMin;
+ } else {
+ return *min;
+ }
+ }
+}
+
+bool QSplitterPrivate::collapsible(QSplitterLayoutStruct *s) const
+{
+ if (s->collapsible != Default) {
+ return (bool)s->collapsible;
+ } else {
+ return childrenCollapsible;
+ }
+}
+
+void QSplitterPrivate::updateHandles()
+{
+ Q_Q(QSplitter);
+ recalc(q->isVisible());
+}
+
+void QSplitterPrivate::setSizes_helper(const QList<int> &sizes, bool clampNegativeSize)
+{
+ int j = 0;
+
+ for (int i = 0; i < list.size(); ++i) {
+ QSplitterLayoutStruct *s = list.at(i);
+
+ s->collapsed = false;
+ s->sizer = sizes.value(j++);
+ if (clampNegativeSize && s->sizer < 0)
+ s->sizer = 0;
+ int smartMinSize = pick(qSmartMinSize(s->widget));
+
+ // Make sure that we reset the collapsed state.
+ if (s->sizer == 0) {
+ if (collapsible(s) && smartMinSize > 0) {
+ s->collapsed = true;
+ } else {
+ s->sizer = smartMinSize;
+ }
+ } else {
+ if (s->sizer < smartMinSize)
+ s->sizer = smartMinSize;
+ }
+ }
+ doResize();
+}
+
+void QSplitterPrivate::setGeo(QSplitterLayoutStruct *sls, int p, int s, bool allowCollapse)
+{
+ Q_Q(QSplitter);
+ QWidget *w = sls->widget;
+ QRect r;
+ QRect contents = q->contentsRect();
+ if (orient == Qt::Horizontal) {
+ r.setRect(p, contents.y(), s, contents.height());
+ } else {
+ r.setRect(contents.x(), p, contents.width(), s);
+ }
+ sls->rect = r;
+
+ int minSize = pick(qSmartMinSize(w));
+
+ if (orient == Qt::Horizontal && q->isRightToLeft())
+ r.moveRight(contents.width() - r.left());
+
+ if (allowCollapse)
+ sls->collapsed = s <= 0 && minSize > 0 && !w->isHidden();
+
+ // Hide the child widget, but without calling hide() so that
+ // the splitter handle is still shown.
+ if (sls->collapsed)
+ r.moveTopLeft(QPoint(-r.width()-1, -r.height()-1));
+
+ w->setGeometry(r);
+
+ if (!sls->handle->isHidden()) {
+ QSplitterHandle *h = sls->handle;
+ QSize hs = h->sizeHint();
+ int left, top, right, bottom;
+ h->getContentsMargins(&left, &top, &right, &bottom);
+ if (orient==Qt::Horizontal) {
+ if (q->isRightToLeft())
+ p = contents.width() - p + hs.width();
+ h->setGeometry(p-hs.width() - left, contents.y(), hs.width() + left + right, contents.height());
+ } else {
+ h->setGeometry(contents.x(), p-hs.height() - top, contents.width(), hs.height() + top + bottom);
+ }
+ }
+}
+
+void QSplitterPrivate::doMove(bool backwards, int hPos, int index, int delta, bool mayCollapse,
+ int *positions, int *widths)
+{
+ if (index < 0 || index >= list.count())
+ return;
+
+#ifdef QSPLITTER_DEBUG
+ qDebug() << "QSplitterPrivate::doMove" << backwards << hPos << index << delta << mayCollapse;
+#endif
+
+ QSplitterLayoutStruct *s = list.at(index);
+ QWidget *w = s->widget;
+
+ int nextId = backwards ? index - delta : index + delta;
+
+ if (w->isHidden()) {
+ doMove(backwards, hPos, nextId, delta, collapsible(nextId), positions, widths);
+ } else {
+ int hs =s->handle->isHidden() ? 0 : s->getHandleSize(orient);
+
+ int ws = backwards ? hPos - pick(s->rect.topLeft())
+ : pick(s->rect.bottomRight()) - hPos -hs + 1;
+ if (ws > 0 || (!s->collapsed && !mayCollapse)) {
+ ws = qMin(ws, pick(w->maximumSize()));
+ ws = qMax(ws, pick(qSmartMinSize(w)));
+ } else {
+ ws = 0;
+ }
+ positions[index] = backwards ? hPos - ws : hPos + hs;
+ widths[index] = ws;
+ doMove(backwards, backwards ? hPos - ws - hs : hPos + hs + ws, nextId, delta,
+ collapsible(nextId), positions, widths);
+ }
+
+}
+
+QSplitterLayoutStruct *QSplitterPrivate::findWidget(QWidget *w) const
+{
+ for (int i = 0; i < list.size(); ++i) {
+ if (list.at(i)->widget == w)
+ return list.at(i);
+ }
+ return 0;
+}
+
+#ifdef QT3_SUPPORT
+static void setStretch(QWidget *w, int sf)
+{
+ QSizePolicy sp = w->sizePolicy();
+ sp.setHorizontalStretch(sf);
+ sp.setVerticalStretch(sf);
+ w->setSizePolicy(sp);
+}
+
+static int getStretch(const QWidget *w)
+{
+ QSizePolicy sp = w->sizePolicy();
+ return qMax(sp.horizontalStretch(), sp.verticalStretch());
+}
+
+void QSplitter::setResizeMode(QWidget *w, ResizeMode mode)
+{
+ /*
+ Internal comment:
+
+ This function tries to simulate the Qt 3.x ResizeMode
+ behavior using QSizePolicy stretch factors. This isn't easy,
+ because the default \l ResizeMode was \l Stretch, not \l
+ KeepSize, whereas the default stetch factor is 0.
+
+ So what we do is this: When the user calls setResizeMode()
+ the first time, we iterate through all the child widgets and
+ set their stretch factors to 1. Later on, if children are
+ added (using addWidget()), their stretch factors are also set
+ to 1.
+
+ There is just one problem left: Often, setResizeMode() is
+ called \e{before} addWidget(), because addWidget() is called
+ from the event loop. In that case, we use a special value,
+ 243, instead of 0 to prevent 0 from being overwritten with 1
+ in addWidget(). This is a wicked hack, but fortunately it
+ only occurs as a result of calling a \c QT3_SUPPORT function.
+ */
+
+ Q_D(QSplitter);
+ bool metWidget = false;
+ if (!d->compatMode) {
+ d->compatMode = true;
+ for (int i = 0; i < d->list.size(); ++i) {
+ QSplitterLayoutStruct *s = d->list.at(i);
+ if (s->widget == w)
+ metWidget = true;
+ if (getStretch(s->widget) == 0)
+ setStretch(s->widget, 1);
+ }
+ }
+ int sf;
+ if (mode == KeepSize)
+ sf = metWidget ? 0 : 243;
+ else
+ sf = 1;
+ setStretch(w, sf);
+}
+
+/*!
+ Use one of the constructors that doesn't take the \a name
+ argument and then use setObjectName() instead.
+*/
+QSplitter::QSplitter(QWidget *parent, const char *name)
+ : QFrame(*new QSplitterPrivate, parent)
+{
+ Q_D(QSplitter);
+ setObjectName(QString::fromAscii(name));
+ d->orient = Qt::Horizontal;
+ d->init();
+}
+
+
+/*!
+ Use one of the constructors that don't take the \a name argument
+ and then use setObjectName() instead.
+*/
+QSplitter::QSplitter(Qt::Orientation orientation, QWidget *parent, const char *name)
+ : QFrame(*new QSplitterPrivate, parent)
+{
+ Q_D(QSplitter);
+ setObjectName(QString::fromAscii(name));
+ d->orient = orientation;
+ d->init();
+}
+#endif
+
+/*!
+ \internal
+*/
+void QSplitterPrivate::insertWidget_helper(int index, QWidget *widget, bool show)
+{
+ Q_Q(QSplitter);
+ QBoolBlocker b(blockChildAdd);
+ bool needShow = show && q->isVisible() &&
+ !(widget->isHidden() && widget->testAttribute(Qt::WA_WState_ExplicitShowHide));
+ if (widget->parentWidget() != q)
+ widget->setParent(q);
+ if (needShow)
+ widget->show();
+ insertWidget(index, widget);
+ recalc(q->isVisible());
+}
+
+/*
+ Inserts the widget \a w at position \a index in the splitter's list of widgets.
+
+ If \a w is already in the splitter, it will be moved to the new position.
+*/
+
+QSplitterLayoutStruct *QSplitterPrivate::insertWidget(int index, QWidget *w)
+{
+ Q_Q(QSplitter);
+ QSplitterLayoutStruct *sls = 0;
+ int i;
+ int last = list.count();
+ for (i = 0; i < list.size(); ++i) {
+ QSplitterLayoutStruct *s = list.at(i);
+ if (s->widget == w) {
+ sls = s;
+ --last;
+ break;
+ }
+ }
+ if (index < 0 || index > last)
+ index = last;
+
+ if (sls) {
+ list.move(i,index);
+ } else {
+ QSplitterHandle *newHandle = 0;
+ sls = new QSplitterLayoutStruct;
+ QString tmp = QLatin1String("qt_splithandle_");
+ tmp += w->objectName();
+ newHandle = q->createHandle();
+ newHandle->setObjectName(tmp);
+ sls->handle = newHandle;
+ sls->widget = w;
+ w->lower();
+ list.insert(index,sls);
+
+ if (newHandle && q->isVisible())
+ newHandle->show(); // will trigger sending of post events
+
+#ifdef QT3_SUPPORT
+ if (compatMode) {
+ int sf = getStretch(sls->widget);
+ if (sf == 243)
+ setStretch(sls->widget, 0);
+ else if (sf == 0)
+ setStretch(sls->widget, 1);
+ }
+#endif
+ }
+ return sls;
+}
+
+/*!
+ \class QSplitter
+ \brief The QSplitter class implements a splitter widget.
+
+ \ingroup organizers
+
+
+ A splitter lets the user control the size of child widgets by dragging the
+ boundary between the children. Any number of widgets may be controlled by a
+ single splitter. The typical use of a QSplitter is to create several
+ widgets and add them using insertWidget() or addWidget().
+
+ The following example will show a QListView, QTreeView, and
+ QTextEdit side by side, with two splitter handles:
+
+ \snippet doc/src/snippets/splitter/splitter.cpp 0
+
+ If a widget is already inside a QSplitter when insertWidget() or
+ addWidget() is called, it will move to the new position. This can be used
+ to reorder widgets in the splitter later. You can use indexOf(),
+ widget(), and count() to get access to the widgets inside the splitter.
+
+ A default QSplitter lays out its children horizontally (side by side); you
+ can use setOrientation(Qt::Vertical) to lay its
+ children out vertically.
+
+ By default, all widgets can be as large or as small as the user
+ wishes, between the \l minimumSizeHint() (or \l minimumSize())
+ and \l maximumSize() of the widgets.
+
+ QSplitter resizes its children dynamically by default. If you
+ would rather have QSplitter resize the children only at the end of
+ a resize operation, call setOpaqueResize(false).
+
+ The initial distribution of size between the widgets is determined by
+ multiplying the initial size with the stretch factor.
+ You can also use setSizes() to set the sizes
+ of all the widgets. The function sizes() returns the sizes set by the user.
+ Alternatively, you can save and restore the sizes of the widgets from a
+ QByteArray using saveState() and restoreState() respectively.
+
+ When you hide() a child its space will be distributed among the
+ other children. It will be reinstated when you show() it again.
+
+ \sa QSplitterHandle, QHBoxLayout, QVBoxLayout, QTabWidget
+*/
+
+
+/*!
+ Constructs a horizontal splitter with the \a parent
+ arguments is passed on to the QFrame constructor.
+
+ \sa setOrientation()
+*/
+QSplitter::QSplitter(QWidget *parent)
+ : QFrame(*new QSplitterPrivate, parent)
+{
+ Q_D(QSplitter);
+ d->orient = Qt::Horizontal;
+ d->init();
+}
+
+
+/*!
+ Constructs a splitter with the given \a orientation and \a parent.
+
+ \sa setOrientation()
+*/
+QSplitter::QSplitter(Qt::Orientation orientation, QWidget *parent)
+ : QFrame(*new QSplitterPrivate, parent)
+{
+ Q_D(QSplitter);
+ d->orient = orientation;
+ d->init();
+}
+
+
+/*!
+ Destroys the splitter. All children are deleted.
+*/
+
+QSplitter::~QSplitter()
+{
+ Q_D(QSplitter);
+ delete d->rubberBand;
+ while (!d->list.isEmpty())
+ delete d->list.takeFirst();
+}
+
+/*!
+ Updates the splitter's state. You should not need to call this
+ function.
+*/
+void QSplitter::refresh()
+{
+ Q_D(QSplitter);
+ d->recalc(true);
+}
+
+/*!
+ \property QSplitter::orientation
+ \brief the orientation of the splitter
+
+ By default the orientation is horizontal (i.e., the widgets are
+ laid out side by side). The possible orientations are
+ Qt::Horizontal and Qt::Vertical.
+
+ \sa QSplitterHandle::orientation()
+*/
+
+void QSplitter::setOrientation(Qt::Orientation orientation)
+{
+ Q_D(QSplitter);
+ if (d->orient == orientation)
+ return;
+
+ if (!testAttribute(Qt::WA_WState_OwnSizePolicy)) {
+ QSizePolicy sp = sizePolicy();
+ sp.transpose();
+ setSizePolicy(sp);
+ setAttribute(Qt::WA_WState_OwnSizePolicy, false);
+ }
+
+ d->orient = orientation;
+
+ for (int i = 0; i < d->list.size(); ++i) {
+ QSplitterLayoutStruct *s = d->list.at(i);
+ s->handle->setOrientation(orientation);
+ }
+ d->recalc(isVisible());
+}
+
+Qt::Orientation QSplitter::orientation() const
+{
+ Q_D(const QSplitter);
+ return d->orient;
+}
+
+/*!
+ \property QSplitter::childrenCollapsible
+ \brief whether child widgets can be resized down to size 0 by the user
+
+ By default, children are collapsible. It is possible to enable
+ and disable the collapsing of individual children using
+ setCollapsible().
+
+ \sa setCollapsible()
+*/
+
+void QSplitter::setChildrenCollapsible(bool collapse)
+{
+ Q_D(QSplitter);
+ d->childrenCollapsible = collapse;
+}
+
+bool QSplitter::childrenCollapsible() const
+{
+ Q_D(const QSplitter);
+ return d->childrenCollapsible;
+}
+
+/*!
+ Sets whether the child widget at index \a index is collapsible to \a collapse.
+
+ By default, children are collapsible, meaning that the user can
+ resize them down to size 0, even if they have a non-zero
+ minimumSize() or minimumSizeHint(). This behavior can be changed
+ on a per-widget basis by calling this function, or globally for
+ all the widgets in the splitter by setting the \l
+ childrenCollapsible property.
+
+ \sa childrenCollapsible
+*/
+
+void QSplitter::setCollapsible(int index, bool collapse)
+{
+ Q_D(QSplitter);
+
+ if (index < 0 || index >= d->list.size()) {
+ qWarning("QSplitter::setCollapsible: Index %d out of range", index);
+ return;
+ }
+ d->list.at(index)->collapsible = collapse ? 1 : 0;
+}
+
+/*!
+ Returns true if the widget at \a index is collapsible, otherwise returns false
+*/
+bool QSplitter::isCollapsible(int index) const
+{
+ Q_D(const QSplitter);
+ if (index < 0 || index >= d->list.size()) {
+ qWarning("QSplitter::isCollapsible: Index %d out of range", index);
+ return false;
+ }
+ return d->list.at(index)->collapsible;
+}
+
+/*!
+ \reimp
+*/
+void QSplitter::resizeEvent(QResizeEvent *)
+{
+ Q_D(QSplitter);
+ d->doResize();
+}
+
+/*!
+ Adds the given \a widget to the splitter's layout after all the other
+ items.
+
+ If \a widget is already in the splitter, it will be moved to the new position.
+
+ \sa insertWidget() widget() indexOf()
+*/
+void QSplitter::addWidget(QWidget *widget)
+{
+ Q_D(QSplitter);
+ insertWidget(d->list.count(), widget);
+}
+
+/*!
+ Inserts the \a widget specified into the splitter's layout at the
+ given \a index.
+
+ If \a widget is already in the splitter, it will be moved to the new position.
+
+ if \a index is an invalid index, then the widget will be inserted at the end.
+
+ \sa addWidget() indexOf() widget()
+*/
+void QSplitter::insertWidget(int index, QWidget *widget)
+{
+ Q_D(QSplitter);
+ d->insertWidget_helper(index, widget, true);
+}
+
+/*!
+ \fn int QSplitter::indexOf(QWidget *widget) const
+
+ Returns the index in the splitter's layout of the specified \a widget. This
+ also works for handles.
+
+ Handles are numbered from 0. There are as many handles as there
+ are child widgets, but the handle at position 0 is always hidden.
+
+
+ \sa count(), widget()
+*/
+int QSplitter::indexOf(QWidget *w) const
+{
+ Q_D(const QSplitter);
+ for (int i = 0; i < d->list.size(); ++i) {
+ QSplitterLayoutStruct *s = d->list.at(i);
+ if (s->widget == w || s->handle == w)
+ return i;
+ }
+ return -1;
+}
+
+/*!
+ Returns a new splitter handle as a child widget of this splitter.
+ This function can be reimplemented in subclasses to provide support
+ for custom handles.
+
+ \sa handle(), indexOf()
+*/
+QSplitterHandle *QSplitter::createHandle()
+{
+ Q_D(QSplitter);
+ return new QSplitterHandle(d->orient, this);
+}
+
+/*!
+ Returns the handle to the left (or above) for the item in the
+ splitter's layout at the given \a index. The handle at index 0 is
+ always hidden.
+
+ For right-to-left languages such as Arabic and Hebrew, the layout
+ of horizontal splitters is reversed. The handle will be to the
+ right of the widget at \a index.
+
+ \sa count(), widget(), indexOf(), createHandle(), setHandleWidth()
+*/
+QSplitterHandle *QSplitter::handle(int index) const
+{
+ Q_D(const QSplitter);
+ if (index < 0 || index >= d->list.size())
+ return 0;
+ return d->list.at(index)->handle;
+}
+
+/*!
+ Returns the widget at the given \a index in the splitter's layout.
+
+ \sa count(), handle(), indexOf(), insertWidget()
+*/
+QWidget *QSplitter::widget(int index) const
+{
+ Q_D(const QSplitter);
+ if (index < 0 || index >= d->list.size())
+ return 0;
+ return d->list.at(index)->widget;
+}
+
+/*!
+ Returns the number of widgets contained in the splitter's layout.
+
+ \sa widget(), handle()
+*/
+int QSplitter::count() const
+{
+ Q_D(const QSplitter);
+ return d->list.count();
+}
+
+/*!
+ \reimp
+
+ Tells the splitter that the child widget described by \a c has been
+ inserted or removed.
+
+ This method is also used to handle the situation where a widget is created
+ with the splitter as a parent but not explicitly added with insertWidget()
+ or addWidget(). This is for compatibility and not the recommended way of
+ putting widgets into a splitter in new code. Please use insertWidget() or
+ addWidget() in new code.
+
+ \sa addWidget() insertWidget()
+*/
+
+void QSplitter::childEvent(QChildEvent *c)
+{
+ Q_D(QSplitter);
+ if (!c->child()->isWidgetType())
+ return;
+ QWidget *w = static_cast<QWidget*>(c->child());
+
+ if (c->added() && !d->blockChildAdd && !w->isWindow() && !d->findWidget(w)) {
+ d->insertWidget_helper(d->list.count(), w, false);
+ } else if (c->polished() && !d->blockChildAdd) {
+ if (isVisible() && !(w->isHidden() && w->testAttribute(Qt::WA_WState_ExplicitShowHide)))
+ w->show();
+ } else if (c->type() == QEvent::ChildRemoved) {
+ for (int i = 0; i < d->list.size(); ++i) {
+ QSplitterLayoutStruct *s = d->list.at(i);
+ if (s->widget == w) {
+ d->list.removeAt(i);
+ delete s;
+ d->recalc(isVisible());
+ return;
+ }
+ }
+ }
+}
+
+
+/*!
+ Displays a rubber band at position \a pos. If \a pos is negative, the
+ rubber band is removed.
+*/
+
+void QSplitter::setRubberBand(int pos)
+{
+ Q_D(QSplitter);
+ if (pos < 0) {
+ if (d->rubberBand)
+ QTimer::singleShot(0, d->rubberBand, SLOT(deleteLater()));
+ return;
+ }
+ QRect r = contentsRect();
+ const int rBord = 3; // customizable?
+ int hw = handleWidth();
+ if (!d->rubberBand) {
+ d->rubberBand = new QRubberBand(QRubberBand::Line);
+ // For accessibility to identify this special widget.
+ d->rubberBand->setObjectName(QLatin1String("qt_rubberband"));
+ }
+ if (d->orient == Qt::Horizontal)
+ d->rubberBand->setGeometry(QRect(QPoint(pos + hw / 2 - rBord, r.y()),
+ QSize(2 * rBord, r.height())).translated(mapToGlobal(QPoint())));
+ else
+ d->rubberBand->setGeometry(QRect(QPoint(r.x(), pos + hw / 2 - rBord),
+ QSize(r.width(), 2 * rBord)).translated(mapToGlobal(QPoint())));
+ if (!d->rubberBand->isVisible())
+ d->rubberBand->show();
+}
+
+/*!
+ \reimp
+*/
+
+bool QSplitter::event(QEvent *e)
+{
+ Q_D(QSplitter);
+ switch (e->type()) {
+ case QEvent::Hide:
+ // Reset firstShow to false here since things can be done to the splitter in between
+ if (!d->firstShow)
+ d->firstShow = true;
+ break;
+ case QEvent::Show:
+ if (!d->firstShow)
+ break;
+ d->firstShow = false;
+ // fall through
+ case QEvent::HideToParent:
+ case QEvent::ShowToParent:
+ case QEvent::LayoutRequest:
+#ifdef QT3_SUPPORT
+ case QEvent::LayoutHint:
+#endif
+ d->recalc(isVisible());
+ break;
+ default:
+ ;
+ }
+ return QWidget::event(e);
+}
+
+/*!
+ \fn QSplitter::splitterMoved(int pos, int index)
+
+ This signal is emitted when the splitter handle at a particular \a
+ index has been moved to position \a pos.
+
+ For right-to-left languages such as Arabic and Hebrew, the layout
+ of horizontal splitters is reversed. \a pos is then the
+ distance from the right edge of the widget.
+
+ \sa moveSplitter()
+*/
+
+/*!
+ Moves the left or top edge of the splitter handle at \a index as
+ close as possible to position \a pos, which is the distance from the
+ left or top edge of the widget.
+
+ For right-to-left languages such as Arabic and Hebrew, the layout
+ of horizontal splitters is reversed. \a pos is then the distance
+ from the right edge of the widget.
+
+ \sa splitterMoved(), closestLegalPosition(), getRange()
+*/
+void QSplitter::moveSplitter(int pos, int index)
+{
+ Q_D(QSplitter);
+ QSplitterLayoutStruct *s = d->list.at(index);
+ int farMin;
+ int min;
+ int max;
+ int farMax;
+
+#ifdef QSPLITTER_DEBUG
+ int debugp = pos;
+#endif
+
+ pos = d->adjustPos(pos, index, &farMin, &min, &max, &farMax);
+ int oldP = d->pick(s->rect.topLeft());
+#ifdef QSPLITTER_DEBUG
+ qDebug() << "QSplitter::moveSplitter" << debugp << index << "adjusted" << pos << "oldP" << oldP;
+#endif
+
+ QVarLengthArray<int, 32> poss(d->list.count());
+ QVarLengthArray<int, 32> ws(d->list.count());
+ bool upLeft;
+
+ d->doMove(false, pos, index, +1, (d->collapsible(s) && (pos > max)), poss.data(), ws.data());
+ d->doMove(true, pos, index - 1, +1, (d->collapsible(index - 1) && (pos < min)), poss.data(), ws.data());
+ upLeft = (pos < oldP);
+
+ int wid, delta, count = d->list.count();
+ if (upLeft) {
+ wid = 0;
+ delta = 1;
+ } else {
+ wid = count - 1;
+ delta = -1;
+ }
+ for (; wid >= 0 && wid < count; wid += delta) {
+ QSplitterLayoutStruct *sls = d->list.at( wid );
+ if (!sls->widget->isHidden())
+ d->setGeo(sls, poss[wid], ws[wid], true);
+ }
+ d->storeSizes();
+
+ emit splitterMoved(pos, index);
+}
+
+
+/*!
+ Returns the valid range of the splitter with index \a index in
+ *\a{min} and *\a{max} if \a min and \a max are not 0.
+*/
+
+void QSplitter::getRange(int index, int *min, int *max) const
+{
+ Q_D(const QSplitter);
+ d->getRange(index, min, 0, 0, max);
+}
+
+
+/*!
+ Returns the closest legal position to \a pos of the widget with index
+ \a index.
+
+ For right-to-left languages such as Arabic and Hebrew, the layout
+ of horizontal splitters is reversed. Positions are then measured
+ from the right edge of the widget.
+
+ \sa getRange()
+*/
+
+int QSplitter::closestLegalPosition(int pos, int index)
+{
+ Q_D(QSplitter);
+ int x, i, n, u;
+ return d->adjustPos(pos, index, &u, &n, &i, &x);
+}
+
+/*!
+ \property QSplitter::opaqueResize
+ \brief whether resizing is opaque
+
+ Opaque resizing is on by default.
+*/
+
+bool QSplitter::opaqueResize() const
+{
+ Q_D(const QSplitter);
+ return d->opaque;
+}
+
+
+void QSplitter::setOpaqueResize(bool on)
+{
+ Q_D(QSplitter);
+ d->opaque = on;
+}
+
+#ifdef QT3_SUPPORT
+/*!
+ \fn void QSplitter::moveToFirst(QWidget *widget)
+
+ Use insertWidget(0, \a widget) instead.
+*/
+
+
+/*!
+ \fn void QSplitter::moveToLast(QWidget *widget)
+
+ Use addWidget(\a widget) instead.
+*/
+
+/*!
+ \fn void QSplitter::setResizeMode(QWidget *widget, ResizeMode mode)
+
+ Use setStretchFactor() instead.
+
+ \oldcode
+ splitter->setResizeMode(firstChild, QSplitter::KeepSize);
+ splitter->setResizeMode(secondChild, QSplitter::Stretch);
+ \newcode
+ splitter->setStretchFactor(splitter->indexOf(firstChild), 0);
+ splitter->setStretchFactor(splitter->indexOf(secondChild), 1);
+ \endcode
+*/
+
+/*!
+ \enum QSplitter::ResizeMode
+ \compat
+
+ This enum describes the different resizing behaviors child
+ widgets can have:
+
+ \value Auto The widget will be resized according to the stretch factors set in its sizePolicy().
+ \value Stretch The widget will be resized when the splitter itself is resized.
+ \value KeepSize QSplitter will try to keep the widget's size unchanged.
+ \value FollowSizeHint QSplitter will resize the widget when the widget's size hint changes.
+
+ Use setStretchFactor() instead.
+*/
+
+/*!
+ \fn void QSplitter::setCollapsible(QWidget *widget, bool collapsible)
+
+ Use setCollapsible(indexOf(\a widget, \a collapsible)) instead.
+*/
+
+/*!
+ \fn void QSplitter::setMargin(int margin)
+ Sets the width of the margin around the contents of the widget to \a margin.
+
+ Use QWidget::setContentsMargins() instead.
+ \sa margin(), QWidget::setContentsMargins()
+*/
+
+/*!
+ \fn int QSplitter::margin() const
+ Returns the width of the margin around the contents of the widget.
+
+ Use QWidget::getContentsMargins() instead.
+ \sa setMargin(), QWidget::getContentsMargins()
+*/
+
+#endif
+
+/*!
+ \reimp
+*/
+QSize QSplitter::sizeHint() const
+{
+ Q_D(const QSplitter);
+ ensurePolished();
+ int l = 0;
+ int t = 0;
+ QObjectList childList = children();
+ for (int i = 0; i < childList.size(); ++i) {
+ if (QWidget *w = qobject_cast<QWidget *>(childList.at(i))) {
+ if (w->isHidden())
+ continue;
+ QSize s = w->sizeHint();
+ if (s.isValid()) {
+ l += d->pick(s);
+ t = qMax(t, d->trans(s));
+ }
+ }
+ }
+ return orientation() == Qt::Horizontal ? QSize(l, t) : QSize(t, l);
+}
+
+
+/*!
+ \reimp
+*/
+
+QSize QSplitter::minimumSizeHint() const
+{
+ Q_D(const QSplitter);
+ ensurePolished();
+ int l = 0;
+ int t = 0;
+
+ for (int i = 0; i < d->list.size(); ++i) {
+ QSplitterLayoutStruct *s = d->list.at(i);
+ if (!s || !s->widget)
+ continue;
+ if (s->widget->isHidden())
+ continue;
+ QSize widgetSize = qSmartMinSize(s->widget);
+ if (widgetSize.isValid()) {
+ l += d->pick(widgetSize);
+ t = qMax(t, d->trans(widgetSize));
+ }
+ if (!s->handle || s->handle->isHidden())
+ continue;
+ QSize splitterSize = s->handle->sizeHint();
+ if (splitterSize.isValid()) {
+ l += d->pick(splitterSize);
+ t = qMax(t, d->trans(splitterSize));
+ }
+ }
+ return orientation() == Qt::Horizontal ? QSize(l, t) : QSize(t, l);
+}
+
+
+/*!
+ Returns a list of the size parameters of all the widgets in this splitter.
+
+ If the splitter's orientation is horizontal, the list contains the
+ widgets width in pixels, from left to right; if the orientation is
+ vertical, the list contains the widgets height in pixels,
+ from top to bottom.
+
+ Giving the values to another splitter's setSizes() function will
+ produce a splitter with the same layout as this one.
+
+ Note that invisible widgets have a size of 0.
+
+ \sa setSizes()
+*/
+
+QList<int> QSplitter::sizes() const
+{
+ Q_D(const QSplitter);
+ ensurePolished();
+
+ QList<int> list;
+ for (int i = 0; i < d->list.size(); ++i) {
+ QSplitterLayoutStruct *s = d->list.at(i);
+ list.append(d->pick(s->rect.size()));
+ }
+ return list;
+}
+
+/*!
+ Sets the child widgets respective sizes to the values given in the \a list.
+
+ If the splitter is horizontal, the values set the widths of each
+ widget in pixels, from left to right. If the splitter is vertical, the
+ heights of each widget is set, from top to bottom.
+
+ Extra values in the \a list are ignored. If \a list contains too few
+ values, the result is undefined but the program will still be well-behaved.
+
+ The overall size of the splitter widget is not affected.
+ Instead, any additional/missing space is distributed amongst the
+ widgets according to the relative weight of the sizes.
+
+ If you specify a size of 0, the widget will be invisible. The size policies
+ of the widgets are preserved. That is, a value smaller then the minimal size
+ hint of the respective widget will be replaced by the value of the hint.
+
+ \sa sizes()
+*/
+
+void QSplitter::setSizes(const QList<int> &list)
+{
+ Q_D(QSplitter);
+ d->setSizes_helper(list, true);
+}
+
+/*!
+ \property QSplitter::handleWidth
+ \brief the width of the splitter handles
+
+ By default, this property contains a value that depends on the user's platform
+ and style preferences.
+*/
+
+int QSplitter::handleWidth() const
+{
+ Q_D(const QSplitter);
+ if (d->handleWidth > 0) {
+ return d->handleWidth;
+ } else {
+ return style()->pixelMetric(QStyle::PM_SplitterWidth, 0, this);
+ }
+}
+
+void QSplitter::setHandleWidth(int width)
+{
+ Q_D(QSplitter);
+ d->handleWidth = width;
+ d->updateHandles();
+}
+
+/*!
+ \reimp
+*/
+void QSplitter::changeEvent(QEvent *ev)
+{
+ Q_D(QSplitter);
+ if(ev->type() == QEvent::StyleChange)
+ d->updateHandles();
+ QFrame::changeEvent(ev);
+}
+
+static const qint32 SplitterMagic = 0xff;
+
+/*!
+ Saves the state of the splitter's layout.
+
+ Typically this is used in conjunction with QSettings to remember the size
+ for a future session. A version number is stored as part of the data.
+ Here is an example:
+
+ \snippet doc/src/snippets/splitter/splitter.cpp 1
+
+ \sa restoreState()
+*/
+QByteArray QSplitter::saveState() const
+{
+ Q_D(const QSplitter);
+ int version = 0;
+ QByteArray data;
+ QDataStream stream(&data, QIODevice::WriteOnly);
+
+ stream << qint32(SplitterMagic);
+ stream << qint32(version);
+ QList<int> list;
+ for (int i = 0; i < d->list.size(); ++i) {
+ QSplitterLayoutStruct *s = d->list.at(i);
+ list.append(s->sizer);
+ }
+ stream << list;
+ stream << childrenCollapsible();
+ stream << qint32(handleWidth());
+ stream << opaqueResize();
+ stream << qint32(orientation());
+ return data;
+}
+
+/*!
+ Restores the splitter's layout to the \a state specified.
+ Returns true if the state is restored; otherwise returns false.
+
+ Typically this is used in conjunction with QSettings to restore the size
+ from a past session. Here is an example:
+
+ Restore the splitters's state:
+
+ \snippet doc/src/snippets/splitter/splitter.cpp 2
+
+ A failure to restore the splitter's layout may result from either
+ invalid or out-of-date data in the supplied byte array.
+
+ \sa saveState()
+*/
+bool QSplitter::restoreState(const QByteArray &state)
+{
+ Q_D(QSplitter);
+ int version = 0;
+ QByteArray sd = state;
+ QDataStream stream(&sd, QIODevice::ReadOnly);
+ QList<int> list;
+ bool b;
+ qint32 i;
+ qint32 marker;
+ qint32 v;
+
+ stream >> marker;
+ stream >> v;
+ if (marker != SplitterMagic || v != version)
+ return false;
+
+ stream >> list;
+ d->setSizes_helper(list, false);
+
+ stream >> b;
+ setChildrenCollapsible(b);
+
+ stream >> i;
+ setHandleWidth(i);
+
+ stream >> b;
+ setOpaqueResize(b);
+
+ stream >> i;
+ setOrientation(Qt::Orientation(i));
+ d->doResize();
+
+ return true;
+}
+
+/*!
+ Updates the size policy of the widget at position \a index to
+ have a stretch factor of \a stretch.
+
+ \a stretch is not the effective stretch factor; the effective
+ stretch factor is calculated by taking the initial size of the
+ widget and multiplying it with \a stretch.
+
+ This function is provided for convenience. It is equivalent to
+
+ \snippet doc/src/snippets/code/src_gui_widgets_qsplitter.cpp 0
+
+ \sa setSizes(), widget()
+*/
+void QSplitter::setStretchFactor(int index, int stretch)
+{
+ Q_D(QSplitter);
+ if (index <= -1 || index >= d->list.count())
+ return;
+
+ QWidget *widget = d->list.at(index)->widget;
+ QSizePolicy sp = widget->sizePolicy();
+ sp.setHorizontalStretch(stretch);
+ sp.setVerticalStretch(stretch);
+ widget->setSizePolicy(sp);
+}
+
+
+//#ifdef QT3_SUPPORT
+#ifndef QT_NO_TEXTSTREAM
+/*!
+ \relates QSplitter
+ \obsolete
+
+ Use \a ts << \a{splitter}.saveState() instead.
+*/
+
+QTextStream& operator<<(QTextStream& ts, const QSplitter& splitter)
+{
+ ts << splitter.saveState() << endl;
+ return ts;
+}
+
+/*!
+ \relates QSplitter
+ \obsolete
+
+ Use \a ts >> \a{splitter}.restoreState() instead.
+*/
+
+QTextStream& operator>>(QTextStream& ts, QSplitter& splitter)
+{
+ QString line = ts.readLine();
+ line = line.simplified();
+ line.replace(QLatin1Char(' '), QString());
+ line = line.toUpper();
+
+ splitter.restoreState(line.toAscii());
+ return ts;
+}
+#endif // QT_NO_TEXTSTREAM
+//#endif // QT3_SUPPORT
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SPLITTER