SkillExecutionTreeWidget.cpp

Go to the documentation of this file.

#include "SkillExecutionTreeWidget.h"
 
#include <mutex>
 
#include <functional>
 
#include <QApplication>
#include <QClipboard>
#include <QDialog>
#include <QFormLayout>
#include <QLabel>
#include <QMenu>
#include <QPushButton>
#include <QTreeWidgetItem>
#include <QVBoxLayout>
 
#include <ArmarXCore/core/logging/Logging.h>
 
#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
#include <RobotAPI/libraries/aron/core/data/variant/container/List.h>
#include <RobotAPI/libraries/aron/core/type/variant/enum/IntEnum.h>
 
#include "../aron_tree_widget/AronTreeWidgetController.h"
#include "../aron_tree_widget/widgets/IntEnumWidget.h"
#include "SkillExecutionTreeWidgetItem.h"
 
namespace armarx::skills::gui
{
    namespace
    {
        // same format as SkillDetailsTreeWidget::copyCurrentConfig(), so the copied
        // parameters can be pasted via "set params from clipboard"
        void
        copyParametersJsonToClipboard(const aron::data::DictPtr& parameters)
        {
            if (!parameters)
            {
                ARMARX_INFO << "The execution has no parameters to copy.";
                return;
            }
            auto json =
                aron::data::converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(parameters);
            QApplication::clipboard()->setText(QString::fromStdString(json.dump(2)));
        }
    } // namespace
 
    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);
        QAction* copyParametersAction = new QAction("Copy parameters to clipboard", this);
        QAction* showDetailsAction = new QAction("Show Execution Details", this);
        menu->addAction(stopSkillAction);
        menu->addAction(rerunSkillAction);
        menu->addAction(copyParametersAction);
        menu->addAction(showDetailsAction);
        connect(stopSkillAction,
                &QAction::triggered,
                this,
                &SkillExecutionTreeWidget::stopSelectedExecution);
        connect(rerunSkillAction,
                &QAction::triggered,
                this,
                &SkillExecutionTreeWidget::rerunSkillWithSimilarParams);
        connect(copyParametersAction,
                &QAction::triggered,
                this,
                &SkillExecutionTreeWidget::copyParametersToClipboard);
        connect(showDetailsAction,
                &QAction::triggered,
                this,
                &SkillExecutionTreeWidget::showExecutionDetails);
 
        // 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::copyParametersToClipboard()
    {
        if (!selectionValid())
            return;
 
        auto executions = memory->getExecutions();
        auto executionIt = executions.find(selectedExecution.skillExecutionId);
        if (executionIt == executions.end())
        {
            ARMARX_IMPORTANT << "The selected execution was not found in memory. The GUI is unable "
                                "to determine the parametrization for this execution.";
            return;
        }
        copyParametersJsonToClipboard(executionIt->second.parameters);
    }
 
    void
    SkillExecutionTreeWidget::showExecutionDetails()
    {
        if (!selectionValid())
            return;
 
        skills::SkillExecutionID executionId = this->selectedExecution.skillExecutionId;
        auto executions = memory->getExecutions();
        if (executions.count(executionId) == 0)
        {
            ARMARX_IMPORTANT << "The selected execution was not found in memory. The GUI is unable "
                                "to determine the details for this execution.";
            return;
        }
        const auto& update = executions.at(executionId);
 
        std::string statusStr = "Unknown";
        for (const auto& [status, name] : EXECUTION_STATUS_TO_STRING)
        {
            if (status == update.status)
            {
                statusStr = name;
            }
        }
 
        auto* dialog = new QDialog(this);
        dialog->setAttribute(Qt::WA_DeleteOnClose);
        dialog->setWindowTitle("Execution Details");
        dialog->resize(600, 500);
 
        auto* layout = new QVBoxLayout(dialog);
        auto* infoLayout = new QFormLayout();
        infoLayout->addRow("Skill:",
                           new QLabel(QString::fromStdString(executionId.skillId.toString())));
        infoLayout->addRow("Executor:",
                           new QLabel(QString::fromStdString(executionId.executorName)));
        infoLayout->addRow(
            "Started:",
            new QLabel(QString::fromStdString(executionId.executionStartedTime.toDateTimeString())));
        infoLayout->addRow("Status:", new QLabel(QString::fromStdString(statusStr)));
        layout->addLayout(infoLayout);
 
        // look up the skill description to get the parameter/result types, so the
        // values can be rendered like in the skill description tab
        std::optional<skills::SkillDescription> description;
        if (executionId.skillId.providerId.has_value())
        {
            const auto skillsMap = memory->getSkills();
            auto providerIt = skillsMap.find(executionId.skillId.providerId.value());
            if (providerIt != skillsMap.end())
            {
                auto skillIt = providerIt->second.find(executionId.skillId);
                if (skillIt != providerIt->second.end())
                {
                    description = skillIt->second;
                }
            }
        }
 
        // same rendering as the skill description tab, but read-only;
        // if defaults are given, parameters differing from them are highlighted
        const auto makeAronTree = [dialog](const std::string& title,
                                           const aron::type::ObjectPtr& type,
                                           const aron::data::DictPtr& data,
                                           const aron::data::DictPtr& defaults) -> QTreeWidget*
        {
            auto* tree = new QTreeWidget(dialog);
            tree->setColumnCount(3);
            tree->setHeaderLabels({"Key", "Value", "Type"});
 
            auto* rootItem = new QTreeWidgetItem(tree);
            rootItem->setText(0, QString::fromStdString(title));
 
            auto* controller = new AronTreeWidgetController(tree, rootItem, type, data);
            // the controller only handles editing; dropping it makes the tree static
            delete controller;
 
            // int enums are shown as an editable combo box holding only the numeric
            // value; replace it with a static "Name (value)" text
            std::function<void(QTreeWidgetItem*)> showEnumNames = [&](QTreeWidgetItem* item)
            {
                if (auto* aronItem = AronTreeWidgetItem::DynamicCast(item))
                {
                    auto enumType = aron::type::IntEnum::DynamicCast(aronItem->aronType);
                    auto* enumWidget = IntEnumWidget::DynamicCast(tree->itemWidget(item, 1));
                    if (enumType && enumWidget)
                    {
                        const std::string text = enumWidget->getText().toStdString();
                        QString display = QString::fromStdString(text);
                        for (const auto& [name, value] : enumType->getAcceptedValueMap())
                        {
                            if (name == text || std::to_string(value) == text)
                            {
                                display = QString::fromStdString(name + " (" +
                                                                 std::to_string(value) + ")");
                                break;
                            }
                        }
                        tree->removeItemWidget(item, 1);
                        item->setText(1, display);
                    }
                }
                for (int i = 0; i < item->childCount(); ++i)
                {
                    showEnumNames(item->child(i));
                }
            };
            showEnumNames(rootItem);
 
            // highlight the specific rows that deviate from the profile defaults,
            // i.e. that were actively set for this execution
            const auto markChanged = [](QTreeWidgetItem* item)
            {
                const QBrush highlight(QColor(255, 200, 100, 90));
                QFont font = item->font(0);
                font.setBold(true);
                for (int column = 0; column < 3; ++column)
                {
                    item->setBackground(column, highlight);
                    item->setToolTip(column,
                                     "This value differs from the profile default, i.e. it "
                                     "was actively set for this execution.");
                }
                item->setFont(0, font);
            };
            // ancestors of a changed row only get a bold key, so the change can be
            // located when the tree is collapsed without drowning it in highlights
            const auto markContainsChange = [](QTreeWidgetItem* item)
            {
                QFont font = item->font(0);
                font.setBold(true);
                item->setFont(0, font);
            };
 
            // walks the tree and both data dicts in parallel; returns whether
            // anything in the subtree differs
            std::function<bool(QTreeWidgetItem*,
                               const aron::data::VariantPtr&,
                               const aron::data::VariantPtr&)>
                markDifferences = [&](QTreeWidgetItem* item,
                                      const aron::data::VariantPtr& value,
                                      const aron::data::VariantPtr& defaultValue) -> bool
            {
                if (!value && !defaultValue)
                {
                    return false;
                }
                if (!value || !defaultValue)
                {
                    // set but no default (or vice versa) -> the whole entry was actively set
                    markChanged(item);
                    return true;
                }
 
                if (auto valueDict = aron::data::Dict::DynamicCast(value))
                {
                    auto defaultDict = aron::data::Dict::DynamicCast(defaultValue);
                    if (!defaultDict)
                    {
                        markChanged(item);
                        return true;
                    }
                    bool anyChildChanged = false;
                    for (int i = 0; i < item->childCount(); ++i)
                    {
                        QTreeWidgetItem* childItem = item->child(i);
                        const std::string key = childItem->text(0).toStdString();
                        const auto childValue =
                            valueDict->hasElement(key) ? valueDict->getElement(key) : nullptr;
                        const auto childDefault = defaultDict->hasElement(key)
                                                      ? defaultDict->getElement(key)
                                                      : nullptr;
                        anyChildChanged |= markDifferences(childItem, childValue, childDefault);
                    }
                    if (anyChildChanged)
                    {
                        markContainsChange(item);
                    }
                    return anyChildChanged;
                }
 
                if (auto valueList = aron::data::List::DynamicCast(value))
                {
                    auto defaultList = aron::data::List::DynamicCast(defaultValue);
                    if (!defaultList)
                    {
                        markChanged(item);
                        return true;
                    }
                    const auto valueElements = valueList->getElements();
                    const auto defaultElements = defaultList->getElements();
                    bool anyChildChanged = false;
                    for (int i = 0; i < item->childCount(); ++i)
                    {
                        QTreeWidgetItem* childItem = item->child(i);
                        const auto childValue = static_cast<size_t>(i) < valueElements.size()
                                                    ? valueElements[i]
                                                    : nullptr;
                        const auto childDefault = static_cast<size_t>(i) < defaultElements.size()
                                                      ? defaultElements[i]
                                                      : nullptr;
                        anyChildChanged |= markDifferences(childItem, childValue, childDefault);
                    }
                    if (valueElements.size() != defaultElements.size())
                    {
                        // fewer elements than the default -> visible only on the list itself
                        markChanged(item);
                        anyChildChanged = true;
                    }
                    else if (anyChildChanged)
                    {
                        markContainsChange(item);
                    }
                    return anyChildChanged;
                }
 
                // leaf value (int, float, string, bool, matrix, ...)
                bool equal = false;
                try
                {
                    equal = (*value == defaultValue);
                }
                catch (...)
                {
                    // type mismatch between value and default -> treat as changed
                }
                if (not equal)
                {
                    markChanged(item);
                    return true;
                }
                return false;
            };
 
            if (data && defaults)
            {
                if (QTreeWidgetItem* objectItem = rootItem->child(0))
                {
                    markDifferences(objectItem, data, defaults);
                }
            }
 
            tree->setEditTriggers(QAbstractItemView::NoEditTriggers);
            std::function<void(QTreeWidgetItem*)> makeReadOnly =
                [&](QTreeWidgetItem* item)
            {
                item->setFlags(item->flags() & ~Qt::ItemIsEditable);
                if (QWidget* itemWidget = tree->itemWidget(item, 1))
                {
                    itemWidget->setEnabled(false);
                }
                for (int i = 0; i < item->childCount(); ++i)
                {
                    makeReadOnly(item->child(i));
                }
            };
            makeReadOnly(rootItem);
 
            tree->expandAll();
            tree->resizeColumnToContents(0);
            return tree;
        };
 
        if (description.has_value())
        {
            layout->addWidget(makeAronTree("Parameters",
                                           description->parametersType,
                                           update.parameters,
                                           description->rootProfileDefaults));
 
            if (update.result)
            {
                layout->addWidget(
                    makeAronTree("Result", description->resultType, update.result, nullptr));
            }
        }
        else
        {
            layout->addWidget(
                new QLabel("The skill description is no longer available; the parameters "
                           "cannot be displayed."));
        }
 
        auto* copyButton = new QPushButton("Copy parameters to clipboard", dialog);
        connect(copyButton,
                &QPushButton::clicked,
                [parameters = update.parameters]() { copyParametersJsonToClipboard(parameters); });
        layout->addWidget(copyButton);
 
        dialog->show();
    }
 
    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