IntEnumWidget.cpp

Go to the documentation of this file.

#include "IntEnumWidget.h"
 
#include <QHBoxLayout>
 
#include <SimoxUtility/algorithm/string/string_conversion.h>
#include <SimoxUtility/error/SimoxError.h>
 
#include "../ColorPalettes.h"
#include "../visitors/AronTreeWidgetConverter.h"
 
namespace armarx::skills::gui
{
    IntEnumWidget::IntEnumWidget(const aron::type::IntEnumPtr& enumPtr,
                                 QTreeWidgetItem* currentItem) :
        CustomWidget(currentItem), element_type(enumPtr)
    {
        auto outerLayout = new QHBoxLayout();
        outerLayout->setContentsMargins(0, 0, 0, 0);
        innerWidget = new QComboBox();
        outerLayout->addWidget(innerWidget);
 
        for (const auto& [name, value] : enumPtr->getAcceptedValueMap())
        {
            innerWidget->addItem(QString::fromStdString(toDisplayText(name, value)));
        }
        innerWidget->setInsertPolicy(QComboBox::NoInsert);
        innerWidget->setEditable(true);
        innerWidget->setCurrentIndex(0);
 
        setLayout(outerLayout);
        ARMARX_CHECK(connect(innerWidget,
                             SIGNAL(currentTextChanged(const QString&)),
                             this,
                             SLOT(textChanged(const QString&))));
    }
 
    IntEnumWidget*
    IntEnumWidget::DynamicCast(QWidget* widget)
    {
        return dynamic_cast<IntEnumWidget*>(widget);
    }
 
    IntEnumWidget*
    IntEnumWidget::DynamicCastAndCheck(QWidget* elem)
    {
        if (!elem)
        {
            return nullptr;
        }
        auto* casted = DynamicCast(elem);
        ARMARX_CHECK_NOT_NULL(casted);
        return casted;
    }
 
    bool
    IntEnumWidget::hasParseErrors()
    {
        return parseToAron().first;
    }
 
    std::string
    IntEnumWidget::toDisplayText(const std::string& name, int value)
    {
        return name + " (" + std::to_string(value) + ")";
    }
 
    std::optional<std::pair<std::string, int>>
    IntEnumWidget::resolveText(const std::string& text) const
    {
        const auto valueMap = element_type->getAcceptedValueMap();
 
        // display format or plain name
        for (const auto& [name, value] : valueMap)
        {
            if (text == toDisplayText(name, value) || text == name)
            {
                return std::make_pair(name, value);
            }
        }
 
        // plain number
        try
        {
            const int parsed = simox::alg::to_<int>(text);
            for (const auto& [name, value] : valueMap)
            {
                if (value == parsed)
                {
                    return std::make_pair(name, value);
                }
            }
        }
        catch (const simox::error::SimoxError&)
        {
        }
 
        return std::nullopt;
    }
 
    void
    IntEnumWidget::setText(const QString& text)
    {
        // if the text identifies an enum entry, show it in the display format;
        // this only affects the GUI, parseToAron() resolves it back to the int value
        if (const auto resolved = resolveText(text.toStdString()))
        {
            innerWidget->setEditText(
                QString::fromStdString(toDisplayText(resolved->first, resolved->second)));
        }
        else
        {
            innerWidget->setEditText(text);
        }
        highlightUnparsableEntries();
    }
 
    QString
    IntEnumWidget::getText()
    {
        return innerWidget->currentText();
    }
 
    std::pair<bool, aron::data::IntPtr>
    IntEnumWidget::parseToAron()
    {
        // accepts the display format ("Name (value)"), a plain name, or a plain
        // number; the resulting aron data is always the plain int value
        const std::string toParse = getText().toStdString();
        const auto resolved = resolveText(toParse);
        if (not resolved.has_value())
        {
            ARMARX_VERBOSE << "Failed to parse IntEnum: \'" << toParse
                           << "\' is neither an accepted name nor an accepted value.";
            return {false, nullptr};
        }
 
        auto crAron = std::make_shared<aron::data::Int>(element_type->getPath());
        crAron->setValue(resolved->second);
        return {true, crAron};
    }
 
    void
    IntEnumWidget::highlightUnparsableEntries()
    {
        auto parsed = parseToAron().first;
        if (parsed)
        {
            innerWidget->setPalette(gui_color_palette::getNormalPalette());
        }
        else
        {
            innerWidget->setPalette(gui_color_palette::getErrorPalette());
        }
    }
 
    void
    IntEnumWidget::textChanged(const QString&)
    {
        setSupressSignals(true);
        highlightUnparsableEntries();
        setSupressSignals(false);
        // fire change signal
        emit CustomWidget::elemChanged(overlayingItem, 1);
    }
} // namespace armarx::skills::gui