TaskTree: De-utils-ize manual test, rename it to demo

Change-Id: I80a2522f7ba12ee9b63c19d66e514d7047951733
Reviewed-by: Marcus Tillmanns <marcus.tillmanns@qt.io>

tests/manual/CMakeLists.txt

@@ -17,5 +17,5 @@ add_subdirectory(proparser)
 # add_subdirectory(search)
 add_subdirectory(shootout)
 add_subdirectory(subdirfileiterator)
-add_subdirectory(tasktree)
+add_subdirectory(tasking)
 add_subdirectory(widgets)

tests/manual/manual.qbs

@@ -14,7 +14,7 @@ Project {
         "proparser/testreader.qbs",
         "shootout/shootout.qbs",
         "subdirfileiterator/subdirfileiterator.qbs",
-        "tasktree/tasktree.qbs",
+        "tasking/demo/demo.qbs",
         "widgets/widgets.qbs",
     ]
 }

tests/manual/tasking/CMakeLists.txt

@@ -0,0 +1 @@
+add_subdirectory(demo)

tests/manual/tasking/demo/CMakeLists.txt

@@ -0,0 +1,11 @@
+add_qtc_test(tst_tasking_demo
+  MANUALTEST
+  DEPENDS Tasking Qt::Widgets
+  SOURCES
+    demo.qrc
+    main.cpp
+    progressindicator.h
+    progressindicator.cpp
+    taskwidget.h
+    taskwidget.cpp
+)

tests/manual/tasking/demo/demo.qbs

@@ -0,0 +1,18 @@
+import qbs.FileInfo
+
+QtcManualtest {
+    name: "Tasking demo"
+    type: ["application"]
+
+    Depends { name: "Qt"; submodules: ["widgets"] }
+    Depends { name: "Tasking" }
+
+    files: [
+        "demo.qrc",
+        "main.cpp",
+        "progressindicator.h",
+        "progressindicator.cpp",
+        "taskwidget.h",
+        "taskwidget.cpp",
+    ]
+}

tests/manual/tasking/demo/demo.qrc

@@ -0,0 +1,6 @@
+<RCC>
+    <qresource prefix="/" >
+        <file>icons/progressindicator.png</file>
+        <file>icons/progressindicator@2x.png</file>
+    </qresource>
+</RCC>

tests/manual/tasking/demo/main.cpp

@@ -1,53 +1,66 @@
-// Copyright (C) 2022 The Qt Company Ltd.
-// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
 #include "taskwidget.h"
 
-#include <utils/async.h>
-#include <utils/futuresynchronizer.h>
-#include <utils/layoutbuilder.h>
-#include <utils/theme/theme_p.h>
+#include <tasking/tasktree.h>
 
 #include <QApplication>
-#include <QCheckBox>
+#include <QBoxLayout>
+#include <QGroupBox>
 #include <QProgressBar>
 #include <QScrollArea>
 #include <QTimer>
 #include <QToolButton>
 
-using namespace Utils;
+using namespace Tasking;
 
-// TODO: make tasks cancellable
-static void sleepInThread(QPromise<void> &promise, int seconds, bool reportSuccess)
+using namespace std::chrono;
+
+static QWidget *hr()
 {
-    QThread::sleep(seconds);
-    if (!reportSuccess)
-        promise.future().cancel();
+    auto frame = new QFrame;
+    frame->setFrameShape(QFrame::HLine);
+    frame->setFrameShadow(QFrame::Sunken);
+    return frame;
+}
+
+QWidget *taskGroup(QWidget *groupWidget, const QList<QWidget *> &widgets)
+{
+    QWidget *widget = new QWidget;
+    QBoxLayout *layout = new QHBoxLayout(widget);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->addWidget(groupWidget);
+    QGroupBox *groupBox = new QGroupBox;
+    QBoxLayout *subLayout = new QVBoxLayout(groupBox);
+    for (int i = 0; i < widgets.size(); ++i) {
+        if (i > 0)
+            subLayout->addWidget(hr());
+        subLayout->addWidget(widgets.at(i));
+    }
+    layout->addWidget(groupBox);
+    return widget;
 }
 
 int main(int argc, char *argv[])
 {
     QApplication app(argc, argv);
 
-    setCreatorTheme(new Theme("default", &app));
-
     QWidget mainWidget;
     mainWidget.setWindowTitle("Task Tree Demo");
 
     // Non-task GUI
 
-    QToolButton *startButton = new QToolButton();
+    QToolButton *startButton = new QToolButton;
     startButton->setText("Start");
-    QToolButton *stopButton = new QToolButton();
+    QToolButton *stopButton = new QToolButton;
     stopButton->setText("Stop");
-    QToolButton *resetButton = new QToolButton();
+    QToolButton *resetButton = new QToolButton;
     resetButton->setText("Reset");
-    QProgressBar *progressBar = new QProgressBar();
-    QCheckBox *synchronizerCheckBox = new QCheckBox("Use Future Synchronizer");
-    synchronizerCheckBox->setChecked(true);
-    QScrollArea *scrollArea = new QScrollArea();
+    QProgressBar *progressBar = new QProgressBar;
+    QScrollArea *scrollArea = new QScrollArea;
     scrollArea->setWidgetResizable(true);
-    QWidget *scrollAreaWidget = new QWidget();
+    QWidget *scrollAreaWidget = new QWidget;
 
     // Task GUI
 
@@ -100,120 +113,124 @@ int main(int argc, char *argv[])
     task_4_4->setBusyTime(6);
     task_4_4->setBusyTime(3);
 
-    groupTask_1->setWorkflowPolicy(Tasking::WorkflowPolicy::ContinueOnDone);
-    groupTask_4->setWorkflowPolicy(Tasking::WorkflowPolicy::FinishAllAndDone);
+    groupTask_1->setWorkflowPolicy(WorkflowPolicy::ContinueOnDone);
+    groupTask_4->setWorkflowPolicy(WorkflowPolicy::FinishAllAndDone);
     groupTask_4_3->setExecuteMode(ExecuteMode::Parallel);
-    groupTask_4_3->setWorkflowPolicy(Tasking::WorkflowPolicy::StopOnError);
+    groupTask_4_3->setWorkflowPolicy(WorkflowPolicy::StopOnError);
 
     // Task layout
 
     {
-        using namespace Layouting;
-
-        Column {
-            TaskGroup { rootGroup, {
-                TaskGroup { groupTask_1, {
-                    task_1_1, hr,
-                    task_1_2, hr,
-                    task_1_3,
-                }}, hr,
-                task_2, hr,
-                task_3, hr,
-                TaskGroup { groupTask_4, {
-                    task_4_1, hr,
-                    task_4_2, hr,
-                    TaskGroup { groupTask_4_3, {
-                        task_4_3_1, hr,
-                        task_4_3_2, hr,
-                        task_4_3_3, hr,
+        QWidget *taskTree = taskGroup(rootGroup, {
+            taskGroup(groupTask_1, {
+                task_1_1,
+                task_1_2,
+                task_1_3
+            }),
+            task_2,
+            task_3,
+            taskGroup(groupTask_4, {
+                task_4_1,
+                task_4_2,
+                taskGroup(groupTask_4_3, {
+                    task_4_3_1,
+                    task_4_3_2,
+                    task_4_3_3,
                     task_4_3_4,
-                    }}, hr,
-                    task_4_4, hr,
-                    task_4_5,
-                }}, hr,
+                }),
+                task_4_4,
+                task_4_5
+            }),
             task_5
-            }}, st
-        }.attachTo(scrollAreaWidget);
-
+        });
+        QBoxLayout *scrollLayout = new QVBoxLayout(scrollAreaWidget);
+        scrollLayout->addWidget(taskTree);
+        scrollLayout->addStretch();
         scrollArea->setWidget(scrollAreaWidget);
 
-        Column {
-            Row { startButton, stopButton, resetButton, synchronizerCheckBox, progressBar },
-            hr,
-            scrollArea
-        }.attachTo(&mainWidget);
+        QBoxLayout *mainLayout = new QVBoxLayout(&mainWidget);
+        QBoxLayout *subLayout = new QHBoxLayout;
+        subLayout->addWidget(startButton);
+        subLayout->addWidget(stopButton);
+        subLayout->addWidget(resetButton);
+        subLayout->addWidget(progressBar);
+        mainLayout->addLayout(subLayout);
+        mainLayout->addWidget(hr());
+        mainLayout->addWidget(scrollArea);
     }
 
-    // Task tree creator (takes configuation from GUI)
-
-    using namespace Tasking;
+    // Task tree (takes initial configuation from GUI)
 
     std::unique_ptr<TaskTree> taskTree;
-    FutureSynchronizer synchronizer;
+
+    const auto createTask = [](TaskWidget *widget) -> TaskItem {
+        const auto setupTask = [](TaskWidget *widget) {
+            return [widget](milliseconds &taskObject) {
+                taskObject = milliseconds{widget->busyTime() * 1000};
+                widget->setState(State::Running);
+            };
+        };
+        if (widget->isSuccess()) {
+            return TimeoutTask(setupTask(widget),
+                [widget](const milliseconds &) { widget->setState(State::Done); },
+                [widget](const milliseconds &) { widget->setState(State::Error); });
+        }
+        const Group root {
+            finishAllAndError,
+            TimeoutTask(setupTask(widget)),
+            onGroupDone([widget] { widget->setState(State::Done); }),
+            onGroupError([widget] { widget->setState(State::Error); })
+        };
+        return root;
+    };
 
     auto treeRoot = [&] {
 
-        auto taskItem = [sync = &synchronizer, synchronizerCheckBox](TaskWidget *widget) {
-            const auto setupHandler = [=](Async<void> &task) {
-                task.setConcurrentCallData(sleepInThread, widget->busyTime(), widget->isSuccess());
-                if (synchronizerCheckBox->isChecked())
-                    task.setFutureSynchronizer(sync);
-                widget->setState(State::Running);
-            };
-            const auto doneHandler = [widget](const Async<void> &) {
-                widget->setState(State::Done);
-            };
-            const auto errorHandler = [widget](const Async<void> &) {
-                widget->setState(State::Error);
-            };
-            return AsyncTask<void>(setupHandler, doneHandler, errorHandler);
-        };
-
         const Group root {
             rootGroup->executeMode(),
-            workflowPolicy(rootGroup->workflowPolicy()),
+            rootGroup->workflowPolicy(),
             onGroupSetup([rootGroup] { rootGroup->setState(State::Running); }),
             onGroupDone([rootGroup] { rootGroup->setState(State::Done); }),
             onGroupError([rootGroup] { rootGroup->setState(State::Error); }),
 
             Group {
                 groupTask_1->executeMode(),
-                workflowPolicy(groupTask_1->workflowPolicy()),
+                groupTask_1->workflowPolicy(),
                 onGroupSetup([groupTask_1] { groupTask_1->setState(State::Running); }),
                 onGroupDone([groupTask_1] { groupTask_1->setState(State::Done); }),
                 onGroupError([groupTask_1] { groupTask_1->setState(State::Error); }),
 
-                taskItem(task_1_1),
-                taskItem(task_1_2),
-                taskItem(task_1_3)
+                createTask(task_1_1),
+                createTask(task_1_2),
+                createTask(task_1_3)
             },
-            taskItem(task_2),
-            taskItem(task_3),
+            createTask(task_2),
+            createTask(task_3),
             Group {
                 groupTask_4->executeMode(),
-                workflowPolicy(groupTask_4->workflowPolicy()),
+                groupTask_4->workflowPolicy(),
                 onGroupSetup([groupTask_4] { groupTask_4->setState(State::Running); }),
                 onGroupDone([groupTask_4] { groupTask_4->setState(State::Done); }),
                 onGroupError([groupTask_4] { groupTask_4->setState(State::Error); }),
 
-                taskItem(task_4_1),
-                taskItem(task_4_2),
+                createTask(task_4_1),
+                createTask(task_4_2),
                 Group {
                     groupTask_4_3->executeMode(),
-                    workflowPolicy(groupTask_4_3->workflowPolicy()),
+                    groupTask_4_3->workflowPolicy(),
                     onGroupSetup([groupTask_4_3] { groupTask_4_3->setState(State::Running); }),
                     onGroupDone([groupTask_4_3] { groupTask_4_3->setState(State::Done); }),
                     onGroupError([groupTask_4_3] { groupTask_4_3->setState(State::Error); }),
 
-                    taskItem(task_4_3_1),
-                    taskItem(task_4_3_2),
-                    taskItem(task_4_3_3),
-                    taskItem(task_4_3_4)
+                    createTask(task_4_3_1),
+                    createTask(task_4_3_2),
+                    createTask(task_4_3_3),
+                    createTask(task_4_3_4)
                 },
-                taskItem(task_4_4),
-                taskItem(task_4_5)
+                createTask(task_4_4),
+                createTask(task_4_5)
             },
-            taskItem(task_5)
+            createTask(task_5)
         };
         return root;
     };
@@ -258,7 +275,7 @@ int main(int argc, char *argv[])
 
     // Hack in order to show initial size minimal, but without scrollbars.
     // Apparently setSizeAdjustPolicy(QAbstractScrollArea::AdjustToContentsOnFirstShow) doesn't work.
-    const int margin = 2;
+    const int margin = 4;
     scrollArea->setMinimumSize(scrollAreaWidget->minimumSizeHint().grownBy({0, 0, margin, margin}));
     QTimer::singleShot(0, scrollArea, [&] { scrollArea->setMinimumSize({0, 0}); });
 

tests/manual/tasking/demo/progressindicator.cpp

@@ -0,0 +1,149 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "progressindicator.h"
+
+#include <QEvent>
+#include <QPainter>
+#include <QTimer>
+#include <QWidget>
+
+class OverlayWidget : public QWidget
+{
+public:
+    using PaintFunction = std::function<void(QWidget *, QPainter &, QPaintEvent *)>;
+
+    explicit OverlayWidget(QWidget *parent = nullptr)
+    {
+        setAttribute(Qt::WA_TransparentForMouseEvents);
+        if (parent)
+            attachToWidget(parent);
+    }
+
+    void attachToWidget(QWidget *parent)
+    {
+        if (parentWidget())
+            parentWidget()->removeEventFilter(this);
+        setParent(parent);
+        if (parent) {
+            parent->installEventFilter(this);
+            resizeToParent();
+            raise();
+        }
+    }
+    void setPaintFunction(const PaintFunction &paint) { m_paint = paint; }
+
+protected:
+    bool eventFilter(QObject *obj, QEvent *ev) override
+    {
+        if (obj == parent() && ev->type() == QEvent::Resize)
+            resizeToParent();
+        return QWidget::eventFilter(obj, ev);
+    }
+    void paintEvent(QPaintEvent *ev) override
+    {
+        if (m_paint) {
+            QPainter p(this);
+            m_paint(this, p, ev);
+        }
+    }
+
+private:
+    void resizeToParent() { setGeometry(QRect(QPoint(0, 0), parentWidget()->size())); }
+
+    PaintFunction m_paint;
+};
+
+class ProgressIndicatorPainter
+{
+public:
+    using UpdateCallback = std::function<void()>;
+
+    ProgressIndicatorPainter();
+    virtual ~ProgressIndicatorPainter() = default;
+
+    void setUpdateCallback(const UpdateCallback &cb) { m_callback = cb; }
+
+    QSize size() const { return m_pixmap.size() / m_pixmap.devicePixelRatio(); }
+
+    void paint(QPainter &painter, const QRect &rect) const;
+    void startAnimation() { m_timer.start(); }
+    void stopAnimation() { m_timer.stop(); }
+
+protected:
+    void nextAnimationStep() { m_rotation = (m_rotation + m_rotationStep + 360) % 360; }
+
+private:
+    const int m_rotationStep = 45;
+    int m_rotation = 0;
+    QTimer m_timer;
+    QPixmap m_pixmap;
+    UpdateCallback m_callback;
+};
+
+ProgressIndicatorPainter::ProgressIndicatorPainter()
+{
+    m_timer.setSingleShot(false);
+    QObject::connect(&m_timer, &QTimer::timeout, &m_timer, [this] {
+        nextAnimationStep();
+        if (m_callback)
+            m_callback();
+    });
+
+    m_timer.setInterval(100);
+    m_pixmap = QPixmap(":/icons/progressindicator.png");
+}
+
+void ProgressIndicatorPainter::paint(QPainter &painter, const QRect &rect) const
+{
+    painter.save();
+    painter.setRenderHint(QPainter::SmoothPixmapTransform);
+    QPoint translate(rect.x() + rect.width() / 2, rect.y() + rect.height() / 2);
+    QTransform t;
+    t.translate(translate.x(), translate.y());
+    t.rotate(m_rotation);
+    t.translate(-translate.x(), -translate.y());
+    painter.setTransform(t);
+    QSize pixmapUserSize(m_pixmap.size() / m_pixmap.devicePixelRatio());
+    painter.drawPixmap(QPoint(rect.x() + ((rect.width() - pixmapUserSize.width()) / 2),
+                              rect.y() + ((rect.height() - pixmapUserSize.height()) / 2)),
+                 m_pixmap);
+    painter.restore();
+}
+
+class ProgressIndicatorWidget : public OverlayWidget
+{
+public:
+    explicit ProgressIndicatorWidget(QWidget *parent = nullptr)
+        : OverlayWidget(parent)
+    {
+        setPaintFunction(
+            [this](QWidget *w, QPainter &p, QPaintEvent *) { m_paint.paint(p, w->rect()); });
+        m_paint.setUpdateCallback([this] { update(); });
+        updateGeometry();
+    }
+
+    QSize sizeHint() const final { return m_paint.size(); }
+
+protected:
+    void showEvent(QShowEvent *) final { m_paint.startAnimation(); }
+    void hideEvent(QHideEvent *) final { m_paint.stopAnimation(); }
+
+private:
+    ProgressIndicatorPainter m_paint;
+};
+
+ProgressIndicator::ProgressIndicator(QWidget *parent)
+    : QObject(parent)
+    , m_widget(new ProgressIndicatorWidget(parent)) {}
+
+
+void ProgressIndicator::show()
+{
+    m_widget->show();
+}
+
+void ProgressIndicator::hide()
+{
+    m_widget->hide();
+}

tests/manual/tasking/demo/progressindicator.h

@@ -0,0 +1,21 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#ifndef PROGRESSINDICATOR_H
+#define PROGRESSINDICATOR_H
+
+#include <QObject>
+
+class ProgressIndicator : public QObject
+{
+public:
+    ProgressIndicator(QWidget *parent = nullptr);
+
+    void show();
+    void hide();
+
+private:
+    class ProgressIndicatorWidget *m_widget = nullptr;
+};
+
+#endif // PROGRESSINDICATOR_H

tests/manual/tasking/demo/taskwidget.cpp

@@ -1,20 +1,18 @@
-// Copyright (C) 2022 The Qt Company Ltd.
-// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
+#include "progressindicator.h"
 #include "taskwidget.h"
 
-#include <utils/layoutbuilder.h>
-#include <utils/progressindicator.h>
-#include <utils/qtcassert.h>
-
+#include <QBoxLayout>
 #include <QCheckBox>
 #include <QComboBox>
 #include <QGroupBox>
 #include <QLabel>
+#include <QMetaEnum>
 #include <QSpinBox>
 
-using namespace Utils;
-using namespace Layouting;
+using namespace Tasking;
 
 static QString colorButtonStyleSheet(const QColor &bgColor)
 {
@@ -37,10 +35,10 @@ static QColor stateToColor(State state) {
 class StateIndicator : public QLabel
 {
 public:
-    StateIndicator()
+    StateIndicator(QWidget *parent = nullptr)
+        : QLabel(parent)
     {
-        m_progressIndicator = new ProgressIndicator(ProgressIndicatorSize::Small);
-        m_progressIndicator->attachToWidget(this);
+        m_progressIndicator = new ProgressIndicator(this);
         m_progressIndicator->hide();
         updateState();
     }
@@ -67,9 +65,7 @@ private:
 };
 
 StateWidget::StateWidget()
-    : m_stateIndicator(new StateIndicator)
-{
-}
+    : m_stateIndicator(new StateIndicator(this)) {}
 
 void StateWidget::setState(State state)
 {
@@ -86,14 +82,13 @@ TaskWidget::TaskWidget()
     setBusyTime(1);
     setSuccess(true);
 
-    Row {
-        m_stateIndicator,
-        m_infoLabel,
-        m_spinBox,
-        m_checkBox,
-        st,
-        noMargin,
-    }.attachTo(this);
+    QBoxLayout *layout = new QHBoxLayout(this);
+    layout->addWidget(m_stateIndicator);
+    layout->addWidget(m_infoLabel);
+    layout->addWidget(m_spinBox);
+    layout->addWidget(m_checkBox);
+    layout->addStretch();
+    layout->setContentsMargins(0, 0, 0, 0);
 }
 
 void TaskWidget::setBusyTime(int seconds)
@@ -122,34 +117,32 @@ GroupWidget::GroupWidget()
 {
     m_stateIndicator->setFixedWidth(30);
 
-    m_executeCombo->addItem("Sequential", (int)ExecuteMode::Sequential);
-    m_executeCombo->addItem("Parallel", (int)ExecuteMode::Parallel);
+    m_executeCombo->addItem("Sequential", int(ExecuteMode::Sequential));
+    m_executeCombo->addItem("Parallel", int(ExecuteMode::Parallel));
     updateExecuteMode();
     connect(m_executeCombo, &QComboBox::currentIndexChanged, this, [this](int index) {
         m_executeMode = (ExecuteMode)m_executeCombo->itemData(index).toInt();
     });
 
-    m_workflowCombo->addItem("Stop On Error", (int)Tasking::WorkflowPolicy::StopOnError);
-    m_workflowCombo->addItem("Cont On Error", (int)Tasking::WorkflowPolicy::ContinueOnError);
-    m_workflowCombo->addItem("Stop On Done", (int)Tasking::WorkflowPolicy::StopOnDone);
-    m_workflowCombo->addItem("Cont On Done", (int)Tasking::WorkflowPolicy::ContinueOnDone);
-    m_workflowCombo->addItem("Optional", (int)Tasking::WorkflowPolicy::FinishAllAndDone);
+    const QMetaEnum workflow = QMetaEnum::fromType<WorkflowPolicy>();
+    for (int i = 0; i < workflow.keyCount(); ++i)
+        m_workflowCombo->addItem(workflow.key(i), workflow.value(i));
+
     updateWorkflowPolicy();
     connect(m_workflowCombo, &QComboBox::currentIndexChanged, this, [this](int index) {
-        m_workflowPolicy = (Tasking::WorkflowPolicy)m_workflowCombo->itemData(index).toInt();
+        m_workflowPolicy = (WorkflowPolicy)m_workflowCombo->itemData(index).toInt();
     });
 
-    Row {
-        m_stateIndicator,
-        Column {
-            new QLabel("Execute:"),
-            m_executeCombo,
-            new QLabel("Workflow:"),
-            m_workflowCombo,
-            st,
-            noMargin
-        }
-    }.attachTo(this);
+    QBoxLayout *layout = new QHBoxLayout(this);
+    layout->addWidget(m_stateIndicator);
+    QBoxLayout *subLayout = new QVBoxLayout;
+    subLayout->addWidget(new QLabel("Execute Mode:"));
+    subLayout->addWidget(m_executeCombo);
+    subLayout->addWidget(new QLabel("Workflow Policy:"));
+    subLayout->addWidget(m_workflowCombo);
+    subLayout->addStretch();
+    layout->addLayout(subLayout);
+    layout->setContentsMargins(0, 0, 0, 0);
 
     setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
 }
@@ -165,12 +158,12 @@ void GroupWidget::updateExecuteMode()
     m_executeCombo->setCurrentIndex(m_executeCombo->findData((int)m_executeMode));
 }
 
-Tasking::TaskItem GroupWidget::executeMode() const
+TaskItem GroupWidget::executeMode() const
 {
-    return m_executeMode == ExecuteMode::Sequential ? Tasking::sequential : Tasking::parallel;
+    return m_executeMode == ExecuteMode::Sequential ? sequential : parallel;
 }
 
-void GroupWidget::setWorkflowPolicy(Tasking::WorkflowPolicy policy)
+void GroupWidget::setWorkflowPolicy(WorkflowPolicy policy)
 {
     m_workflowPolicy = policy;
     updateWorkflowPolicy();
@@ -181,13 +174,7 @@ void GroupWidget::updateWorkflowPolicy()
     m_workflowCombo->setCurrentIndex(m_workflowCombo->findData((int)m_workflowPolicy));
 }
 
-Tasking::WorkflowPolicy GroupWidget::workflowPolicy() const
+TaskItem GroupWidget::workflowPolicy() const
 {
-    return m_workflowPolicy;
+    return Tasking::workflowPolicy(m_workflowPolicy);
 }
-
-void createItem(Layouting::LayoutItem *item, const TaskGroup &taskGroup)
-{
-    item->addItems({taskGroup.group, Group { taskGroup.items }, br});
-}
-

tests/manual/tasking/demo/taskwidget.h

@@ -1,9 +1,10 @@
-// Copyright (C) 2022 The Qt Company Ltd.
-// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
-#include <solutions/tasking/tasktree.h>
+#ifndef TASKWIDGET_H
+#define TASKWIDGET_H
 
-#include <utils/layoutbuilder.h>
+#include <tasking/tasktree.h>
 
 #include <QWidget>
 
@@ -64,7 +65,7 @@ public:
     Tasking::TaskItem executeMode() const;
 
     void setWorkflowPolicy(Tasking::WorkflowPolicy policy);
-    Tasking::WorkflowPolicy workflowPolicy() const;
+    Tasking::TaskItem workflowPolicy() const;
 
 private:
     void updateExecuteMode();
@@ -77,11 +78,4 @@ private:
     Tasking::WorkflowPolicy m_workflowPolicy = Tasking::WorkflowPolicy::StopOnError;
 };
 
-class TaskGroup
-{
-public:
-    QWidget *group;
-    Layouting::Column items;
-};
-
-void createItem(Layouting::LayoutItem *item, const TaskGroup &taskGroup);
+#endif // TASKWIDGET_H

tests/manual/tasktree/CMakeLists.txt

@@ -1,6 +0,0 @@
-add_qtc_test(tst_manual_tasktree
-  MANUALTEST
-  DEPENDS Utils
-  SOURCES
-    main.cpp taskwidget.h taskwidget.cpp
-)

tests/manual/tasktree/tasktree.qbs

@@ -1,14 +0,0 @@
-import qbs.FileInfo
-
-QtcManualtest {
-    name: "Manual TaskTree test"
-    type: ["application"]
-
-    Depends { name: "Utils" }
-
-    files: [
-        "main.cpp",
-        "taskwidget.h",
-        "taskwidget.cpp",
-    ]
-}