Démonstration de TaskTree

La démonstration de l'arbre des tâches montre comment construire une recette d'arbre des tâches imbriqué à l'aide de timeoutTask et présente les différents modes d'exécution execution modes et workflow policies. Son application fournit un aperçu graphique de la progression de l'arbre des tâches au fur et à mesure qu'il exécute les différents éléments de travail qui composent la tâche.

L'application de démonstration utilise un seul QWidget pour afficher et gérer une hiérarchie de TaskTree. Voici ce que vous trouverez dans l'interface :

• Les tâches apparaissent comme des nœuds de feuilles sur le côté droit de l'arbre.

  Pour chaque tâche, vous pouvez définir la durée d'exécution et configurer les états de réussite ou d'erreur.

• Les nœuds de groupe apparaissent à gauche et au milieu de l'arbre.

  Chaque groupe peut contenir plusieurs tâches enfants ou groupes imbriqués. Vous pouvez configurer execution modes et workflow policies pour chaque groupe.

• Des indicateurs de couleur montrent l'état d'exécution actuel de chaque nœud.

Les sections suivantes décrivent plus en détail le code de l'exemple.

Classes d'aide

La classe abstraite GlueItem relie les composants de l'interface utilisateur (UI) à leurs recettes TaskTree correspondantes. Ce modèle de conception permet une séparation nette entre l'interface utilisateur et la logique de la tâche.

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

    virtual ~GlueItem() = default;
};

La classe GlueItem définit trois méthodes virtuelles clés :

La classe GroupGlueItem gère les éléments Group dans votre hiérarchie de tâches. Chaque groupe peut contenir d'autres éléments GlueItem en tant qu'enfants, y compris des éléments imbriqués GroupGlueItemou TaskGlueItem.

Voici comment la méthode recipe() crée et configure un groupe :

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

Composants clés de l'implémentation :

• Création d'un nouveau Group avec des recettes enfantines
• Applique execution mode et workflow policy à partir des paramètres de l'interface utilisateur.
• Utilise onGroupSetup() pour mettre à jour l'interface utilisateur au début de l'exécution.
• Utilise onGroupDone() pour refléter les résultats de l'exécution dans l'interface utilisateur.

La classe TaskGlueItem implémente les nœuds feuilles de l'arbre des tâches à l'aide de timeoutTask.

Voici l'implémentation de recipe() qui crée la tâche :

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

L'implémentation :

• Crée un Group qui englobe un nœud feuille de la tâche. timeoutTask
• Utilise les paramètres de l'interface utilisateur pour configurer la durée et le résultat attendu
• Met à jour l'état de l'interface utilisateur lorsque la tâche commence via onGroupSetup()
• Reflète l'état d'achèvement de la tâche via onGroupDone()

Construction de la hiérarchie des tâches

Deux méthodes d'aide simplifient la création d'arbres de tâches :

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(): Crée un nouveau GroupGlueItem
• task(): Crée un nouveau TaskGlueItem

Définition de l'arborescence

Le code suivant montre comment construire une hiérarchie de tâches complète :

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

Vous pouvez modifier la construction ci-dessus pour créer différentes structures arborescentes.

Connecter l'interface utilisateur à TaskTree

La dernière étape consiste à connecter l'arbre des tâches aux contrôles de l'interface utilisateur de l'application :

    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();

Ce code :

• crée un QSingleTaskTreeRunner pour exécuter l'arbre des tâches
• met en place des gestionnaires pour les boutons Démarrer, Annuler et Réinitialiser
• Connecte la barre de progression pour suivre l'exécution de la tâche

Exécution de l'exemple

Pour exécuter l'exemple à partir de Qt Creatorouvrez le mode Welcome et sélectionnez l'exemple à partir de Examples. Pour plus d'informations, voir Qt Creator: Tutoriel : Construire et exécuter.

Exemple de projet @ code.qt.io