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 <QPalette>
#include <QStringList>
#include <QTimer>
 
#include <ArmarXCore/core/application/Application.h>
#include <ArmarXCore/core/time/LocalTimeServer.h>
#include <ArmarXCore/core/time/TimeUtil.h>
 
static const std::string config_key_imrecman = "imrecman_name";
static const std::string config_key_start_in = "start_in";
 
namespace armarx
{
    OperatorViewWidgetController::OperatorViewWidgetController() :
        DEFAULT_SETTINGS_PLUGIN_NAME("OperatorViewWidgetGuiPlugin"),
        DEFAULT_SETTINGS_CUSTOM_TEXT("custom text")
    {
        // init gui
        // getWidget() returns a container into which this widget is embedded
        widget.setupUi(getWidget());
        widget.clear->setStyleSheet("background-color: green;");
        ARMARX_INFO << " setup of ui finished" << flush;
    }
 
    void
    OperatorViewWidgetController::loadSettings(QSettings* settings)
    {
        ARMARX_TRACE;
 
        demoStateManagerName =
            settings
                ->value(QString::fromStdString(::config_key_imrecman), "DemoStateManagerInterface")
                .toString()
                .toStdString();
    }
 
    void
    OperatorViewWidgetController::saveSettings(QSettings* settings)
    {
        ARMARX_TRACE;
 
        settings->setValue(QString::fromStdString(::config_key_imrecman),
                           QString::fromStdString(demoStateManagerName));
    }
 
    void
    OperatorViewWidgetController::onInitComponent()
    {
        ARMARX_TRACE;
 
        if (not demoStateManagerName.empty())
        {
            usingProxy(demoStateManagerName);
        }
    }
 
    void
    OperatorViewWidgetController::onConnectComponent()
    {
 
        ARMARX_TRACE;
        getProxy(demoStateManagerPrx, demoStateManagerName);
        Q_ASSERT(widget.clear != nullptr);
 
        connect(widget.clear, SIGNAL(clicked()), this, SLOT(clearButtonPressed()));
        connect(widget.sendOnly, SIGNAL(clicked()), this, SLOT(sendOnlyButtonPressed()));
        connect(widget.insert, SIGNAL(clicked()), this, SLOT(insertButtonPressed()));
        connect(widget.insertSend, SIGNAL(clicked()), this, SLOT(insertAndSendButtonPressed()));
        connect(
            widget.exportButtons, SIGNAL(clicked()), this, SLOT(exportButtonsToPropertyFormat()));
 
        connect(this,
                &OperatorViewWidgetController::defaultValuesLoaded,
                this,
                &OperatorViewWidgetController::createButtonLayout);
 
 
        try
        {
            this->defaultStateValues = demoStateManagerPrx->getDefaultStates();
            emit defaultValuesLoaded();
            QObject::disconnect(this,
                                &OperatorViewWidgetController::defaultValuesLoaded,
                                this,
                                &OperatorViewWidgetController::createButtonLayout);
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not fetch default states." << deactivateSpam(10);
        }
    }
 
    void
    OperatorViewWidgetController::createButtonLayout()
    {
 
        QWidget* container = getWidget();
        QLayout* existingLayout = container->layout();
 
        this->layoutNormal = new QHBoxLayout();
        this->layoutWarning = new QHBoxLayout();
        this->layoutError = new QHBoxLayout();
        this->layoutFatal = new QHBoxLayout();
 
        if (!existingLayout)
        {
            existingLayout = new QVBoxLayout(container);
            container->setLayout(existingLayout);
            ARMARX_IMPORTANT << "no existing layout";
        }
 
        createButtons(QString::fromStdString(this->defaultStateValues));
 
        if (QVBoxLayout* hLayout = qobject_cast<QVBoxLayout*>(existingLayout))
        {
            hLayout->addLayout(this->layoutNormal);
            hLayout->addLayout(this->layoutWarning);
            hLayout->addLayout(this->layoutError);
            hLayout->addLayout(this->layoutFatal);
        }
    }
 
    void
    OperatorViewWidgetController::clearButtonPressed()
    {
 
        try
        {
            this->demoStateManagerPrx->clear();
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not set state clear." << deactivateSpam(10);
        }
    }
 
    void
    OperatorViewWidgetController::insertAndSendButtonPressed()
    {
        QString newState = this->widget.newState->toPlainText();
        int newSeverity = this->widget.severty->currentIndex();
        this->sendOnlyButtonPressed(newState, newSeverity);
        this->insertButtonPressed(newState, newSeverity);
    }
 
    void
    OperatorViewWidgetController::insertButtonPressed(QString text, int severity)
    {
        QString newState = text.toStdString() == "" ? this->widget.newState->toPlainText() : text;
        int newSeverity = severity == -1 ? this->widget.severty->currentIndex() : severity;
 
        if (this->buttonText.find(newState.toStdString()) != this->buttonText.end())
        {
            ARMARX_IMPORTANT << "This button with text " << newState.toStdString()
                             << " already exists!";
            return;
        }
 
        this->buttonText.insert(newState.toStdString());
 
        armarx::severity::SeverityEnum buttonSeverity =
            static_cast<armarx::severity::SeverityEnum>(newSeverity);
 
        QPushButton* button = new QPushButton(newState, getWidget());
 
        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); });
    }
 
    void
    OperatorViewWidgetController::sendOnlyButtonPressed(QString text, int severity)
    {
        std::string newState = text.toStdString() == ""
                                   ? this->widget.newState->toPlainText().toStdString()
                                   : text.toStdString();
        int newSeverity = severity == -1 ? this->widget.severty->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(const QString& input)
    {
        QStringList pairs = input.split(";");
 
        for (const QString& pair : pairs)
        {
            QStringList keyValue = pair.split(":");
            if (keyValue.size() == 2)
            {
                QString text = keyValue[0].trimmed();
                int value = keyValue[1].toInt();
                armarx::severity::SeverityEnum buttonSeverity =
                    static_cast<armarx::severity::SeverityEnum>(value);
 
                QPushButton* button = new QPushButton(text, getWidget());
 
                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 + ";");
                }
                this->buttonText.insert(text.toStdString());
                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, text, buttonSeverity]()
                        { this->defaultButtonPressed(text.toStdString(), buttonSeverity); });
            }
        }
    }
 
    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.clear, SIGNAL(clicked()), this, SLOT(clearButtonPressed()));
        QObject::disconnect(
            widget.sendOnly, SIGNAL(clicked()), this, SLOT(sendOnlyButtonPressed()));
        QObject::disconnect(widget.insert, SIGNAL(clicked()), this, SLOT(insertButtonPressed()));
        QObject::disconnect(
            widget.insertSend, SIGNAL(clicked()), this, SLOT(insertAndSendButtonPressed()));
        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;
 
        this->buttonText.clear();
 
        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>(
                {::config_key_imrecman, "Demo State Manager", "*"});
        }
        return qobject_cast<QDialog*>(m_config_dialog);
    }
 
    void
    OperatorViewWidgetController::configured()
    {
        ARMARX_TRACE;
 
        if (m_config_dialog)
        {
            demoStateManagerName = m_config_dialog->getProxyName(::config_key_imrecman);
        }
    }
 
 
} // namespace armarx