SkillDashboardWidgetController.cpp

Go to the documentation of this file.

#include "SkillDashboardWidgetController.h"
 
#include <RobotAPI/gui-plugins/ui_SkillDashboardWidget_small.h>
 
#include <cmath>
#include <fstream>
#include <iostream>
#include <string>
 
#include <IceUtil/Optional.h>
 
#include <nlohmann/json.hpp>
 
#include <QDateTime>
#include <QDebug>
#include <QHBoxLayout>
#include <QLabel>
#include <QLineEdit>
#include <QMessageBox>
#include <QPalette>
#include <QPushButton>
#include <QString>
#include <QStringList>
#include <QTimer>
#include <QToolButton>
#include <Qt>
#include <QtConcurrent/QtConcurrent>
#include <QtGlobal>
#include <QtWidgets/QSlider>
#include <QtWidgets/QTableWidgetItem>
 
#include <ArmarXCore/core/application/Application.h>
#include <ArmarXCore/core/system/ArmarXDataPath.h>
#include <ArmarXCore/core/time/Clock.h>
#include <ArmarXCore/core/time/Duration.h>
#include <ArmarXCore/core/time/LocalTimeServer.h>
#include <ArmarXCore/core/time/TimeUtil.h>
#include <ArmarXCore/core/time/ice_conversions.h>
#include <ArmarXCore/observers/variant/SingleTypeVariantList.h>
 
#include "RobotAPI/libraries/skills/core/SkillID.h"
#include "RobotAPI/libraries/skills_gui/aron_tree_widget/AronTreeWidgetController.h"
#include "RobotAPI/libraries/skills_gui/aron_tree_widget/widgets/SkillDescriptionWidget.h"
#include <RobotAPI/interface/components/SkillDashboardInterface.h>
#include <RobotAPI/interface/skills/SkillManagerInterface.h>
 
#include "EllipsisPushButton.h"
 
namespace armarx
{
    SkillDashboardGuiPlugin::SkillDashboardGuiPlugin()
    {
        addWidget<SkillDashboardWidget>();
    }
 
    SkillDashboardWidget::~SkillDashboardWidget() = default;
 
    SkillDashboardWidget::SkillDashboardWidget() :
        DEFAULT_SETTINGS_PLUGIN_NAME("SkillDashboardGuiPlugin"),
        DEFAULT_SETTINGS_CUSTOM_TEXT("custom text")
    {
        // init gui
        ARMARX_INFO << "Setup UI";
        ui = std::make_unique<Ui::SkillDashboardWidget>();
        ui->setupUi(getWidget());
        this->shortcutLayout = new QVBoxLayout();
        this->dialog = new SkillDashboardConfigWindow();
        this->editModeAction = new QAction("Edit Mode", this);
        this->editModeAction->setCheckable(true);
        this->editModeAction->setToolTip("If toggled the shortcut config buttons and the reload, "
                                         "add and export button will be shown.");
 
        this->recoverButtons = new QToolButton();
        QIcon iconRecover = getWidget()->style()->standardIcon(QStyle::SP_BrowserReload);
        this->recoverButtons->setIcon(iconRecover);
        this->recoverButtons->setToolTip("Recover all buttons");
 
        this->errorMessageArea = new MessageWidget(true, getWidget());
        ui->messageArea->layout()->addWidget(this->errorMessageArea);
 
        ui->shortcutListWidget->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
        ui->shortcutListWidget->setDragDropMode(QAbstractItemView::InternalMove);
        ui->shortcutListWidget->setDefaultDropAction(Qt::MoveAction);
        ui->shortcutListWidget->setSelectionMode(QAbstractItemView::SingleSelection);
        ui->shortcutListWidget->setSizeAdjustPolicy(QAbstractScrollArea::AdjustToContents);
        ui->shortcutListWidget->setStyleSheet(R"(
    QListWidget {
        background: transparent;
        border: none;
    }
    QListWidget::item {
        margin: 0px;
        padding: 0px;
    }
)");
 
        qRegisterMetaType<skills::core::dto::Execution::Status>(
            "skills::core::dto::Execution::Status");
 
        connect(this->editModeAction, SIGNAL(toggled(bool)), this, SLOT(editMode(bool)));
        connect(this->recoverButtons,
                &QToolButton::clicked,
                this,
                &SkillDashboardWidget::enableBlockedButtons);
        connect(ui->addFromClipboardButton,
                &QPushButton::clicked,
                this,
                &SkillDashboardWidget::addFromClipboard);
        connect(ui->addButton,
                &QPushButton::clicked,
                this,
                [this]() { openConfigWindow("", "", "", "", ""); });
        connect(ui->reloadButton, &QPushButton::clicked, this, &SkillDashboardWidget::loadButtons);
        connect(
            this, &SkillDashboardWidget::loadButtonInit, this, &SkillDashboardWidget::loadButtons);
        connect(ui->exportButton, &QPushButton::clicked, this, &SkillDashboardWidget::exportButtons);
        connect(ui->importButton, &QPushButton::clicked, this, &SkillDashboardWidget::importButtons);
 
        connect(this,
                &SkillDashboardWidget::skillFinished,
                this,
                &SkillDashboardWidget::activateButton);
 
 
        connect(this->dialog,
                &SkillDashboardConfigWindow::shortcutNameHasChanged,
                this,
                &SkillDashboardWidget::onShortcutNameChanged);
        connect(ui->stopAllButton, &QPushButton::clicked, this, &SkillDashboardWidget::stopAll);
        connect(this, &SkillDashboardWidget::loadPathInfo, this, &SkillDashboardWidget::loadPath);
 
        this->editModeAction->toggle();
 
        ARMARX_INFO << "Done: Setup UI";
    }
 
    void
    SkillDashboardWidget::onInitComponent()
    {
        ARMARX_TRACE;
 
        usingProxy(skillDashboardProxyName);
 
        if (not this->skillManagerOberserverName.empty())
        {
            usingProxy(this->skillManagerOberserverName);
        }
        else
        {
            ARMARX_IMPORTANT << "empty";
        }
    }
 
    void
    SkillDashboardWidget::onConnectComponent()
    {
        ARMARX_TRACE;
        this->connected.store(true);
        getProxy(this->dashboardPrx, skillDashboardProxyName);
        getProxy(this->managerPrx, this->skillManagerOberserverName);
        ARMARX_INFO << "Starting thread that queries the SkillsMemory if skills are running in the "
                       "dashboard.";
        this->exampleTask = std::thread([&] { exampleThreadMethod(); });
        emit loadButtonInit();
        emit loadPathInfo();
    }
 
    void
    SkillDashboardWidget::updateShortcutListHeight()
    {
        int rows = ui->shortcutListWidget->count();
        if (rows == 0)
        {
            ui->shortcutListWidget->setMinimumHeight(0);
            return;
        }
 
        int rowHeight = ui->shortcutListWidget->sizeHintForRow(0);
        int frame = ui->shortcutListWidget->frameWidth() * 2;
        ui->shortcutListWidget->setMinimumHeight(rows * rowHeight + frame);
    }
 
    std::string
    errorStatustoString(skills::core::dto::Execution::Status s)
    {
        switch (s)
        {
            case skills::core::dto::Execution::Status::Failed:
                return "Failed";
            case skills::core::dto::Execution::Status::Succeeded:
                return "Succeeded";
            case skills::core::dto::Execution::Status::Aborted:
                return "Aborted";
            default:
                return "Other";
        }
        return "Unknown";
    }
 
    void
    SkillDashboardWidget::saveShortcutOrder()
    {
        std::vector<std::string> order;
 
        for (int i = 0; i < ui->shortcutListWidget->count(); ++i)
        {
            QListWidgetItem* item = ui->shortcutListWidget->item(i);
            QString name = item->data(Qt::UserRole).toString();
            order.push_back(name.toStdString());
        }
 
        try
        {
            dashboardPrx->saveShortcutOrder(order);
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not save shortcut order";
        }
    }
 
    void
    SkillDashboardWidget::loadPath()
    {
        std::vector<std::string> pathSegments;
        try
        {
            pathSegments = dashboardPrx->getPathStructure();
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not request path";
        }
        if (pathSegments.size() == 3)
        {
            ui->packageEdit->setText(QString::fromStdString(pathSegments[0]));
            ui->folderEdit->setText(QString::fromStdString(pathSegments[1]));
            ui->fileNameEdit->setText(QString::fromStdString(pathSegments[2]));
        }
    }
 
    void
    SkillDashboardWidget::activateButton(const std::string& name,
                                         skills::core::dto::Execution::Status status)
    {
        auto* btn = this->shortcutButtons.at(name);
        btn->setDisabled(false);
        if (status != skills::core::dto::Execution::Status::Succeeded)
        {
            btn->finishProgress(true);
            std::string text = "Shortcut '" + name + "' terminated with status '" +
                               errorStatustoString(status) + "'.";
            QString timestamp = QDateTime::currentDateTime().toString("HH:mm:ss");
            QString messageWithTimestamp =
                QString("[%1] %2").arg(timestamp, QString::fromStdString(text));
            this->errorMessageArea->newErrorMessage(messageWithTimestamp);
        }
        btn->finishProgress(false);
    }
 
    void
    SkillDashboardWidget::addFromClipboard()
    {
        QClipboard* clipboard = QApplication::clipboard();
        auto clipboardText = clipboard->text().toStdString();
        nlohmann::json j;
        try
        {
            j = nlohmann::json::parse(clipboardText);
        }
        catch (const nlohmann::json::parse_error& e)
        {
            ARMARX_ERROR << "JSON Parse Error: " << e.what() << "\n";
        }
 
        auto shortcutImport = j["shortcuts"][0];
        auto skillArgs = shortcutImport["skill_args"].dump(2);
        auto skillId = shortcutImport["skill_id"];
        this->openConfigWindow("", skillId, skillArgs, "", "");
    }
 
    void
    SkillDashboardWidget::stopAll()
    {
        QtConcurrent::run(
            [this]
            {
                try
                {
                    auto results = managerPrx->abortAllSkills();
                    for (auto& r : results)
                        ARMARX_IMPORTANT << r.success;
                }
                catch (Ice::Exception const&)
                {
                    ARMARX_WARNING << "Could not send stop all request.";
                }
            });
        this->enableBlockedButtons();
    }
 
    void
    SkillDashboardWidget::exampleThreadMethod()
    {
        while (this->connected.load())
        {
            if (not this->runningSkills.empty())
            {
                for (auto it = this->runningSkills.cbegin(); it != this->runningSkills.cend();)
                {
                    skills::core::dto::Execution::Status status =
                        skills::core::dto::Execution::Status::Succeeded;
 
                    try
                    {
                        IceUtil::Optional<skills::manager::dto::SkillStatusUpdate> update =
                            this->managerPrx->getSkillExecutionStatus(it->second);
                        if (update)
                        {
                            status = update->status;
                        }
                    }
                    catch (Ice::Exception const&)
                    {
                        ARMARX_WARNING << "Could not get skill status." << deactivateSpam(10);
                    }
 
                    if (status == skills::core::dto::Execution::Status::Succeeded ||
                        status == skills::core::dto::Execution::Status::Failed ||
                        status == skills::core::dto::Execution::Status::Aborted)
                    {
                        ARMARX_INFO << "Finished skill " << it->first;
                        emit skillFinished(it->first, status);
                        it = this->runningSkills.erase(it);
                    }
                    else
                    {
                        ++it;
                    }
                }
                ARMARX_INFO << deactivateSpam(10) << "Waiting for skills to finish..";
            }
            armarx::core::time::Clock::WaitFor(armarx::Duration::SecondsDouble(0.5));
        }
    }
 
    void
    SkillDashboardWidget::onShortcutNameChanged()
    {
 
        if ((this->shortcutButtons.find(this->dialog->getShortcutName().toStdString()) !=
             this->shortcutButtons.end()) and
            (this->dialog->getShortcutName().toStdString() != this->currentShortcutName))
        {
            this->dialog->setInfoText(
                "A shortcut with this name already exists! The old one will be overwritten.");
            ARMARX_IMPORTANT
                << "A shortcut with this name already exists! The old one will be overwritten!";
        }
        else
        {
            this->dialog->setInfoText("");
        }
    }
 
    void
    SkillDashboardWidget::openConfigWindow(const std::string& name,
                                           const std::string& id,
                                           const std::string& args,
                                           const std::string& iconName,
                                           const std::string& shortcutId)
    {
 
        this->dialog->setShortcutName(name);
        this->dialog->setSkillId(id);
        this->dialog->setIconName(iconName);
        this->dialog->setSkillConfig(args);
 
 
        if (this->dialog->exec() == QDialog::Accepted)
        {
            try
            {
                SkillShortcut newShortcut;
                newShortcut.shortcutName = this->dialog->getShortcutName().toStdString();
                newShortcut.skillId = this->dialog->getSkillId().toStdString();
                newShortcut.skillArgs = this->dialog->getSkillConfig().toStdString();
                newShortcut.iconName = this->dialog->getIconName().toStdString();
                newShortcut.id = shortcutId;
                this->dashboardPrx->addNewShortcut(newShortcut);
            }
            catch (Ice::Exception const&)
            {
                ARMARX_WARNING << "Could not send new Shortcut." << deactivateSpam(10);
            }
            loadButtons();
        }
    }
 
    void
    SkillDashboardWidget::exportButtons()
    {
        saveShortcutOrder();
        std::string packageName = ui->packageEdit->text().toStdString();
        std::string folderName = ui->folderEdit->text().toStdString();
        if (ui->fileNameEdit->text().count(' ') == ui->fileNameEdit->text().length())
        {
            ARMARX_ERROR << "please enter a file name!";
            return;
        }
        std::string fileName = ui->fileNameEdit->text().toStdString();
        try
        {
            this->dashboardPrx->exportShortcuts(packageName, folderName, fileName);
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not send export task." << deactivateSpam(10);
        }
 
        std::string coloredPath = "<span style='color:red;'>" + packageName + "/" + folderName +
                                  "/" + fileName + "</span>";
        std::string propertyPath = "Insert " + coloredPath +
                                   " into the property 'ArmarX.SkillDashboard.ShortcutPath' of the "
                                   "SkillDashboard component.";
 
 
        ui->exportPath->setFullText(QString::fromStdString(propertyPath));
        ui->exportPath->setTextInteractionFlags(Qt::TextSelectableByMouse);
    }
 
    void
    SkillDashboardWidget::importButtons()
    {
        bool success = false;
        std::string packageName = ui->packageEdit->text().toStdString();
        std::string folderName = ui->folderEdit->text().toStdString();
        if (ui->fileNameEdit->text().count(' ') == ui->fileNameEdit->text().length())
        {
            ARMARX_ERROR << "please enter a file name!";
            return;
        }
        std::string fileName = ui->fileNameEdit->text().toStdString();
        try
        {
            success = this->dashboardPrx->importShortcuts(packageName, folderName, fileName);
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not send import task." << deactivateSpam(10);
        }
        if (success)
        {
            this->loadButtons();
        }
    }
 
    void
    SkillDashboardWidget::loadButtons()
    {
 
        this->saveShortcutOrder();
        this->dashboardPrx->syncOrderedWithDefault();
        this->shortcutButtons.clear();
        this->configButtons.clear();
        this->deleteButtons.clear();
        ui->shortcutListWidget->clear();
 
        std::vector<SkillShortcut> shortcuts;
        try
        {
            shortcuts = this->dashboardPrx->getShortcuts();
        }
        catch (Ice::Exception const& e)
        {
            ARMARX_WARNING << "Could not fetch shortcuts. " << e.what() << deactivateSpam(10);
        }
 
 
        for (const auto& shortcut : shortcuts)
        {
            auto* mainButton =
                new EllipsisPushButton(QString::fromStdString(shortcut.shortcutName));
            mainButton->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
            mainButton->setToolTip(QString("Execute"));
 
            QToolButton* editButton = new QToolButton();
            editButton->setIcon(
                getWidget()->style()->standardIcon(QStyle::SP_FileDialogContentsView));
            editButton->setToolTip(QString("Edit"));
 
            QToolButton* deleteButton = new QToolButton();
            deleteButton->setIcon(getWidget()->style()->standardIcon(QStyle::SP_TrashIcon));
            deleteButton->setToolTip(QString("Delete"));
 
            QWidget* rowWidget = new QWidget();
            QHBoxLayout* layout = new QHBoxLayout(rowWidget);
            layout->setContentsMargins(0, 0, 0, 0);
            layout->setSpacing(2);
            layout->addWidget(mainButton);
            layout->addWidget(editButton);
            layout->addWidget(deleteButton);
 
            QListWidgetItem* item = new QListWidgetItem(ui->shortcutListWidget);
            item->setSizeHint(rowWidget->sizeHint());
            item->setData(Qt::UserRole, QString::fromStdString(shortcut.shortcutName));
            ui->shortcutListWidget->addItem(item);
            ui->shortcutListWidget->setItemWidget(item, rowWidget);
 
            this->shortcutButtons[shortcut.shortcutName] = mainButton;
            this->configButtons[shortcut.shortcutName] = editButton;
            this->deleteButtons[shortcut.shortcutName] = deleteButton;
 
            connect(mainButton,
                    &QPushButton::clicked,
                    this,
                    [this, name = shortcut.shortcutName] { executeSkill(name); });
            connect(editButton,
                    &QToolButton::clicked,
                    this,
                    [this, name = shortcut.shortcutName] { editShortcut(name); });
            connect(deleteButton,
                    &QToolButton::clicked,
                    this,
                    [this, name = shortcut.shortcutName] { deleteShortcut(name); });
        }
        updateShortcutListHeight();
    }
 
    void
    SkillDashboardWidget::executeSkill(const std::string& name)
    {
        ARMARX_INFO << "About to execute skill with shortcut name `" << name
                    << "` from skill dashboard.";
 
        SkillShortcut shortcut;
        try
        {
            shortcut = this->dashboardPrx->getShortcut(name);
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not fetch shortcut." << deactivateSpam(10);
            std::string text = "Shortcut '" + name + "': Could not fetch shortcut.";
            QString timestamp = QDateTime::currentDateTime().toString("HH:mm:ss");
            QString messageWithTimestamp =
                QString("[%1] %2").arg(timestamp, QString::fromStdString(text));
            this->errorMessageArea->newErrorMessage(messageWithTimestamp);
        }
 
        size_t pos = shortcut.skillId.find('/');
        std::string provider = "";
        std::string nameSkill = "";
        nlohmann::json json = nlohmann::json::parse(shortcut.skillArgs);
        aron::data::DictPtr data =
            aron::data::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(json);
        aron::data::dto::DictPtr paramterDto = data->toAronDictDTO();
 
        if (pos != std::string::npos)
        {
            provider = shortcut.skillId.substr(0, pos);
            nameSkill = shortcut.skillId.substr(pos + 1);
            skills::manager::dto::ProviderID providerId{.providerName = provider};
 
            skills::manager::dto::SkillID skillId{.providerId = providerId, .skillName = nameSkill};
 
            char hostname[HOST_NAME_MAX];
            gethostname(hostname, HOST_NAME_MAX);
 
            skills::manager::dto::SkillExecutionRequest request{
                .skillId = skillId,
                .executorName = "Skills.Dashboard GUI (hostname: " + std::string(hostname) + ")",
                .parameters = paramterDto,
            };
 
 
            try
            {
                ARMARX_IMPORTANT << "Executing skill with shortcut name `" << shortcut.shortcutName
                                 << "` from skill dashboard.";
                armarx::core::time::Duration skillTimeout =
                    armarx::core::time::Duration::Seconds(0);
 
                IceUtil::Optional<armarx::skills::manager::dto::SkillDescription> optDto =
                    managerPrx->getSkillDescription(skillId);
 
                if (optDto)
                {
                    const auto& dto = *optDto;
                    skillTimeout =
                        armarx::core::time::Duration::MicroSeconds(dto.timeout.microSeconds);
                }
                else
                {
                    ARMARX_WARNING << "SkillDescription not found";
                }
                skills::manager::dto::SkillExecutionID executionId =
                    this->managerPrx->executeSkillAsync(request);
                this->runningSkills[shortcut.shortcutName] = executionId;
                auto* btn = this->shortcutButtons.at(shortcut.shortcutName);
                btn->setDisabled(true);
                btn->startTimeout(skillTimeout.toSeconds());
            }
            catch (Ice::Exception const&)
            {
                ARMARX_WARNING << "Could not send execute request." << deactivateSpam(10);
                std::string text = "Shortcut '" + name + "': Could not send execute request.";
                QString timestamp = QDateTime::currentDateTime().toString("HH:mm:ss");
                QString messageWithTimestamp =
                    QString("[%1] %2").arg(timestamp, QString::fromStdString(text));
                this->errorMessageArea->newErrorMessage(messageWithTimestamp);
            }
        }
        else
        {
            ARMARX_IMPORTANT << "Invalid SkillID";
        }
    }
 
    void
    SkillDashboardWidget::editShortcut(const std::string& name)
    {
        this->currentShortcutName = name;
 
        SkillShortcut shortcut;
        try
        {
            shortcut = this->dashboardPrx->getShortcut(name);
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not fetch shortcut." << deactivateSpam(10);
        }
        openConfigWindow(shortcut.shortcutName,
                         shortcut.skillId,
                         shortcut.skillArgs,
                         shortcut.iconName,
                         shortcut.id);
        this->currentShortcutName = "not set";
    }
 
    void
    SkillDashboardWidget::deleteShortcut(const std::string& name)
    {
        ARMARX_INFO << "delete shortcut: " << name;
        try
        {
            this->dashboardPrx->deleteShortcut(name);
            //this->shortcutButtons.erase(this->shortcutButtons.find(name));
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not delete shortcut." << deactivateSpam(10);
        }
        loadButtons();
    }
 
    void
    SkillDashboardWidget::clearLayout(QLayout* layout)
    {
        if (!layout)
            return;
 
        while (QLayoutItem* item = layout->takeAt(0))
        {
            if (QWidget* widget = item->widget())
            {
                widget->deleteLater();
            }
            else if (QLayout* subLayout = item->layout())
            {
                clearLayout(subLayout);
            }
            delete item;
        }
    }
 
    QPointer<QWidget>
    SkillDashboardWidget::getCustomTitlebarWidget(QWidget* parent)
    {
        if (customToolbar)
        {
            if (parent != customToolbar->parent())
            {
                customToolbar->setParent(parent);
            }
 
            return customToolbar.data();
        }
 
        customToolbar = new QToolBar(parent);
        customToolbar->setIconSize(QSize(16, 16));
        customToolbar->addAction(editModeAction);
        customToolbar->addWidget(this->recoverButtons);
 
        return customToolbar.data();
    }
 
    void
    SkillDashboardWidget::editMode(bool edit)
    {
        if (edit)
        {
            for (const auto& button : this->deleteButtons)
            {
                button.second->setVisible(true);
            }
            for (const auto& button : this->configButtons)
            {
                button.second->setVisible(true);
            }
            ui->addButton->setVisible(true);
            ui->reloadButton->setVisible(true);
            ui->exportButton->setVisible(true);
            ui->importButton->setVisible(true);
            ui->exportConfiguration->setVisible(true);
            ui->addFromClipboardButton->setVisible(true);
            ui->shortcutListWidget->setDragDropMode(QAbstractItemView::InternalMove);
        }
        else
        {
            for (const auto& button : this->deleteButtons)
            {
                button.second->setVisible(false);
            }
            for (const auto& button : this->configButtons)
            {
                button.second->setVisible(false);
            }
            ui->addButton->setVisible(false);
            ui->reloadButton->setVisible(false);
            ui->exportButton->setVisible(false);
            ui->importButton->setVisible(false);
            ui->exportConfiguration->setVisible(false);
            ui->addFromClipboardButton->setVisible(false);
            ui->shortcutListWidget->setDragDropMode(QAbstractItemView::NoDragDrop);
        }
    }
 
    void
    SkillDashboardWidget::enableBlockedButtons()
    {
        for (auto& shortCutB : this->shortcutButtons)
        {
            shortCutB.second->setDisabled(false);
        }
    }
 
    void
    SkillDashboardWidget::onDisconnectComponent()
    {
        this->connected.store(false);
        ARMARX_INFO << "Stopping thread which queries skill memory ...";
        this->exampleTask.join();
        ARMARX_INFO << "Stopped!";
    }
 
    void
    SkillDashboardWidget::onExitComponent()
    {
    }
 
    QPointer<QDialog>
    SkillDashboardWidget::getConfigDialog(QWidget* parent)
    {
        ARMARX_TRACE;
 
        if (not m_config_dialog)
        {
            m_config_dialog = new armarx::SimpleConfigDialog{parent};
            m_config_dialog->addProxyFinder<SkillDashboardInterfacePrx>(
                {"SkillDashboard", "Skill Dashboard", "*SkillDashboard"});
            m_config_dialog->addProxyFinder<skills::manager::dti::SkillManagerInterfacePrx>(
                "SkillMemory", "", "*SkillMemory");
        }
        return qobject_cast<QDialog*>(m_config_dialog);
    }
 
    void
    SkillDashboardWidget::loadSettings(QSettings* settings)
    {
        ARMARX_TRACE;
        this->skillDashboardProxyName =
            settings
                ->value("skillDashboardProxyName", QString::fromStdString(skillDashboardProxyName))
                .toString()
                .toStdString();
        this->skillManagerOberserverName =
            settings->value("SkillMemory", "SkillMemory").toString().toStdString();
    }
 
    void
    SkillDashboardWidget::saveSettings(QSettings* settings)
    {
        ARMARX_TRACE;
        settings->setValue("skillDashboardProxyName",
                           QString::fromStdString(skillDashboardProxyName));
        settings->setValue("SkillMemory", QString::fromStdString(this->skillManagerOberserverName));
    }
 
    void
    SkillDashboardWidget::configured()
    {
        ARMARX_TRACE;
        if (m_config_dialog)
        {
            this->skillDashboardProxyName = m_config_dialog->getProxyName("SkillDashboard");
            this->skillManagerOberserverName = m_config_dialog->getProxyName("SkillMemory");
        }
    }
 
 
} // namespace armarx