详谈 QLayout::SizeConstraint 和 QSizePolicy 对 QWidget 尺寸的影响

QT 布局 QLayout::SizeConstraint 和 QSizePolicy 对 QWidget 尺寸的影响 QT窗口布局中,QSizePolicy和QLayout::SizeConstraint共同作用:QSizePolicy控制子控件在布局中的伸缩行为,QLayout::SizeConstraint决定父窗口的尺寸调整策略。当父窗口使用布局时,子控件的QSizePolicy生效;否则仅QLayout::SizeConstraint起作用。布局优先处理尺寸变化事件,通过activate()重新计算布局。组合控件的尺寸由布局决定,单一控件需重写sizeHint()才能正确显示。 阅读详情

QT 窗口布局常用的设置有 QSizePolicy 和 QLayout::SizeConstraint ,当窗口大小调整时,哪个配置会生效或者都会生效?先说一个简单的结论:QSizePolicy 与 QLayout::SizeConstraint 都用于 QLayout 的自动布局,父 widget 尺寸发生变化时,layout 会根据子 widget 的 QSizePolicy 与 QLayout 的方向调整子 widget 的位置及大小;子 widget 显示、隐藏、minimumSize、maximumSize 发生变化时,会触发父 widget 的 layout 重新计算(新尺寸的计算由 QLayout::SizeConstraint 来决定),从而改变父 widget 尺寸。QLayout::SizeConstraint 确定了主 widget (layout 所在 widget) 的尺寸变化策略。如果父 widget 没有使用 layout ,子 widget 的 QSizePolicy 不起任何作用。下面从帮助文档和源码分别分析一下。

1. 帮助文档

1.1 QWidget

默认情况下组合窗口的大小根据子窗口的大小来调整。widget 的 size policy 用于父窗口 layout 的布局管理。

image

sizeHint 属性是 widget 的推荐大小。如果设置了 layout 该属性的值由 layout 计算,如果没设置 layout 该属性的值默认不可用。

image

minimumSizeHint 属性是 widget 推荐的最小尺寸。如果设置了 layout 该属性的值由 layout 计算,如果没设置 layout 该属性的值默认不可用。如果要设置比 minimumSizeHint 更小的尺寸,则必须设置 QSizePolicy::Ignore。

image

maximumSize 属性是 widget 推荐的最大尺寸, 宽高的默认值都是 16777215。

image

adjustSize() 用于调整 widget 的大小到适合子控件大小。如果 sizeHint 属性可用,则使用sizeHint提供的大小,否则,使用所有子控件尺寸的并集(可以涵盖所有子控件的尺寸)来调整尺寸。

image

1.2 QSizePolicy

通过 QWidget 的 sizePolicy() 方法可以设置 widget 的 sizePolicy。但是该设置是 widget 未设置 layout 时的布局配置,如果设置了 layout 该 widget 使用 layout 的 size policy。layout 的 size policy 通过方法 setSizeConstraint() 和 setContentsMargins() 设置。

image

1.3 QLayout

QLayout 的大小调整由 SizeConstraint 配置,它有以下6种预置配置。从源码中可以确认文档中提到的minimumSize()、sizeHint()、maxmumSize() 指的是 QLayout 类中的方法,不是 Qwidget中的方法。 文档中的 main widget 指定的是 /* by 01022.hk - online tools website : 01022.hk/zh/rc4encrypt.html */ QLayout::QLayout(QWidget *parent = nullptr) 实例化时指定的 widget,或调用/* by 01022.hk - online tools website : 01022.hk/zh/rc4encrypt.html */ QWidget::setLayout(QLayout *layout) 方法的 widget。

从文档可以看出只有设置为 QLayout::SetNoConstraint 时,QLayout::SizeConstraint 不会影响 widget 的大小。当设置为 QLayout::SetDefaultConstraint 时,widget 自己的minimunSize() 才会生效。

image

QLayout::activate() 会重新计算父 widget 布局,一般情况下这个方法会自动执行。

image

2. 源码分析

2.1 消息的传递

对于 widget 控件, QApplication 在分发消息时会优先发送给该 widget 的 layout 布局,然后再由 widget 处理。QLayout 中的 widgetEvent() 方法处理了 QEvent::Resize、QEvent::ChildRemoved、QEvent::LayoutRequest 消息。也就是说,当 widget 生子控件移除或大小变动时,layout 优先处理,优先调整大小。layout 调整大小时主要由 activate() 方法处理。

// qapplication.cpp
bool QApplication::notify(QObject *receiver, QEvent *e)
{
    ...
    if (isWidgetType) {
        QWidget * w = static_cast<QWidget *>(receiver);
        switch (e->type()) {
        ...
        default:
            res = d->notify_helper(receiver, e);
            break;
        }
    } else {
        res = d->notify_helper(receiver, e);
    }

    return res;
}

bool QApplicationPrivate::notify_helper(QObject *receiver, QEvent * e)
{
    if (receiver->isWidgetType()) {
        QWidget *widget = static_cast<QWidget *>(receiver);
        ....
        // 如果使用了 layout 布局,消息先发送给 layout 处理
        if (QLayout *layout=widget->d_func()->layout) {
            layout->widgetEvent(e);
        }
    }
    // send to all receiver event filters
    if (sendThroughObjectEventFilters(receiver, e)) {
        filtered = true;
        return filtered;
    }

    // 消息再发送给 widget 处理
    // deliver the event
    consumed = receiver->event(e);

    QCoreApplicationPrivate::setEventSpontaneous(e, false);
    return consumed;
}
// qlayout.cpp
void QLayout::widgetEvent(QEvent *e)
{
    Q_D(QLayout);
    const QEvent::Type type = e->type();
    if (!d->enabled && type != QEvent::ChildRemoved)
        return;

    switch (type) {
    case QEvent::Resize:
        if (d->activated)
            d->doResize();
        else
            activate();
        break;
    case QEvent::ChildRemoved:
        {
            QChildEvent *c = (QChildEvent *)e;
            QObject *child = c->child();
            QObjectPrivate *op = QObjectPrivate::get(child);
            if (op->wasWidget) {
#if QT_CONFIG(menubar)
                if (child == d->menubar)
                    d->menubar = nullptr;
#endif
                removeWidgetRecursively(this, child);
            }
        }
        break;
    case QEvent::LayoutRequest:
        if (static_cast<QWidget *>(parent())->isVisible())
            activate();
        break;
    default:
        break;
    }
}

2.2 QWidget 调整大小

QWidget 在执行 show() 方法时会计算 widget 大小,show() 方法调用 setVisible() 计算widget 布局并显示 widget。调整 widget 尺寸由 adjustSize() 方法执行,调整尺寸时采用 sizeHint() 推荐的大小。sizeHint() 使用 layout 计算的推荐尺寸。
由此可见,当 widget 是组合 widget 时(即该 widget 包含其它 widget),它的尺寸由 layout 来计算,Size Policy 不起作用。当 widget 是单一控件时(不包含其它 widget),必须重写 sizeHint() 方法,否则,该控件不会显示。

// qwidget.cpp
void QWidget::show()
{
    ...
    if (!isWindow()) {
        setVisible(true);
    } else {
        ...
        if (defaultState == Qt::WindowFullScreen)
            showFullScreen();
        else if (defaultState == Qt::WindowMaximized)
            showMaximized();
        else
            setVisible(true);
    }
}
void QWidget::setVisible(bool visible)
{
    ...
    d->setVisible(visible);
}
void QWidgetPrivate::setVisible(bool visible)
{
    ...
    if (visible) { // show
        ...
        // 向父窗口发送布局更改事件
        if (needUpdateGeometry)
            updateGeometry_helper(true);

        // 重新计算 layout 布局
        // activate our layout before we and our children become visible
        if (layout)
            layout->activate();
        
        if (!q->isWindow()) {
            QWidget *parent = q->parentWidget();
            // 依次调整上层 widget 尺寸
            while (parent && parent->isVisible() && parent->d_func()->layout  && !parent->data->in_show) {
                parent->d_func()->layout->activate();
                if (parent->isWindow())
                    break;
                parent = parent->parentWidget();
            }
            if (parent)
                parent->d_func()->setDirtyOpaqueRegion();
        }
        // 如果是 window 或上级 widget 未设置 layout 调整大小
        // adjust size if necessary
        if (!wasResized
            && (q->isWindow() || !q->parentWidget()->d_func()->layout))  {
            if (q->isWindow()) {
                // 调整 window 大小
                q->adjustSize();
                if (q->windowState() != initialWindowState)
                    q->setWindowState(initialWindowState);
            } else {
               // 调整 widget 大小
                q->adjustSize();
            }
            q->setAttribute(Qt::WA_Resized, false);
        }
        q->setAttribute(Qt::WA_KeyboardFocusChange, false);

        if (q->isWindow() || q->parentWidget()->isVisible()) {
            show_helper();// 显示 widget

            qApp->d_func()->sendSyntheticEnterLeave(q);
        }
        QEvent showToParentEvent(QEvent::ShowToParent);
        QCoreApplication::sendEvent(q, &showToParentEvent);
    }else{ // hide
	    ...
        // 隐藏 widget 
        if (!q->testAttribute(Qt::WA_WState_Hidden)) {
            q->setAttribute(Qt::WA_WState_Hidden);
            hide_helper();
        }

        // 向父 widget 发送布局改变消息
        // invalidate layout similar to updateGeometry()
        if (!q->isWindow() && q->parentWidget()) {
            if (q->parentWidget()->d_func()->layout)
                q->parentWidget()->d_func()->layout->invalidate();
            else if (q->parentWidget()->isVisible())
                QCoreApplication::postEvent(q->parentWidget(), new QEvent(QEvent::LayoutRequest));
        }
        QEvent hideToParentEvent(QEvent::HideToParent);
        QCoreApplication::sendEvent(q, &hideToParentEvent);
    }
}

void QWidgetPrivate::updateGeometry_helper(bool forceUpdate)
{
    Q_Q(QWidget);
    if (widgetItem)
        widgetItem->invalidateSizeCache();
    QWidget *parent;
    if (forceUpdate || !extra || extra->minw != extra->maxw || extra->minh != extra->maxh) {
        const int isHidden = q->isHidden() && !size_policy.retainSizeWhenHidden() && !retainSizeWhenHiddenChanged;

        if (!q->isWindow() && !isHidden && (parent = q->parentWidget())) {
            if (parent->d_func()->layout)
                parent->d_func()->layout->invalidate();
            else if (parent->isVisible())
                QCoreApplication::postEvent(parent, new QEvent(QEvent::LayoutRequest));
        }
    }
}

void QWidget::adjustSize()
{
    Q_D(QWidget);
    ensurePolished();
    QSize s = d->adjustedSize();

    if (d->layout)
        d->layout->activate();

    if (s.isValid())
        resize(s);
}

QSize QWidgetPrivate::adjustedSize() const
{
    Q_Q(const QWidget);
    // 使用推荐大小
    QSize s = q->sizeHint();

    if (q->isWindow()) {
        Qt::Orientations exp;
        if (layout) {
            if (layout->hasHeightForWidth())
                s.setHeight(layout->totalHeightForWidth(s.width()));
            exp = layout->expandingDirections();
        } else
        {
            if (q->sizePolicy().hasHeightForWidth())
                s.setHeight(q->heightForWidth(s.width()));
            exp = q->sizePolicy().expandingDirections();
        }
        if (exp & Qt::Horizontal)
            s.setWidth(qMax(s.width(), 200));
        if (exp & Qt::Vertical)
            s.setHeight(qMax(s.height(), 100));

        QRect screen;
        if (const QScreen *screenAtPoint = QGuiApplication::screenAt(q->pos()))
            screen = screenAtPoint->geometry();
        else
            screen = QGuiApplication::primaryScreen()->geometry();

        s.setWidth(qMin(s.width(), screen.width()*2/3));
        s.setHeight(qMin(s.height(), screen.height()*2/3));

        if (QTLWExtra *extra = maybeTopData())
            extra->sizeAdjusted = true;
    }

    if (!s.isValid()) {
        QRect r = q->childrenRect(); // get children rectangle
        if (r.isNull())
            return s;
        s = r.size() + QSize(2 * r.x(), 2 * r.y());
    }

    return s;
}

QSize QWidget::sizeHint() const
{
    Q_D(const QWidget);
    // 使用 layout 计算的推荐尺寸
    if (d->layout)
        return d->layout->totalSizeHint();
    return QSize(-1, -1);
}

QSize QWidget::minimumSizeHint() const
{
    Q_D(const QWidget);
    // 使用 layout 计算的推荐尺寸
    if (d->layout)
        return d->layout->totalMinimumSize();
    return QSize(-1, -1);
}

void QWidget::resize(const QSize &s)
{
    Q_D(QWidget);
    setAttribute(Qt::WA_Resized);
    if (testAttribute(Qt::WA_WState_Created)) {
        d->fixPosIncludesFrame();
        d->setGeometry_sys(geometry().x(), geometry().y(), s.width(), s.height(), false);
        d->setDirtyOpaqueRegion();
    } else {
        const auto oldRect = data->crect;
        // 根据 minimizeSize 与 maximumSize 进行约束后保存到 data->crect
        data->crect.setSize(s.boundedTo(maximumSize()).expandedTo(minimumSize()));
        if (oldRect != data->crect)
            setAttribute(Qt::WA_PendingResizeEvent);
    }
}

2.3 QLayout 布局与 QSizePolicy

在 widget 调整尺寸时,调用了 QLayout::activate() 方法。该方法根据设置的 QLayout::SizeConstraint 调用主 widget 的方法设置对应的尺寸:

  • QLayout::SetFixedSize 调用 QWidget::setFixedSize() 方法,设置 QLayout::totalSizeHint() 计算的尺寸;
  • QLayout::SetMinimumSize 调用 QWidget::setMinimumSize() 方法,设置 QLayout::totalMinimumSize() 计算的尺寸;
  • QLayout::SetMaximumSize 调用 QWidget::SetMaximumSize() 方法,设置 QLayout::totalMaximumSize() 计算的尺寸;
  • QLayout::SetMinAndMaxSize 调用 QWidget::setMinimumSize() 和 QWidget::SetMaximumSize() 方法,设置 QLayout::totalMinimumSize() 和 QLayout::totalMaximumSize() 计算的尺寸;
  • QLayout::SetDefaultConstraint 当 QWidget::minimumSize 属性可用时,使用使用QWidget::minimumSize 指定的尺寸,否则调用 QWidget::setMinimumSize() 方法,设置 QLayout::totalMinimumSize() 计算的尺寸;
  • QLayout::SetNoConstraint 不会修改主 widget 的尺寸

QLayout::totalSizeHint()、QLayout::totalMinimumSize()、QLayout::totalMaximumSize() 会调用子类的 sizeHint()、minimumSize()、maximumSize()。以 QBoxLayout 为例,这些方法中会调用 QLayout::setupGeom() 方法。setupGeom() 方法遍历 layout 中所有 widget 计算 minSize、maxSize、sizeHint。遍历 widget 时,通过 QWidgetItem::expandingDirections() 获取该 widget 的扩展方向。expandingDirections() 方法根据 widget 设置的 size policy 来判断扩展方向。

// qlayout.cpp
bool QLayout::activate()
{
    Q_D(QLayout);
    if (!d->enabled || !parent())
        return false;
    if (!d->topLevel)
        return static_cast<QLayout*>(parent())->activate();
    if (d->activated)
        return false;
    // layout 所属的主widget
    QWidget *mw = static_cast<QWidget*>(parent());
    if (Q_UNLIKELY(!mw)) {
        qWarning("QLayout::activate: %s \"%ls\" does not have a main widget",
                 metaObject()->className(), qUtf16Printable(objectName()));
        return false;
    }
    activateRecursiveHelper(this);

    QWidgetPrivate *md = mw->d_func();
    uint explMin = md->extra ? md->extra->explicitMinSize : 0;
    uint explMax = md->extra ? md->extra->explicitMaxSize : 0;
    // 根据 QLayout::SizeConstraint 设置主 widget 尺寸
    switch (d->constraint) {
    case SetFixedSize:
        // will trigger resize
        mw->setFixedSize(totalSizeHint());
        break;
    case SetMinimumSize:
        mw->setMinimumSize(totalMinimumSize());
        break;
    case SetMaximumSize:
        mw->setMaximumSize(totalMaximumSize());
        break;
    case SetMinAndMaxSize:
        mw->setMinimumSize(totalMinimumSize());
        mw->setMaximumSize(totalMaximumSize());
        break;
    case SetDefaultConstraint: {
        bool widthSet = explMin & Qt::Horizontal;
        bool heightSet = explMin & Qt::Vertical;
        if (mw->isWindow()) {
            QSize ms = totalMinimumSize();
            if (widthSet)
                ms.setWidth(mw->minimumSize().width());
            if (heightSet)
                ms.setHeight(mw->minimumSize().height());
            mw->setMinimumSize(ms);
        } else if (!widthSet || !heightSet) {
            QSize ms = mw->minimumSize();
            if (!widthSet)
                ms.setWidth(0);
            if (!heightSet)
                ms.setHeight(0);
            mw->setMinimumSize(ms);
        }
        break;
    }
    case SetNoConstraint:
        break;
    }
    // 根据主 widget 调整后的尺寸计算 layout 的 rect
    d->doResize();

    if (md->extra) {
        md->extra->explicitMinSize = explMin;
        md->extra->explicitMaxSize = explMax;
    }
    // ideally only if sizeHint() or sizePolicy() has changed
    mw->updateGeometry();
    return true;
}

void QLayoutPrivate::doResize()
{
    Q_Q(QLayout);
    QWidget *mw = q->parentWidget();
    QRect rect = mw->testAttribute(Qt::WA_LayoutOnEntireRect) ? mw->rect() : mw->contentsRect();
    const int mbh = menuBarHeightForWidth(menubar, rect.width());
    const int mbTop = rect.top();
    rect.setTop(mbTop + mbh);
    // 对于 QBoxLayout 此处会调整子 widget 大小
    q->setGeometry(rect);
#if QT_CONFIG(menubar)
    if (menubar)
        menubar->setGeometry(rect.left(), mbTop, rect.width(), mbh);
#endif
}
// 此方法在 QLayout 的子类中会重载,完成子 widget 坐标的计算与设置
void QLayout::setGeometry(const QRect &r)
{
    Q_D(QLayout);
    d->rect = r;
}

QSize QLayout::totalSizeHint() const
{
    Q_D(const QLayout);
    int side=0, top=0;
    if (d->topLevel) {
        QWidget *pw = parentWidget();
        pw->ensurePolished();
        QWidgetPrivate *wd = pw->d_func();
        side += wd->leftmargin + wd->rightmargin;
        top += wd->topmargin + wd->bottommargin;
    }

    QSize s = sizeHint();
    if (hasHeightForWidth())
        s.setHeight(heightForWidth(s.width() + side));
#if QT_CONFIG(menubar)
    top += menuBarHeightForWidth(d->menubar, s.width());
#endif
    return s + QSize(side, top);
}

void QLayout::invalidate()
{
    Q_D(QLayout);
    d->rect = QRect();
    update();
}

void QLayout::update()
{
    QLayout *layout = this;
    while (layout && layout->d_func()->activated) {
        layout->d_func()->activated = false;
        if (layout->d_func()->topLevel) {
            Q_ASSERT(layout->parent()->isWidgetType());
            QWidget *mw = static_cast<QWidget*>(layout->parent());
            QCoreApplication::postEvent(mw, new QEvent(QEvent::LayoutRequest));
            break;
        }
        layout = static_cast<QLayout*>(layout->parent());
    }
}
// qboxlayout.cpp
QSize QBoxLayout::sizeHint() const
{
    Q_D(const QBoxLayout);
    if (d->dirty)
        const_cast<QBoxLayout*>(this)->d_func()->setupGeom();
    return d->sizeHint;
}

QSize QBoxLayout::minimumSize() const
{
    Q_D(const QBoxLayout);
    if (d->dirty)
        const_cast<QBoxLayout*>(this)->d_func()->setupGeom();
    return d->minSize;
}

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;
}

// 此方法遍历 layout 中所有 widget 计算 minSize、maxSize、sizeHint
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.size();
    geomArray.clear();
    QList<QLayoutStruct> a(n);

    QSizePolicy::ControlTypes controlTypes1;
    QSizePolicy::ControlTypes controlTypes2;
    int fixedSpacing = q->spacing();
    int previousNonEmptyIndex = -1;

    QStyle *style = nullptr;
    if (fixedSpacing < 0) {
        if (QWidget *parentWidget = q->parentWidget())
            style = parentWidget->style();
    }

    for (int i = 0; i < n; i++) {
        QBoxLayoutItem *box = list.at(i);
        // 获取 layout 内的 widget 的尺寸
        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_OS_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,
                                             nullptr, 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 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;
}
struct QBoxLayoutItem
{
    ...
    QLayoutItem *item;
    ...
};

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));
        // d->geomArray 已经在 setupGeom() 完成计算
        QList<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.size();
        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;
        }
        // 根据 QRect &r 大小,调整子 widget 尺寸
        qGeomCalc(a, 0, n, pos, space);

        bool reverse = (horz(visualDir)
                        ? ((r.right() > oldRect.right()) != (visualDir == RightToLeft))
                        : r.bottom() > oldRect.bottom());
        // 设置子 widget 坐标
        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));
            }
        }
    }
}

// qlayoutengine_p.h
struct QLayoutStruct
{
    inline void init(int stretchFactor = 0, int minSize = 0) {
        stretch = stretchFactor;
        minimumSize = sizeHint = minSize;
        maximumSize = QLAYOUTSIZE_MAX;
        expansive = false;
        empty = true;
        spacing = 0;
    }

    int smartSizeHint() {
        return (stretch > 0) ? minimumSize : sizeHint;
    }
    int effectiveSpacer(int uniformSpacer) const {
        Q_ASSERT(uniformSpacer >= 0 || spacing >= 0);
        return (uniformSpacer >= 0) ? uniformSpacer : spacing;
    }

    // parameters
    int stretch;
    int sizeHint;
    int maximumSize;
    int minimumSize;
    int spacing;
    bool expansive;
    bool empty;

    // temporary storage
    bool done;

    // result
    int pos;
    int size;
};
Q_WIDGETS_EXPORT void qGeomCalc(QList<QLayoutStruct> &chain, int start, int count, int pos,
                                int space, int spacer = -1);

...

static inline void qMaxExpCalc(int & max, bool &exp, bool &empty,
                               int boxmax, bool boxexp, bool boxempty)
{
    if (exp) {
        if (boxexp)
            max = qMax(max, boxmax);
    } else {
        if (boxexp || (empty && (!boxempty || max == 0)))
            max = boxmax;
        else if (empty == boxempty)
            max = qMin(max, boxmax);
    }
    exp = exp || boxexp;
    empty = empty && boxempty;
}
// qlayoutitem.cpp
Qt::Orientations QWidgetItem::expandingDirections() const
{
    if (isEmpty())
        return {};

    Qt::Orientations e = wid->sizePolicy().expandingDirections();
    /*
      If the layout is expanding, we make the widget expanding, even if
      its own size policy isn't expanding.
    */
    // 根据 widget 设置的 size ploicy 来判断扩展方向
    if (wid->layout()) {
        if (wid->sizePolicy().horizontalPolicy() & QSizePolicy::GrowFlag
                && (wid->layout()->expandingDirections() & Qt::Horizontal))
            e |= Qt::Horizontal;
        if (wid->sizePolicy().verticalPolicy() & QSizePolicy::GrowFlag
                && (wid->layout()->expandingDirections() & Qt::Vertical))
            e |= Qt::Vertical;
    }

    if (align & Qt::AlignHorizontal_Mask)
        e &= ~Qt::Horizontal;
    if (align & Qt::AlignVertical_Mask)
        e &= ~Qt::Vertical;
    return e;
}

3. 分析总结

通过上述分析,widget 调整尺寸主要由 layout 管理控件进行计算调整;如果没有设置 layout 由 sizeHint() 提供 widget 的大小。当子 widget 尺寸发生变化时,会通知其所在的 layout 进行尺寸计算,从而影响父 widget 的尺寸,此时 layout 的 SizeConstraint 对 widget 的尺寸调整起到决定性作用。当包含 widget 的 widget 的尺寸发生变化时,resize 方法会触发 layout 执行 doResize 方法,setGeometry() 方法中重新计算子 widget 应该占用的空间,此时会根据 QSizePolicy 确定扩展方向。下面简单描述以下 widget 尺寸变化的 3 种情况:

3.1 widget 显示或隐藏对父 widget 的影响

此种情况会触发父 widget 直至顶层 widget 的尺寸调整(需要每层 widget 都使用 layout 布局)。父 widget 未使用 layout 布局时,可以通过处理 QEvent::LayoutRequest 事件来手工调整尺寸。

当 widget 隐藏时,QWidget::setVisible() 方法被调用。该方法在完成 widget 隐藏操作后,会调用父 widget 的 layout->invalidate() 方法(当父 widget 使用 layout 管理布局时),或者向父 widget 发送 QEvent::LayoutRequest 事件(当父 widget 未使用 layout 布局并且可见时)。 widget 未使用 layout 布局时,默认不处理 QEvent::LayoutRequest 事件,也就是说此时父 widget 不会因为子 widget 的隐藏而改变尺寸。 此时,父 widget 可以通过处理 QEvent::LayoutRequest 事件来手工调整尺寸。使用 layout 布局时,layout->invalidate() 方法会调用 layout->update() 方法,采用循环的方式将所有上层 widget 的 layout 的 activated 置为 false,并给顶层 widget 发送 QEvent::LayoutRequest 事件。顶层 widget 的 layout 收到 QEvent::LayoutRequest 事件后将调用 activate() 方法重新计算所有下层 widget 及本身的尺寸。 widget 使用 layout 布局时,只需要设置 QLayout::SizeConstraint ,当子 widget 隐藏时会自动重新计算窗口尺寸。

当 widget 显示时,QWidget::setVisible() 方法被调用。该方法首先通过updateGeometry_helper()将父 widget 的 layout 置为 invalidate()(当父 widget 使用 layout 布局时)或向父 widget 发送 QEvent::LayoutRequest 事件。然后调用本级的 layout->activate() 计算本身级下级 widget 的尺寸。最后,再依次调用上层 widget 的 layout->activate() 重新计算尺寸。该过程中,只要有一层 widget 没有设置 layout ,就会中断,上层 widget 都将无法自动调整。

3.2 widget 调整大小对子 widget 的影响

当调用 resize() 方法或 setGeometry() 方法调整 widget时,或者 widget 是 scrollArea 中的控件(设置了自动调整大小)时,如果使用了 layout 布局,其子 widget 的大小会由 layout 根据子 widget 的 SizePolicy 计算尺寸和位置信息并依次调整。如果未使用 layout 布局,子 widget 不会自动调整,可以通过处理 QResizeEvent 事件手工调整子 widget 大小及位置。

resize() 方法或 setGeometry() 方法都会调用 QWidgetPrivate::setGeometry_sys()方法,在该方法中会判断是否移动或改变大小,并发送 QMoveEvent 和 QResizeEvent 事件。下个事件循环中 QLayout 截获 QEvent::Resize 事件,并调用 d->doResize() 方法,该方法会调用 QLayout 子类的 setGeometry() 方法。QBoxLayout::setGeometry() 方法会根据子 widget 的 SizePolicy 计算其尺寸和位置信息并依次调用子 widget 的 setGeometry() 方法修改其位置及尺寸。如果 widget 未设置 layout 布局,widget 尺寸的调整不会影响子 widget 的位置及尺寸。

3.3 widget 主动调整大小对父 widget 的影响

当调用 resize() 方法或 setGeometry() 方法调整 widget 时,widget 会修改大小或位置,但是父 widget 不会有任何变化。如果父 widget 使用了 layout,当父 widget 变化时,该 widget 的大小由 layout 重新设定。

当调用 setMinimumSize() 方法或 setMaximumSize() 方法调整 widget 时,如果 widget 大小改变, 会触发父 widget 的 layout 重新计算父 widget 尺寸。

PyQt(Python+Qt)学习随笔:布局控件layout的layoutSizeConstraint属性 在Qt Designer中布局控件有4个,分别是Vertical Layout(垂直布局)、Horizontal Layout(水平布局)、Grid Layout(网格布局)、Form Layout(表单布局),这些布局控件都有layoutSizeConstraint这个属性,如图: 这个属性实际对应QLayout类的sizeConstraint属性,具体取值由枚举类型QLayout.SizeC... 阅读详情

相关推荐

布局控件layout的layoutSizeConstraint属性无效解决方法

在上面的代码中,我们创建了一个 MainWidget 类来作为程序的主窗口,在 initUI 方法中创建了两个按钮,并使用水平布局和垂直布局将它们排列起来。根据 PyQt5 的官方文档,在使用 layoutSizeConstraint 属性时,应该把它设置在父控件上,而不是布局控件本身。将 layoutSizeConstraint 设置为 SetMinimumSize,即布局控件的最小高度和宽度为指定的值。现在,运行程序,拖动窗口大小,可以看到布局控件的大小是固定的了。

. 1172

Qt SizePolicy 属性

控件的sizePolicy说明控件在布局管理中的缩放方式。Qt提供的控件都有一个合理的缺省sizePolicy,但是这个缺省值有时不能适合 所有的布局,开发人员经常需要改变窗体上的某些控件的sizePolicy。一个QSizePolicy的所有变量对水平方向和垂直方向都适用。下面列举 了一些最长用的值: A. Fixed:控件不能放大或者缩小,控件的大小就是它的sizeHint。 B. ...

weixin_30568591的博客 249

PyQt 布局控件中的 layoutSizeConstraint 属性

在 PyQt 中,布局控件(layout)是一种强大的机制,用于管理和组织界面上的其他控件。总结起来,PyQt 中的布局控件提供了灵活且强大的方式来管理和组织界面上的控件。通过使用 layoutSizeConstraint 属性,我们可以指定布局在调整大小时采取的行为,以满足不同的布局需求。布局控件可以自动调整其子控件的大小和位置,以适应不同的窗口大小或布局要求。这意味着,当窗口被调整大小时,布局将尽可能地保持最小的尺寸,并且不会超出其所需的最小空间。这可以确保布局在窗口缩小时不会发生控件的重叠或截断。

HackDyno的博客 1389

详谈 QT 布局 QLayout::SizeConstraint 和 QSizePolicy 对 QWidget 尺寸的影响

# 一、基础概念:QWidget 的尺寸系统在 QT 中,每个 QWidget 都有三个关键的尺寸概念:-窗口最小尺寸由子部件的最小尺寸总和决定,无法缩小到无法显示内容。建议从简单的固定布局开始,逐步引入伸缩策略,最后再考虑全局约束,这样能够更清晰地把握布局行为。部件会均匀分配额外空间,但窗口的最小尺寸被固定,无法缩小到布局的理想尺寸以下。设置的范围布局管理器在安排子部件时,会优先参考这些尺寸提示,而。:最小尺寸,部件能够正常显示的最小尺寸-:设置父窗口的最小尺寸为布局的理想尺寸-

mX8nB066u的博客 197

窗口layout布局的SizeConstraint和部件的大小约束策略sizePolicy不起作用的解决方法

对于第二个按钮,我们将部件大小策略设为QSizePolicy.Preferred和QSizePolicy.Expanding,这意味着它在水平方向上具有可伸缩性,在垂直方向上可以自动扩展。在PyQt5中,通过调用QLayout中的setSizeConstraint()方法来设置SizeConstraint属性。对于第一个按钮,我们将部件大小策略设为QSizePolicy.Preferred和QSizePolicy.Fixed,这意味着它在水平方向上具有可伸缩性,但在垂直方向上是固定的。

m0_47037246的博客 1016

Mathtype公式下标深度调整技巧:解决固定行距下的显示不全问题

本文针对在Word等文档中设置固定行距时,Mathtype公式下标显示不全的问题,提供了专业解决方案。核心在于调整Mathtype软件内部的“下标深度”参数,通过修改单个公式或批量格式化全文,使公式完美适配固定行距,确保下标清晰完整,且不影响文档整体排版。

pepsi的博客 1504

毕详谈 QT 布局 QLayout::SizeConstraint 和 QSizePolicy 对 QWidget 尺寸的影响a

{"create_time":"2023-10-03 09:15:00","title":"第三条数据","users":[{"username":"user3","age":28,"sex":"male"},{"username":"user4","age":22,"sex":"female"}]}查询的时候有特定的语法 nested查询 且字段要用对象.字段名。扁平化存储,数组中的对象相同字段会合并成数组。每个对象独立存储为隐藏的子文档。每个对象独立存储为隐藏的子文档。适合存储单层的json对象。

xAFASFASFASFA的博客 392

YT8531 PHY芯片硬件设计与MDIO/RGMII实战指南

以太网PHY芯片是FPGA系统实现网络通信的物理层核心,其关键在于标准接口(如MDIO管理总线和RGMII数据接口)的正确实现与协同。MDIO作为IEEE 802.3定义的低速配置通道,负责寄存器级控制与状态监控;RGMII则通过双沿采样精简引脚,在千兆速率下兼顾性能与PCB布线可行性。技术价值体现在电压兼容性(支持1.8V/2.5V/3.3V)、可编程时序调节(RX_DELAY/TX_DELAY)及多级环回测试能力,显著提升国产FPGA平台(如Xilinx Zynq)的工程鲁棒性。典型应用场景涵盖嵌入式网

weixin_42453228的博客 1342

丛详谈 QT 布局 QLayout::SizeConstraint 和 QSizePolicy 对 QWidget 尺寸的影响h

无论是项目初期的快速迭代,还是接口尚未就绪的场景,Mock 都能帮助我们在「没有真实后端数据」的情况下,保障前端开发的连续性和效率。假如我们返回的结果增加一些字段,而且某字段都是实时随机生成的,就像上面例子中,我们增加一个时间日期字段pay_dtime。例如上述返回需要增加一个订单号字段order_id,且订单号字段的要求为以 sn 开头+8位数字组成的字符串,此字段需要高度自定义。接下来我们切换到 「Mock」标签,可以看到自动生成一个Mock URL ,这个URL即为生成的 Mock 链接。

Sei7si9Jh的博客 413

CarPlay无线连接开发实战:从蓝牙EIR查询到iAP2认证的完整代码逻辑梳理

本文详细解析了无线CarPlay连接开发的完整流程,从蓝牙EIR查询到iAP2认证的代码实现。重点介绍了蓝牙握手、WiFi Beacon帧配置、热点信息准备等关键环节的实战技巧,帮助开发者快速搭建稳定可靠的无线CarPlay连接系统。

weixin_31534091的博客 325

IEEE802.11bf: WLAN Sensing Standard

下表为IEEE802.11bf 定义的使用情境 (Use Cases)

qinsd19的博客 1063

论:QSizePolicy 与 QLayout::SizeConstraint 都用于 QLayout 的自动布局,父 widget ...

# 3. QSizePolicy 与 SizeConstraint 的协作机制在 Qt 布局中,父 widget 的尺寸变化会触发布局重新计算。是两个关键概念,它们共同决定了当父 widget 的大小发生变化时,子控件如何调整自身尺寸,以及父 widget 如何适应子控件的需求。控制了父 widget 如何响应布局的推荐尺寸。决定了它们在布局中的伸缩行为,从而影响布局的推荐尺寸。:父 widget 的尺寸被限制在布局推荐的最小和最大尺寸之间。策略,布局会推荐更大的尺寸,而如果父 widget 的。

mX8nB066u的博客 167

从仿真到实践:两级直接耦合放大电路的静态工作点协同调试指南

本文详细解析了两级直接耦合放大电路的静态工作点协同调试方法,从仿真到实践提供系统指南。重点介绍了Rc2电阻调整技巧、集电极电位测量方法及常见问题排查,帮助工程师解决各级静态工作点相互影响的难题,提升模拟电路设计效率。

weixin_29189373的博客 125

QLayoutItem、QSizePolicy、QLayout

QLayoutItem 类提供了一个 QLayout 操作的抽象项。设置项目的对齐方式。除了为布局提供空白空间的 QSpacerItem 之外,所有继承 QLayoutItem 的公共 Qt 类都支持项对齐。返回布局项的控件类型。对于一个 QWidgetItem,控件类型来自widget的大小策略;对于 QLayoutItem,控件类型派生自布局的内容。3、【纯虚函数】Qt::Orientations expandingDirections()

hw5230的博客 561

MOS 管驱动设计细节,波形分析

一般认为MOSFET是电压驱动的,不需要驱动电流。然而,在MOS的G S两级之间有结电容存在,这个电容会让驱动MOS变的不那么简单。 如果不考虑纹波和EMI等要求的话,MOS管开关速度越快越好,因为开关时间越短,开关损耗越小,而在开关电源中开关损耗占总损耗的很大一部分,因此MOS管驱动电路的好坏直接决定了电源的效率。 对于一个MOS管,如果把GS之间的电压从0拉到管子的开启电压所用的时间越短,那么MOS管开启的速度就会越快。与此类似,如果把MOS管的GS电压从开启电压降到0V的时间越短,那么MOS管关断的

m0_50862404的博客 1万+

史上最小白之RNN详解

1.前言 网上目前已经有诸多优秀的RNN相关博客,但是我写博客的出发点主要是为了加深和巩固自己的理解,所以还是决定自己再进行一下总结和描述,如有不正确的地方欢迎指正~ 2.区分RNN 循环神经网络(Recurrent Neural Network),递归神经网络(Recursive Neural Network),你有没有发现他们的缩写都是RNN,那他们两个是同一回事儿吗?网上有一些博客把这两就当...

Tink1995的博客 4万+

Qt布局类分析

查看Qt帮助文档,我们可知所有布局继承QLayout,而QLayout: 一、

Liuqz2009的专栏 1904

Qt —— 百度离线地图 - 加载百度离线地图、及地图上绘图(附:源码)

Qt —— 加载百度离线地图、及简单绘图(附源码)

1065

Qt布局管理实战:掌握sizePolicy与stretch实现控件自适应大小

在GUI界面开发中,布局管理是实现响应式设计的核心技术。其原理是通过布局管理器根据容器尺寸动态分配子控件空间,结合控件的大小策略和拉伸因子进行智能调整。这项技术的价值在于能够构建适应不同屏幕尺寸和分辨率的用户界面,提升用户体验和软件专业性。在桌面应用开发、配置对话框、数据展示面板等场景中,自适应布局都至关重要。本文以Qt框架为例,深入解析sizeHint、QSizePolicy和stretch factor的协同工作机制,通过实际案例演示如何解决qt界面设计中的布局难题,特别是处理qt项目实战中常见的控件伸

weixin_30333885的博客 305

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

PySide6————QWidget的sizePolicy属性解析

sizePolicy属性由四个值组成,分别是水平策略、垂直策略、水平伸展和垂直伸展。每种控件都有一个期望尺寸,即这个控件的建议尺寸,即默认尺寸。绝大多是的控件的默认尺寸是只读的,不可更改。对于不同的部件,默认拥有不同的sizeHint;同一部件的sizeHint也有可能不同,大小随着部件内容的变化而变化。

dbfgngb的博客 1573

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

[QT_042]Qt学习之控件尺寸调整策略(QSizePolicy)

Qt学习之控件尺寸调整策略(QSizePolicy)

kongcheng253的博客 3万+

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

Qt之QSizePolicy

简述 QSizePolicy类是一个描述布局水平和垂直方向调整策略的属性。 大小策略会影响布局引擎处理部件的方式,部件加入布局以后,会返回一个QSizePolicy,描述了其水平和垂直方向的大小策略。可以通过QWidget::sizePolicy属性为特定部件设置大小策略。 简述 详细描述 成员类型 公共函数 示例 控制...

weixin_34294649的博客 1859

[Qt] 怎么将Widget调整为自适应大小?

可以设置为静态分配(Default)、按比例分配(SizePolicy::Ignored)、优先分配给该控件(SizePolicy::Preferred)、尽量避免分配给该控件(SizePolicy::Minimum)或者尽量均分(SizePolicy::Expanding)。因此,它可以被用来自适应任何给定的父容器大小。在布局中使用该Widget时,可以通过调整布局中其他控件的大小,来间接影响该Widget的大小。QSizePolicy(大小策略)是Qt中的一个类,用于控制控件在父容器中的大小和行为。

布屿 1万+

Qt+VS2019中layout()->setSizeConstraint(QLayout::SetFixedSize); 引发异常导致程序崩溃的解决方法

Qt+VS2019中layout()->setSizeConstraint(QLayout::SetFixedSize); 引发异常导致程序崩溃的解决方法

1316
上一篇: CsGrafeq:用C#实现一个几何画板
下一篇: Token续期的5种方案
cmdos
博客等级 码龄19年 83粉丝 105原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值