IntEnumWidget.cpp

Go to the documentation of this file.

#include "IntEnumWidget.h"
 
#include <QHBoxLayout>
 
#include <SimoxUtility/algorithm/string/string_conversion.h>
 
#include "RobotAPI/libraries/aron/core/type/variant/All.h"
 
#include "../../ColorPalettes.h"
#include "../visitors/AronTreeWidgetConverter.h"
 
namespace armarx
{
    IntEnumWidget::IntEnumWidget(const aron::type::IntEnumPtr& enumPtr,
                                 QTreeWidgetItem* currentItem) :
        CustomWidget(currentItem), element_type(enumPtr)
    {
        auto names = enumPtr->getAcceptedValueNames();
        auto outerLayout = new QHBoxLayout();
        outerLayout->setContentsMargins(0, 0, 0, 0);
        innerWidget = new QComboBox();
        outerLayout->addWidget(innerWidget);
 
        for (const auto& n : names)
        {
            innerWidget->addItem(n.c_str());
        }
        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;
    }
 
    void
    IntEnumWidget::setText(const QString& text)
    {
        innerWidget->setEditText(text);
        highlightUnparsableEntries();
    }
 
    QString
    IntEnumWidget::getText()
    {
        return innerWidget->currentText();
    }
 
    std::pair<bool, aron::data::IntPtr>
    IntEnumWidget::parseToAron()
    {
        auto crAron = std::make_shared<aron::data::Int>(element_type->getPath());
 
        // first look for strings in value map
        auto valueMap = element_type->getAcceptedValueMap();
        std::string toParse = getText().toStdString();
 
        auto searchRes = valueMap.find(toParse);
        if (searchRes != valueMap.end())
        {
            crAron->setValue(searchRes->second);
            return {true, crAron};
        }
        // maybe its the number directly
        auto accVals = element_type->getAcceptedValues();
        int res;
        try
        {
            res = simox::alg::to_<int>(toParse);
        }
        catch (const simox::error::SimoxError& err)
        {
            ARMARX_VERBOSE << "Failed to parse IntEnum: Could not convert  \'" << toParse
                           << "\' to an int. It also was not one of the accepted strings.";
            return {false, nullptr};
        }
        if (std::find(accVals.begin(), accVals.end(), res) != accVals.end())
        {
 
            crAron->setValue(res);
        }
        else
        {
            ARMARX_VERBOSE << "Parsed int " << res
                           << "but this int is not part of the accepted values.";
            return {false, nullptr};
        }
        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