ArvizProfileManagerWidget.cpp

Go to the documentation of this file.

#include "ArvizProfileManagerWidget.h"
 
#include <string>
 
#include <QBoxLayout>
#include <QDialogButtonBox>
#include <QFormLayout>
#include <QLabel>
#include <QMessageBox>
#include <QPushButton>
#include <QRadioButton>
#include <QVBoxLayout>
 
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/system/ArmarXDataPath.h>
 
namespace armarx
{
 
    const QString ArvizProfileManagerWidget::SETTINGS_DEFAULT_PROFILE_KEY = "defaultProfileName";
 
    ProfileDialog::ProfileDialog(QWidget* parent,
                                 const QString& name,
                                 bool additive,
                                 bool addDialog,
                                 bool isDefault) :
        QDialog(parent)
    {
        setWindowTitle(addDialog ? "Add ArViz Profile" : "Edit ArViz Profile");
 
        // Set up UI components
        nameInput = new QLineEdit(this);
        nameInput->setText(name);
 
        additiveRadioButton = new QRadioButton("Save added layers", this);
        additiveRadioButton->setChecked(additive);
        substractiveRadioButton = new QRadioButton("Save removed layers", this);
        substractiveRadioButton->setChecked(not additive);
 
        defaultCheckBox = new QCheckBox("Mark default", this);
        defaultCheckBox->setChecked(isDefault);
 
        // Save/Cancel buttons
        QDialogButtonBox* buttonBox =
            new QDialogButtonBox(QDialogButtonBox::Save | QDialogButtonBox::Cancel, this);
        connect(buttonBox, &QDialogButtonBox::accepted, this, &ProfileDialog::accept);
        connect(buttonBox, &QDialogButtonBox::rejected, this, &ProfileDialog::reject);
        buttonBox->setCenterButtons(true);
 
        // Delete button
        deleteButton = new QPushButton("Delete", this);
        connect(deleteButton, &QPushButton::clicked, this, &ProfileDialog::deleteProfile);
 
        // Layouts
        QFormLayout* formLayout = new QFormLayout;
        formLayout->addRow("Profile Name:", nameInput);
        formLayout->addRow(additiveRadioButton);
        formLayout->addRow(substractiveRadioButton);
        formLayout->addRow(defaultCheckBox);
        formLayout->addRow(buttonBox);
        formLayout->addRow(deleteButton);
 
        setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
        setLayout(formLayout);
        adjustSize();
    }
 
    ProfileDialog::~ProfileDialog()
    {
    }
 
    QString
    ProfileDialog::getName() const
    {
        return nameInput->text();
    }
 
    bool
    ProfileDialog::isAdditive() const
    {
        return additiveRadioButton->isChecked();
    }
 
    bool
    ProfileDialog::isDefaultProfile() const
    {
        return defaultCheckBox->isChecked();
    }
 
    void
    ProfileDialog::deleteProfile()
    {
        // Handle the profile deletion
        emit deleteProfileSignal();
        reject(); // Close the dialog after deletion
    }
 
    ArvizProfileManagerWidget::ArvizProfileManagerWidget(QWidget* parent) :
        QWidget(parent),
        settings(QString((armarx::ArmarXDataPath::GetDefaultUserConfigPath() +
                          "/ArvizProfileManager.conf")
                             .c_str()),
                 QSettings::NativeFormat),
        currentProfile(Profile())
    {
        QHBoxLayout* layout = new QHBoxLayout(this);
 
        // Setup UI elements
        layersComboBox = new QComboBox(this);
        connect(layersComboBox,
                QOverload<int>::of(&QComboBox::activated),
                this,
                &ArvizProfileManagerWidget::onProfileSelected);
 
        addButton = new QPushButton("Add", this);
        editButton = new QPushButton("Edit", this);
        saveButton = new QPushButton("Save", this);
 
        layout->addWidget(new QLabel("ArViz Profile: "));
        layout->addWidget(layersComboBox);
        layout->addWidget(addButton);
        layout->addWidget(editButton);
        layout->addWidget(saveButton);
 
        setLayout(layout);
 
        connect(addButton, &QPushButton::clicked, this, &ArvizProfileManagerWidget::addProfile);
        connect(editButton, &QPushButton::clicked, this, &ArvizProfileManagerWidget::editProfile);
        connect(saveButton,
                &QPushButton::clicked,
                this,
                &ArvizProfileManagerWidget::saveCurrentProfile);
 
        loadLayerNames();
 
        // Load default profile
        const QString defaultProfileName = settings.value(SETTINGS_DEFAULT_PROFILE_KEY).toString();
        if (int i = layersComboBox->findText(defaultProfileName); i >= 0)
        {
            layersComboBox->setCurrentText(defaultProfileName);
            onProfileSelected(i);
        }
        else
        {
            // Not found. Load empty profile
            layersComboBox->setCurrentIndex(-1);
        }
    }
 
    void
    ArvizProfileManagerWidget::onProfileSelected(int index)
    {
        if (index >= 0 and index < layersComboBox->count())
        {
            loadProfile(layersComboBox->itemText(index));
            emit publishUpdate();
        }
    }
 
    void
    ArvizProfileManagerWidget::saveCurrentProfile()
    {
        const QString name = layersComboBox->currentText();
        if (name.isEmpty())
        {
            QMessageBox::warning(this, "Warning", "Please enter a valid name.");
            return;
        }
 
        if (saveProfile(name, currentProfile))
        {
            if (layersComboBox->findText(name) == -1)
            {
                layersComboBox->addItem(name);
            }
            layersComboBox->setCurrentText(name);
        }
    }
 
    void
    ArvizProfileManagerWidget::deleteCurrentProfileSave()
    {
        const QString name = layersComboBox->currentText();
        settings.remove(name);
 
        const int index = layersComboBox->currentIndex();
        layersComboBox->removeItem(index);
        settings.remove(name);
 
        if (layersComboBox->count() == 0)
        {
            editButton->setDisabled(true);
            saveButton->setDisabled(true);
        }
 
        emit publishUpdate();
    }
 
    void
    ArvizProfileManagerWidget::addProfile()
    {
        if (dialog == nullptr || !dialog->isVisible())
        {
            const QString defaultName = "Profile";
            const bool defaultAdditive = false;
            QString name = defaultName;
            unsigned int counter = 2;
            while (layersComboBox->count() > 0 and layersComboBox->findText(name) >= 0)
            {
                name = defaultName + QString::fromStdString(std::to_string(counter++));
            }
            dialog = new ProfileDialog(this,
                                       name,
                                       defaultAdditive,
                                       true,
                                       settings.value(SETTINGS_DEFAULT_PROFILE_KEY) == name);
            const int result = dialog->exec();
 
            if (result == QDialog::Accepted)
            {
                if (dialog->getName().isEmpty())
                {
                    ARMARX_WARNING << "Empty name for profile set.";
                    return;
                }
                if (layersComboBox->findText(dialog->getName()) >= 0)
                {
                    ARMARX_WARNING << "Profile with name " << dialog->getName().toStdString()
                                   << " already exists!";
                    return;
                }
 
                if (dialog->isDefaultProfile())
                {
                    settings.setValue(SETTINGS_DEFAULT_PROFILE_KEY, dialog->getName());
                }
 
                currentProfile.layers = {};
                currentProfile.additive = dialog->isAdditive();
                emit fetchUpdate();
 
                saveProfile(dialog->getName(), currentProfile);
                loadLayerNames();
                layersComboBox->setCurrentText(dialog->getName());
            }
            else
            {
                // do nothing
            }
        }
        else
        {
            QMessageBox::information(this, "Dialog Already Open", "The dialog is already open.");
        }
    }
 
    void
    ArvizProfileManagerWidget::editProfile()
    {
        if (layersComboBox->count() > 0)
        {
            if (dialog == nullptr || !dialog->isVisible())
            {
                const auto name = layersComboBox->currentText();
                dialog = new ProfileDialog(this,
                                           name,
                                           currentProfile.additive,
                                           false,
                                           settings.value(SETTINGS_DEFAULT_PROFILE_KEY) == name);
                connect(dialog,
                        &ProfileDialog::deleteProfileSignal,
                        this,
                        &ArvizProfileManagerWidget::deleteCurrentProfileSave);
                const int result = dialog->exec();
 
                if (result == QDialog::Accepted)
                {
                    const auto newName = dialog->getName();
 
                    if (newName.isEmpty())
                    {
                        ARMARX_WARNING << "Empty name for profile set.";
                        return;
                    }
 
                    if (newName != name)
                    {
                        // Rename
                        if (layersComboBox->findText(newName) >= 0)
                        {
                            ARMARX_WARNING << "Profile with name " << newName.toStdString()
                                           << " already exists!";
                            return;
                        }
                        settings.remove(layersComboBox->currentText());
                    }
 
                    if (dialog->isAdditive() != currentProfile.additive)
                    {
                        currentProfile.layers.clear();
                        currentProfile.additive = dialog->isAdditive();
                        emit fetchUpdate();
                    }
 
                    if (dialog->isDefaultProfile())
                    {
                        settings.setValue(SETTINGS_DEFAULT_PROFILE_KEY, newName);
                    }
                    else if (settings.value(SETTINGS_DEFAULT_PROFILE_KEY) == name)
                    {
                        settings.setValue(SETTINGS_DEFAULT_PROFILE_KEY, "");
                    }
 
                    saveProfile(dialog->getName(), currentProfile);
                    loadLayerNames();
                    layersComboBox->setCurrentText(newName);
                }
                else
                {
                    // do nothing
                }
            }
            else
            {
                QMessageBox::information(
                    this, "Dialog Already Open", "The dialog is already open.");
            }
        }
    }
 
    void
    ArvizProfileManagerWidget::loadLayerNames()
    {
        layersComboBox->clear();
        for (const QString& groups : settings.childGroups())
        {
            layersComboBox->addItem(groups);
        }
        if (layersComboBox->count() == 0)
        {
            editButton->setDisabled(true);
            saveButton->setDisabled(true);
        }
        else
        {
            editButton->setEnabled(true);
            saveButton->setEnabled(true);
        }
    }
 
    void
    ArvizProfileManagerWidget::loadProfile(const QString& name)
    {
        ARMARX_INFO << "Loading ArViz profile " << name.toStdString();
 
        std::scoped_lock lock(mtx);
        currentProfile.layers.clear();
 
        settings.beginGroup(name);
        currentProfile.additive = settings.value("additive").toBool();
        const int size = settings.beginReadArray("layers");
        for (int i = 0; i < size; ++i)
        {
            settings.setArrayIndex(i);
            QString first = settings.value("component").toString();
            QString second = settings.value("layer").toString();
            currentProfile.layers.insert({first.toStdString(), second.toStdString()});
        }
        settings.endArray();
        settings.endGroup();
        editButton->setEnabled(true);
    }
 
    bool
    ArvizProfileManagerWidget::saveProfile(const QString& name, const Profile& profile)
    {
        settings.beginGroup(name);
        settings.setValue("additive", profile.additive);
        settings.remove("layers");
        settings.beginWriteArray("layers", profile.layers.size());
        int i = 0;
        for (const auto& pair : profile.layers)
        {
            settings.setArrayIndex(i++);
            settings.setValue("component", QString::fromStdString(pair.first));
            settings.setValue("layer", QString::fromStdString(pair.second));
        }
        settings.endArray();
        settings.endGroup();
        return true;
    }
 
} // namespace armarx