LTMWidget.cpp

Go to the documentation of this file.

#include "LTMWidget.h"
 
#include <QCheckBox>
#include <QHBoxLayout>
#include <QLineEdit>
#include <QPushButton>
#include <QTabWidget>
#include <QTextEdit>
#include <QVBoxLayout>
#include <QWidget>
#include <QScrollArea>
#include <QGroupBox>
 
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
 
namespace armarx::armem::gui
{
 
    LTMWidget::LTMWidget()
    {
        auto* vlayout = new QVBoxLayout();
        auto* hlayout = new QHBoxLayout();
 
        {
            _availableMemoriesGroupBox = new QGroupBox("Available memories");
            auto vboxlayout = new QVBoxLayout();
            vboxlayout->setMargin(1);
            vboxlayout->setSizeConstraint(QLayout::SizeConstraint::SetMinAndMaxSize);
            vboxlayout->setAlignment(Qt::AlignTop);
            _de_selectMemoryServers = new QPushButton(_selectText);
            _de_selectMemoryServers->setEnabled(false);
            vboxlayout->addWidget(_de_selectMemoryServers);
            _availableMemoriesGroupBox->setLayout(vboxlayout);
 
            // make _availableMemoriesGroupBox scrollable 
            _availableMemoriesScrollArea = new QScrollArea();
            _availableMemoriesScrollArea->setWidget(_availableMemoriesGroupBox);
            _availableMemoriesScrollArea->setWidgetResizable(true);
 
            hlayout->addWidget(_availableMemoriesScrollArea, 1);
        }
 
        QFrame* vFrame = new QFrame;
        vFrame->setFrameShape(QFrame::VLine);
        hlayout->addWidget(vFrame);
 
        {
            auto ltmButtonsGroupBox = new QGroupBox("LTM recording");
            auto ltmButtonsLayout = new QVBoxLayout();
            ltmButtonsLayout->setMargin(9);
            ltmButtonsLayout->setSizeConstraint(QLayout::SizeConstraint::SetMinAndMaxSize);
            ltmButtonsLayout->setAlignment(Qt::AlignTop);
            ltmButtonsGroupBox->setLayout(ltmButtonsLayout);
 
            _storeInLTMButton = new QPushButton("Query and store in LTM");
            ltmButtonsLayout->addWidget(_storeInLTMButton);
 
            auto* ltmRecHLayout = new QHBoxLayout();
            _startLTMRecordingButton = new QPushButton("Start LTM Recording");
            _stopLTMRecordingButton = new QPushButton("Stop LTM Recording");
            ltmRecHLayout->addWidget(_startLTMRecordingButton);
            ltmRecHLayout->addWidget(_stopLTMRecordingButton);
 
            ltmButtonsLayout->addLayout(ltmRecHLayout);
 
            hlayout->addWidget(ltmButtonsGroupBox, 1);
 
        }
        vlayout->addLayout(hlayout);
 
        // Private connects
        connect(_de_selectMemoryServers, &QPushButton::pressed, this, &This::deSelectMemoryServers);
 
        // Public connections.
        connect(_storeInLTMButton, &QPushButton::pressed, this, &This::storeInLTM);
        connect(_startLTMRecordingButton, &QPushButton::pressed, this, &This::startRecording);
        connect(_stopLTMRecordingButton, &QPushButton::pressed, this, &This::stopRecording);
 
        setLayout(vlayout);
    }
 
    void
    LTMWidget::update(const std::vector<std::string>& activeMemoryNames)
    {
        
        std::vector<std::string> alreadyPresentMemoryCheckboxes;
 
        // get information about memories already present and activate inactive ones if necessary
        int maxIndex = _availableMemoriesGroupBox->layout()
                       ->count(); //as the (de)select button is counted as well
 
        for (int i = 1; i < maxIndex; ++i)
        {
            auto w = _availableMemoriesGroupBox->layout()->itemAt(i)->widget();
            QCheckBox* box = static_cast<QCheckBox*>(w);
            std::string memoryName = box->text().toStdString();
            if (box->isEnabled() &&
                std::find(activeMemoryNames.begin(), activeMemoryNames.end(), memoryName) ==
                    activeMemoryNames.end())
            {
                // checkbox is enabled but memory is not available anymore
                box->setVisible(false);
                box->setChecked(false);
                box->setEnabled(false);
            }
            if (not(box->isEnabled()) &&
                std::find(activeMemoryNames.begin(), activeMemoryNames.end(), memoryName) !=
                    activeMemoryNames.end())
            {
                // checkbox is disabled but memory is available again
                box->setVisible(true);
                box->setChecked(false);
                box->setEnabled(true);
            }
            alreadyPresentMemoryCheckboxes.push_back(memoryName);
        }
 
 
        // Add checkboxes for new memories
        for (const auto& memoryName : activeMemoryNames)
        {
            if (std::find(alreadyPresentMemoryCheckboxes.begin(),
                        alreadyPresentMemoryCheckboxes.end(),
                        memoryName) == alreadyPresentMemoryCheckboxes.end())
            {
                // new memory available
                auto box = new QCheckBox(QString::fromStdString(memoryName));
                box->setChecked(
                    false); // we do not want all memories to be enabled on startup, to reduce communication overhead
                box->setVisible(true);
                box->setEnabled(true);
                _availableMemoriesGroupBox->layout()->addWidget(box);
 
                // necessary to select the correct select/deselect button
                connect(box, &QCheckBox::stateChanged, this, &This::updateSelectAllButtonState);
            }
        }
 
        // activate/deactivate button 
        _de_selectMemoryServers->setEnabled(!activeMemoryNames.empty());
        
    }
 
    std::vector<std::string>
    LTMWidget::getEnabledLTMMemories() const
    {
        int maxIndex = _availableMemoriesGroupBox->layout()->count();
        std::vector<std::string> memoryNames;
        memoryNames.reserve(maxIndex);
        for (int i = 1; i < maxIndex; ++i)
        {
            auto w = _availableMemoriesGroupBox->layout()->itemAt(i)->widget();
            QCheckBox* box = static_cast<QCheckBox*>(w);
            std::string memoryName = box->text().toStdString();
            if (box->isEnabled() && box->isChecked())
            {
                memoryNames.push_back(memoryName);
            }
        }
        return memoryNames;
    }
 
    void
    LTMWidget::deSelectMemoryServers()
    {
        if (!_allMemoryServersSelected)
        {
 
            // get information about memories already present and activate inactive ones if necessary
            int maxIndex = _availableMemoriesGroupBox->layout()
                               ->count(); //as the (de)select button is counted as well
            for (int i = 1; i < maxIndex; ++i)
            {
                auto w = _availableMemoriesGroupBox->layout()->itemAt(i)->widget();
                QCheckBox* box = static_cast<QCheckBox*>(w);
                box->setChecked(true);
            }
            //set variables and text:
            _allMemoryServersSelected = true;
            _de_selectMemoryServers->setText(_deselectText);
        }
        else
        {
 
            // get information about memories already present and activate inactive ones if necessary
            int maxIndex = _availableMemoriesGroupBox->layout()
                               ->count(); //as the (de)select button is counted as well
            for (int i = 1; i < maxIndex; ++i)
            {
                auto w = _availableMemoriesGroupBox->layout()->itemAt(i)->widget();
                QCheckBox* box = static_cast<QCheckBox*>(w);
                box->setChecked(false);
            }
 
            _allMemoryServersSelected = false;
            _de_selectMemoryServers->setText(_selectText);
        }
    }
 
    void
    LTMWidget::updateSelectAllButtonState()
{
 
    int maxIndex = _availableMemoriesGroupBox->layout()->count();
    bool allSelected = true;
 
    for (int i = 1; i < maxIndex; ++i)
    {
        auto w = _availableMemoriesGroupBox->layout()->itemAt(i)->widget();
        QCheckBox* box = static_cast<QCheckBox*>(w);
 
        if (box->isEnabled() && !box->isChecked())
        {
            allSelected = false;
            break;
        }
    }
 
    _allMemoryServersSelected = allSelected;
    _de_selectMemoryServers->setText(allSelected ? _deselectText : _selectText);
}
 
} // namespace armarx::armem::gui