PresenterViewWidgetController.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::PresenterViewWidgetController
 * \author     Leonie Leven
 * \date       2024
 * \copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "PresenterViewWidgetController.h"
 
#include <string>
 
#include <QDebug>
#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>
 
static const std::string config_key_imrecman = "imrecman_name";
static const std::string config_key_start_in = "start_in";
 
namespace armarx
{
    PresenterViewWidgetController::PresenterViewWidgetController() :
        DEFAULT_SETTINGS_PLUGIN_NAME("PresenterViewWidgetGuiPlugin"),
        DEFAULT_SETTINGS_CUSTOM_TEXT("custom text")
    {
        // init gui
        // getWidget() returns a container into which this widget is embedded
        widget.setupUi(getWidget());
        widget.timeSinceUpdate->setText("00 ms");
        this->updateTimer = new QTimer(this);
        stopwatch.start();
        this->updateTimer->start(50);
 
 
        this->statusIndicationLabel = new StatusIndicationLabel(getWidget());
        this->statusIndicationLabel->setTextWithScaling("testestset");
 
 
        QLayout* existingLayout = getWidget()->layout();
 
        existingLayout->addWidget(this->statusIndicationLabel);
 
        ARMARX_INFO << " setup of ui finished" << flush;
    }
 
    void
    PresenterViewWidgetController::loadSettings(QSettings* settings)
    {
        ARMARX_TRACE;
 
        demoStateManagerName =
            settings
                ->value(QString::fromStdString(::config_key_imrecman), "DemoStateManagerInterface")
                .toString()
                .toStdString();
    }
 
    void
    PresenterViewWidgetController::saveSettings(QSettings* settings)
    {
        ARMARX_TRACE;
 
        settings->setValue(QString::fromStdString(::config_key_imrecman),
                           QString::fromStdString(demoStateManagerName));
    }
 
    void
    PresenterViewWidgetController::onInitComponent()
    {
 
        // if you want to use proxies you can specify them here
        //usingProxy(myProxyName);
        ARMARX_TRACE;
 
        if (not demoStateManagerName.empty())
        {
            usingProxy(demoStateManagerName);
        }
    }
 
    void
    PresenterViewWidgetController::onConnectComponent()
    {
        ARMARX_TRACE;
        getProxy(demoStateManagerPrx, demoStateManagerName);
 
        stopCheckStateTask.store(false);
        checkStateTask = std::thread([&] { checkState(); });
 
        connect(this,
                &PresenterViewWidgetController::stateAndSeverityUpdated,
                this,
                &PresenterViewWidgetController::updateStateAndSeverity);
 
        connect(
            updateTimer, &QTimer::timeout, this, &PresenterViewWidgetController::updateStopwatch);
    }
 
    void
    PresenterViewWidgetController::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
    PresenterViewWidgetController::updateStateAndSeverity(QString state, int severity)
    {
        //int textSize = widget.textSize->value();
        std::string color = mapColor(static_cast<armarx::severity::SeverityEnum>(severity));
        //        QString styleSheet =
        //            QString("color: %1; font-size: %2px;").arg(QString::fromStdString(color)).arg(textSize);
        //        widget.label->setStyleSheet(styleSheet);
        //        widget.label->setText(QString::fromStdString(state.toStdString()));
 
        QString styleSheet2 = QString("color: %1;").arg(QString::fromStdString(color));
        this->statusIndicationLabel->setTextWithScaling(state);
        this->statusIndicationLabel->setStyleSheet(styleSheet2);
 
 
        this->stopwatch.restart();
    }
 
    void
    PresenterViewWidgetController::updateStopwatch()
    {
        qint64 elapsedMs = stopwatch.elapsed();
        double elapsedMilliSeconds = elapsedMs;
        widget.timeSinceUpdate->setText(QString::number(elapsedMilliSeconds, 'f', 1) + " ms");
    }
 
    std::string
    PresenterViewWidgetController::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
    PresenterViewWidgetController::onDisconnectComponent()
    {
        stopCheckStateTask.store(true);
        checkStateTask.join();
    }
 
    void
    PresenterViewWidgetController::onExitComponent()
    {
        // implement cleanup
        ARMARX_INFO << "Cleanup";
    }
 
    QPointer<QDialog>
    PresenterViewWidgetController::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
    PresenterViewWidgetController::configured()
    {
        ARMARX_TRACE;
 
        if (m_config_dialog)
        {
            demoStateManagerName = m_config_dialog->getProxyName(::config_key_imrecman);
        }
    }
 
 
} // namespace armarx