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 <QSignalBlocker>
 
#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);
            _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);
        }
 
        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);
 
            hlayout->addWidget(_additionalSettingsGroupBox);
        }
        vlayout->addLayout(hlayout);
 
        // Private connections.
        connect(
            _dataCheckBox, &QCheckBox::stateChanged, this, &This::setRecursionDepthSpinnerEnabled);
 
        connect(_de_selectMemoryServers, &QPushButton::pressed, this, &This::deSelectMemoryServers);
 
        connect(_recursionDepthSpinner,
                qOverload<int>(&QSpinBox::valueChanged),
                this,
                [this](int val) { emit recursionDepthChanged(val); });
 
        connect(_dropRemovedCheckBox,
                &QCheckBox::toggled,
                this,
                &This::dropRemovedMemoriesChanged);
 
        connect(_dropDisabledCheckBox,
                &QCheckBox::toggled,
                this,
                &This::dropDisabledMemoriesChanged);
 
        connect(_dataCheckBox,
                &QCheckBox::toggled,
                this,
                &This::dataModeChanged);
 
        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);
                QSignalBlocker blocker(box);
                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);
                    connect(box, &QCheckBox::toggled, this, &This::activeMemoriesChanged);
                }
            }
 
            // activate/deactivate button 
            _de_selectMemoryServers->setEnabled(!activeMemoryNames.empty());
        }
        // signals cannot be within the lock scope, otherwise potential deadlocks
        emit activeMemoriesChanged();
    }
 
    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, armem::gui::ActiveMemoryState>
    QueryWidget::getAvailableMemoryStates() const
    {
        std::scoped_lock l(enabledMemoriesMutex);
 
        std::map<std::string, armem::gui::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] = armem::gui::ActiveMemoryState::FoundAndChecked;
            }
            else if (box->isEnabled() && !box->isChecked())
            {
                states[memoryName] = armem::gui::ActiveMemoryState::FoundAndNotChecked;
            }
            else
            {
                states[memoryName] = armem::gui::ActiveMemoryState::NotFound;
            }
        }
        return states;
    }
 
    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);
                QSignalBlocker blocker(box);
                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);
                QSignalBlocker blocker(box);
                box->setChecked(false);
            }
 
            _allMemoryServersSelected = false;
            _de_selectMemoryServers->setText(_selectText);
        }
        // necessary after using QSignalBlocker
        emit activeMemoriesChanged();
    }
 
    void
    QueryWidget::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