En esta página

Demostración de TaskTree

Muestra cómo los diferentes modos de ejecución y políticas de flujo de trabajo afectan a la ejecución compleja de TaskTree.

La demostración de TaskTree muestra cómo construir una receta anidada de TaskTree utilizando timeoutTask, y muestra diferentes execution modes y workflow policies. Su aplicación ofrece una visión general gráfica del progreso a medida que TaskTree ejecuta los distintos elementos de trabajo que componen la tarea.

Grupos de tareas anidados con estados codificados por colores que muestran un progreso del 78 por ciento

La aplicación de demostración utiliza un único QWidget para mostrar y gestionar una jerarquía de TaskTree. Esto es lo que encontrarás en la interfaz:

  • Las tareas aparecen como nodos hoja en el lado derecho del árbol.

    Para cada tarea, puedes establecer la duración de la ejecución y configurar los estados de finalización: éxito o error.

  • Los nodos de grupo aparecen a la izquierda y en el centro del árbol.

    Cada grupo puede contener varias tareas secundarias o grupos anidados. Puedes configurar « execution modes » y « workflow policies » para cada grupo.

  • Los indicadores de color muestran el estado de ejecución actual de cada nodo.

En las siguientes secciones se describen con más detalle los códigos del ejemplo.

Clases auxiliares de enlace

La clase abstracta « GlueItem » conecta los componentes de la interfaz de usuario (UI) con sus correspondientes recetas de TaskTree. Este patrón de diseño permite una separación clara entre la interfaz de usuario y la lógica de las tareas.

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

    virtual ~GlueItem() = default;
};

La clase ` GlueItem ` define tres métodos virtuales clave:

MétodoFinalidad
recipe()Crea y devuelve una receta de TaskTree que define el comportamiento del elemento
widget()Proporciona acceso al componente de la UI asociado
reset()Restablece el componente de la interfaz de usuario a su estado inicial

La clase ` GroupGlueItem ` gestiona los elementos ` Group ` de la jerarquía de tareas. Cada grupo puede contener otros elementos ` GlueItem ` como hijos, incluidos elementos ` GroupGlueItem` o ` TaskGlueItem` anidados.

A continuación se explica cómo el método ` recipe() ` crea y configura un grupo:

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

Componentes clave de la implementación:

  • Crea un nuevo Group con recetas secundarias
  • Aplica execution mode y workflow policy a partir de la configuración de la interfaz de usuario
  • Utiliza ` onGroupSetup()` para actualizar la interfaz de usuario cuando comienza la ejecución
  • Utiliza ` onGroupDone()` para reflejar los resultados de la ejecución en la interfaz de usuario

La clase ` TaskGlueItem ` implementa los nodos hoja en el árbol de tareas mediante ` timeoutTask`.

A continuación se muestra la implementación de ` recipe() ` que crea la tarea:

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

La implementación:

  • Crea un ` Group ` que envuelve un timeoutTask
  • Utiliza la configuración de la interfaz de usuario para definir la duración y el resultado esperado
  • Actualiza el estado de la interfaz de usuario cuando comienza la tarea mediante onGroupSetup()
  • Refleja el estado de finalización de la tarea mediante onGroupDone()

Creación de la jerarquía de tareas

Dos métodos auxiliares simplifican la creación de árboles de tareas:

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(): Crea un nuevo GroupGlueItem
  • task(): Crea un nuevo TaskGlueItem

Definición de la estructura del árbol

El siguiente código muestra cómo se puede construir una jerarquía completa de tareas:

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

Puedes modificar la construcción anterior para crear diferentes estructuras de árbol.

Conectar la interfaz de usuario con TaskTree

El último paso consiste en conectar el árbol de tareas con los controles de la interfaz de usuario de la aplicación:

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

Este código:

  • Crea un QSingleTaskTreeRunner para ejecutar el árbol de tareas
  • Configura los controladores para los botones «Iniciar», «Cancelar» y «Restablecer»
  • Conecta la barra de progreso para seguir la ejecución de las tareas

Ejecución del ejemplo

Puedes ejecutar el ejemplo desde:

Proyecto de ejemplo en code.qt.io

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.