Revision control
++ // Copyright (C) 2025 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ #include "qqstylekitlayout_p.h"
++
++ QT_BEGIN_NAMESPACE
++
++ static qreal layoutWidth(QQStyleKitLayoutItem *li, qreal availableWidth = .0)
++ {
++ Q_ASSERT(li);
++ Q_ASSERT(li->item());
++ QQuickItem *item = li->item();
++ qreal w = item->implicitWidth();
++ if (li->fillWidth())
++ w = qMax(.0, availableWidth - li->margins().left() - li->margins().right());
++ return qMax(.0, w);
++ }
++
++ static qreal layoutHeight(QQStyleKitLayoutItem *li, qreal availableHeight = .0)
++ {
++ Q_ASSERT(li);
++ Q_ASSERT(li->item());
++ QQuickItem *item = li->item();
++ qreal h = item->implicitHeight();
++ if (li->fillHeight())
++ h = qMax(.0, availableHeight - li->margins().top() - li->margins().bottom());
++ return qMax(.0, h);
++ }
++
++ static qreal totalWidth(const QList<QQStyleKitLayoutItem *> &items, qreal spacing)
++ {
++ qreal total = .0;
++ for (QQStyleKitLayoutItem *li : items) {
++ if (li->item() && li->item()->isVisible())
++ total += layoutWidth(li) + li->margins().left() + li->margins().right() + spacing;
++ }
++ return total;
++ }
++
++ static qreal totalHeight(const QList<QQStyleKitLayoutItem *> &items)
++ {
++ qreal maxHeight = .0;
++ for (QQStyleKitLayoutItem *li : items) {
++ if (li->item() && li->item()->isVisible()) {
++ const qreal h = layoutHeight(li) + li->margins().top() + li->margins().bottom();
++ if (h > maxHeight)
++ maxHeight = h;
++ }
++ }
++ return maxHeight;
++ }
++
++ static qreal vAlignY(QQStyleKitLayoutItem *li, qreal containerY, qreal containerHeight)
++ {
++ Q_ASSERT(li);
++ Q_ASSERT(li->item());
++
++ const auto itemHeight = layoutHeight(li, containerHeight);
++ const auto vAlign = li->alignment() & Qt::AlignVertical_Mask;
++ const auto margins = li->margins();
++ if (vAlign & Qt::AlignTop)
++ return containerY + margins.top();
++ if (vAlign & Qt::AlignBottom)
++ return containerY + containerHeight - itemHeight - margins.bottom();
++ return containerY + margins.top()
++ + (containerHeight - margins.top() - margins.bottom() - itemHeight) / 2.0;
++ }
++
++ QQStyleKitLayoutItem::QQStyleKitLayoutItem(QObject *parent)
++ : QObject(parent)
++ {
++ }
++
++ QQuickItem *QQStyleKitLayoutItem::item() const
++ {
++ return m_item;
++ }
++
++ void QQStyleKitLayoutItem::setItem(QQuickItem *item)
++ {
++ if (m_item == item)
++ return;
++
++ if (m_item)
++ disconnect(m_item, nullptr, this, nullptr);
++
++ m_item = item;
++ if (m_item) {
++ connect(m_item, &QQuickItem::implicitWidthChanged, this, [this]() { emit itemChanged(); });
++ connect(m_item, &QQuickItem::implicitHeightChanged, this, [this]() { emit itemChanged(); });
++ connect(m_item, &QQuickItem::visibleChanged, this, [this]() { emit itemChanged(); });
++ }
++ // TODO: parentchanged
++ emit itemChanged();
++ }
++
++ qreal QQStyleKitLayoutItem::x() const
++ {
++ return m_x;
++ }
++
++ void QQStyleKitLayoutItem::setX(qreal x)
++ {
++ if (qFuzzyCompare(m_x, x))
++ return;
++
++ m_x = x;
++ emit xChanged();
++ }
++
++ qreal QQStyleKitLayoutItem::y() const
++ {
++ return m_y;
++ }
++
++ void QQStyleKitLayoutItem::setY(qreal y)
++ {
++ if (qFuzzyCompare(m_y, y))
++ return;
++
++ m_y = y;
++ emit yChanged();
++ }
++
++ qreal QQStyleKitLayoutItem::width() const
++ {
++ return m_width;
++ }
++
++ void QQStyleKitLayoutItem::setWidth(qreal width)
++ {
++ if (qFuzzyCompare(m_width, width))
++ return;
++
++ m_width = width;
++ emit widthChanged();
++ }
++
++ qreal QQStyleKitLayoutItem::height() const
++ {
++ return m_height;
++ }
++
++ void QQStyleKitLayoutItem::setHeight(qreal height)
++ {
++ if (qFuzzyCompare(m_height, height))
++ return;
++
++ m_height = height;
++ emit heightChanged();
++ }
++
++ Qt::Alignment QQStyleKitLayoutItem::alignment() const
++ {
++ return m_alignment;
++ }
++
++ void QQStyleKitLayoutItem::setAlignment(Qt::Alignment alignment)
++ {
++ if (m_alignment == alignment)
++ return;
++
++ m_alignment = alignment;
++ emit alignmentChanged();
++ }
++
++ QMarginsF QQStyleKitLayoutItem::margins() const
++ {
++ return m_margins;
++ }
++
++ void QQStyleKitLayoutItem::setMargins(const QMarginsF &margins)
++ {
++ if (m_margins == margins)
++ return;
++
++ m_margins = margins;
++ emit marginsChanged();
++ }
++
++ bool QQStyleKitLayoutItem::fillWidth() const
++ {
++ return m_fillWidth;
++ }
++
++ void QQStyleKitLayoutItem::setFillWidth(bool fill)
++ {
++ if (m_fillWidth == fill)
++ return;
++
++ m_fillWidth = fill;
++ emit fillWidthChanged();
++ }
++
++ bool QQStyleKitLayoutItem::fillHeight() const
++ {
++ return m_fillHeight;
++ }
++
++ void QQStyleKitLayoutItem::setFillHeight(bool fill)
++ {
++ if (m_fillHeight == fill)
++ return;
++
++ m_fillHeight = fill;
++ emit fillHeightChanged();
++ }
++
++ QQStyleKitLayout::QQStyleKitLayout(QQuickItem *parent)
++ : QQuickItem(parent)
++ , m_mirrored(false)
++ , m_enabled(true)
++ {
++ }
++
++ QQuickItem *QQStyleKitLayout::container() const
++ {
++ return m_container;
++ }
++
++ void QQStyleKitLayout::setContainer(QQuickItem *container)
++ {
++ if (m_container == container)
++ return;
++
++ m_container = container;
++ emit containerChanged();
++ connect(m_container, &QQuickItem::widthChanged, this, &QQStyleKitLayout::polish);
++ connect(m_container, &QQuickItem::heightChanged, this, &QQStyleKitLayout::polish);
++
++ polish();
++ }
++
++ QQmlListProperty<QQStyleKitLayoutItem> QQStyleKitLayout::layoutItems()
++ {
++ return QQmlListProperty<QQStyleKitLayoutItem>(const_cast<QQStyleKitLayout *>(this),
++ nullptr,
++ &QQStyleKitLayout::layoutItem_append,
++ &QQStyleKitLayout::layoutItem_count,
++ &QQStyleKitLayout::layoutItem_at,
++ &QQStyleKitLayout::layoutItem_clear);
++ }
++
++ void QQStyleKitLayout::layoutItem_append(QQmlListProperty<QQStyleKitLayoutItem> *list, QQStyleKitLayoutItem *item)
++ {
++ QQStyleKitLayout *layout = qobject_cast<QQStyleKitLayout *>(list->object);
++ if (layout && item) {
++ layout->m_layoutItems.append(item);
++ connect(item, &QQStyleKitLayoutItem::itemChanged, layout, &QQStyleKitLayout::polish);
++ connect(item, &QQStyleKitLayoutItem::alignmentChanged, layout, &QQStyleKitLayout::polish);
++ connect(item, &QQStyleKitLayoutItem::marginsChanged, layout, &QQStyleKitLayout::polish);
++ connect(item, &QQStyleKitLayoutItem::fillWidthChanged, layout, &QQStyleKitLayout::polish);
++ connect(item, &QQStyleKitLayoutItem::fillHeightChanged, layout, &QQStyleKitLayout::polish);
++ emit layout->layoutItemsChanged();
++ layout->polish();
++ }
++ }
++
++ qsizetype QQStyleKitLayout::layoutItem_count(QQmlListProperty<QQStyleKitLayoutItem> *list)
++ {
++ QQStyleKitLayout *layout = qobject_cast<QQStyleKitLayout *>(list->object);
++ if (layout)
++ return layout->m_layoutItems.size();
++ return 0;
++ }
++
++ QQStyleKitLayoutItem *QQStyleKitLayout::layoutItem_at(QQmlListProperty<QQStyleKitLayoutItem> *list, qsizetype index)
++ {
++ QQStyleKitLayout *layout = qobject_cast<QQStyleKitLayout *>(list->object);
++ if (layout)
++ return layout->m_layoutItems.value(index);
++ return nullptr;
++ }
++
++ void QQStyleKitLayout::layoutItem_clear(QQmlListProperty<QQStyleKitLayoutItem> *list)
++ {
++ QQStyleKitLayout *layout = qobject_cast<QQStyleKitLayout *>(list->object);
++ if (layout) {
++ layout->m_layoutItems.clear();
++ emit layout->layoutItemsChanged();
++ layout->polish();
++ }
++ }
++
++ QMarginsF QQStyleKitLayout::padding() const
++ {
++ return m_padding;
++ }
++
++ QMarginsF QQStyleKitLayout::contentMargins() const
++ {
++ return m_contentMargins;
++ }
++
++ void QQStyleKitLayout::setContentMargins(const QMarginsF &margins)
++ {
++ if (m_contentMargins == margins)
++ return;
++
++ m_contentMargins = margins;
++ emit contentMarginsChanged();
++ polish();
++ }
++
++ qreal QQStyleKitLayout::spacing() const
++ {
++ return m_spacing;
++ }
++
++ void QQStyleKitLayout::setSpacing(qreal spacing)
++ {
++ if (qFuzzyCompare(m_spacing, spacing))
++ return;
++
++ m_spacing = spacing;
++ emit spacingChanged();
++ polish();
++ }
++
++ bool QQStyleKitLayout::isMirrored() const
++ {
++ return m_mirrored;
++ }
++
++ void QQStyleKitLayout::setMirrored(bool mirrored)
++ {
++ if (m_mirrored == mirrored)
++ return;
++
++ m_mirrored = mirrored;
++ emit mirroredChanged();
++ polish();
++ }
++
++ qreal QQStyleKitLayout::implicitWidth() const
++ {
++ return m_implicitWidth;
++ }
++
++ qreal QQStyleKitLayout::implicitHeight() const
++ {
++ return m_implicitHeight;
++ }
++
++ void QQStyleKitLayout::setImplicitWidth(qreal width)
++ {
++ if (qFuzzyCompare(m_implicitWidth, width))
++ return;
++
++ m_implicitWidth = width;
++ emit implicitWidthChanged();
++ polish();
++ }
++
++ void QQStyleKitLayout::setImplicitHeight(qreal height)
++ {
++ if (qFuzzyCompare(m_implicitHeight, height))
++ return;
++
++ m_implicitHeight = height;
++ emit implicitHeightChanged();
++ polish();
++ }
++
++ bool QQStyleKitLayout::isEnabled() const
++ {
++ return m_enabled;
++ }
++
++ void QQStyleKitLayout::setEnabled(bool enabled)
++ {
++ if (m_enabled == enabled)
++ return;
++
++ m_enabled = enabled;
++ emit enabledChanged();
++
++ if (m_enabled)
++ polish();
++ }
++
++ void QQStyleKitLayout::updatePolish()
++ {
++ if (!m_enabled)
++ return;
++
++ if (!m_container || m_container->width() <= 0 || m_container->height() <= 0)
++ return;
++
++ QList<QQStyleKitLayoutItem *> left;
++ QList<QQStyleKitLayoutItem *> right;
++ QList<QQStyleKitLayoutItem *> center;
++
++ for (QQStyleKitLayoutItem *li : m_layoutItems) {
++ if (!li->item() || !li->item()->isVisible())
++ continue;
++ if (li->fillWidth()) {
++ // fillWidth items always expand to fill the available width,
++ // so horizontal alignment has no effect.
++ left.append(li);
++ continue;
++ }
++ const auto hAlign = li->alignment() & Qt::AlignHorizontal_Mask;
++ const bool isMirrored = m_mirrored && !(hAlign & Qt::AlignAbsolute);
++ switch (hAlign) {
++ case Qt::AlignLeft:
++ if (isMirrored)
++ right.append(li);
++ else
++ left.append(li);
++ break;
++ case Qt::AlignRight:
++ if (isMirrored)
++ left.append(li);
++ else
++ right.append(li);
++ break;
++ default:
++ center.append(li);
++ break;
++ }
++ }
++
++ const qreal containerWidth = m_container->width() ? m_container->width() : m_container->implicitWidth();
++ const qreal containerHeight = m_container->height() ? m_container->height() : m_container->implicitHeight();
++ const qreal paddedX = m_contentMargins.left();
++ const qreal paddedY = m_contentMargins.top();
++ const qreal paddedWidth = qMax(containerWidth - m_contentMargins.left() - m_contentMargins.right(), .0);
++ const qreal paddedHeight = qMax(containerHeight - m_contentMargins.top() - m_contentMargins.bottom(), .0);
++
++ qreal maxTopMargin = .0;
++ qreal maxBottomMargin = .0;
++
++ // Position left-aligned items
++ {
++ qreal x = paddedX;
++ for (QQStyleKitLayoutItem *li : left) {
++ QQuickItem *item = li->item();
++ if (!item || !item->isVisible())
++ continue;
++
++ const QMarginsF margins = li->margins();
++ const qreal itemWidth = layoutWidth(li, paddedWidth);
++ const qreal itemHeight = layoutHeight(li, paddedHeight);
++ auto y = vAlignY(li, paddedY, paddedHeight);
++ li->setX(x + margins.left());
++ li->setY(y);
++ li->setWidth(itemWidth);
++ li->setHeight(itemHeight);
++ x += itemWidth + margins.left() + margins.right() + m_spacing;
++ maxTopMargin = qMax(maxTopMargin, margins.top());
++ maxBottomMargin = qMax(maxBottomMargin, margins.bottom());
++ }
++ }
++
++ // Position right-aligned items
++ {
++ qreal x = paddedX + paddedWidth;
++ for (QQStyleKitLayoutItem *li : right) {
++ QQuickItem *item = li->item();
++ if (!item || !item->isVisible())
++ continue;
++
++ const QMarginsF margins = li->margins();
++ const qreal itemWidth = layoutWidth(li, paddedWidth);
++ const qreal itemHeight = layoutHeight(li, paddedHeight);
++ x -= itemWidth + margins.right() + margins.left();
++ auto y = vAlignY(li, paddedY, paddedHeight);
++ li->setX(x + margins.left());
++ li->setY(y);
++ li->setWidth(itemWidth);
++ li->setHeight(itemHeight);
++ x -= m_spacing;
++ maxTopMargin = qMax(maxTopMargin, margins.top());
++ maxBottomMargin = qMax(maxBottomMargin, margins.bottom());
++ }
++ }
++
++ // Position center-aligned items
++ {
++ qreal x = paddedX + (paddedWidth - totalWidth(center, m_spacing)) / 2;
++ for (QQStyleKitLayoutItem *li : center) {
++ QQuickItem *item = li->item();
++ if (!item || !item->isVisible())
++ continue;
++
++ const QMarginsF margins = li->margins();
++ const qreal itemWidth = layoutWidth(li, paddedWidth);
++ const qreal itemHeight = layoutHeight(li, paddedHeight);
++ auto y = vAlignY(li, paddedY, paddedHeight);
++ li->setX(x + margins.left());
++ li->setY(y);
++ li->setWidth(itemWidth);
++ li->setHeight(itemHeight);
++ x += itemWidth + margins.left() + margins.right() + m_spacing;
++ maxTopMargin = qMax(maxTopMargin, margins.top());
++ maxBottomMargin = qMax(maxBottomMargin, margins.bottom());
++ }
++ }
++
++ const auto leftWidth = totalWidth(left, m_spacing);
++ const auto leftHeight = totalHeight(left);
++ const auto rightWidth = totalWidth(right, m_spacing);
++ const auto rightHeight = totalHeight(right);
++ const auto centerWidth = totalWidth(center, m_spacing);
++ const auto centerHeight = totalHeight(center);
++
++ const auto implicitWidth = leftWidth + rightWidth + centerWidth
++ - m_spacing * (left.isEmpty() ? 0 : 1)
++ - m_spacing * (right.isEmpty() ? 0 : 1)
++ - m_spacing * (center.isEmpty() ? 0 : 1)
++ + m_contentMargins.left() + m_contentMargins.right();
++ setImplicitWidth(implicitWidth);
++ const auto implicitHeight = qMax(qMax(leftHeight, rightHeight), centerHeight)
++ + m_contentMargins.top() + m_contentMargins.bottom();
++ setImplicitHeight(implicitHeight);
++
++ // HACK for control's contentItem
++ // QQuickControl determines the contentItem geometry based on the control size and padding
++ // So we include the layout's left/right widths into the padding calculation
++ auto leftPadding = m_contentMargins.left() + leftWidth;
++ auto topPadding = m_contentMargins.top() + maxTopMargin; // TODO: support vertical layout items
++ auto rightPadding = m_contentMargins.right() + rightWidth;
++ auto bottomPadding = m_contentMargins.bottom() + maxBottomMargin; // TODO: support vertical layout items
++ if (isMirrored())
++ std::swap(leftPadding, rightPadding);
++ QMarginsF newPadding = QMarginsF(leftPadding, topPadding, rightPadding, bottomPadding);
++ if (m_padding != newPadding) {
++ m_padding = newPadding;
++ emit paddingChanged();
++ }
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qqstylekitlayout_p.cpp"