SkillDetailsTreeWidget.cpp

Go to the documentation of this file.

#include "SkillDetailsTreeWidget.h"
 
#include <QApplication>
#include <QClipboard>
#include <QHeaderView>
#include <QResizeEvent>
#include <QVBoxLayout>
 
#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
 
namespace armarx::skills::gui
{
    SkillDetailsTreeWidget::SkillDetailsTreeWidget(std::shared_ptr<SkillManagerWrapper> _memory,
                                                   QWidget* parent) :
        QTreeWidget(parent), MemoryCommunicatorBase(_memory)
    {
        setupUi();
    }
 
    std::optional<SkillID>
    SkillDetailsTreeWidget::getShownId()
    {
        if (shownSkill.has_value())
        {
            return shownSkill.value().skillId;
        }
        else
        {
            return std::nullopt;
        }
    }
 
    void
    SkillDetailsTreeWidget::updateContents(const SkillID& skillId, const SkillDescription& descr)
    {
        // dont touch the widget if the skill id didn't change
        // note: this is only relevant when periodic updates are enabled
        /*
        if (shownSkill.has_value() && skillId == shownSkill.value().skillId)
            return;
        */
 
        // check the parameters: did they change?
        if (shownSkill.has_value())
        {
            auto remDesc = shownSkill.value().descr;
            if (descr.rootProfileDefaults != remDesc.rootProfileDefaults)
            {
                // TODO: ask the user if they want to reset to defaults
                // for now, we just overwrite without asking... (and do nothing)
            }
            // other cases: if the parameter types change, we *have* to reset; else the skill
            // cannot be started with the parameters.
            // same goes for the result type.
        }
 
        this->resetWidget();
 
        auto aron_args = descr.parametersType;
        auto default_args_of_profile = descr.rootProfileDefaults;
        // ideally we want to use the invisible root item, but aron expects a parent...
        QTreeWidgetItem* aronTreeWidgetItem = new QTreeWidgetItem(this);
        aronTreeWidgetItem->setText(0, QString::fromStdString("Parameters"));
 
        aronTreeWidgetController = std::make_shared<AronTreeWidgetController>(
            this, aronTreeWidgetItem, aron_args, default_args_of_profile);
 
 
        this->expandAll();
        resizeContents();
 
        // update the ShownSkill
        shownSkill = {skillId, descr};
    }
 
    void
    SkillDetailsTreeWidget::disconnectGui()
    {
        this->aronTreeWidgetController = nullptr;
    }
 
    void
    SkillDetailsTreeWidget::updateGui()
    {
        if (!shownSkill.has_value())
            return;
        skills::SkillID sid = shownSkill.value().skillId;
 
        // we assume the id to be fully specified, as it is checked while constructing
        // sanity check
        ARMARX_CHECK(sid.isFullySpecified());
 
        // maybe the search is empty?
        auto skillsMap = memory->getSkills();
        if (skillsMap.count(sid.providerId.value()) == 0 ||
            skillsMap.at(sid.providerId.value()).count(sid) == 0)
        {
            this->resetWidget();
            return;
        }
 
        auto descr = memory->getSkills().at(sid.providerId.value()).at(sid);
 
        this->updateContents(sid, descr);
    }
 
    void
    SkillDetailsTreeWidget::setupUi()
    {
        this->setColumnCount(3);
 
        this->setContextMenuPolicy(Qt::CustomContextMenu);
        this->setEditTriggers(QAbstractItemView::DoubleClicked | QAbstractItemView::EditKeyPressed);
 
        QTreeWidgetItem* qtreewidgetitem2 = this->headerItem();
        qtreewidgetitem2->setText(3, "defaultValue (hidden in GUI)");
        qtreewidgetitem2->setText(2, "Type");
        qtreewidgetitem2->setText(1, "Value");
        qtreewidgetitem2->setText(0, "Key");
 
        setColumnHidden(3, true);
    }
 
    /**
     * Problem: columns 0 and 1 have arbitrary size; so we want to limit their size, to make sure
     * everything is visible without scrolling. Column 2 is limited by design, as it only contains
     * type information.
     */
    void
    SkillDetailsTreeWidget::resizeContents()
    {
        // take remainder of width (which we want to assign to dynamic columns)
        const int widthRemainder = this->width() - typeWidth;
 
        // we want to assign half of it to each dynamic column
        const int dynamicColumnSize = widthRemainder / 2;
 
        // set width...
 
        this->setColumnWidth(0, dynamicColumnSize);
 
        this->setColumnWidth(1, dynamicColumnSize);
    }
 
    aron::data::DictPtr
    SkillDetailsTreeWidget::getConfigAsAron()
    {
        // create argument aron (if there is an accepted type set)
        if (aronTreeWidgetController)
        {
            return aronTreeWidgetController->convertToAron();
        }
        return nullptr;
    }
 
    void
    SkillDetailsTreeWidget::copyCurrentConfig()
    {
        auto data = getConfigAsAron();
        if (!data)
        {
            return;
        }
 
        auto json = aron::data::converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(data);
        QClipboard* clipboard = QApplication::clipboard();
        clipboard->setText(QString::fromStdString(json.dump(2)));
    }
 
    void
    SkillDetailsTreeWidget::pasteCurrentConfig()
    {
        QClipboard* clipboard = QApplication::clipboard();
        std::string s = clipboard->text().toStdString();
        nlohmann::json json = nlohmann::json::parse(s);
        auto data =
            aron::data::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(json);
 
        if (!aronTreeWidgetController)
        {
            return;
        }
 
        aronTreeWidgetController->setFromAron(data);
    }
 
    void
    SkillDetailsTreeWidget::resetCurrentConfig()
    {
        // this will always reset the args to the root profile
        // good while there is only the root, not good when profiles are properly implemented
 
 
        if (!shownSkill.has_value())
        {
            return;
        }
        skills::SkillID& skillId = shownSkill.value().skillId;
        const auto skills = memory->getSkills();
        ARMARX_CHECK(skillId.isProviderSpecified());
 
        // find description
        // did the provider die?
        if (skills.count(skillId.providerId.value()) == 0 ||
            skills.at(skillId.providerId.value()).count(skillId) == 0)
            return;
        skills::SkillDescription descr = skills.at(skillId.providerId.value()).at(skillId);
        this->updateContents(skillId, descr);
    }
 
    void
    SkillDetailsTreeWidget::resetWidget()
    {
        this->clear();
        aronTreeWidgetController = nullptr;
    }
 
 
} // namespace armarx::skills::gui