qdockwidgetlayout.cpp

qt-x11-opensource-src-4.1.4.tar.gz源码

            ls.sizeHint = ls.minimumSize = ls.maximumSize = separator_extent;
        } else {
            const QSizePolicy &sp =
                info.item->widget()
                ? info.item->widget()->sizePolicy()
                : QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);

            if (info.is_dropped) {
                Q_ASSERT(relayout_type != QInternal::RelayoutNormal);
                Q_ASSERT(info.cur_size > 0);

                // item was just dropped into the layout
                ls.minimumSize = info.cur_size;
                ls.sizeHint = info.cur_size;
                ls.maximumSize = info.cur_size;
                // do not use stretch for dropped items... we want them in the
                // exact size we specify
                ls.stretch = 0;
            } else {
                ls.minimumSize = pick(orientation, info.item->minimumSize());
                ls.maximumSize = pick(orientation, info.item->maximumSize());

                if (canGrow(orientation, sp)) {
                    ls.sizeHint = ls.minimumSize;
                    ls.stretch = info.cur_size == -1
                                 ? pick(orientation, info.item->sizeHint())
                                 : info.cur_size;
                    ls.expansive = true;
                } else {
                    ls.sizeHint = info.cur_size == -1
                                  ? pick(orientation, info.item->sizeHint())
                                  : info.cur_size;
                }
            }

            // sanity checks
            ls.sizeHint = qMax(ls.sizeHint, ls.minimumSize);
            ls.minimumSize = qMin(ls.minimumSize, ls.maximumSize);

            VDEBUG("    dockwidget cur %4d min %4d max %4d, hint %4d stretch %4d "
                   "expansive %d empty %d",
                   info.cur_size, ls.minimumSize, ls.maximumSize, ls.sizeHint, ls.stretch, ls.expansive, ls.empty);
        }
    }

    qGeomCalc(a, 0, a.count(), 0, pick(orientation, rect.size()), 0);

    // DO IT
    VDEBUG("  final placement:");
    for (int i = 0; i < a.count(); ++i) {
	const QLayoutStruct &ls = a.at(i);
	QDockWidgetLayoutInfo &info = layout_info[i];

        if (ls.empty) {
            if (info.item->layout()) {
                // this is a hack, but we need to make sure that empty
                // nested layouts have a chance to hide unneeded
                // separators
                info.item->setGeometry(QRect());
            }
            continue;
        }

	if (info.is_sep) {
	    VDEBUG("    separator  cur %4d", ls.size);
	} else {
	    VDEBUG("    dockwidget cur %4d min %4d max %4d pos %4d",
		   ls.size, ls.minimumSize, ls.maximumSize, ls.pos);
	}


	if (relayout_type == QInternal::RelayoutDragging) {
	    // we are testing a layout, so don't actually change
	    // anything... but make sure that we update all the dummy
	    // items with the correct geometry
	    continue;
	}

	info.cur_pos = ls.pos;
	info.cur_size = ls.size;
	info.min_size = ls.minimumSize;
	info.max_size = ls.maximumSize;

        QRect vr = QStyle::visualRect(QApplication::layoutDirection(),
                                      rect, ((orientation == Qt::Horizontal)
                                             ? QRect(rect.x() + ls.pos, rect.y(), ls.size, rect.height())
                                             : QRect(rect.x(), rect.y() + ls.pos, rect.width(), ls.size)));
	info.item->setGeometry(vr);
    }

    VDEBUG("END");
}

/*! \reimp */
QSize QDockWidgetLayout::minimumSize() const
{
    if (!minSize.isValid()) {
        VDEBUG("QDockWidget::minimumSize");

        int size = 0, perp = 0;
        const int sep_extent =
            parentWidget()->style()->pixelMetric(QStyle::PM_DockWidgetSeparatorExtent);

        for (int it = 0; it < layout_info.count(); ++it) {
            const QDockWidgetLayoutInfo &info = layout_info.at(it);
            if (info.item->isEmpty())
                continue;
            int s, p;
            if (info.is_sep) {
                s = p = (info.item->widget()->isHidden()) ? 0 : sep_extent;
            } else {
                QSize sz = info.item->minimumSize();
                s = pick(orientation, sz);
                p = pick_perp(orientation, sz);
            }

            VDEBUG("  size %d perp %d", s, p);
            size += s;
            perp = qMax(perp, p);
        }

        VDEBUG("END: size %4d perp %4d", size, perp);

        minSize = (orientation == Qt::Horizontal) ? QSize(size, perp) : QSize(perp, size);
    }
    return minSize;
}

/*! \reimp */
QSize QDockWidgetLayout::maximumSize() const
{
    if (!maxSize.isValid()) {
        VDEBUG("QDockWidget::maximumSize");

        int size = 0, perp = QLAYOUTSIZE_MAX;
        const int sep_extent =
            parentWidget()->style()->pixelMetric(QStyle::PM_DockWidgetSeparatorExtent);

        for (int it = 0; it < layout_info.count(); ++it) {
            const QDockWidgetLayoutInfo &info = layout_info.at(it);
            if (info.item->isEmpty())
                continue;
            int s, p;
            if (info.is_sep) {
                p = QLAYOUTSIZE_MAX;
                s = (info.item->widget()->isHidden()) ? 0 : sep_extent;
            } else {
                QSize sz = info.item->maximumSize();
                s = pick(orientation, sz);
                p = pick_perp(orientation, sz);
            }

            VDEBUG("  size %d perp %d", s, p);
            if (s >= QLAYOUTSIZE_MAX) {
                size = QLAYOUTSIZE_MAX;
            } else if ((size + s) < QLAYOUTSIZE_MAX) {
                size += s;
            } else {
                size = QLAYOUTSIZE_MAX;
            }
            perp = qMin(perp, p);
        }

        if (size == 0) {
            // no visible items, use QLAYOUTSIZE_MAX instead of zero
            size = QLAYOUTSIZE_MAX;
        }

        VDEBUG("END: size %4d perp %4d", size, perp);

        maxSize = (orientation == Qt::Horizontal) ? QSize(size, perp) : QSize(perp, size);
    }
    return maxSize;
}

/*! \reimp */
QSize QDockWidgetLayout::sizeHint() const
{
    if (!szHint.isValid()) {
        VDEBUG("QDockWidget::sizeHint");

        int size = 0, perp = 0;
        const int sep_extent =
            parentWidget()->style()->pixelMetric(QStyle::PM_DockWidgetSeparatorExtent);

        for (int it = 0; it < layout_info.count(); ++it) {
            const QDockWidgetLayoutInfo &info = layout_info.at(it);
            if (info.item->isEmpty())
                continue;
            int s, p;
            if (info.is_sep) {
                s = p = (info.item->widget()->isHidden()) ? 0 : sep_extent;
            } else {
                QSize sz = info.item->sizeHint();
                s = pick(orientation, sz);
                p = pick_perp(orientation, sz);
            }

            VDEBUG("  size %d perp %d", s, p);
            size += s;
            perp = qMax(perp, p);
        }

        VDEBUG("END: size %4d perp %4d", size, perp);

        szHint = (orientation == Qt::Horizontal) ? QSize(size, perp) : QSize(perp, size);
    }
    return szHint;
}

void QDockWidgetLayout::invalidate()
{
    if (relayout_type != QInternal::RelayoutDragging) {
        QLayout::invalidate();
        minSize = maxSize = szHint = QSize();
    }
}

bool QDockWidgetLayout::isEmpty() const
{
    for (int i = 0; i < layout_info.count(); ++i) {
        const QDockWidgetLayoutInfo &info = layout_info.at(i);
        if (info.is_sep)
            continue;
        if (!info.item->isEmpty())
            return false;
    }
    return true;
}

void QDockWidgetLayout::setOrientation(Qt::Orientation o)
{
    orientation = o;
    invalidate();
}

/*!
 */
QDockWidgetLayoutInfo &QDockWidgetLayout::insert(int index, QLayoutItem *layoutitem)
{
    DEBUG("QDockWidgetLayout::insert: index %d, layoutitem '%s'",
          index < 0 ? layout_info.count() : index,
          ((layoutitem->widget() || layoutitem->layout())
           ? (layoutitem->layout()
              ? layoutitem->layout()->objectName().toLatin1().constData()
              : layoutitem->widget()->objectName().toLatin1().constData())
           : "dummy"));

    bool append = index < 0;
    if (!append) {
	int it = 0;
	int idx = 0;

	// skip to the specified index
	while (it < layout_info.count()) {
	    if (idx == index) {
		VDEBUG("found index %d at %d", index, it);
		break;
	    }

	    if (it + 1 == layout_info.count()) {
		++idx;
		++it; // ran of the end, force append
		break;
	    }

	    ++idx;
	    it += 2;
	}

	if (it == layout_info.count()) {
	    append = true;
	} else {
	    VDEBUG("inserting at %d (%d of %d)", it, idx, index);

	    // insert the dockwidget
	    VDEBUG("    inserting dockwidget at %d", it);
	    QDockWidgetLayoutInfo dockwidget_info(layoutitem);
	    int save_it = it;
	    layout_info.insert(it++, dockwidget_info);

	    // insert a separator
	    QLayoutItem *sep_item = 0;
            Q_ASSERT(!layout_info[it].is_sep);
            QDockWidgetSeparator *sep = new QDockWidgetSeparator(this, parentWidget());
            sep_item = new QWidgetItem(sep);

	    QDockWidgetLayoutInfo sep_info(sep_item);
	    sep_info.is_sep = 1;
	    VDEBUG("    inserting separator at %d", it);
	    layout_info.insert(it++, sep_info);

	    return layout_info[save_it];
	}
    }

    Q_ASSERT(append == true);

    // append the dockwidget
    if (!layout_info.isEmpty()) {
	Q_ASSERT(!layout_info.last().is_sep);

	// insert a separator before the dockwidget
	QLayoutItem *sep_item = 0;
        QDockWidgetSeparator *sep = new QDockWidgetSeparator(this, parentWidget());
        sep_item = new QWidgetItem(sep);

	QDockWidgetLayoutInfo sep_info(sep_item);
	sep_info.is_sep = 1;
	layout_info.append(sep_info);
    }

    QDockWidgetLayoutInfo dockwidget_info(layoutitem);
    layout_info.append(dockwidget_info);

    return layout_info.last();
}

void QDockWidgetLayout::dump()
{
    DEBUG("QDockWidgetLayout::dump");
    for (int i = 0; i < layout_info.count(); ++i) {
	const QDockWidgetLayoutInfo &info = layout_info.at(i);

	if (info.is_sep) {
	    DEBUG("  index %3d pos %4d size %4d SEPARATOR", i, info.cur_pos, info.cur_size);
	} else if (info.item->layout()) {
            DEBUG("  index %3d pos %4d size %4d %s", i, info.cur_pos, info.cur_size,
		  (info.item->layout()
                   ? info.item->layout()->objectName().toLatin1().constData()
                   : "dummy"));
            QDockWidgetLayout *l = qobject_cast<QDockWidgetLayout *>(info.item->layout());
            Q_ASSERT(l != 0);
            l->dump();
        } else {
            DEBUG("  index %3d pos %4d size %4d %s", i, info.cur_pos, info.cur_size,
		  (info.item->widget()
                   ? info.item->widget()->objectName().toLatin1().constData()
                   : "dummy"));
	}
    }
    DEBUG("END of dump");
}

void QDockWidgetLayout::saveLayoutInfo()
{
    Q_ASSERT(save_layout_info == 0);
    save_layout_info = new QList<QDockWidgetLayoutInfo>(layout_info);

    for (int i = 0; i < layout_info.count(); ++i) {
	const QDockWidgetLayoutInfo &info = layout_info.at(i);
        if (info.is_sep)
            continue;
        if (!info.item->layout())
            continue;

        QDockWidgetLayout *l = qobject_cast<QDockWidgetLayout *>(info.item->layout());
        Q_ASSERT(l != 0);
        l->saveLayoutInfo();
    }
}

void QDockWidgetLayout::resetLayoutInfo()
{
    Q_ASSERT(save_layout_info != 0);
    layout_info = *save_layout_info;

    for (int i = 0; i < layout_info.count(); ++i) {
	const QDockWidgetLayoutInfo &info = layout_info.at(i);
        if (info.is_sep)
            continue;
        if (!info.item->layout())
            continue;

        QDockWidgetLayout *l = qobject_cast<QDockWidgetLayout *>(info.item->layout());
        Q_ASSERT(l != 0);
        l->resetLayoutInfo();
    }
}

void QDockWidgetLayout::discardLayoutInfo()
{