OperatorViewWidgetController.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * \package    ArmarXGui::gui-plugins::OperatorViewWidgetController
 * \author     Leonie Leven
 * \date       2024
 * \copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "OperatorViewWidgetController.h"
 
#include <string>
 
#include <QDebug>
#include <QHBoxLayout>
#include <QMenu>
#include <QPalette>
#include <QStringList>
#include <QTimer>
 
#include <ArmarXCore/core/application/Application.h>
#include <ArmarXCore/core/time/LocalTimeServer.h>
#include <ArmarXCore/core/time/Metronome.h>
#include <ArmarXCore/core/time/TimeUtil.h>
 
namespace armarx
{
    OperatorViewWidgetController::OperatorViewWidgetController() :
        DEFAULT_SETTINGS_PLUGIN_NAME("OperatorViewWidgetGuiPlugin"),
        DEFAULT_SETTINGS_CUSTOM_TEXT("custom text")
    {
        widget.setupUi(getWidget());
        this->updateTimer = new QTimer(this);
        this->updateTimer->start(50);
 
        ARMARX_INFO << " setup of ui finished" << flush;
    }
 
    void
    OperatorViewWidgetController::loadSettings(QSettings* settings)
    {
        ARMARX_TRACE;
        demoStateProxyName =
            settings->value("demoStateProxyName", QString::fromStdString(demoStateProxyName))
                .toString()
                .toStdString();
    }
 
    void
    OperatorViewWidgetController::saveSettings(QSettings* settings)
    {
        ARMARX_TRACE;
        settings->setValue("demoStateProxyName", QString::fromStdString(demoStateProxyName));
    }
 
    void
    OperatorViewWidgetController::onInitComponent()
    {
        ARMARX_TRACE;
        usingProxy(demoStateProxyName);
    }
 
    void
    OperatorViewWidgetController::onConnectComponent()
    {
 
        ARMARX_TRACE;
        getProxy(demoStateManagerPrx, demoStateProxyName);
 
        connect(widget.sendOnly, SIGNAL(clicked()), this, SLOT(sendOnlyButtonPressed()));
        connect(widget.insert, SIGNAL(clicked()), this, SLOT(insertButtonPressed()));
        connect(
            widget.exportButtons, SIGNAL(clicked()), this, SLOT(exportButtonsToPropertyFormat()));
 
        connect(this,
                &OperatorViewWidgetController::defaultValuesLoaded,
                this,
                &OperatorViewWidgetController::createButtonLayout);
        stopCheckStateTask.store(false);
        checkStateTask = std::thread([&] { checkState(); });
 
        connect(this,
                &OperatorViewWidgetController::stateAndSeverityUpdated,
                this,
                &OperatorViewWidgetController::updateStateAndSeverity);
 
 
        try
        {
            emit defaultValuesLoaded();
            QObject::disconnect(this,
                                &OperatorViewWidgetController::defaultValuesLoaded,
                                this,
                                &OperatorViewWidgetController::createButtonLayout);
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not fetch states." << deactivateSpam(10);
        }
    }
 
    void
    OperatorViewWidgetController::checkState()
    {
        armarx::core::time::Metronome metronome{armarx::core::time::Frequency::Hertz(10)};
 
        while (not stopCheckStateTask.load())
        {
            try
            {
                // Might throw due to Ice.
                auto stateAndSeverity = this->demoStateManagerPrx->getStateAndSeverity();
                // /critical section
 
                emit stateAndSeverityUpdated(QString::fromStdString(stateAndSeverity.state),
                                             static_cast<int>(stateAndSeverity.severity));
            }
            catch (Ice::Exception const&)
            {
                ARMARX_WARNING << "Could not fetch current state and severity."
                               << deactivateSpam(10);
            }
 
            metronome.waitForNextTick();
        }
    }
 
    void
    OperatorViewWidgetController::updateStateAndSeverity(QString state, int severity)
    {
        std::string color = mapColor(static_cast<armarx::severity::SeverityEnum>(severity));
        std::string coloredSeverity =
            "<span style='color:" + color + ";'>" + state.toStdString() + "</span>";
        std::string finalText = "Current State: " + coloredSeverity;
 
        widget.currentState->setText(QString::fromStdString(finalText));
    }
 
    void
    OperatorViewWidgetController::createButtonLayout()
    {
 
        widget.groupSend->setLayout(new QVBoxLayout(getWidget()));
 
        this->layoutNormal = new FlowLayout();
        this->layoutWarning = new FlowLayout();
        this->layoutError = new FlowLayout();
        this->layoutFatal = new FlowLayout();
 
        createButtons();
 
        if (QVBoxLayout* hLayout = qobject_cast<QVBoxLayout*>(widget.groupSend->layout()))
        {
            hLayout->addLayout(this->layoutNormal);
            hLayout->addLayout(this->layoutWarning);
            hLayout->addLayout(this->layoutError);
            hLayout->addLayout(this->layoutFatal);
        }
    }
 
    void
    OperatorViewWidgetController::insertButtonPressed(QString text, int severity)
    {
        std::string newStateSend = text.toStdString() == ""
                                       ? this->widget.newState->text().toStdString()
                                       : text.toStdString();
        int newSeveritySend = severity == -1 ? this->widget.severity->currentIndex() : severity;
 
        try
        {
            this->demoStateManagerPrx->insertState(
                newStateSend, static_cast<armarx::severity::SeverityEnum>(newSeveritySend));
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not send current state and severity." << deactivateSpam(10);
        }
 
        QString newState = text.toStdString() == "" ? this->widget.newState->text() : text;
        int newSeverity = severity == -1 ? this->widget.severity->currentIndex() : severity;
 
        armarx::severity::SeverityEnum buttonSeverity =
            static_cast<armarx::severity::SeverityEnum>(newSeverity);
 
        QPushButton* button = new QPushButton(newState, getWidget());
        button->setToolTip("Leftclick to send to presenter view; Rightclick to delete.");
 
 
        QString color = QString::fromStdString(mapColor(buttonSeverity));
        if (!color.isEmpty())
        {
            QPalette palette = button->palette();
            palette.setColor(QPalette::Button, QColor(color));
            button->setPalette(palette);
            button->setStyleSheet("background-color: " + color + ";");
        }
        switch (buttonSeverity)
        {
            case armarx::severity::SeverityEnum::normal:
                this->layoutNormal->addWidget(button);
                break;
            case armarx::severity::SeverityEnum::warning:
                this->layoutWarning->addWidget(button);
                break;
            case armarx::severity::SeverityEnum::error:
                this->layoutError->addWidget(button);
                break;
            case armarx::severity::SeverityEnum::fatal:
                this->layoutFatal->addWidget(button);
                break;
        }
 
        connect(button,
                &QPushButton::clicked,
                this,
                [this, newState, buttonSeverity]()
                { this->defaultButtonPressed(newState.toStdString(), buttonSeverity); });
        button->setContextMenuPolicy(Qt::CustomContextMenu);
 
        connect(button,
                &QPushButton::customContextMenuRequested,
                this,
                [this, button, newStateSend, newSeveritySend](const QPoint& pos)
                {
                    QMenu menu;
                    QAction* deleteAction = menu.addAction("Delete");
 
                    QAction* selectedAction = menu.exec(button->mapToGlobal(pos));
                    if (selectedAction == deleteAction)
                    {
                        this->deleteButton(
                            newStateSend,
                            static_cast<armarx::severity::SeverityEnum>(newSeveritySend));
                    }
                });
    }
 
    void
    OperatorViewWidgetController::sendOnlyButtonPressed(QString text, int severity)
    {
        std::string newState = text.toStdString() == ""
                                   ? this->widget.newState->text().toStdString()
                                   : text.toStdString();
        int newSeverity = severity == -1 ? this->widget.severity->currentIndex() : severity;
 
        try
        {
            this->demoStateManagerPrx->setState(
                newState, static_cast<armarx::severity::SeverityEnum>(newSeverity));
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not send current state and severity." << deactivateSpam(10);
        }
    }
 
    void
    OperatorViewWidgetController::createButtons()
    {
        std::vector<StateAndSeverity> allStates;
        try
        {
            allStates = demoStateManagerPrx->getCurrentStates();
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not fetch states." << deactivateSpam(10);
        }
 
        for (const StateAndSeverity& state : allStates)
        {
            QPushButton* button = new QPushButton(QString::fromStdString(state.state), getWidget());
 
            QString color = QString::fromStdString(mapColor(state.severity));
            if (!color.isEmpty())
            {
                QPalette palette = button->palette();
                palette.setColor(QPalette::Button, QColor(color));
                button->setPalette(palette);
                button->setStyleSheet("background-color: " + color + ";");
            }
            switch (state.severity)
            {
                case armarx::severity::SeverityEnum::normal:
                    this->layoutNormal->addWidget(button);
                    break;
                case armarx::severity::SeverityEnum::warning:
                    this->layoutWarning->addWidget(button);
                    break;
                case armarx::severity::SeverityEnum::error:
                    this->layoutError->addWidget(button);
                    break;
                case armarx::severity::SeverityEnum::fatal:
                    this->layoutFatal->addWidget(button);
                    break;
            }
 
            button->setToolTip("Leftclick to send to presenter view; Rightclick to delete.");
 
            connect(button,
                    &QPushButton::clicked,
                    this,
                    [this, state]() { this->defaultButtonPressed(state.state, state.severity); });
            button->setContextMenuPolicy(Qt::CustomContextMenu);
 
            connect(button,
                    &QPushButton::customContextMenuRequested,
                    this,
                    [this, button, state](const QPoint& pos)
                    {
                        QMenu menu;
                        QAction* deleteAction = menu.addAction("Delete");
 
                        QAction* selectedAction = menu.exec(button->mapToGlobal(pos));
                        if (selectedAction == deleteAction)
                        {
                            this->deleteButton(state.state, state.severity);
                        }
                    });
        }
    }
 
    void
    OperatorViewWidgetController::deleteButton(std::string state,
                                               armarx::severity::SeverityEnum severity)
    {
        ARMARX_IMPORTANT << "Delete Button";
        try
        {
            this->demoStateManagerPrx->deleteState(state, severity);
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not delete Button." << deactivateSpam(10);
            return;
        }
 
        this->cleanUI();
        this->onConnectComponent();
    }
 
    void
    OperatorViewWidgetController::defaultButtonPressed(std::string state,
                                                       armarx::severity::SeverityEnum severity)
    {
        try
        {
            this->demoStateManagerPrx->setState(state, severity);
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not send current state and severity." << deactivateSpam(10);
        }
    }
 
    void
    OperatorViewWidgetController::exportButtonsToPropertyFormat()
    {
        std::string exportProperty = "";
        QList<QPushButton*> normalButtons = getButtonsFromLayout(this->layoutNormal);
        QList<QPushButton*> warningButtons = getButtonsFromLayout(this->layoutWarning);
        QList<QPushButton*> errorButtons = getButtonsFromLayout(this->layoutError);
        QList<QPushButton*> fatalButtons = getButtonsFromLayout(this->layoutFatal);
        std::vector<QList<QPushButton*>> buttons;
        buttons.push_back(normalButtons);
        buttons.push_back(warningButtons);
        buttons.push_back(errorButtons);
        buttons.push_back(fatalButtons);
 
        for (unsigned long i = 0; i < buttons.size(); i++)
        {
            auto buttonList = buttons[i];
 
            for (auto it = buttonList.begin(); it != buttonList.end(); ++it)
            {
                std::string buttonText = (*it)->text().toStdString();
                exportProperty.append(buttonText + ":" + std::to_string(i) + ";");
            }
        }
        QClipboard* clipboard = QGuiApplication::clipboard();
        clipboard->setText(QString::fromStdString(exportProperty));
        ARMARX_INFO << "Button configuration: " << exportProperty;
    }
 
    QList<QPushButton*>
    OperatorViewWidgetController::getButtonsFromLayout(QLayout* layout)
    {
        QList<QPushButton*> buttons;
 
        if (!layout)
            return buttons;
 
        for (int i = 0; i < layout->count(); ++i)
        {
            if (auto* button = qobject_cast<QPushButton*>(layout->itemAt(i)->widget()))
            {
                buttons.append(button);
            }
        }
 
        return buttons;
    }
 
    std::string
    OperatorViewWidgetController::mapColor(severity::SeverityEnum severity)
    {
        std::string color;
        switch (severity)
        {
            case severity::SeverityEnum::normal:
                color = "green";
                break;
            case severity::SeverityEnum::warning:
                color = "orange";
                break;
            case severity::SeverityEnum::error:
                color = "red";
                break;
            case severity::SeverityEnum::fatal:
                color = "magenta";
                break;
            default:
                color = "black";
        }
        return color;
    }
 
    void
    OperatorViewWidgetController::cleanUI()
    {
 
        QObject::disconnect(
            widget.sendOnly, SIGNAL(clicked()), this, SLOT(sendOnlyButtonPressed()));
        QObject::disconnect(widget.insert, SIGNAL(clicked()), this, SLOT(insertButtonPressed()));
        QObject::disconnect(
            widget.exportButtons, SIGNAL(clicked()), this, SLOT(exportButtonsToPropertyFormat()));
 
        clearLayout(this->layoutNormal);
        clearLayout(this->layoutWarning);
        clearLayout(this->layoutError);
        clearLayout(this->layoutFatal);
 
        delete this->layoutNormal;
        delete this->layoutWarning;
        delete this->layoutError;
        delete this->layoutFatal;
 
        this->layoutNormal = nullptr;
        this->layoutWarning = nullptr;
        this->layoutError = nullptr;
        this->layoutFatal = nullptr;
 
        stopCheckStateTask.store(true);
        checkStateTask.join();
 
 
        ARMARX_INFO << "UI cleaned successfully";
    }
 
    void
    OperatorViewWidgetController::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;
        }
    }
 
    void
    OperatorViewWidgetController::onDisconnectComponent()
    {
 
        cleanUI();
        ARMARX_INFO << "Disconnect";
    }
 
    void
    OperatorViewWidgetController::onExitComponent()
    {
        ARMARX_INFO << "Exit";
    }
 
    QPointer<QDialog>
    OperatorViewWidgetController::getConfigDialog(QWidget* parent)
    {
        ARMARX_TRACE;
 
        if (not m_config_dialog)
        {
            m_config_dialog = new armarx::SimpleConfigDialog{parent};
            m_config_dialog->addProxyFinder<DemoStateManagerInterfacePrx>(
                {"DemoStateManager", "Demo State Manager", "*"});
        }
        return qobject_cast<QDialog*>(m_config_dialog);
    }
 
    void
    OperatorViewWidgetController::configured()
    {
        ARMARX_TRACE;
 
        if (m_config_dialog)
        {
            demoStateProxyName = m_config_dialog->getProxyName("DemoStateManager");
        }
    }
 
 
} // namespace armarx