QueryWidget.cpp

Go to the documentation of this file.

#include "QueryWidget.h"
 
#include <limits>
#include <mutex>
 
#include <QCheckBox>
#include <QGroupBox>
#include <QHBoxLayout>
#include <QLabel>
#include <QLineEdit>
#include <QPushButton>
#include <QScrollArea>
#include <QSpinBox>
#include <QTabWidget>
#include <QVBoxLayout>
#include <QWidget>
 
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
 
namespace armarx::armem::gui
{
 
    QueryWidget::QueryWidget()
    {
        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);
            allMemoryServersSelected = false;
            vboxlayout->addWidget(_de_selectMemoryServers);
            _availableMemoriesGroupBox->setLayout(vboxlayout);
            hlayout->addWidget(_availableMemoriesGroupBox);
        }
 
        QFrame* vFrame = new QFrame;
        vFrame->setFrameShape(QFrame::VLine);
        hlayout->addWidget(vFrame);
 
        {
            _additionalSettingsGroupBox = new QGroupBox("Additional query settings");
            auto vboxlayout = new QVBoxLayout();
            vboxlayout->setMargin(1);
            vboxlayout->setSizeConstraint(QLayout::SizeConstraint::SetMinAndMaxSize);
            vboxlayout->setAlignment(Qt::AlignTop);
            _additionalSettingsGroupBox->setLayout(vboxlayout);
 
            _dataCheckBox = new QCheckBox("Get Data");
            _dataCheckBox->setChecked(true);
            vboxlayout->addWidget(_dataCheckBox);
 
            _dropRemovedCheckBox = new QCheckBox("Drop disconnected memories");
            _dropRemovedCheckBox->setChecked(true);
            vboxlayout->addWidget(_dropRemovedCheckBox);
 
            _dropDisabledCheckBox = new QCheckBox("Drop disabled memories");
            _dropDisabledCheckBox->setChecked(false);
            vboxlayout->addWidget(_dropDisabledCheckBox);
 
            auto* recDepthHLayout = new QHBoxLayout();
            _recursionDepthLabel = new QLabel("Link resolution depth:");
            recDepthHLayout->addWidget(_recursionDepthLabel);
            _recursionDepthLabel->setFixedWidth(200);
 
            _recursionDepthSpinner = new QSpinBox(); // NOLINT
            _recursionDepthSpinner->setRange(-1, std::numeric_limits<int>::max());
            _recursionDepthSpinner->setValue(0);
            _recursionDepthSpinner->setEnabled(_dataCheckBox->isChecked());
            _recursionDepthSpinner->setSpecialValueText(QString("Unlimited"));
            recDepthHLayout->addWidget(_recursionDepthSpinner);
            recDepthHLayout->addStretch();
            vboxlayout->addLayout(recDepthHLayout);
 
            /*
            auto* exportPathHLayout = new QHBoxLayout();
            _exportPathLabel = new QLabel("Export path:");
            exportPathHLayout->addWidget(_exportPathLabel);
            _exportPathLabel->setFixedWidth(200);
 
            _exportPathLineEdit = new QLineEdit();
            exportPathHLayout->addWidget(_exportPathLineEdit);
            exportPathHLayout->setStretchFactor(_exportPathLineEdit, 4);
 
            _exportPathConfirmButton = new QPushButton("Confirm Path");
            exportPathHLayout->addWidget(_exportPathConfirmButton);
            _exportPathConfirmButton->setFixedWidth(100);
            vboxlayout->addLayout(exportPathHLayout);
 
            auto* exportNameHLayout = new QHBoxLayout();
            _exportNameLabel = new QLabel("Export name:");
            exportNameHLayout->addWidget(_exportNameLabel);
            _exportNameLabel->setFixedWidth(200);
 
            _exportNameLineEdit = new QLineEdit();
            exportNameHLayout->addWidget(_exportNameLineEdit);
            exportNameHLayout->setStretchFactor(_exportNameLineEdit, 4);
 
            _exportNameConfirmButton = new QPushButton("Confirm Name");
            exportNameHLayout->addWidget(_exportNameConfirmButton);
            _exportNameConfirmButton->setFixedWidth(100);
            vboxlayout->addLayout(exportNameHLayout);
*/
 
            auto ltmButtonsLayout = new QVBoxLayout();
            _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);
 
            vboxlayout->addLayout(ltmButtonsLayout);
 
            hlayout->addWidget(_additionalSettingsGroupBox);
        }
        vlayout->addLayout(hlayout);
 
        // Public connections.
        /*
        connect(_exportPathConfirmButton, &QPushButton::pressed, this, [=]() {
            confirmExportPath(_exportPathLineEdit->text().toStdString());
        });
        connect(_exportNameConfirmButton, &QPushButton::pressed, this, [=]() {
            confirmExportPath(_exportNameLineEdit->text().toStdString());
        });
*/
        connect(_storeInLTMButton, &QPushButton::pressed, this, &This::storeInLTM);
        connect(_startLTMRecordingButton, &QPushButton::pressed, this, &This::startRecording);
        connect(_stopLTMRecordingButton, &QPushButton::pressed, this, &This::stopRecording);
 
        // Private connections.
        connect(
            _dataCheckBox, &QCheckBox::stateChanged, this, &This::setRecursionDepthSpinnerEnabled);
 
        connect(_de_selectMemoryServers, &QPushButton::pressed, this, &This::deSelectMemoryServers);
 
        setLayout(vlayout);
    }
 
    void
    QueryWidget::update(const std::vector<std::string>& activeMemoryNames)
    {
        std::scoped_lock l(enabledMemoriesMutex);
        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(
                    true); // 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);
            }
        }
    }
 
    armem::query::DataMode
    QueryWidget::dataMode() const
    {
        return _dataCheckBox->isChecked() ? armem::query::DataMode::WithData
                                          : armem::query::DataMode::NoData;
    }
 
    bool
    QueryWidget::dropRemovedMemories() const
    {
        return _dropRemovedCheckBox->isChecked();
    }
 
    bool
    QueryWidget::dropDisabledMemories() const
    {
        return _dropDisabledCheckBox->isChecked();
    }
 
    std::map<std::string, QueryWidget::ActiveMemoryState>
    QueryWidget::getAvailableMemoryStates() const
    {
        std::scoped_lock l(enabledMemoriesMutex);
 
        std::map<std::string, QueryWidget::ActiveMemoryState> states;
        int maxIndex = _availableMemoriesGroupBox->layout()->count();
        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())
            {
                states[memoryName] = ActiveMemoryState::FoundAndChecked;
            }
            else if (box->isEnabled() && !box->isChecked())
            {
                states[memoryName] = ActiveMemoryState::FoundAndNotChecked;
            }
            else
            {
                states[memoryName] = ActiveMemoryState::NotFound;
            }
        }
        return states;
    }
 
    std::vector<std::string>
    QueryWidget::getEnabledMemories() const
    {
        std::scoped_lock l(enabledMemoriesMutex);
 
        std::vector<std::string> enabledMemoryCheckboxes;
        int maxIndex = _availableMemoriesGroupBox->layout()->count();
        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())
            {
                // Invisible ones are always unchecked if set to invisible from update method
                enabledMemoryCheckboxes.push_back(memoryName);
            }
        }
        return enabledMemoryCheckboxes;
    }
 
    int
    QueryWidget::queryLinkRecursionDepth() const
    {
        return _recursionDepthSpinner->value();
    }
 
    void
    QueryWidget::setRecursionDepthSpinnerEnabled(int state)
    {
        switch (state)
        {
            case Qt::Checked:
                _recursionDepthSpinner->setEnabled(true);
                break;
            case Qt::Unchecked:
            default:
                _recursionDepthSpinner->setEnabled(false);
                break;
        }
    }
 
    void
    QueryWidget::deSelectMemoryServers()
    {
        if (!allMemoryServersSelected)
        {
            //ARMARX_INFO << "Selecting all memory servers";
            //not all servers are selected -> select all memory servers:
            std::scoped_lock l(enabledMemoriesMutex);
 
            // 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();
                box->setChecked(true);
            }
            //set variables and text:
            allMemoryServersSelected = true;
            _de_selectMemoryServers->setText(deselectText);
        }
        else
        {
            //ARMARX_INFO << "Deselecting all memory servers";
            //memories should be deselected:
            std::scoped_lock l(enabledMemoriesMutex);
 
            // 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);
        }
    }
 
} // namespace armarx::armem::gui