LayoutBuilder: Rework

Everying is a LayoutItem now, and everything is split into
a proper setup and execution phase.

Execution happens only via LayoutBuilder (directly or via
convenience wrappers in LayoutItem).

No direct access to the widget in creation, funnel out is
via the new bindTo() facility.

Change-Id: I7eb38fd736ae57a68f9a72a6add5c767da82b49f
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>

32 files changed, 678 insertions, 558 deletions

diff --git a/src/libs/utils/aspects.cpp b/src/libs/utils/aspects.cpp
index baf80e3fe7..fd953d2493 100644
--- a/src/libs/utils/aspects.cpp
+++ b/src/libs/utils/aspects.cpp
@@ -216,9 +216,7 @@ void BaseAspect::addLabeledItem(Layouting::LayoutBuilder &builder, QWidget *widg
     if (QLabel *l = label()) {
         l->setBuddy(widget);
         builder.addItem(l);
-        LayoutItem item(widget);
-        item.span = std::max(d->m_spanX - 1, 1);
-        builder.addItem(item);
+        builder.addItem(Span(std::max(d->m_spanX - 1, 1), LayoutItem(widget)));
     } else {
         builder.addItem(LayoutItem(widget));
     }
@@ -425,13 +423,23 @@ void BaseAspect::addToLayout(LayoutBuilder &)
 {
 }
 
-void doLayout(const BaseAspect &aspect, LayoutBuilder &builder)
+void createItem(Layouting::LayoutItem *item, const BaseAspect &aspect)
 {
-    const_cast<BaseAspect &>(aspect).addToLayout(builder);
-    if (builder.layoutType() == LayoutBuilder::FormLayout || builder.layoutType() == LayoutBuilder::VBoxLayout)
-        builder.finishRow();
+    item->onAdd = [&aspect](LayoutBuilder &builder) {
+        const_cast<BaseAspect &>(aspect).addToLayout(builder);
+        builder.addItem(br);
+    };
+}
+
+void createItem(Layouting::LayoutItem *item, const BaseAspect *aspect)
+{
+    item->onAdd = [aspect](LayoutBuilder &builder) {
+        const_cast<BaseAspect *>(aspect)->addToLayout(builder);
+        builder.addItem(br);
+    };
 }
 
+
 /*!
     Updates this aspect's value from user-initiated changes in the widget.
 
@@ -1063,7 +1071,7 @@ void StringAspect::addToLayout(Layouting::LayoutBuilder &builder)
 {
     if (d->m_checker && d->m_checkBoxPlacement == CheckBoxPlacement::Top) {
         d->m_checker->addToLayout(builder);
-        builder.finishRow();
+        builder.addItem(br);
     }
 
     const auto useMacroExpander = [this](QWidget *w) {
@@ -1404,8 +1412,7 @@ void BoolAspect::addToLayout(Layouting::LayoutBuilder &builder)
         break;
     case LabelPlacement::AtCheckBox: {
         d->m_checkBox->setText(labelText());
-        Layouting::LayoutBuilder::LayoutType type = builder.layoutType();
-        if (type == LayoutBuilder::FormLayout)
+        if (builder.isForm())
             builder.addItem(createSubWidget<QLabel>());
         builder.addItem(d->m_checkBox.data());
         break;
@@ -1566,7 +1573,8 @@ void SelectionAspect::addToLayout(Layouting::LayoutBuilder &builder)
             button->setChecked(i == value());
             button->setEnabled(option.enabled);
             button->setToolTip(option.tooltip);
-            builder.addItems({Layouting::empty, button});
+            builder.addItem(Layouting::empty);
+            builder.addItem(button);
             d->m_buttons.append(button);
             d->m_buttonGroup->addButton(button, i);
             if (isAutoApply()) {
@@ -2284,7 +2292,7 @@ TextDisplay::~TextDisplay() = default;
 /*!
     \reimp
 */
-void TextDisplay::addToLayout(LayoutBuilder &builder)
+void TextDisplay::addToLayout(Layouting::LayoutBuilder &builder)
 {
     if (!d->m_label) {
         d->m_label = createSubWidget<InfoLabel>(d->m_message, d->m_type);
diff --git a/src/libs/utils/aspects.h b/src/libs/utils/aspects.h
index 9950fbef61..3eae9ffaea 100644
--- a/src/libs/utils/aspects.h
+++ b/src/libs/utils/aspects.h
@@ -18,7 +18,10 @@ class QAction;
 class QSettings;
 QT_END_NAMESPACE
 
-namespace Layouting { class LayoutBuilder; }
+namespace Layouting {
+class LayoutItem;
+class LayoutBuilder;
+}
 
 namespace Utils {
 
@@ -204,7 +207,8 @@ private:
     std::unique_ptr<Internal::BaseAspectPrivate> d;
 };
 
-QTCREATOR_UTILS_EXPORT void doLayout(const BaseAspect &aspect, Layouting::LayoutBuilder &builder);
+QTCREATOR_UTILS_EXPORT void createItem(Layouting::LayoutItem *item, const BaseAspect &aspect);
+QTCREATOR_UTILS_EXPORT void createItem(Layouting::LayoutItem *item, const BaseAspect *aspect);
 
 class QTCREATOR_UTILS_EXPORT BoolAspect : public BaseAspect
 {
diff --git a/src/libs/utils/layoutbuilder.cpp b/src/libs/utils/layoutbuilder.cpp
index e86e69a830..c7ead009c7 100644
--- a/src/libs/utils/layoutbuilder.cpp
+++ b/src/libs/utils/layoutbuilder.cpp
@@ -10,10 +10,12 @@
 #include <QLabel>
 #include <QPushButton>
 #include <QStackedLayout>
+#include <QSpacerItem>
 #include <QSplitter>
 #include <QStyle>
 #include <QTabWidget>
 #include <QTextEdit>
+#include <QApplication>
 
 namespace Layouting {
 
@@ -26,20 +28,7 @@ namespace Layouting {
 
 
 /*!
-    \enum Utils::LayoutBuilder::LayoutType
-    \inmodule QtCreator
-
-    The LayoutType enum describes the type of \c QLayout a layout builder
-    operates on.
-
-    \value Form
-    \value Grid
-    \value HBox
-    \value VBox
-*/
-
-/*!
-    \class Utils::LayoutBuilder::LayoutItem
+    \class Layouting::LayoutItem
     \inmodule QtCreator
 
     \brief The LayoutItem class represents widgets, layouts, and aggregate
@@ -53,8 +42,9 @@ namespace Layouting {
 /*!
     Constructs a layout item instance representing an empty cell.
  */
-LayoutItem::LayoutItem()
-{}
+LayoutItem::LayoutItem() = default;
+
+LayoutItem::~LayoutItem() = default;
 
 
 /*!
@@ -70,47 +60,38 @@ LayoutItem::LayoutItem()
     \endlist
  */
 
+struct ResultItem
+{
+    ResultItem() = default;
+    explicit ResultItem(QLayout *l) : layout(l) {}
+    explicit ResultItem(QWidget *w) : widget(w) {}
 
-/*!
-    Constructs a layout item representing something that knows how to add it
-    to a layout by itself.
- */
-QLayout *LayoutBuilder::createLayout() const
+    QString text;
+    QLayout *layout = nullptr;
+    QWidget *widget = nullptr;
+    int space = -1;
+    int stretch = -1;
+    int span = 1;
+};
+
+struct LayoutBuilder::Slice
 {
+    Slice() = default;
+    Slice(QLayout *l) : layout(l) {}
+    Slice(QWidget *w) : widget(w) {}
+    Slice(QWidget *w, AttachType a) : widget(w), attachType(a) {}
+
     QLayout *layout = nullptr;
-    switch (m_layoutType) {
-    case LayoutBuilder::FormLayout: {
-        auto formLayout = new QFormLayout;
-        formLayout->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow);
-        layout = formLayout;
-        break;
-    }
-    case LayoutBuilder::GridLayout: {
-        auto gridLayout = new QGridLayout;
-        layout = gridLayout;
-        break;
-    }
-    case LayoutBuilder::HBoxLayout: {
-        auto hboxLayout = new QHBoxLayout;
-        layout = hboxLayout;
-        break;
-    }
-    case LayoutBuilder::VBoxLayout: {
-        auto vboxLayout = new QVBoxLayout;
-        layout = vboxLayout;
-        break;
-    }
-    case LayoutBuilder::StackLayout: {
-        auto stackLayout = new QStackedLayout;
-        layout = stackLayout;
-        break;
-    }
-    }
-    QTC_ASSERT(layout, return nullptr);
-    if (m_spacing)
-        layout->setSpacing(*m_spacing);
-    return layout;
-}
+    QWidget *widget = nullptr;
+
+    void flush();
+
+    int currentGridColumn = 0;
+    int currentGridRow = 0;
+
+    AttachType attachType = WithMargins;
+    QList<ResultItem> pendingItems;
+};
 
 static QWidget *widgetForItem(QLayoutItem *item)
 {
@@ -135,18 +116,16 @@ static QLabel *createLabel(const QString &text)
     return label;
 }
 
-static void addItemToBoxLayout(QBoxLayout *layout, const LayoutItem &item)
+static void addItemToBoxLayout(QBoxLayout *layout, const ResultItem &item)
 {
     if (QWidget *w = item.widget) {
         layout->addWidget(w);
     } else if (QLayout *l = item.layout) {
         layout->addLayout(l);
-    } else if (item.specialType == LayoutItem::SpecialType::Stretch) {
-        layout->addStretch(item.specialValue.toInt());
-    } else if (item.specialType == LayoutItem::SpecialType::Space) {
-        layout->addSpacing(item.specialValue.toInt());
-    } else if (item.specialType == LayoutItem::SpecialType::HorizontalRule) {
-        layout->addWidget(Layouting::createHr());
+    } else if (item.stretch != -1) {
+        layout->addStretch(item.stretch);
+    } else if (item.space != -1) {
+        layout->addSpacing(item.space);
     } else if (!item.text.isEmpty()) {
         layout->addWidget(createLabel(item.text));
     } else {
@@ -154,138 +133,168 @@ static void addItemToBoxLayout(QBoxLayout *layout, const LayoutItem &item)
     }
 }
 
-static void flushPendingFormItems(QFormLayout *formLayout,
-                                  LayoutBuilder::LayoutItems &pendingFormItems)
+void LayoutBuilder::Slice::flush()
 {
-    QTC_ASSERT(formLayout, return);
-
-    if (pendingFormItems.empty())
+    if (pendingItems.empty())
         return;
 
-    // If there are more than two items, we cram the last ones in one hbox.
-    if (pendingFormItems.size() > 2) {
-        auto hbox = new QHBoxLayout;
-        hbox->setContentsMargins(0, 0, 0, 0);
-        for (int i = 1; i < pendingFormItems.size(); ++i)
-            addItemToBoxLayout(hbox, pendingFormItems.at(i));
-        while (pendingFormItems.size() >= 2)
-            pendingFormItems.pop_back();
-        pendingFormItems.append(LayoutItem(hbox));
-    }
+    if (auto formLayout = qobject_cast<QFormLayout *>(layout)) {
+
+        // If there are more than two items, we cram the last ones in one hbox.
+        if (pendingItems.size() > 2) {
+            auto hbox = new QHBoxLayout;
+            hbox->setContentsMargins(0, 0, 0, 0);
+            for (int i = 1; i < pendingItems.size(); ++i)
+                addItemToBoxLayout(hbox, pendingItems.at(i));
+            while (pendingItems.size() > 1)
+                pendingItems.pop_back();
+            pendingItems.append(ResultItem(hbox));
+        }
 
-    if (pendingFormItems.size() == 1) { // One one item given, so this spans both columns.
-        if (auto layout = pendingFormItems.at(0).layout)
-            formLayout->addRow(layout);
-        else if (auto widget = pendingFormItems.at(0).widget)
-            formLayout->addRow(widget);
-    } else if (pendingFormItems.size() == 2) { // Normal case, both columns used.
-        if (auto label = pendingFormItems.at(0).widget) {
-            if (auto layout = pendingFormItems.at(1).layout)
-                formLayout->addRow(label, layout);
-            else if (auto widget = pendingFormItems.at(1).widget)
-                formLayout->addRow(label, widget);
-        } else  {
-            if (auto layout = pendingFormItems.at(1).layout)
-                formLayout->addRow(pendingFormItems.at(0).text, layout);
-            else if (auto widget = pendingFormItems.at(1).widget)
-                formLayout->addRow(pendingFormItems.at(0).text, widget);
+        if (pendingItems.size() == 1) { // One one item given, so this spans both columns.
+            const ResultItem &f0 = pendingItems.at(0);
+            if (auto layout = f0.layout)
+                formLayout->addRow(layout);
+            else if (auto widget = f0.widget)
+                formLayout->addRow(widget);
+        } else if (pendingItems.size() == 2) { // Normal case, both columns used.
+            ResultItem &f1 = pendingItems[1];
+            const ResultItem &f0 = pendingItems.at(0);
+            if (!f1.widget && !f1.layout && !f1.text.isEmpty())
+                f1.widget = createLabel(f1.text);
+
+            if (f0.widget) {
+                if (f1.layout)
+                    formLayout->addRow(f0.widget, f1.layout);
+                else if (f1.widget)
+                    formLayout->addRow(f0.widget, f1.widget);
+            } else  {
+                if (f1.layout)
+                    formLayout->addRow(f0.text, f1.layout);
+                else if (f1.widget)
+                    formLayout->addRow(f0.text, f1.widget);
+            }
+        } else {
+            QTC_CHECK(false);
         }
+
+        // Set up label as buddy if possible.
+        const int lastRow = formLayout->rowCount() - 1;
+        QLayoutItem *l = formLayout->itemAt(lastRow, QFormLayout::LabelRole);
+        QLayoutItem *f = formLayout->itemAt(lastRow, QFormLayout::FieldRole);
+        if (l && f) {
+            if (QLabel *label = qobject_cast<QLabel *>(l->widget())) {
+                if (QWidget *widget = widgetForItem(f))
+                    label->setBuddy(widget);
+            }
+        }
+
+    } else if (auto gridLayout = qobject_cast<QGridLayout *>(layout)) {
+
+        for (const ResultItem &item : std::as_const(pendingItems)) {
+             Qt::Alignment align = {};
+    //         if (attachType == Layouting::WithFormAlignment && currentGridColumn == 0)
+    //             align = Qt::Alignment(m_widget->style()->styleHint(QStyle::SH_FormLayoutLabelAlignment));
+             if (item.widget)
+                 gridLayout->addWidget(item.widget, currentGridRow, currentGridColumn, 1, item.span, align);
+             else if (item.layout)
+                 gridLayout->addLayout(item.layout, currentGridRow, currentGridColumn, 1, item.span, align);
+             else if (!item.text.isEmpty())
+                 gridLayout->addWidget(createLabel(item.text), currentGridRow, currentGridColumn, 1, 1, align);
+             currentGridColumn += item.span;
+        }
+        ++currentGridRow;
+        currentGridColumn = 0;
+
+    } else if (auto boxLayout = qobject_cast<QBoxLayout *>(layout)) {
+
+        for (const ResultItem &item : std::as_const(pendingItems))
+            addItemToBoxLayout(boxLayout, item);
+
+    } else if (auto stackLayout = qobject_cast<QStackedLayout *>(layout)) {
+        for (const ResultItem &item : std::as_const(pendingItems)) {
+            if (item.widget)
+                stackLayout->addWidget(item.widget);
+            else
+                QTC_CHECK(false);
+        }
+
     } else {
         QTC_CHECK(false);
     }
 
-    // Set up label as buddy if possible.
-    const int lastRow = formLayout->rowCount() - 1;
-    QLayoutItem *l = formLayout->itemAt(lastRow, QFormLayout::LabelRole);
-    QLayoutItem *f = formLayout->itemAt(lastRow, QFormLayout::FieldRole);
-    if (l && f) {
-        if (QLabel *label = qobject_cast<QLabel *>(l->widget())) {
-            if (QWidget *widget = widgetForItem(f))
-                label->setBuddy(widget);
-        }
+    pendingItems.clear();
+}
+
+static void addItemHelper(LayoutBuilder &builder, const LayoutItem &item)
+{
+    if (item.onAdd)
+        item.onAdd(builder);
+
+    if (item.setter) {
+        if (QWidget *widget = builder.stack.last().widget)
+            item.setter(widget);
+        else if (QLayout *layout = builder.stack.last().layout)
+            item.setter(layout);
+        else
+            QTC_CHECK(false);
     }
 
-    pendingFormItems.clear();
+    for (const LayoutItem &subItem : item.subItems)
+        addItemHelper(builder, subItem);
+
+    if (item.onExit)
+        item.onExit(builder);
 }
 
-static void doLayoutHelper(QLayout *layout,
-                           const LayoutBuilder::LayoutItems &items,
-                           const Layouting::AttachType attachType,
-                           int currentGridRow = 0)
+void doAddText(LayoutBuilder &builder, const QString &text)
 {
-    int currentGridColumn = 0;
-    LayoutBuilder::LayoutItems pendingFormItems;
-
-    auto formLayout = qobject_cast<QFormLayout *>(layout);
-    auto gridLayout = qobject_cast<QGridLayout *>(layout);
-    auto boxLayout = qobject_cast<QBoxLayout *>(layout);
-    auto stackLayout = qobject_cast<QStackedLayout *>(layout);
-
-    for (const LayoutItem &item : items) {
-        if (item.specialType == LayoutItem::SpecialType::Break) {
-            if (formLayout)
-                flushPendingFormItems(formLayout, pendingFormItems);
-            else if (gridLayout) {
-                if (currentGridColumn != 0) {
-                    ++currentGridRow;
-                    currentGridColumn = 0;
-                }
-            }
-            continue;
-        }
+    ResultItem fi;
+    fi.text = text;
+    builder.stack.last().pendingItems.append(fi);
+}
 
-        QWidget *widget = item.widget;
-
-        if (gridLayout) {
-            Qt::Alignment align = {};
-            if (attachType == Layouting::WithFormAlignment && currentGridColumn == 0)
-                align = Qt::Alignment(widget->style()->styleHint(QStyle::SH_FormLayoutLabelAlignment));
-            if (widget)
-                gridLayout->addWidget(widget, currentGridRow, currentGridColumn, 1, item.span, align);
-            else if (item.layout)
-                gridLayout->addLayout(item.layout, currentGridRow, currentGridColumn, 1, item.span, align);
-            else if (!item.text.isEmpty())
-                gridLayout->addWidget(createLabel(item.text), currentGridRow, currentGridColumn, 1, 1, align);
-            currentGridColumn += item.span;
-        } else if (boxLayout) {
-            addItemToBoxLayout(boxLayout, item);
-        } else if (stackLayout) {
-            stackLayout->addWidget(item.widget);
-        } else {
-            pendingFormItems.append(item);
-        }
-    }
+void doAddSpace(LayoutBuilder &builder, const Space &space)
+{
+    ResultItem fi;
+    fi.space = space.space;
+    builder.stack.last().pendingItems.append(fi);
+}
 
-    if (formLayout)
-        flushPendingFormItems(formLayout, pendingFormItems);
+void doAddStretch(LayoutBuilder &builder, const Stretch &stretch)
+{
+    ResultItem fi;
+    fi.stretch = stretch.stretch;
+    builder.stack.last().pendingItems.append(fi);
 }
 
+void doAddLayout(LayoutBuilder &builder, QLayout *layout)
+{
+    builder.stack.last().pendingItems.append(ResultItem(layout));
+}
 
-/*!
-    Constructs a layout item from the contents of another LayoutBuilder
- */
-void LayoutItem::setBuilder(const LayoutBuilder &builder)
+void doAddWidget(LayoutBuilder &builder, QWidget *widget)
 {
-    layout = builder.createLayout();
-    doLayoutHelper(layout, builder.m_items, Layouting::WithoutMargins);
+    builder.stack.last().pendingItems.append(ResultItem(widget));
 }
 
+
 /*!
-    \class Utils::LayoutBuilder::Space
+    \class Layouting::Space
     \inmodule QtCreator
 
-    \brief The LayoutBuilder::Space class represents some empty space in a layout.
+    \brief The Layouting::Space class represents some empty space in a layout.
  */
 
 /*!
-    \class Utils::LayoutBuilder::Stretch
+    \class Layouting::Stretch
     \inmodule QtCreator
 
-    \brief The LayoutBuilder::Stretch class represents some stretch in a layout.
+    \brief The Layouting::Stretch class represents some stretch in a layout.
  */
 
 /*!
-    \class Utils::LayoutBuilder
+    \class LayoutBuilder
     \inmodule QtCreator
 
     \brief The LayoutBuilder class provides a convenient way to fill \c QFormLayout
@@ -298,20 +307,6 @@ void LayoutItem::setBuilder(const LayoutBuilder &builder)
     \sa addItem(), addItems(), addRow(), finishRow()
 */
 
-LayoutBuilder::LayoutBuilder(LayoutType layoutType, const LayoutItems &items)
-    : m_layoutType(layoutType)
-{
-    m_items.reserve(items.size() * 2);
-    for (const LayoutItem &item : items)
-        addItem(item);
-}
-
-LayoutBuilder &LayoutBuilder::setSpacing(int spacing)
-{
-    m_spacing = spacing;
-    return *this;
-}
-
 LayoutBuilder::LayoutBuilder() = default;
 
 /*!
@@ -319,14 +314,30 @@ LayoutBuilder::LayoutBuilder() = default;
  */
 LayoutBuilder::~LayoutBuilder() = default;
 
+void LayoutBuilder::addItem(const LayoutItem &item)
+{
+    addItemHelper(*this, item);
+}
+
+void LayoutBuilder::addItems(const LayoutItems &items)
+{
+    for (const LayoutItem &item : items)
+        addItemHelper(*this, item);
+}
+
+void LayoutBuilder::addRow(const LayoutItems &items)
+{
+    addItem(br);
+    addItems(items);
+}
+
 /*!
     Instructs a layout builder to finish the current row.
     This is implicitly called by LayoutBuilder's destructor.
  */
-LayoutBuilder &LayoutBuilder::finishRow()
+void LayoutItem::finishRow()
 {
-    addItem(Break());
-    return *this;
+    addItem(br);
 }
 
 /*!
@@ -335,42 +346,26 @@ LayoutBuilder &LayoutBuilder::finishRow()
 
     \sa finishRow(), addItem(), addItems()
  */
-LayoutBuilder &LayoutBuilder::addRow(const LayoutItems &items)
+void LayoutItem::addRow(const LayoutItems &items)
 {
-    return finishRow().addItems(items);
+    finishRow();
+    addItems(items);
 }
 
 /*!
-    Adds the layout item \a item to the current row.
+    Adds the layout item \a item as sub items.
  */
-LayoutBuilder &LayoutBuilder::addItem(const LayoutItem &item)
+void LayoutItem::addItem(const LayoutItem &item)
 {
-    if (item.onAdd) {
-        item.onAdd(*this);
-    } else {
-        m_items.push_back(item);
-    }
-    return *this;
-}
-
-void LayoutBuilder::doLayout(QWidget *parent, Layouting::AttachType attachType) const
-{
-    QLayout *layout = createLayout();
-    parent->setLayout(layout);
-
-    doLayoutHelper(layout, m_items, attachType);
-    if (attachType == Layouting::WithoutMargins)
-        layout->setContentsMargins(0, 0, 0, 0);
+    subItems.append(item);
 }
 
 /*!
-    Adds the layout item \a items to the current row.
+    Adds the layout items \a items as sub items.
  */
-LayoutBuilder &LayoutBuilder::addItems(const LayoutItems &items)
+void LayoutItem::addItems(const LayoutItems &items)
 {
-    for (const LayoutItem &item : items)
-        addItem(item);
-    return *this;
+    subItems.append(items);
 }
 
 /*!
@@ -378,18 +373,106 @@ LayoutBuilder &LayoutBuilder::addItems(const LayoutItems &items)
 
     This operation can only be performed once per LayoutBuilder instance.
  */
-void LayoutBuilder::attachTo(QWidget *w, Layouting::AttachType attachType) const
+
+void LayoutItem::attachTo(QWidget *w, AttachType attachType) const
 {
-    doLayout(w, attachType);
+    LayoutBuilder builder;
+
+    builder.stack.append({w, attachType});
+    addItemHelper(builder, *this);
 }
 
-QWidget *LayoutBuilder::emerge(Layouting::AttachType attachType)
+QWidget *LayoutItem::emerge(Layouting::AttachType attachType)
 {
     auto w = new QWidget;
-    doLayout(w, attachType);
+    attachTo(w, attachType);
     return w;
 }
 
+bool LayoutBuilder::isForm() const
+{
+    return qobject_cast<QFormLayout *>(stack.last().layout);
+}
+
+static void layoutExit(LayoutBuilder &builder)
+{
+    builder.stack.last().flush();
+    QLayout *layout = builder.stack.last().layout;
+    if (builder.stack.back().attachType == WithoutMargins)
+        layout->setContentsMargins(0, 0, 0, 0);
+    builder.stack.pop_back();
+
+    if (QWidget *widget = builder.stack.last().widget)
+        widget->setLayout(layout);
+    else
+        builder.stack.last().pendingItems.append(ResultItem(layout));
+}
+
+static void widgetExit(LayoutBuilder &builder)
+{
+    QWidget *widget = builder.stack.last().widget;
+    if (builder.stack.back().attachType == WithoutMargins)
+        widget->setContentsMargins(0, 0, 0, 0);
+    builder.stack.pop_back();
+    builder.stack.last().pendingItems.append(ResultItem(widget));
+}
+
+Column::Column(std::initializer_list<LayoutItem> items)
+{
+    subItems = items;
+    onAdd = [](LayoutBuilder &builder) { builder.stack.append(new QVBoxLayout); };
+    onExit = layoutExit;
+}
+
+Row::Row(std::initializer_list<LayoutItem> items)
+{
+    subItems = items;
+    onAdd = [](LayoutBuilder &builder) { builder.stack.append(new QHBoxLayout); };
+    onExit = layoutExit;
+}
+
+Grid::Grid(std::initializer_list<LayoutItem> items)
+{
+    subItems = items;
+    onAdd = [](LayoutBuilder &builder) { builder.stack.append(new QGridLayout); };
+    onExit = layoutExit;
+}
+
+static QFormLayout *newFormLayout()
+{
+    auto formLayout = new QFormLayout;
+    formLayout->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow);
+    return formLayout;
+}
+
+Form::Form(std::initializer_list<LayoutItem> items)
+{
+    subItems = items;
+    onAdd = [](LayoutBuilder &builder) { builder.stack.append(newFormLayout()); };
+    onExit = layoutExit;
+}
+
+Stack::Stack(std::initializer_list<LayoutItem> items)
+{
+    subItems = items;
+    onAdd = [](LayoutBuilder &builder) { builder.stack.append(new QStackedLayout); };
+    onExit = layoutExit;
+}
+
+LayoutItem br()
+{
+    LayoutItem item;
+    item.onAdd = [](LayoutBuilder &builder) {
+        builder.stack.last().flush();
+        };
+    return item;
+}
+
+LayoutItem empty()
+{
+    return {};
+}
+
 /*!
     Constructs a layout extender to extend an existing \a layout.
 
@@ -399,111 +482,123 @@ QWidget *LayoutBuilder::emerge(Layouting::AttachType attachType)
  */
 
 LayoutExtender::LayoutExtender(QLayout *layout, Layouting::AttachType attachType)
-    : m_layout(layout), m_attachType(attachType)
-{}
-
-LayoutExtender::~LayoutExtender()
 {
-    QTC_ASSERT(m_layout, return);
-    int currentGridRow = 0;
-    if (auto gridLayout = qobject_cast<QGridLayout *>(m_layout))
-        currentGridRow = gridLayout->rowCount();
-    doLayoutHelper(m_layout, m_items, m_attachType, currentGridRow);
+    Slice slice;
+    slice.layout = layout;
+    if (auto gridLayout = qobject_cast<QGridLayout *>(layout))
+        slice.currentGridRow = gridLayout->rowCount();
+    slice.attachType = attachType;
+    stack.append(slice);
 }
 
-// Special items
-
-Tab::Tab(const QString &tabName, const LayoutBuilder &item)
-{
-    text = tabName;
-    widget = new QWidget;
-    item.attachTo(widget);
-    specialType = LayoutItem::SpecialType::Tab;
-}
+LayoutExtender::~LayoutExtender() = default;
 
 // "Widgets"
 
-static void applyItems(LayoutItem *owner, QWidget *widget, const QList<LayoutItem> &items)
+template <class T>
+void setupWidget(LayoutItem *item)
 {
-    owner->widget = widget;
-    bool hadLayout = false;
-    for (const LayoutItem &item : items) {
-        if (item.setter) {
-            item.setter(widget);
-        } else if (item.specialType == LayoutItem::SpecialType::Tab) {
-            auto tabWidget = qobject_cast<QTabWidget *>(widget);
-            QTC_ASSERT(tabWidget, continue);
-            tabWidget->addTab(item.widget, item.text);
-        } else if (item.layout && !hadLayout) {
-            hadLayout = true;
-            widget->setLayout(item.layout);
-        } else {
-            QTC_CHECK(false);
-        }
-    }
-}
+    item->onAdd = [](LayoutBuilder &builder) { builder.stack.append(new T); };
+    item->onExit = widgetExit;
+};
 
 Group::Group(std::initializer_list<LayoutItem> items)
 {
-    applyItems(this, new QGroupBox, items);
+    this->subItems = items;
+    setupWidget<QGroupBox>(this);
 }
 
 PushButton::PushButton(std::initializer_list<LayoutItem> items)
 {
-    applyItems(this, new QPushButton, items);
+    this->subItems = items;
+    setupWidget<QPushButton>(this);
 }
 
 TextEdit::TextEdit(std::initializer_list<LayoutItem> items)
 {
-    applyItems(this, new QTextEdit, items);
+    this->subItems = items;
+    setupWidget<QTextEdit>(this);
 }
 
 Splitter::Splitter(std::initializer_list<LayoutItem> items)
 {
-    applyItems(this, new QSplitter(Qt::Vertical), items);
- }
-
+    this->subItems = items;
+    setupWidget<QSplitter>(this); // FIXME: Default was Qt::Vertical)
+}
 
 TabWidget::TabWidget(std::initializer_list<LayoutItem> items)
- {
-    applyItems(this, new QTabWidget, items);
+{
+    this->subItems = items;
+    setupWidget<QTabWidget>(this);
 }
 
-// "Properties"
+// Special Tab
 
-static LayoutItem setter(const LayoutItem::Setter &setter)
+Tab::Tab(const QString &tabName, const LayoutItem &item)
 {
-    LayoutItem item;
-    item.setter = setter;
-    return item;
+    onAdd = [item](LayoutBuilder &builder) {
+        auto tab = new QWidget;
+        builder.stack.append(tab);
+        item.attachTo(tab);
+    };
+    onExit = [tabName](LayoutBuilder &builder) {
+        QWidget *inner = builder.stack.last().widget;
+        builder.stack.pop_back();
+        auto tabWidget = qobject_cast<QTabWidget *>(builder.stack.last().widget);
+        QTC_ASSERT(tabWidget, return);
+        tabWidget->addTab(inner, tabName);
+    };
+}
+
+// Special Application
+
+Application::Application(std::initializer_list<LayoutItem> items)
+{
+    subItems = items;
+    setupWidget<QWidget>(this);
+    onExit = {}; // Hack: Don't dropp the last slice, we need the resulting widget.
+}
+
+int Application::exec(int &argc, char *argv[])
+{
+    auto app = new QApplication(argc, argv);
+    LayoutBuilder builder;
+    addItemHelper(builder, *this);
+    if (QWidget *widget = builder.stack.last().widget)
+        widget->show();
+    return app->exec();
 }
 
+// "Properties"
+
 LayoutItem title(const QString &title)
 {
-    return setter([title](QObject *target) {
+    return [title](QObject *target) {
         if (auto groupBox = qobject_cast<QGroupBox *>(target)) {
             groupBox->setTitle(title);
             groupBox->setObjectName(title);
+        } else if (auto widget = qobject_cast<QWidget *>(target)) {
+            widget->setWindowTitle(title);
         } else {
             QTC_CHECK(false);
         }
-    });
+    };
 }
 
 LayoutItem onClicked(const std::function<void ()> &func, QObject *guard)
 {
-    return setter([func, guard](QObject *target) {
+    return [func, guard](QObject *target) {
         if (auto button = qobject_cast<QAbstractButton *>(target)) {
             QObject::connect(button, &QAbstractButton::clicked, guard ? guard : target, func);
         } else {
             QTC_CHECK(false);
         }
-    });
+    };
 }
 
 LayoutItem text(const QString &text)
 {
-    return setter([text](QObject *target) {
+    return [text](QObject *target) {
         if (auto button = qobject_cast<QAbstractButton *>(target)) {
             button->setText(text);
         } else if (auto textEdit = qobject_cast<QTextEdit *>(target)) {
@@ -511,32 +606,40 @@ LayoutItem text(const QString &text)
         } else {
             QTC_CHECK(false);
         }
-    });
+    };
 }
 
 LayoutItem tooltip(const QString &toolTip)
 {
-    return setter([toolTip](QObject *target) {
+    return [toolTip](QObject *target) {
         if (auto widget = qobject_cast<QWidget *>(target)) {
             widget->setToolTip(toolTip);
         } else {
             QTC_CHECK(false);
         }
-    });
+    };
 }
 
-LayoutItem bindTo(QSplitter **out)
+LayoutItem spacing(int spacing)
 {
-    return setter([out](QObject *target) {
-        *out = qobject_cast<QSplitter *>(target);
-    });
+    return [spacing](QObject *target) {
+        if (auto layout = qobject_cast<QLayout *>(target)) {
+            layout->setSpacing(spacing);
+        } else {
+            QTC_CHECK(false);
+        }
+    };
 }
 
-LayoutItem bindTo(QTabWidget **out)
+LayoutItem resize(int w, int h)
 {
-    return setter([out](QObject *target) {
-        *out = qobject_cast<QTabWidget *>(target);
-    });
+    return [w, h](QObject *target) {
+        if (auto widget = qobject_cast<QWidget *>(target)) {
+            widget->resize(w, h);
+        } else {
+            QTC_CHECK(false);
+        }
+    };
 }
 
 QWidget *createHr(QWidget *parent)
@@ -548,9 +651,67 @@ QWidget *createHr(QWidget *parent)
 }
 
 // Singletons.
-Break br;
-Stretch st;
-Space empty(0);
-HorizontalRule hr;
+
+LayoutItem::LayoutItem(const LayoutItem &t)
+{
+    operator=(t);
+}
+
+void createItem(LayoutItem *item,  LayoutItem(*t)())
+{
+    *item = t();
+}
+
+void createItem(LayoutItem *item, const std::function<void(QObject *target)> &t)
+{
+    item->setter = t;
+}
+
+void createItem(LayoutItem *item, QWidget *t)
+{
+    item->onAdd = [t](LayoutBuilder &builder) { doAddWidget(builder, t); };
+}
+
+void createItem(LayoutItem *item, QLayout *t)
+{
+    item->onAdd = [t](LayoutBuilder &builder) { doAddLayout(builder, t); };
+}
+
+void createItem(LayoutItem *item, const QString &t)
+{
+    item->onAdd = [t](LayoutBuilder &builder) { doAddText(builder, t); };
+}
+
+void createItem(LayoutItem *item, const Space &t)
+{
+    item->onAdd = [t](LayoutBuilder &builder) { doAddSpace(builder, t); };
+}
+
+void createItem(LayoutItem *item, const Stretch &t)
+{
+    item->onAdd = [t](LayoutBuilder &builder) { doAddStretch(builder, t); };
+}
+
+void createItem(LayoutItem *item, const Span &t)
+{
+    item->onAdd = [t](LayoutBuilder &builder) {
+        addItemHelper(builder, t.item);
+        builder.stack.last().pendingItems.last().span = t.span;
+    };
+}
+
+LayoutItem hr()
+{
+    LayoutItem item;
+    item.onAdd = [](LayoutBuilder &builder) { doAddWidget(builder, createHr()); };
+    return item;
+}
+
+LayoutItem st()
+{
+    LayoutItem item;
+    item.onAdd = [](LayoutBuilder &builder) { doAddStretch(builder, Stretch(1)); };
+    return item;
+}
 
 } // Layouting
diff --git a/src/libs/utils/layoutbuilder.h b/src/libs/utils/layoutbuilder.h
index aea4db876c..1e9e6b9ad3 100644
--- a/src/libs/utils/layoutbuilder.h
+++ b/src/libs/utils/layoutbuilder.h
@@ -5,7 +5,6 @@
 
 #include <QList>
 #include <QString>
-#include <QVariant>
 #include <QtGlobal>
 
 #include <optional>
@@ -18,10 +17,9 @@
 
 QT_BEGIN_NAMESPACE
 class QLayout;
-class QSplitter;
-class QTabWidget;
-class QTextEdit;
+class QObject;
 class QWidget;
+template <class T> T qobject_cast(QObject *object);
 QT_END_NAMESPACE
 
 namespace Layouting {
@@ -34,6 +32,7 @@ enum AttachType {
 
 class LayoutBuilder;
 class LayoutItem;
+class Span;
 
 // Special items
 
@@ -51,27 +50,19 @@ public:
     const int stretch;
 };
 
-class QTCREATOR_UTILS_EXPORT Break
-{
-public:
-    Break() {}
-};
 
-class QTCREATOR_UTILS_EXPORT Span
-{
-public:
-    Span(int span, const LayoutItem &item) : span(span), item(item) {}
-    const int span;
-    const LayoutItem &item;
-};
+// LayoutItem
 
-class QTCREATOR_UTILS_EXPORT HorizontalRule
-{
-public:
-    HorizontalRule() {}
-};
+using LayoutItems = QList<LayoutItem>;
 
-// LayoutItem
+void QTCREATOR_UTILS_EXPORT createItem(LayoutItem *item, const std::function<void(QObject *target)> &t);
+void QTCREATOR_UTILS_EXPORT createItem(LayoutItem *item, QWidget *t);
+void QTCREATOR_UTILS_EXPORT createItem(LayoutItem *item, QLayout *t);
+void QTCREATOR_UTILS_EXPORT createItem(LayoutItem *item, LayoutItem(*t)());
+void QTCREATOR_UTILS_EXPORT createItem(LayoutItem *item, const QString &t);
+void QTCREATOR_UTILS_EXPORT createItem(LayoutItem *item, const Span &t);
+void QTCREATOR_UTILS_EXPORT createItem(LayoutItem *item, const Space &t);
+void QTCREATOR_UTILS_EXPORT createItem(LayoutItem *item, const Stretch &t);
 
 class QTCREATOR_UTILS_EXPORT LayoutItem
 {
@@ -81,72 +72,81 @@ public:
         AlignAsFormLabel,
     };
 
-    enum class SpecialType {
-        NotSpecial,
-        Space,
-        Stretch,
-        Break,
-        HorizontalRule,
-        Tab,
-    };
-
     using Setter = std::function<void(QObject *target)>;
-    using OnAdder = std::function<void(LayoutBuilder &)>;
 
     LayoutItem();
+    ~LayoutItem();
+
+    LayoutItem(const LayoutItem &t);
+    LayoutItem &operator=(const LayoutItem &t) = default;
 
     template <class T> LayoutItem(const T &t)
     {
-        if constexpr (std::is_same_v<QString, T>) {
-            text = t;
-        } else if constexpr (std::is_same_v<Space, T>) {
-            specialType = LayoutItem::SpecialType::Space;
-            specialValue = t.space;
-        } else if constexpr (std::is_same_v<Stretch, T>) {
-            specialType = LayoutItem::SpecialType::Stretch;
-            specialValue = t.stretch;
-        } else if constexpr (std::is_same_v<Break, T>) {
-            specialType = LayoutItem::SpecialType::Break;
-        } else if constexpr (std::is_same_v<Span, T>) {
-            LayoutItem::operator=(t.item);
-            span = t.span;
-        } else if constexpr (std::is_same_v<HorizontalRule, T>) {
-            specialType = SpecialType::HorizontalRule;
-        } else if constexpr (std::is_base_of_v<LayoutBuilder, T>) {
-            setBuilder(t);
-        } else if constexpr (std::is_base_of_v<LayoutItem, T>) {
+        if constexpr (std::is_base_of_v<LayoutItem, T>)
             LayoutItem::operator=(t);
-        } else if constexpr (std::is_base_of_v<Setter, T>) {
-            setter = t;
-        } else if constexpr (std::is_base_of_v<QLayout, std::remove_pointer_t<T>>) {
-            layout = t;
-        } else if constexpr (std::is_base_of_v<QWidget, std::remove_pointer_t<T>>) {
-            widget = t;
-        } else if constexpr (std::is_pointer_v<T>) {
-            onAdd = [t](LayoutBuilder &builder) { doLayout(*t, builder); };
-        } else {
-            onAdd = [&t](LayoutBuilder &builder) { doLayout(t, builder); };
-        }
+        else
+            createItem(this, t);
     }
 
-    void setBuilder(const LayoutBuilder &builder);
+    void attachTo(QWidget *w, AttachType attachType = WithMargins) const;
+    QWidget *emerge(AttachType attachType = WithMargins);
+
+    void addItem(const LayoutItem &item);
+    void addItems(const LayoutItems &items);
+    void addRow(const LayoutItems &items);
+    void finishRow();
+
+    std::function<void(LayoutBuilder &)> onAdd;
+    std::function<void(LayoutBuilder &)> onExit;
+    std::function<void(QObject *target)> setter;
+    LayoutItems subItems;
+};
+
+class QTCREATOR_UTILS_EXPORT Span
+{
+public:
+    Span(int span, const LayoutItem &item) : span(span), item(item) {}
+    const int span;
+    LayoutItem item;
+};
 
-    QLayout *layout = nullptr;
-    QWidget *widget = nullptr;
-    OnAdder onAdd;
+class QTCREATOR_UTILS_EXPORT Column : public LayoutItem
+{
+public:
+    Column(std::initializer_list<LayoutItem> items);
+};
+
+class QTCREATOR_UTILS_EXPORT Row : public LayoutItem
+{
+public:
+    Row(std::initializer_list<LayoutItem> items);
+};
+
+class QTCREATOR_UTILS_EXPORT Grid : public LayoutItem
+{
+public:
+    Grid() : Grid({}) {}
+    Grid(std::initializer_list<LayoutItem> items);
+};
+
+class QTCREATOR_UTILS_EXPORT Form : public LayoutItem
+{
+public:
+    Form() : Form({}) {}
+    Form(std::initializer_list<LayoutItem> items);
+};
 
-    QString text; // FIXME: Use specialValue for that
-    int span = 1;
-    AlignmentType align = AlignmentType::DefaultAlignment;
-    Setter setter;
-    SpecialType specialType = SpecialType::NotSpecial;
-    QVariant specialValue;
+class QTCREATOR_UTILS_EXPORT Stack : public LayoutItem
+{
+public:
+    Stack() : Stack({}) {}
+    Stack(std::initializer_list<LayoutItem> items);
 };
 
 class QTCREATOR_UTILS_EXPORT Tab : public LayoutItem
 {
 public:
-    Tab(const QString &tabName, const LayoutBuilder &item);
+    Tab(const QString &tabName, const LayoutItem &item);
 };
 
 class QTCREATOR_UTILS_EXPORT Group : public LayoutItem
@@ -179,124 +179,67 @@ public:
     TabWidget(std::initializer_list<LayoutItem> items);
 };
 
-// Singleton items.
+class QTCREATOR_UTILS_EXPORT Application : public LayoutItem
+{
+public:
+    Application(std::initializer_list<LayoutItem> items);
 
-QTCREATOR_UTILS_EXPORT extern Break br;
-QTCREATOR_UTILS_EXPORT extern Stretch st;
-QTCREATOR_UTILS_EXPORT extern Space empty;
-QTCREATOR_UTILS_EXPORT extern HorizontalRule hr;
+    int exec(int &argc, char *argv[]);
+};
 
-// "Properties"
+// "Singletons"
 
-QTCREATOR_UTILS_EXPORT LayoutItem bindTo(QTabWidget **);
-QTCREATOR_UTILS_EXPORT LayoutItem bindTo(QSplitter **);
+QTCREATOR_UTILS_EXPORT LayoutItem br();
+QTCREATOR_UTILS_EXPORT LayoutItem st();
+QTCREATOR_UTILS_EXPORT LayoutItem empty();
+QTCREATOR_UTILS_EXPORT LayoutItem hr();
+
+// "Properties"
 
 QTCREATOR_UTILS_EXPORT LayoutItem title(const QString &title);
 QTCREATOR_UTILS_EXPORT LayoutItem text(const QString &text);
 QTCREATOR_UTILS_EXPORT LayoutItem tooltip(const QString &toolTip);
-QTCREATOR_UTILS_EXPORT LayoutItem onClicked(const std::function<void()> &func,
-                                                    QObject *guard = nullptr);
-
+QTCREATOR_UTILS_EXPORT LayoutItem resize(int, int);
+QTCREATOR_UTILS_EXPORT LayoutItem spacing(int);
+QTCREATOR_UTILS_EXPORT LayoutItem windowTitle(const QString &windowTitle);
+QTCREATOR_UTILS_EXPORT LayoutItem onClicked(const std::function<void()> &,
+                                            QObject *guard = nullptr);
 
 // Convenience
 
 QTCREATOR_UTILS_EXPORT QWidget *createHr(QWidget *parent = nullptr);
 
+template <class T>
+LayoutItem bindTo(T **out)
+{
+    return [out](QObject *target) { *out = qobject_cast<T *>(target); };
+}
 
 // LayoutBuilder
 
 class QTCREATOR_UTILS_EXPORT LayoutBuilder
 {
-    Q_DISABLE_COPY(LayoutBuilder)
+    Q_DISABLE_COPY_MOVE(LayoutBuilder)
 
 public:
-    enum LayoutType {
-        HBoxLayout,
-        VBoxLayout,
-        FormLayout,
-        GridLayout,
-        StackLayout,
-    };
-
-    using LayoutItems = QList<LayoutItem>;
-
-    explicit LayoutBuilder(LayoutType layoutType, const LayoutItems &items = {});
-
-    LayoutBuilder(LayoutBuilder &&) = default;
-    LayoutBuilder &operator=(LayoutBuilder &&) = default;
-
+    LayoutBuilder();
     ~LayoutBuilder();
 
-    LayoutBuilder &setSpacing(int spacing);
-
-    LayoutBuilder &addItem(const LayoutItem &item);
-    LayoutBuilder &addItems(const LayoutItems &items);
-
-    LayoutBuilder &finishRow();
-    LayoutBuilder &addRow(const LayoutItems &items);
-
-    LayoutType layoutType() const { return m_layoutType; }
-
-    void attachTo(QWidget *w, Layouting::AttachType attachType = Layouting::WithMargins) const;
-    QWidget *emerge(Layouting::AttachType attachType = Layouting::WithMargins);
-
-protected:
-    friend class LayoutItem;
-
-    explicit LayoutBuilder(); // Adds to existing layout.
+    void addItem(const LayoutItem &item);
+    void addItems(const LayoutItems &items);
+    void addRow(const LayoutItems &items);
 
-    QLayout *createLayout() const;
-    void doLayout(QWidget *parent, Layouting::AttachType attachType) const;
+    bool isForm() const;
 
-    LayoutItems m_items;
-    LayoutType m_layoutType;
-    std::optional<int> m_spacing;
+    struct Slice;
+    QList<Slice> stack;
 };
 
 class QTCREATOR_UTILS_EXPORT LayoutExtender : public LayoutBuilder
 {
 public:
-    explicit LayoutExtender(QLayout *layout, Layouting::AttachType attachType);
+    explicit LayoutExtender(QLayout *layout, AttachType attachType);
     ~LayoutExtender();
-
-private:
-    QLayout *m_layout = nullptr;
-    Layouting::AttachType m_attachType = {};
-};
-
-class QTCREATOR_UTILS_EXPORT Column : public LayoutBuilder
-{
-public:
-    Column() : LayoutBuilder(VBoxLayout) {}
-    Column(std::initializer_list<LayoutItem> items) : LayoutBuilder(VBoxLayout, items) {}
-};
-
-class QTCREATOR_UTILS_EXPORT Row : public LayoutBuilder
-{
-public:
-    Row() : LayoutBuilder(HBoxLayout) {}
-    Row(std::initializer_list<LayoutItem> items) : LayoutBuilder(HBoxLayout, items) {}
-};
-
-class QTCREATOR_UTILS_EXPORT Grid : public LayoutBuilder
-{
-public:
-    Grid() : LayoutBuilder(GridLayout) {}
-    Grid(std::initializer_list<LayoutItem> items) : LayoutBuilder(GridLayout, items) {}
-};
-
-class QTCREATOR_UTILS_EXPORT Form : public LayoutBuilder
-{
-public:
-    Form() : LayoutBuilder(FormLayout) {}
-    Form(std::initializer_list<LayoutItem> items) : LayoutBuilder(FormLayout, items) {}
-};
-
-class QTCREATOR_UTILS_EXPORT Stack : public LayoutBuilder
-{
-public:
-    Stack() : LayoutBuilder(StackLayout) {}
-    Stack(std::initializer_list<LayoutItem> items) : LayoutBuilder(StackLayout, items) {}
 };
 
 } // Layouting
diff --git a/src/plugins/beautifier/artisticstyle/artisticstyleoptionspage.cpp b/src/plugins/beautifier/artisticstyle/artisticstyleoptionspage.cpp
index 9d2741209e..a968c2eb96 100644
--- a/src/plugins/beautifier/artisticstyle/artisticstyleoptionspage.cpp
+++ b/src/plugins/beautifier/artisticstyle/artisticstyleoptionspage.cpp
@@ -91,7 +91,7 @@ ArtisticStyleOptionsPageWidget::ArtisticStyleOptionsPageWidget(ArtisticStyleSett
         Row { m_useSpecificConfigFile, m_specificConfigFile },
         m_useHomeFile,
         Row { m_useCustomStyle, m_configurations }
-    }.attachTo(options);
+    }.attachTo(options, WithoutMargins);
 
     Column {
         Group {
diff --git a/src/plugins/clangformat/clangformatglobalconfigwidget.cpp b/src/plugins/clangformat/clangformatglobalconfigwidget.cpp
index c70b5251a2..44d32cc3a9 100644
--- a/src/plugins/clangformat/clangformatglobalconfigwidget.cpp
+++ b/src/plugins/clangformat/clangformatglobalconfigwidget.cpp
@@ -44,7 +44,10 @@ ClangFormatGlobalConfigWidget::ClangFormatGlobalConfigWidget(
 
     using namespace Layouting;
 
+    QWidget *globalSettingsGroupBoxWidget = nullptr;
+
     Group globalSettingsGroupBox {
+        bindTo(&globalSettingsGroupBoxWidget),
         title(Tr::tr("ClangFormat settings:")),
             Column {
                 m_useGlobalSettings,
@@ -73,7 +76,8 @@ ClangFormatGlobalConfigWidget::ClangFormatGlobalConfigWidget(
         m_useGlobalSettings->show();
         return;
     }
-    globalSettingsGroupBox.widget->show();
+
+    globalSettingsGroupBoxWidget->show();
 }
 
 ClangFormatGlobalConfigWidget::~ClangFormatGlobalConfigWidget() = default;
diff --git a/src/plugins/coreplugin/find/findtoolbar.cpp b/src/plugins/coreplugin/find/findtoolbar.cpp
index 11c51fe26e..4690502f50 100644
--- a/src/plugins/coreplugin/find/findtoolbar.cpp
+++ b/src/plugins/coreplugin/find/findtoolbar.cpp
@@ -147,8 +147,8 @@ FindToolBar::FindToolBar(CurrentDocumentFind *currentDocumentFind)
         m_findEdit,
         findButtonsWidget,
         br,
-        Column { m_replaceLabel, st }.setSpacing(0),
-        Column { m_replaceEdit, st }.setSpacing(0),
+        Column { spacing(0), m_replaceLabel, st },
+        Column { spacing(0), m_replaceEdit, st },
         gridLayout,
     }.attachTo(this);
 
diff --git a/src/plugins/cpaster/pasteview.cpp b/src/plugins/cpaster/pasteview.cpp
index c575fa582b..b1f4864b6e 100644
--- a/src/plugins/cpaster/pasteview.cpp
+++ b/src/plugins/cpaster/pasteview.cpp
@@ -108,6 +108,7 @@ PasteView::PasteView(const QList<Protocol *> &protocols,
     }.attachTo(groupBox);
 
     Column {
+        spacing(2),
         Form {
             Tr::tr("Protocol:"), m_protocolBox, br,
             Tr::tr("&Expires after:"), m_expirySpinBox, br,
@@ -117,7 +118,7 @@ PasteView::PasteView(const QList<Protocol *> &protocols,
         m_uiComment,
         m_stackedWidget,
         buttonBox
-    }.setSpacing(2).attachTo(this);
+    }.attachTo(this);
 
     connect(m_uiPatchList, &QListWidget::itemChanged, this, &PasteView::contentChanged);
 
diff --git a/src/plugins/cppeditor/cppcodestylesettingspage.cpp b/src/plugins/cppeditor/cppcodestylesettingspage.cpp
index 72308ed4ca..b9cdbc47f3 100644
--- a/src/plugins/cppeditor/cppcodestylesettingspage.cpp
+++ b/src/plugins/cppeditor/cppcodestylesettingspage.cpp
@@ -175,8 +175,15 @@ public:
 
         using namespace Layouting;
 
+        QWidget *contentGroupWidget = nullptr;
+        QWidget *bracesGroupWidget = nullptr;
+        QWidget *switchGroupWidget = nullptr;
+        QWidget *alignmentGroupWidget = nullptr;
+        QWidget *typesGroupWidget = nullptr;
+
         const Group contentGroup {
             title(Tr::tr("Indent")),
+            bindTo(&contentGroupWidget),
             Column {
                 m_indentAccessSpecifiers,
                 m_indentDeclarationsRelativeToAccessSpecifiers,
@@ -189,6 +196,7 @@ public:
 
         const Group bracesGroup {
             title(Tr::tr("Indent Braces")),
+            bindTo(&bracesGroupWidget),
             Column {
                 m_indentClassBraces,
                 m_indentNamespaceBraces,
@@ -201,6 +209,7 @@ public:
 
         const Group switchGroup {
             title(Tr::tr("Indent within \"switch\"")),
+            bindTo(&switchGroupWidget),
             Column {
                 m_indentSwitchLabels,
                 m_indentCaseStatements,
@@ -212,6 +221,7 @@ public:
 
         const Group alignmentGroup {
             title(Tr::tr("Align")),
+            bindTo(&alignmentGroupWidget),
             Column {
                 m_alignAssignments,
                 m_extraPaddingConditions,
@@ -221,6 +231,7 @@ public:
 
         const Group typesGroup {
             title(Tr::tr("Bind '*' and '&&' in types/declarations to")),
+            bindTo(&typesGroupWidget),
             Column {
                 m_bindStarToIdentifier,
                 m_bindStarToTypeName,
@@ -247,11 +258,11 @@ public:
         m_categoryTab->setProperty("_q_custom_style_disabled", true);
 
         m_controllers.append(m_tabSettingsWidget);
-        m_controllers.append(contentGroup.widget);
-        m_controllers.append(bracesGroup.widget);
-        m_controllers.append(switchGroup.widget);
-        m_controllers.append(alignmentGroup.widget);
-        m_controllers.append(typesGroup.widget);
+        m_controllers.append(contentGroupWidget);
+        m_controllers.append(bracesGroupWidget);
+        m_controllers.append(switchGroupWidget);
+        m_controllers.append(alignmentGroupWidget);
+        m_controllers.append(typesGroupWidget);
     }
 
     QCheckBox *createCheckBox(const QString &text, const QString &toolTip = {})
diff --git a/src/plugins/debugger/debuggersourcepathmappingwidget.cpp b/src/plugins/debugger/debuggersourcepathmappingwidget.cpp
index 8aa30b3c63..d7abf7b12b 100644
--- a/src/plugins/debugger/debuggersourcepathmappingwidget.cpp
+++ b/src/plugins/debugger/debuggersourcepathmappingwidget.cpp
@@ -496,7 +496,7 @@ void SourcePathMapAspect::addToLayout(Layouting::LayoutBuilder &builder)
     QTC_CHECK(!d->m_widget);
     d->m_widget = createSubWidget<DebuggerSourcePathMappingWidget>();
     d->m_widget->setSourcePathMap(value());
-    builder.addRow({d->m_widget.data()});
+    builder.addItem(d->m_widget.data());
 }
 
 QVariant SourcePathMapAspect::volatileValue() const
diff --git a/src/plugins/mesonprojectmanager/mesonbuildsettingswidget.cpp b/src/plugins/mesonprojectmanager/mesonbuildsettingswidget.cpp
index cedd9c5f3e..8becece66b 100644
--- a/src/plugins/mesonprojectmanager/mesonbuildsettingswidget.cpp
+++ b/src/plugins/mesonprojectmanager/mesonbuildsettingswidget.cpp
@@ -74,9 +74,9 @@ MesonBuildSettingsWidget::MesonBuildSettingsWidget(MesonBuildConfiguration *buil
         Row { configureButton, wipeButton, }
     }.attachTo(this, WithoutMargins);
 
-    Form buildDirWBuilder;
-    buildCfg->buildDirectoryAspect()->addToLayout(buildDirWBuilder);
-    buildDirWBuilder.attachTo(buildDirWidget, WithoutMargins);
+    Form {
+        buildCfg->buildDirectoryAspect(),
+    }.attachTo(buildDirWidget, WithoutMargins);
 
     parametersLineEdit->setText(buildCfg->parameters());
     optionsFilterLineEdit->setFiltering(true);
diff --git a/src/plugins/projectexplorer/buildaspects.cpp b/src/plugins/projectexplorer/buildaspects.cpp
index adf37a3362..133cfb15b3 100644
--- a/src/plugins/projectexplorer/buildaspects.cpp
+++ b/src/plugins/projectexplorer/buildaspects.cpp
@@ -112,7 +112,7 @@ void BuildDirectoryAspect::addToLayout(Layouting::LayoutBuilder &builder)
     StringAspect::addToLayout(builder);
     d->problemLabel = new InfoLabel({}, InfoLabel::Warning);
     d->problemLabel->setElideMode(Qt::ElideNone);
-    builder.addRow({{}, d->problemLabel.data()});
+    builder.addItems({{}, d->problemLabel.data()});
     updateProblemLabel();
     if (!d->sourceDir.isEmpty()) {
         connect(this, &StringAspect::checkedChanged, this, [this] {
diff --git a/src/plugins/projectexplorer/buildconfiguration.cpp b/src/plugins/projectexplorer/buildconfiguration.cpp
index 124941b11a..904530e9c7 100644
--- a/src/plugins/projectexplorer/buildconfiguration.cpp
+++ b/src/plugins/projectexplorer/buildconfiguration.cpp
@@ -322,12 +322,12 @@ NamedWidget *BuildConfiguration::createConfigWidget()
         widget = named;
     }
 
-    Layouting::Form builder;
+    Layouting::Form form;
     for (BaseAspect *aspect : aspects()) {
         if (aspect->isVisible())
-            aspect->addToLayout(builder.finishRow());
+            form.addItem(aspect);
     }
-    builder.attachTo(widget, Layouting::WithoutMargins);
+    form.attachTo(widget, Layouting::WithoutMargins);
 
     return named;
 }
diff --git a/src/plugins/projectexplorer/buildstep.cpp b/src/plugins/projectexplorer/buildstep.cpp
index 69f05e41c4..a7f74c3f03 100644
--- a/src/plugins/projectexplorer/buildstep.cpp
+++ b/src/plugins/projectexplorer/buildstep.cpp
@@ -160,12 +160,12 @@ QWidget *BuildStep::doCreateConfigWidget()
 
 QWidget *BuildStep::createConfigWidget()
 {
-    Layouting::Form builder;
+    Layouting::Form form;
     for (BaseAspect *aspect : std::as_const(m_aspects)) {
         if (aspect->isVisible())
-            aspect->addToLayout(builder.finishRow());
+            form.addItem(aspect);
     }
-    auto widget = builder.emerge(Layouting::WithoutMargins);
+    auto widget = form.emerge(Layouting::WithoutMargins);
 
     if (m_addMacroExpander)
         VariableChooser::addSupportForChildWidgets(widget, macroExpander());
diff --git a/src/plugins/projectexplorer/kitmanager.cpp b/src/plugins/projectexplorer/kitmanager.cpp
index cb67e11fac..65c8475adb 100644
--- a/src/plugins/projectexplorer/kitmanager.cpp
+++ b/src/plugins/projectexplorer/kitmanager.cpp
@@ -757,8 +757,7 @@ void KitAspectWidget::addToLayoutWithLabel(QWidget *parent)
     });
 
     Layouting::LayoutExtender builder(parent->layout(), Layouting::WithFormAlignment);
-    builder.finishRow();
-    builder.addItem(label);
+    builder.addItems({label, Layouting::br});
     addToLayout(builder);
 }
 
diff --git a/src/plugins/projectexplorer/miniprojecttargetselector.cpp b/src/plugins/projectexplorer/miniprojecttargetselector.cpp
index 558e4fa712..5ab5f109ff 100644
--- a/src/plugins/projectexplorer/miniprojecttargetselector.cpp
+++ b/src/plugins/projectexplorer/miniprojecttargetselector.cpp
@@ -551,6 +551,11 @@ int SelectorView::padding()
 /////////
 // KitAreaWidget
 /////////
+void doLayout(KitAspectWidget *widget, Layouting::LayoutBuilder &builder)
+{
+    widget->addToLayout(builder);
+}
+
 class KitAreaWidget : public QWidget
 {
     Q_OBJECT
@@ -573,18 +578,15 @@ public:
 
         delete layout();
 
-        Layouting::LayoutBuilder builder(Layouting::LayoutBuilder::GridLayout);
+        Layouting::Grid grid;
         for (KitAspect *aspect : KitManager::kitAspects()) {
             if (k && k->isMutable(aspect->id())) {
                 KitAspectWidget *widget = aspect->createConfigWidget(k);
                 m_widgets << widget;
-                QLabel *label = new QLabel(aspect->displayName());
-                builder.addItem(label);
-                widget->addToLayout(builder);
-                builder.finishRow();
+                grid.addItems({aspect->displayName(), widget, Layouting::br});
             }
         }
-        builder.attachTo(this);
+        grid.attachTo(this);
         layout()->setContentsMargins(3, 3, 3, 3);
 
         m_kit = k;
diff --git a/src/plugins/projectexplorer/runconfiguration.cpp b/src/plugins/projectexplorer/runconfiguration.cpp
index 32740d6c33..c6e47f7f83 100644
--- a/src/plugins/projectexplorer/runconfiguration.cpp
+++ b/src/plugins/projectexplorer/runconfiguration.cpp
@@ -216,13 +216,13 @@ bool RunConfiguration::isEnabled() const
 
 QWidget *RunConfiguration::createConfigurationWidget()
 {
-    Layouting::Form builder;
+    Layouting::Form form;
     for (BaseAspect *aspect : std::as_const(m_aspects)) {
         if (aspect->isVisible())
-            aspect->addToLayout(builder.finishRow());
+            form.addItem(aspect);
     }
 
-    auto widget = builder.emerge(Layouting::WithoutMargins);
+    auto widget = form.emerge(Layouting::WithoutMargins);
 
     VariableChooser::addSupportForChildWidgets(widget, &m_expander);
 
diff --git a/src/plugins/projectexplorer/runconfigurationaspects.cpp b/src/plugins/projectexplorer/runconfigurationaspects.cpp
index c1fceb613c..face7d2ce4 100644
--- a/src/plugins/projectexplorer/runconfigurationaspects.cpp
+++ b/src/plugins/projectexplorer/runconfigurationaspects.cpp
@@ -634,9 +634,9 @@ FilePath ExecutableAspect::executable() const
 */
 void ExecutableAspect::addToLayout(LayoutBuilder &builder)
 {
-    m_executable.addToLayout(builder);
+    builder.addItem(m_executable);
     if (m_alternativeExecutable)
-        m_alternativeExecutable->addToLayout(builder.finishRow());
+        builder.addItems({br, m_alternativeExecutable});
 }
 
 /*!
diff --git a/src/plugins/qbsprojectmanager/qbsbuildstep.cpp b/src/plugins/qbsprojectmanager/qbsbuildstep.cpp
index acea24b076..1f7fca3b85 100644
--- a/src/plugins/qbsprojectmanager/qbsbuildstep.cpp
+++ b/src/plugins/qbsprojectmanager/qbsbuildstep.cpp
@@ -658,25 +658,26 @@ QbsBuildStepConfigWidget::QbsBuildStepConfigWidget(QbsBuildStep *step)
     installDirChooser = new PathChooser(this);
     installDirChooser->setExpectedKind(PathChooser::Directory);
 
-    Layouting::Form builder;
-    builder.addRow({m_qbsStep->m_buildVariant});
-    builder.addRow({m_qbsStep->m_selectedAbis});
-    builder.addRow({m_qbsStep->m_maxJobCount});
-    builder.addRow({QbsProjectManager::Tr::tr("Properties:"), propertyEdit});
-
-    builder.addRow({QbsProjectManager::Tr::tr("Flags:")});
-    m_qbsStep->m_keepGoing->addToLayout(builder);
-    m_qbsStep->m_showCommandLines->addToLayout(builder);
-    m_qbsStep->m_forceProbes->addToLayout(builder);
-
-    builder.addRow({QbsProjectManager::Tr::tr("Installation flags:")});
-    m_qbsStep->m_install->addToLayout(builder);
-    m_qbsStep->m_cleanInstallDir->addToLayout(builder);
-    builder.addItem(defaultInstallDirCheckBox);
-
-    builder.addRow({QbsProjectManager::Tr::tr("Installation directory:"), installDirChooser});
-    builder.addRow({m_qbsStep->m_commandLine});
-    builder.attachTo(this, Layouting::WithoutMargins);
+    using namespace Layouting;
+    Form {
+        m_qbsStep->m_buildVariant, br,
+        m_qbsStep->m_selectedAbis, br,
+        m_qbsStep->m_maxJobCount, br,
+        QbsProjectManager::Tr::tr("Properties:"), propertyEdit, br,
+
+        QbsProjectManager::Tr::tr("Flags:"),
+        m_qbsStep->m_keepGoing,
+        m_qbsStep->m_showCommandLines,
+        m_qbsStep->m_forceProbes, br,
+
+        QbsProjectManager::Tr::tr("Installation flags:"),
+        m_qbsStep->m_install,
+        m_qbsStep->m_cleanInstallDir,
+        defaultInstallDirCheckBox, br,
+
+        QbsProjectManager::Tr::tr("Installation directory:"), installDirChooser, br,
+        m_qbsStep->m_commandLine, br,
+    }.attachTo(this, Layouting::WithoutMargins);
 
     propertyEdit->setToolTip(QbsProjectManager::Tr::tr("Properties to pass to the project."));
     defaultInstallDirCheckBox->setText(QbsProjectManager::Tr::tr("Use default location"));
diff --git a/src/plugins/qbsprojectmanager/qbsinstallstep.cpp b/src/plugins/qbsprojectmanager/qbsinstallstep.cpp
index 179928c179..939a03d9d9 100644
--- a/src/plugins/qbsprojectmanager/qbsinstallstep.cpp
+++ b/src/plugins/qbsprojectmanager/qbsinstallstep.cpp
@@ -172,15 +172,12 @@ QWidget *QbsInstallStep::createConfigWidget()
     commandLineTextEdit->setTextInteractionFlags(Qt::TextSelectableByKeyboard|Qt::TextSelectableByMouse);
     commandLineTextEdit->setMinimumHeight(QFontMetrics(widget->font()).height() * 8);
 
-    Layouting::Form builder;
-    builder.addRow({Tr::tr("Install root:"), installRootValueLabel});
-    builder.addRow({Tr::tr("Flags:")});
-    m_dryRun->addToLayout(builder);
-    m_keepGoing->addToLayout(builder);
-    m_cleanInstallRoot->addToLayout(builder);
-
-    builder.addRow({commandLineKeyLabel, commandLineTextEdit});
-    builder.attachTo(widget);
+    using namespace Layouting;
+    Form {
+        Tr::tr("Install root:"), installRootValueLabel, br,
+        Tr::tr("Flags:"),  m_dryRun, m_keepGoing, m_cleanInstallRoot, br,
+        commandLineKeyLabel, commandLineTextEdit
+     }.attachTo(widget);
 
     const auto updateState = [this, commandLineTextEdit, installRootValueLabel] {
         installRootValueLabel->setText(installRoot().toUserOutput());
diff --git a/src/plugins/qmljseditor/qmljseditingsettingspage.cpp b/src/plugins/qmljseditor/qmljseditingsettingspage.cpp
index 8d168d440a..7b6474449c 100644
--- a/src/plugins/qmljseditor/qmljseditingsettingspage.cpp
+++ b/src/plugins/qmljseditor/qmljseditingsettingspage.cpp
@@ -246,10 +246,13 @@ public:
         QObject::connect(useQmlls, &QCheckBox::stateChanged, this, [this](int checked) {
             useLatestQmlls->setEnabled(checked != Qt::Unchecked);
         });
+
         using namespace Layouting;
         // clang-format off
-        const auto formattingGroup =
+        QWidget *formattingGroup = nullptr;
+        Column {
             Group {
+                bindTo(&formattingGroup),
                 title(Tr::tr("Automatic Formatting on File Save")),
                 Column {
                     autoFormatOnSave,
@@ -260,10 +263,7 @@ public:
                         formatCommandOptionsLabel, formatCommandOptions
                     }
                 },
-            };
-
-        Column {
-            formattingGroup,
+            },
             Group {
                 title(Tr::tr("Qt Quick Toolbars")),
                 Column { pinContextPane, enableContextPane },
@@ -283,7 +283,7 @@ public:
         }.attachTo(this);
         // clang-format on
 
-        Utils::VariableChooser::addSupportForChildWidgets(formattingGroup.widget,
+        Utils::VariableChooser::addSupportForChildWidgets(formattingGroup,
                                                           Utils::globalMacroExpander());
 
         const auto updateFormatCommandState = [&, formatCommandLabel, formatCommandOptionsLabel] {
diff --git a/src/plugins/scxmleditor/common/navigatorslider.cpp b/src/plugins/scxmleditor/common/navigatorslider.cpp
index 68d74dd1be..dd45a1c8af 100644
--- a/src/plugins/scxmleditor/common/navigatorslider.cpp
+++ b/src/plugins/scxmleditor/common/navigatorslider.cpp
@@ -31,11 +31,12 @@ NavigatorSlider::NavigatorSlider(QWidget *parent)
 
     using namespace Layouting;
     Row {
+        spacing(0),
         zoomOut,
         m_slider,
         zoomIn,
         Space(20),
-    }.setSpacing(0).attachTo(this, WithoutMargins);
+    }.attachTo(this, WithoutMargins);
 
     connect(zoomOut, &QToolButton::clicked, this, &NavigatorSlider::zoomOut);
     connect(zoomIn, &QToolButton::clicked, this, &NavigatorSlider::zoomIn);
diff --git a/src/plugins/scxmleditor/common/search.cpp b/src/plugins/scxmleditor/common/search.cpp
index 34f2601733..b7b56295fd 100644
--- a/src/plugins/scxmleditor/common/search.cpp
+++ b/src/plugins/scxmleditor/common/search.cpp
@@ -47,9 +47,10 @@ Search::Search(QWidget *parent)
 
     using namespace Layouting;
     Column {
+        spacing(0),
         m_searchEdit,
         m_searchView,
-    }.setSpacing(0).attachTo(this, WithoutMargins);
+    }.attachTo(this, WithoutMargins);
 
     connect(m_searchEdit, &Utils::FancyLineEdit::textChanged, this, &Search::setSearchText);
     connect(m_searchView, &TableView::pressed, this, &Search::rowActivated);
diff --git a/src/plugins/scxmleditor/common/shapestoolbox.cpp b/src/plugins/scxmleditor/common/shapestoolbox.cpp
index 1343859cc6..a0354d0bce 100644
--- a/src/plugins/scxmleditor/common/shapestoolbox.cpp
+++ b/src/plugins/scxmleditor/common/shapestoolbox.cpp
@@ -31,8 +31,9 @@ ShapesToolbox::ShapesToolbox(QWidget *parent)
 
     using namespace Layouting;
     Column {
+        spacing(0),
         scrollArea,
-    }.setSpacing(0).attachTo(this, WithoutMargins);
+    }.attachTo(this, WithoutMargins);
 }
 
 void ShapesToolbox::setUIFactory(ScxmlEditor::PluginInterface::ScxmlUiFactory *factory)
diff --git a/src/plugins/scxmleditor/common/stateview.cpp b/src/plugins/scxmleditor/common/stateview.cpp
index 57759263fd..e4c23046c7 100644
--- a/src/plugins/scxmleditor/common/stateview.cpp
+++ b/src/plugins/scxmleditor/common/stateview.cpp
@@ -38,8 +38,10 @@ StateView::StateView(StateItem *state, QWidget *parent)
     }.attachTo(titleBar, WithoutMargins);
 
     Column {
-        titleBar, m_graphicsView
-    }.setSpacing(0).attachTo(this, WithoutMargins);
+        spacing(0),
+        titleBar,
+        m_graphicsView
+    }.attachTo(this, WithoutMargins);
 
     initScene();
 }
diff --git a/tests/manual/layoutbuilder/comparison/layoutbuilder/main.cpp b/tests/manual/layoutbuilder/comparison/layoutbuilder/main.cpp
index 96911edee8..6620ba52e2 100644
--- a/tests/manual/layoutbuilder/comparison/layoutbuilder/main.cpp
+++ b/tests/manual/layoutbuilder/comparison/layoutbuilder/main.cpp
@@ -1,11 +1,6 @@
 #include "mainwindow.h"
 
-#include <QApplication>
-
 int main(int argc, char *argv[])
 {
-    QApplication a(argc, argv);
-    ApplicationWindow w;
-    w.show();
-    return a.exec();
+    return app.exec(argc, argv);
 }
diff --git a/tests/manual/layoutbuilder/comparison/layoutbuilder/mainwindow.h b/tests/manual/layoutbuilder/comparison/layoutbuilder/mainwindow.h
index 8ff57827f9..5ccb647f84 100644
--- a/tests/manual/layoutbuilder/comparison/layoutbuilder/mainwindow.h
+++ b/tests/manual/layoutbuilder/comparison/layoutbuilder/mainwindow.h
@@ -2,28 +2,23 @@
 
 #include "layoutbuilder.h"
 
-#include <QCoreApplication>
-#include <QWidget>
+#include <QApplication>
 
 using namespace Layouting;
 
-class ApplicationWindow : public QWidget
+Application app
 {
-public:
-    ApplicationWindow()
-    {
-        resize(600, 400);
-        setWindowTitle("Hello World");
+    resize(600, 400),
+    title("Hello World"),
 
-        Column {
-            TextEdit {
-                text("Hallo")
-            },
+    Column {
+        TextEdit {
+            text("Hallo")
+        },
 
-            PushButton {
-                text("Quit"),
-                onClicked([] { QCoreApplication::quit(); })
-            }
-        }.attachTo(this);
+        PushButton {
+            text("Quit"),
+            onClicked([] { QApplication::quit(); })
+        }
     }
 };
diff --git a/tests/manual/layoutbuilder/comparison/quick/Main.qml b/tests/manual/layoutbuilder/comparison/quick/Main.qml
index 2200399429..617b573caa 100644
--- a/tests/manual/layoutbuilder/comparison/quick/Main.qml
+++ b/tests/manual/layoutbuilder/comparison/quick/Main.qml
@@ -2,8 +2,8 @@ import QtQuick
 import QtQuick.Controls
 import QtQuick.Layouts
 
-ApplicationWindow {
-
+ApplicationWindow
+{
     width: 640
     height: 480
     visible: true
diff --git a/tests/manual/layoutbuilder/comparison/widgets/main.cpp b/tests/manual/layoutbuilder/comparison/widgets/main.cpp
index 5d394e06c3..c610fc6a49 100644
--- a/tests/manual/layoutbuilder/comparison/widgets/main.cpp
+++ b/tests/manual/layoutbuilder/comparison/widgets/main.cpp
@@ -1,8 +1,5 @@
-
 #include "mainwindow.h"
 
-#include <QApplication>
-
 int main(int argc, char *argv[])
 {
     QApplication a(argc, argv);
diff --git a/tests/manual/layoutbuilder/comparison/widgets/mainwindow.h b/tests/manual/layoutbuilder/comparison/widgets/mainwindow.h
index 9acf84d4b5..1dc8ad6f83 100644
--- a/tests/manual/layoutbuilder/comparison/widgets/mainwindow.h
+++ b/tests/manual/layoutbuilder/comparison/widgets/mainwindow.h
@@ -23,6 +23,6 @@ public:
         l->addWidget(pushButton);
 
         connect(pushButton, &QPushButton::clicked,
-                qApp, &QCoreApplication::quit);
+                qApp, &QApplication::quit);
     }
 };
diff --git a/tests/manual/tasktree/taskwidget.cpp b/tests/manual/tasktree/taskwidget.cpp
index d5420defe5..e2770d916e 100644
--- a/tests/manual/tasktree/taskwidget.cpp
+++ b/tests/manual/tasktree/taskwidget.cpp
@@ -184,11 +184,8 @@ Tasking::WorkflowPolicy GroupWidget::workflowPolicy() const
     return m_workflowPolicy;
 }
 
-
-void doLayout(const TaskGroup &taskGroup, LayoutBuilder &builder)
+void createItem(Layouting::LayoutItem *item, const TaskGroup &taskGroup)
 {
-    builder.addItem(taskGroup.group);
-    builder.addItem(Group { taskGroup.items });
-    builder.finishRow();
+    item->addItems({taskGroup.group, Group { taskGroup.items }, br});
 }
 
diff --git a/tests/manual/tasktree/taskwidget.h b/tests/manual/tasktree/taskwidget.h
index 8caebf658b..0e7828ac84 100644
--- a/tests/manual/tasktree/taskwidget.h
+++ b/tests/manual/tasktree/taskwidget.h
@@ -83,4 +83,4 @@ public:
     Layouting::Column items;
 };
 
-void doLayout(const TaskGroup &taskGroup, Layouting::LayoutBuilder &builder);
+void createItem(Layouting::LayoutItem *item, const TaskGroup &taskGroup);