MemoryViewer.cpp

Go to the documentation of this file.

#include "MemoryViewer.h"
 
#include <QApplication>
#include <QClipboard>
#include <QLabel>
#include <QMenu>
#include <QSettings>
#include <QTimer>
 
#include <Ice/Exception.h>
 
#include <ArmarXCore/core/ManagedIceObject.h>
#include <ArmarXCore/core/ice_conversions/ice_conversions_templates.h>
#include <ArmarXCore/core/time/TimeUtil.h>
#include <ArmarXCore/observers/variant/Variant.h>
 
#include <ArmarXGui/libraries/SimpleConfigDialog/SimpleConfigDialog.h>
 
#include <RobotAPI/interface/armem/actions.h>
#include <RobotAPI/interface/armem/memory.h>
#include <RobotAPI/interface/armem/mns/MemoryNameSystemInterface.h>
#include <RobotAPI/libraries/armem/core/wm/ice_conversions.h>
#include <RobotAPI/libraries/armem/server/query_proc/ltm/disk/ltm.h>
#include <RobotAPI/libraries/armem/server/query_proc/wm/wm.h>
#include <RobotAPI/libraries/armem_gui/util/ActionsMenuBuilder.h>
 
namespace armarx::armem::gui
{
    MemoryViewer::MemoryViewer(MemoryViewerUIContext& uiContext)
    {
        Logging::setTag("MemoryViewer");
 
 
        _statusLabel = uiContext.statusLabel;
        _statusLabel->clear();
        _statusLabel->setContextMenuPolicy(Qt::CustomContextMenu);
        connect(_statusLabel,
                &QLabel::customContextMenuRequested,
                [this](const QPoint& pos)
                {
                    QMenu menu(_statusLabel);
                    menu.addAction("Copy to clipboard",
                                   [this]()
                                   { QApplication::clipboard()->setText(_statusLabel->text()); });
                    menu.addAction("Clear status", [this]() { _statusLabel->clear(); });
                    menu.exec(_statusLabel->mapToGlobal(pos));
                });
 
        _model = std::make_shared<armem::gui::model::MemoryViewerModel>();
 
        _diskIOController = std::make_unique<armem::gui::controller::DiskIOController>(
            uiContext, 
            _model);
 
        _periodicUpdateController = std::make_unique<armem::gui::controller::PeriodicUpdateController>(
            uiContext,
            _model);
 
        connect(_periodicUpdateController
                    ->memoryGroupBoxController()
                    ->memoryGroupBoxView()
                    ->tree(),
                &armem::gui::MemoryTreeWidget::actionsMenuRequested,
                this,
                &This::showActionsMenu);
        connect(_periodicUpdateController
                    ->memoryGroupBoxController()
                    ->instanceGroupBoxController()
                    ->instanceGroupBoxView()
                    ->instanceView(),
                &armem::gui::InstanceView::actionsMenuRequested,
                this,
                &This::showActionsMenu);
 
        _livePlotController =
            std::make_unique<armem::gui::controller::LivePlotController>(_model);
        _periodicUpdateController
            ->memoryGroupBoxController()
            ->instanceGroupBoxController()
            ->instanceGroupBoxView()
            ->instanceView()
            ->setLivePlotController(_livePlotController.get());
    }
 
    void
    MemoryViewer::setLogTag(const std::string& _tag) // Leading _ silences a warning
    {
        Logging::setTag(_tag);
    }
 
    void
    MemoryViewer::onInit(ManagedIceObject& component)
    {
        if (_mnsName.size() > 0)
        {
            component.usingProxy(_mnsName);
        }
        if (_debugObserverName.size() > 0)
        {
            component.usingProxy(_debugObserverName);
        }
 
        _model->setInitialized(true);
        emit initialized();
    }
 
    void
    MemoryViewer::onConnect(ManagedIceObject& component)
    {
        if (not _mnsName.empty())
        {
            armem::mns::MemoryNameSystemInterfacePrx mnsProxy;
            component.getProxy(mnsProxy, _mnsName);
            _model->setMns(std::make_unique<client::MemoryNameSystem>(mnsProxy));
 
            const bool update = true;
            
            _model->setMemoryReaders(_model->mns().getAllReaders(update));
            _model->setMemoryWriters(_model->mns().getAllWriters(update));
        }
        // DebugObserver is optional (check for null on every call)
        if (not _debugObserverName.empty())
        {
            DebugObserverInterfacePrx observer;
            component.getProxy(observer, _debugObserverName, false, "", false);
            _model->setDebugObserver(observer);
        }
 
        emit _periodicUpdateController->startPeriodicTimerSignal();
        _periodicUpdateController->startAutoUpdateTimerIfEnabled();
 
        _livePlotController->onConnect();
 
        _model->setConnected(true);
        emit connected();
    }
 
    void
    MemoryViewer::onDisconnect(ManagedIceObject&)
    {
        emit _periodicUpdateController->stopAutoUpdateTimerSignal();
        emit _periodicUpdateController->stopPeriodicTimerSignal();
 
        _livePlotController->onDisconnect();
 
        _model->setConnected(false);
 
        emit disconnected();
    }
 
    void
    MemoryViewer::showActionsMenu(const MemoryID& memoryID,
                                  QWidget* parent,
                                  const QPoint& pos,
                                  QMenu* menu)
    {
        // Called if we have to stop because of an error.
        auto showMenu = [menu, pos]()
        {
            if (menu)
                menu->exec(pos);
        };
 
        if (memoryID == MemoryID())
        {
            // Empty MemoryID, don't try to generate actions.
            showMenu();
            return;
        }
 
        mns::dto::MemoryServerInterfaces prx;
        try
        {
            prx = _model->mns().resolveServer(memoryID);
        }
        catch (const error::CouldNotResolveMemoryServer& e)
        {
            _statusLabel->setText(
                QString::fromStdString(e.makeMsg(memoryID, "Could not resolve memory server.")));
            showMenu();
            return;
        }
 
        if (!prx.actions)
        {
            std::stringstream ss;
            ss << "Memory server " << memoryID << " does not support actions or is offline.";
            _statusLabel->setText(QString::fromStdString(ss.str()));
            showMenu();
            return;
        }
 
        actions::GetActionsOutputSeq result;
        try
        {
            result = prx.actions->getActions({{armarx::toIce<data::MemoryID>(memoryID)}});
        }
        catch (const Ice::LocalException& e)
        {
            std::stringstream ss;
            ss << "Could not get actions for " << memoryID << ".";
            _statusLabel->setText(QString::fromStdString(ss.str()));
            showMenu();
            return;
        }
 
        if (result.size() == 0)
        {
            showMenu();
            return;
        }
        auto builder = ActionsMenuBuilder(
            memoryID,
            parent,
            [this, prx](const MemoryID& memoryID, const actions::ActionPath& path)
            {
                actions::data::ExecuteActionOutputSeq result;
                try
                {
                    result = prx.actions->executeActions(
                        {{armarx::toIce<armem::data::MemoryID>(memoryID), path}});
                }
                catch (const Ice::LocalException& e)
                {
                    std::stringstream ss;
                    ss << "Failed to execute action: " << e.what();
                    _statusLabel->setText(QString::fromStdString(ss.str()));
                }
 
                for (const auto& [success, errorMessage] : result)
                {
                    if (not success)
                    {
                        std::stringstream ss;
                        ss << "Failed to execute action: " << errorMessage;
                        _statusLabel->setText(QString::fromStdString(ss.str()));
                        ARMARX_WARNING << ss.str();
                    }
                }
            });
 
        QMenu* actionsMenu = builder.buildActionsMenu(result[0]);
        if (menu == nullptr)
        {
            actionsMenu->exec(pos);
        }
        else
        {
            menu->addMenu(actionsMenu);
            menu->exec(pos);
        }
    }
 
    const static std::string CONFIG_KEY_MEMORY = "MemoryViewer.MemoryNameSystem";
    const static std::string CONFIG_KEY_DEBUG_OBSERVER = "MemoryViewer.DebugObserverName";
 
    void
    MemoryViewer::loadSettings(QSettings* settings)
    {
        _mnsName = settings->value(QString::fromStdString(CONFIG_KEY_MEMORY), "MemoryNameSystem")
            .toString()
            .toStdString();
        _debugObserverName =
            settings->value(QString::fromStdString(CONFIG_KEY_DEBUG_OBSERVER), "DebugObserver")
                .toString()
                .toStdString();
    }
 
    void
    MemoryViewer::saveSettings(QSettings* settings)
    {
        settings->setValue(QString::fromStdString(CONFIG_KEY_MEMORY),
                           QString::fromStdString(_mnsName));
        settings->setValue(QString::fromStdString(CONFIG_KEY_DEBUG_OBSERVER),
                           QString::fromStdString(_debugObserverName));
    }
 
    void
    MemoryViewer::writeConfigDialog(SimpleConfigDialog* dialog)
    {
        dialog->addProxyFinder<armarx::armem::mns::MemoryNameSystemInterfacePrx>(
            {CONFIG_KEY_MEMORY, "MemoryNameSystem", "MemoryNameSystem"});
        dialog->addProxyFinder<armarx::DebugObserverInterfacePrx>(
            {CONFIG_KEY_DEBUG_OBSERVER, "Debug Observer", "DebugObserver"});
    }
 
    void
    MemoryViewer::readConfigDialog(SimpleConfigDialog* dialog)
    {
        _mnsName = dialog->getProxyName(CONFIG_KEY_MEMORY);
        if (_mnsName.empty())
        {
            _mnsName = "MemoryNameSystem";
        }
 
        _debugObserverName = dialog->getProxyName(CONFIG_KEY_DEBUG_OBSERVER);
    }
 
} // namespace armarx::armem::gui