SkillExecutionTreeWidget.cpp

Go to the documentation of this file.

#include "SkillExecutionTreeWidget.h"
 
#include <mutex>
 
#include <QMenu>
#include <QTreeWidgetItem>
 
#include <ArmarXCore/core/logging/Logging.h>
 
#include "SkillExecutionTreeWidgetItem.h"
 
namespace armarx::skills::gui
{
 
    void
    SkillExecutionTreeWidget::runContextMenu(const QPoint& pos)
    {
        // sanity check
        ARMARX_CHECK(selectionValid());
 
        QMenu* menu = new QMenu();
 
        // Stop skill
        QAction* stopSkillAction = new QAction("Stop execution", this);
        const auto& executions = memory->getExecutions();
        if (executions.count(selectedExecution.skillExecutionId) == 0)
            return;
        skills::SkillStatus currentStatus =
            memory->getExecutions().at(selectedExecution.skillExecutionId).status;
        stopSkillAction->setDisabled(currentStatus == skills::SkillStatus::Aborted ||
                                     currentStatus == skills::SkillStatus::Failed ||
                                     currentStatus == skills::SkillStatus::Succeeded);
 
        QAction* rerunSkillAction = new QAction("Re-execute with similar parameters", this);
        menu->addAction(stopSkillAction);
        menu->addAction(rerunSkillAction);
        connect(stopSkillAction,
                &QAction::triggered,
                this,
                &SkillExecutionTreeWidget::stopSelectedExecution);
        connect(rerunSkillAction,
                &QAction::triggered,
                this,
                &SkillExecutionTreeWidget::rerunSkillWithSimilarParams);
 
        // open menu
        menu->popup(this->viewport()->mapToGlobal(pos));
    }
 
    void
    SkillExecutionTreeWidget::stopSelectedExecution()
    {
        if (!selectionValid())
            return;
        memory->stopExecution(this->selectedExecution.skillExecutionId);
    }
 
    void
    SkillExecutionTreeWidget::rerunSkillWithSimilarParams()
    {
        if (!selectionValid())
            return;
        // we don't want to hold state in the gui, so we need to get the parameters from memory:
        skills::SkillExecutionID currentExecutionId = this->selectedExecution.skillExecutionId;
        auto executions = memory->getExecutions();
        if (executions.empty())
            return;
 
        if (executions.count(currentExecutionId) == 0)
        {
            // we didn't find an entry for the execution id
            ARMARX_IMPORTANT << "The selected execution was not found in memory. The GUI is unable "
                                "to determine the parametrization for this execution.";
            return;
        }
        auto params = executions[currentExecutionId].parameters;
 
        ARMARX_INFO << "Re-executing the skill " << currentExecutionId.skillId
                    << " with previous parameters.";
 
        // give all information to manager
        this->memory->startExecutionWithParams(currentExecutionId.skillId, params);
    }
 
    void
    SkillExecutionTreeWidget::disconnectGui()
    {
        this->selectedExecution = SelectedExecution();
        this->clear();
    }
 
    void
    SkillExecutionTreeWidget::setupUi()
    {
        this->setColumnCount(6);
 
        this->setContextMenuPolicy(Qt::CustomContextMenu);
 
        QTreeWidgetItem* qtreewidgetitem = this->headerItem();
        qtreewidgetitem->setText(5, "");
        qtreewidgetitem->setText(4, "");
        qtreewidgetitem->setText(3, "Status");
        qtreewidgetitem->setText(2, "SkillID");
        qtreewidgetitem->setText(1, "Executor");
        qtreewidgetitem->setText(0, "Timestamp");
 
        this->setColumnWidth(4, 30);
 
        connectSignals();
    }
 
    void
    SkillExecutionTreeWidget::connectSignals()
    {
        connect(this,
                &QTreeWidget::customContextMenuRequested,
                this,
                &SkillExecutionTreeWidget::runContextMenu);
        connect(this,
                &QTreeWidget::currentItemChanged,
                this,
                &SkillExecutionTreeWidget::executionSelectionChanged);
    }
 
    inline bool
    SkillExecutionTreeWidget::selectionValid()
    {
        return selectedExecution.skillExecutionId.skillId.skillName != skills::SkillID::UNKNOWN;
    }
 
    void
    SkillExecutionTreeWidget::executionSelectionChanged(QTreeWidgetItem* current,
                                                        QTreeWidgetItem* previous)
    {
        // update internal state
        SkillExecutionTreeWidgetItem* selected =
            dynamic_cast<SkillExecutionTreeWidgetItem*>(current);
        if (selected)
        {
            this->selectedExecution.skillExecutionId = selected->getExecutionId();
        }
    }
 
    void
    SkillExecutionTreeWidget::updateGui(SkillManagerWrapper::Snapshot update)
    {
        if (update.statuses.empty())
        {
            return;
        }
 
        for (const auto& [k, v] : update.statuses)
        {
            skills::SkillExecutionID executionId = k;
            skills::SkillStatusUpdate statusUpdate = v;
 
            SkillExecutionTreeWidgetItem* found = nullptr;
            for (int i = 0; i < this->topLevelItemCount(); ++i)
            {
                auto c = dynamic_cast<SkillExecutionTreeWidgetItem*>(topLevelItem(i));
                if (!c)
                {
                    // the item is probably not the correct type, skip...
                    continue;
                }
 
                found = SkillExecutionTreeWidgetItem::SearchRecursiveForMatch(c, executionId);
 
                if (found)
                {
                    found->updateItem(statusUpdate.status);
 
                    break;
                }
            }
 
            if (!found)
            {
                // TODO: Sort to executor!
                auto item = new SkillExecutionTreeWidgetItem(executionId, memory, this);
 
                item->updateItem(statusUpdate.status);
            }
        }
    }
} // namespace armarx::skills::gui