AronTreeWidgetItem.cpp

Go to the documentation of this file.

#include "AronTreeWidgetItem.h"
 
#include <QAction>
#include <QMenu>
 
#include <RobotAPI/libraries/aron/core/type/variant/All.h>
 
#include "../ColorPalettes.h"
#include "visitors/AronTreeWidgetConverter.h"
#include "widgets/CustomWidget.h"
 
namespace armarx
{
    AronTreeWidgetItem*
    AronTreeWidgetItem::DynamicCast(QTreeWidgetItem* i)
    {
        return dynamic_cast<AronTreeWidgetItem*>(i);
    }
 
    AronTreeWidgetItem*
    AronTreeWidgetItem::DynamicCastAndCheck(QTreeWidgetItem* i)
    {
        if (!i)
        {
            return nullptr;
        }
        auto c = DynamicCast(i);
        ARMARX_CHECK_NOT_NULL(c);
        return c;
    }
 
    bool
    AronTreeWidgetItem::isValueErrorneous()
    {
        return itemValueError;
    }
 
    void
    AronTreeWidgetItem::setValueErrorState(bool isErrorSource, bool isTransitiveError)
    {
        itemValueError |= isErrorSource;
        transitiveValueError |= isTransitiveError;
 
 
        if (CustomWidget::DynamicCast(treeWidget()->itemWidget(this, 1)))
        {
            // The widgets handle errors themselves
            return;
        }
        auto palette = gui_color_palette::getNormalPalette();
        if (itemValueError)
        {
            palette = gui_color_palette::getErrorPalette();
        }
        else if (transitiveValueError)
        {
            palette = gui_color_palette::getIndirectErrorPalette();
        }
 
        QTreeWidgetItem::setBackground(1, QBrush(palette.color(QPalette::Base)));
    }
 
    void
    AronTreeWidgetItem::setKeyErrorState(bool hasError)
    {
        ARMARX_CHECK(col0Editable); //only editable keys should call this function!
        auto palette =
            hasError ? gui_color_palette::getErrorPalette() : gui_color_palette::getNormalPalette();
 
        keyValueError = hasError;
 
        QTreeWidgetItem::setBackground(1, QBrush(palette.color(QPalette::Base)));
    }
 
    void
    AronTreeWidgetItem::resetError()
    {
        keyValueError = false;
        itemValueError = false;
        transitiveValueError = false;
        // also reset children
        for (int i = 0; i < childCount(); ++i)
        {
            auto* arChild = AronTreeWidgetItem::DynamicCastAndCheck(QTreeWidgetItem::child(i));
            arChild->resetError();
        }
    }
 
 
    void
    AronTreeWidgetItem::checkKeyValidityOfChildren()
    {
        ARMARX_CHECK(aronType->getDescriptor() == aron::type::Descriptor::DICT);
        // return if check failed
        if (aronType->getDescriptor() != aron::type::Descriptor::DICT)
        {
            return;
        }
        // iterate through children; memorize keys
        std::map<QString, std::vector<int>> found_keys;
        auto numChildren = childCount();
        for (int i = 0; i < numChildren; ++i)
        {
            auto* casted = AronTreeWidgetItem::DynamicCastAndCheck(child(i));
            if (!casted)
            {
                // soft error here, we already report it above. - Definetly programming error
                continue;
            }
            auto& vec = found_keys[casted->text(0)];
            vec.push_back(i);
        }
        // highlight keys that conflict
        // memorize children that are not ok
        std::set<int> errorneous_indices;
        for (auto [key, vals] : found_keys)
        {
            if (vals.size() > 1)
            {
                for (int i : vals)
                {
                    auto* casted = AronTreeWidgetItem::DynamicCastAndCheck(child(i));
                    if (!casted)
                    {
                        // soft error here, we already report it above. - Definetly programming error
                        continue;
                    }
                    casted->setKeyErrorState(true);
                    errorneous_indices.emplace(i);
                }
            }
        }
        // clear potential error state of other elements
        for (int i = 0; i < numChildren; ++i)
        {
            if (errorneous_indices.find(i) != errorneous_indices.end())
            {
                continue;
            }
            auto* casted = AronTreeWidgetItem::DynamicCastAndCheck(child(i));
            if (!casted)
            {
                // soft error here, we already report it above. - Definetly programming error
                continue;
            }
            casted->setKeyErrorState(false);
        }
    }
 
    void
    AronTreeWidgetItem::onUserChange(int changedColumn)
    {
        QTreeWidgetItem* qParent = QTreeWidgetItem::parent();
        ARMARX_CHECK(qParent);
        AronTreeWidgetItem* aronParent = DynamicCast(qParent);
        if (changedColumn == 0)
        {
            if (col0Editable)
            {
                // Topmost should always be an Object and col0 is not editable in the child then...
                // -> aronParent should never be nullptr
                ARMARX_CHECK(aronParent);
                // check if the element is child of a dict. If so, validate uniqueness of keys
                if (aronParent->aronType->getDescriptor() == aron::type::Descriptor::DICT)
                {
                    aronParent->checkKeyValidityOfChildren();
                }
            }
            else
            {
                // maybe while editing keys, we try to edit a key that should not change by tabbing.
                // Catch that here and undo the edit
                preventIllegalKeyChange();
            }
        }
    }
 
    void
    AronTreeWidgetItem::preventIllegalKeyChange()
    {
        if (!col0Editable)
        {
            setText(0, unchangeableKey);
        }
    }
 
    AronTreeWidgetItem::AronTreeWidgetItem(bool editKey,
                                           bool editVal,
                                           QString key,
                                           aron::type::VariantPtr type) :
        aronType(type), col0Editable(editKey), col1Editable(editVal)
    {
        this->setText(0, key);
        // add hook to check for edited keys for children of dictionaries
        if (!editKey)
        {
            unchangeableKey = std::move(key);
        }
    }
 
} // namespace armarx