TaskTree-Demo

Die TaskTree-Demo zeigt, wie man mithilfe von „ timeoutTask “ ein verschachteltes TaskTree-Rezept erstellt, und demonstriert verschiedene „ execution modes “ und „ workflow policies “. Die Anwendung bietet einen grafischen Überblick über den Fortschritt, während der TaskTree die verschiedenen Arbeitselemente ausführt, aus denen sich die Aufgabe zusammensetzt.

Die Demo-Anwendung verwendet ein einzelnes QWidget zur Anzeige und Verwaltung einer TaskTree-Hierarchie. Folgendes finden Sie in der Benutzeroberfläche:

• Aufgaben werden als Blattknoten auf der rechten Seite des Baums angezeigt.

  Für jede Aufgabe können Sie die Ausführungsdauer festlegen und die Abschlusszustände „erfolgreich“ oder „Fehler“ konfigurieren.

• Gruppenknoten werden auf der linken und mittleren Seite des Baums angezeigt.

  Jede Gruppe kann mehrere untergeordnete Aufgaben oder verschachtelte Gruppen enthalten. Sie können für jede Gruppe „ execution modes “ und „ workflow policies “ konfigurieren.

• Farbindikatoren zeigen den aktuellen Ausführungsstatus jedes Knotens an.

In den folgenden Abschnitten werden weitere Details zum Code des Beispiels beschrieben.

Hilfsklassen

Die abstrakte Klasse „ GlueItem “ verbindet die Komponenten der Benutzeroberfläche (UI) mit den entsprechenden „TaskTree“-Rezepten. Dieses Entwurfsmuster ermöglicht eine klare Trennung zwischen der Benutzeroberfläche und der Aufgabenlogik.

class GlueItem
{
public:
    virtual ExecutableItem recipe() const = 0;
    virtual QWidget *widget() const = 0;
    virtual void reset() const = 0;

    virtual ~GlueItem() = default;
};

Die Klasse „ GlueItem “ definiert drei wichtige virtuelle Methoden:

Die Klasse „ GroupGlueItem “ verwaltet „ Group “-Elemente in Ihrer Aufgabenhierarchie. Jede Gruppe kann andere „ GlueItem “-Elemente als untergeordnete Elemente enthalten, darunter verschachtelte „ GroupGlueItem“-Elemente oder „ TaskGlueItem“-Elemente.

So erstellt und konfiguriert die Methode „ recipe() “ eine Gruppe:

ExecutableItem GroupGlueItem::recipe() const
{
    GroupItems childRecipes;
    for (GlueItem *child : m_children)
        childRecipes.append(child->recipe());

    return Group {
        m_groupWidget->executeModeItem(),
        m_groupWidget->workflowPolicyItem(),
        onGroupSetup([this] { m_groupWidget->setState(State::Running); }),
        childRecipes,
        onGroupDone([this](DoneWith result) { m_groupWidget->setState(resultToState(result)); })
    };
}

Wichtige Komponenten der Implementierung:

• Erstellt eine neue „ Group “ mit untergeordneten Rezepten
• Wendet „ execution mode “ und „ workflow policy “ aus den UI-Einstellungen an
• Verwendet „ onGroupSetup()“, um die Benutzeroberfläche zu aktualisieren, sobald die Ausführung beginnt
• Verwendet ` onGroupDone()` zur Darstellung der Ausführungsergebnisse in der Benutzeroberfläche

Die Klasse „ TaskGlueItem “ implementiert Blattknoten in Ihrem Aufgabenbaum mithilfe von „ timeoutTask “.

Hier ist die „ recipe() “-Implementierung, die die Aufgabe erstellt:

ExecutableItem TaskGlueItem::recipe() const
{
    return Group {
        onGroupSetup([this] { m_taskWidget->setState(State::Running); }),
        timeoutTask(seconds(m_taskWidget->busyTime()), m_taskWidget->desiredResult()),
        onGroupDone([this](DoneWith result) { m_taskWidget->setState(resultToState(result)); })
    };
}

Die Implementierung:

• Erstellt ein ` Group `, das ein timeoutTask
• Verwendet UI-Einstellungen, um Dauer und erwartetes Ergebnis zu konfigurieren
• Aktualisiert den UI-Status bei Beginn der Aufgabe über ` onGroupSetup()`
• Gibt den Status der Aufgabenfertigstellung über ` onGroupDone()` wieder

Aufbau der Aufgabenhierarchie

Zwei Hilfsmethoden vereinfachen die Erstellung von Aufgabenbäumen:

static GlueItem *group(const GroupSetup &groupSetup, const QList<GlueItem *> children)
{
    return new GroupGlueItem(groupSetup, children);
}

static GlueItem *task(int busyTime = 1, DoneResult result = DoneResult::Success)
{
    return new TaskGlueItem(busyTime, result);
}

• group(): Erstellt eine neue GroupGlueItem
• task(): Erstellt eine neue TaskGlueItem

Definition der Baumstruktur

Der folgende Code zeigt, wie Sie eine vollständige Aufgabenhierarchie aufbauen können:

    std::unique_ptr<GlueItem> tree {
        group({WorkflowPolicy::ContinueOnSuccess}, {
            group({}, {
                task(),
                task(2, DoneResult::Error),
                task(3)
            }),
            task(),
            task(),
            group({WorkflowPolicy::FinishAllAndSuccess}, {
                task(),
                task(),
                group({WorkflowPolicy::StopOnError, ExecuteMode::Parallel}, {
                    task(4),
                    task(2),
                    task(1),
                    task(3, DoneResult::Error)
                }),
                task(2),
                task(3)
            }),
            task()
        })
    };

Sie können die obige Konstruktion anpassen, um verschiedene Baumstrukturen zu erstellen.

Verbindung der Benutzeroberfläche mit TaskTree

Im letzten Schritt wird der Aufgabenbaum mit den UI-Steuerelementen der Anwendung verknüpft:

    QSingleTaskTreeRunner taskTreeRunner;

    const auto resetTaskTree = [&] {
        taskTreeRunner.reset();
        tree->reset();
        progressBar->setValue(0);
        cancelButton->setEnabled(false);
    };

    const auto cancelTaskTree = [&] { taskTreeRunner.cancel(); };

    const auto startTaskTree = [&] {
        resetTaskTree();
        cancelButton->setEnabled(true);

        const auto onTaskTreeSetup = [progressBar](QTaskTree &taskTree) {
            progressBar->setMaximum(taskTree.progressMaximum());
            QObject::connect(&taskTree, &QTaskTree::progressValueChanged,
                             progressBar, &QProgressBar::setValue);
        };

        const auto onTaskTreeDone = [cancelButton] { cancelButton->setEnabled(false); };

        taskTreeRunner.start({tree->recipe()}, onTaskTreeSetup, onTaskTreeDone);
    };

    QObject::connect(startButton, &QAbstractButton::clicked, &app, startTaskTree);
    QObject::connect(cancelButton, &QAbstractButton::clicked, &app, cancelTaskTree);
    QObject::connect(resetButton, &QAbstractButton::clicked, &app, resetTaskTree);

    mainWidget.show();

    return app.exec();

Dieser Code:

• Erstellt einen `QSingleTaskTreeRunner` zur Ausführung des Aufgabenbaums
• Richtet Handler für die Schaltflächen „Start“, „Abbrechen“ und „Zurücksetzen“ ein
• Verbindet den Fortschrittsbalken, um die Aufgabenausführung zu verfolgen

Ausführen des Beispiels

Sie können das Beispiel wie folgt ausführen:

• Qt Creator

  Öffnen Sie den Modus „ Welcome “ und wählen Sie das Beispiel unter „ Examples “ aus. Weitere Informationen finden Sie unter Qt Creator: Tutorial: Erstellen und Ausführen.

• Qt Extension for Visual Studio Code

  Führen Sie den Befehl „ Qt: Open Qt examples “ aus dem Verzeichnis „ Command Palette “ aus und wählen Sie das Beispiel aus der Liste aus. Weitere Informationen finden Sie unter Qt Extension for Visual Studio Code: Tutorial: Erstellen und Ausführen.

Beispielprojekt @ code.qt.io