LayerInfoTree.cpp

Go to the documentation of this file.

#include "LayerInfoTree.h"
 
#include <QCheckBox>
#include <QDoubleSpinBox>
#include <QLineEdit>
#include <QPushButton>
#include <QSpinBox>
 
#include <SimoxUtility/algorithm/string.h>
 
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/logging/Logging.h>
 
#include <RobotAPI/components/ArViz/Introspection/ElementJsonSerializers.h>
#include <RobotAPI/components/ArViz/Introspection/json_base.h>
#include <RobotAPI/components/ArViz/Introspection/json_elements.h>
#include <RobotAPI/components/ArViz/Introspection/json_layer.h>
 
namespace armarx
{
    LayerInfoTree::LayerInfoTree()
    {
    }
 
    void
    LayerInfoTree::setWidget(QTreeWidget* widget)
    {
        if (!widgetConnections.empty())
        {
            // Disconnect connections to prior widget.
            for (const auto& conn : widgetConnections)
            {
                disconnect(conn);
            }
            widgetConnections.clear();
        }
 
        this->widget = widget;
 
        // Update layer element properties when expanded.
        widgetConnections.append(
            connect(widget,
                    &QTreeWidget::itemExpanded,
                    [this](QTreeWidgetItem* item)
                    {
                        if (item->parent() || this->layers == nullptr)
                        {
                            return;
                        }
 
                        std::string id = item->text(0).toStdString();
                        auto* layer = this->layers->findLayer(this->layerID);
                        if (layer != nullptr)
                        {
                            viz::CoinLayerElement const* element = layer->findElement(id);
                            if (element != nullptr)
                            {
                                this->updateLayerElementProperties(item, element->data);
                            }
                        }
                    }));
 
        widget->setColumnCount(2);
        widget->setHeaderLabels({"Property", "Value"});
        widget->setHeaderHidden(false);
    }
 
    void
    LayerInfoTree::registerVisualizerCallbacks(viz::CoinVisualizer& visualizer)
    {
        visualizer.layerUpdatedCallbacks.emplace_back(
            [this](const viz::CoinLayerID& layerID, const viz::CoinLayer& layer)
            {
                if (layerID == this->layerID)
                {
                    this->update();
                }
            });
    }
 
    void
    LayerInfoTree::setMaxElementCountDefault(int max)
    {
        this->maxElementCountDefault = max;
    }
 
    void
    LayerInfoTree::setEnabled(bool value)
    {
        if (this->enabled != value)
        {
            this->enabled = value;
            if (value)
            {
                update();
            }
            else
            {
                clearLayerElements();
            }
        }
    }
 
    void
    LayerInfoTree::setSelectedLayer(viz::CoinLayerID id, viz::CoinLayerMap* layers)
    {
        this->layerID = id;
        this->layers = layers;
 
        showMoreItem = nullptr;
        maxElementCount = maxElementCountDefault;
 
        widget->clear();
 
        update();
    }
 
    void
    LayerInfoTree::update()
    {
        if (enabled && layers)
        {
            auto* layer = layers->findLayer(layerID);
            if (layer != nullptr)
            {
                updateLayerElements(layer->elements);
            }
        }
    }
 
    void
    LayerInfoTree::clearLayerElements()
    {
        if (widget)
        {
            widget->clear();
            showMoreItem = nullptr;
        }
    }
 
    void
    LayerInfoTree::updateLayerElements(const std::vector<viz::CoinLayerElement>& elements)
    {
        if (showMoreItem)
        {
            // We always delete the item up-front. If we still need it, it will be added again.
            // This way, we don't have to check for the showMoreItem while we update the entries.
            int index = widget->indexOfTopLevelItem(showMoreItem);
            ARMARX_CHECK_NONNEGATIVE(index)
                << "Invariant: If showMoreItem != nullptr, then the widget contains it.";
            delete widget->takeTopLevelItem(index);
            showMoreItem = nullptr;
        }
        ARMARX_CHECK_IS_NULL(showMoreItem);
 
        int currentIndex = 0;
        for (viz::CoinLayerElement const& element : elements)
        {
            std::string const& name = element.data->id;
 
            if (maxElementCount >= 0 && currentIndex >= maxElementCount)
            {
                // Stop adding more.
                addShowMoreItem();
                break;
            }
 
            if (currentIndex >= widget->topLevelItemCount())
            {
                // Add elements to the end of the list.
                QTreeWidgetItem* item = insertLayerElementItem(currentIndex, name, element.data);
                updateLayerElementProperties(item, element.data);
                ++currentIndex;
                continue;
            }
 
            // Get current item.
            QTreeWidgetItem* currentItem = widget->topLevelItem(currentIndex);
 
            // Compare current item to name.
 
            while (currentItem != nullptr && name.c_str() > currentItem->text(0))
            {
                // Delete items before current item.
                delete widget->takeTopLevelItem(currentIndex);
                currentItem = widget->topLevelItem(currentIndex);
            }
 
            if (currentItem != nullptr && name.c_str() < currentItem->text(0))
            {
                // Insert new item before child.
                currentItem = insertLayerElementItem(currentIndex, name, element.data);
                updateLayerElementProperties(currentItem, element.data);
                ++currentIndex;
                continue;
            }
 
            if (currentItem != nullptr && name.c_str() == currentItem->text(0))
            {
                // Already existing.
                updateLayerElementItem(currentItem, element.data);
                if (currentItem->isExpanded())
                {
                    updateLayerElementProperties(currentItem, element.data);
                }
                ++currentIndex;
                continue;
            }
        }
    }
 
    QTreeWidgetItem*
    LayerInfoTree::insertLayerElementItem(int index,
                                          const std::string& name,
                                          const viz::data::ElementPtr& element)
    {
        QTreeWidgetItem* item =
            new QTreeWidgetItem(QStringList{name.c_str(), getTypeName(element).c_str()});
        // To be used when we can hide specific elements.
        // item->setCheckState(0, Qt::CheckState::Unchecked);
        widget->insertTopLevelItem(index, item);
        return item;
    }
 
    void
    LayerInfoTree::updateLayerElementItem(QTreeWidgetItem* item,
                                          const viz::data::ElementPtr& element)
    {
        // Update type name.
        item->setText(1, getTypeName(element).c_str());
    }
 
    void
    LayerInfoTree::updateLayerElementProperties(QTreeWidgetItem* item,
                                                const viz::data::ElementPtr& element)
    {
        bool recursive = true;
        updateJsonChildren(item, serializeElement(element), recursive);
    }
 
    std::string
    LayerInfoTree::getTypeName(const viz::data::ElementPtr& element) const
    {
        const std::string typeName = simox::meta::get_type_name(*element);
        return viz::json::ElementJsonSerializers::isTypeRegistered(typeName)
                   ? typeName
                   : "<unknown type '" + typeName + "'>";
    }
 
    nlohmann::json
    LayerInfoTree::serializeElement(const viz::data::ElementPtr& element) const
    {
        try
        {
            return nlohmann::json(element);
        }
        catch (const viz::error::NoSerializerForType&)
        {
            return nlohmann::json::object();
        }
    }
 
    void
    LayerInfoTree::updateJsonChildren(QTreeWidgetItem* parent,
                                      const nlohmann::json& json,
                                      bool recursive)
    {
        if (json.is_array())
        {
            nlohmann::json jmeta = nlohmann::json::object();
 
            int iItem = 0;
            for (auto j : json)
            {
                const std::string key = std::to_string(iItem);
 
                if (iItem >= parent->childCount())
                {
                    QTreeWidgetItem* item = addJsonChild(parent, key);
                    updateJsonItem(item, key, j, jmeta, recursive);
                }
                else // iItem < parent->childCount()
                {
                    QTreeWidgetItem* currentItem = parent->child(iItem);
                    updateJsonItem(currentItem, key, j, jmeta, recursive);
                }
                ++iItem;
            }
            while (parent->childCount() > int(json.size()))
            {
                parent->removeChild(parent->child(parent->childCount() - 1));
            }
        }
        else if (json.is_object())
        {
            namespace meta = viz::json::meta;
            const nlohmann::json& jmeta =
                json.count(meta::KEY) > 0 ? json.at(meta::KEY) : nlohmann::json::object();
 
            int iItem = 0;
            for (auto it : json.items())
            {
                // Hide meta entries.
                if (isMetaKey(it.key()))
                {
                    continue;
                }
 
                // Check meta info.
                if (jmeta.count(it.key()) > 0 && jmeta.at(it.key()) == meta::HIDE)
                {
                    continue;
                }
 
                if (iItem >= parent->childCount())
                {
                    QTreeWidgetItem* item = addJsonChild(parent, it.key());
                    updateJsonItem(item, it.key(), it.value(), jmeta, recursive);
                    ++iItem;
                    continue;
                }
 
                QTreeWidgetItem* currentItem = parent->child(iItem);
 
                while (it.key().c_str() > currentItem->text(0))
                {
                    // Delete items before current item.
                    parent->removeChild(currentItem);
                    currentItem = parent->child(iItem);
                }
 
                if (it.key().c_str() < currentItem->text(0))
                {
                    // Insert new item before child.
                    currentItem = addJsonChild(parent, it.key());
                    updateJsonItem(currentItem, it.key(), it.value(), jmeta, recursive);
                    ++iItem;
                    continue;
                }
 
                if (it.key().c_str() == currentItem->text(0))
                {
                    // Already existing.
                    updateJsonItem(currentItem, it.key(), it.value(), jmeta, recursive);
                    ++iItem;
                    continue;
                }
            }
        }
    }
 
    QTreeWidgetItem*
    LayerInfoTree::addJsonChild(QTreeWidgetItem* parent, const std::string& key)
    {
        QTreeWidgetItem* child = new QTreeWidgetItem(QStringList{key.c_str(), ""});
        // To be used when we can actually change the values (enabled = use value from GUI).
        // child->setCheckState(0, Qt::CheckState::Unchecked);
        parent->addChild(child);
 
        return child;
    }
 
    void
    LayerInfoTree::updateJsonItem(QTreeWidgetItem* item,
                                  const std::string& key,
                                  const nlohmann::json& value,
                                  const nlohmann::json& parentMeta,
                                  bool recursive)
    {
        const int columnKey = 0;
 
        // Update key.
        item->setText(columnKey, key.c_str());
        // Update value.
        updateJsonItemValue(item, key, value, parentMeta);
 
        // Recursion.
        if (recursive)
        {
            updateJsonChildren(item, value, recursive);
        }
    }
 
    void
    LayerInfoTree::updateJsonItemValue(QTreeWidgetItem* item,
                                       const std::string& key,
                                       const nlohmann::json& value,
                                       const nlohmann::json& parentMeta)
    {
        const int columnValue = 1;
 
        if (parentMeta.count(key) > 0)
        {
            const nlohmann::json& metaValue = parentMeta.at(key);
            if (metaValue.is_string())
            {
                const std::string metaString = metaValue.get<std::string>();
                if (metaString == viz::json::meta::READ_ONLY)
                {
                    item->setText(columnValue, getValuePreview(value).toString());
                    // Hide check box.
                    item->setData(0, Qt::CheckStateRole, QVariant());
                    return;
                }
            }
        }
 
        // No handled meta info.
        if (QWidget* w = widget->itemWidget(item, columnValue))
        {
            updateValueWidget(value, w);
        }
        else if (QWidget* w = getValueWidget(item, value); w)
        {
            widget->setItemWidget(item, columnValue, w);
        }
        else
        {
            // No widget.
            item->setText(columnValue, getValuePreview(value).toString());
        }
    }
 
    QVariant
    LayerInfoTree::getValuePreview(const nlohmann::json& json) const
    {
        std::stringstream ss;
 
        switch (json.type())
        {
            case nlohmann::json::value_t::null:
                return QVariant("null");
 
            case nlohmann::json::value_t::object:
            {
                std::vector<std::string> keys;
                for (auto it : json.items())
                {
                    if (!isMetaKey(it.key()))
                    {
                        keys.push_back(it.key());
                    }
                }
                ss << "object [" << simox::alg::join(keys, ", ") << "]";
                return QVariant(ss.str().c_str());
            }
 
            case nlohmann::json::value_t::array:
                ss << "array of size " << json.size();
                return QVariant(ss.str().c_str());
 
            case nlohmann::json::value_t::string:
                return QVariant(json.get<std::string>().c_str());
            case nlohmann::json::value_t::boolean:
                return QVariant(json.get<bool>());
            case nlohmann::json::value_t::number_integer:
                return QVariant(json.get<int>());
            case nlohmann::json::value_t::number_unsigned:
                return QVariant(json.get<unsigned int>());
            case nlohmann::json::value_t::number_float:
                return QVariant(json.get<float>());
 
            default:
                return QVariant("n/a");
        }
    }
 
    QWidget*
    LayerInfoTree::getValueWidget(QTreeWidgetItem* item, const nlohmann::json& json) const
    {
        auto setChecked = [item]() { item->setCheckState(0, Qt::CheckState::Checked); };
 
        switch (json.type())
        {
            case nlohmann::json::value_t::string:
            {
 
                QLineEdit* w = new QLineEdit(json.get<std::string>().c_str());
                connect(w, &QLineEdit::editingFinished, this, setChecked);
                return w;
            }
            case nlohmann::json::value_t::boolean:
            {
                QCheckBox* w = new QCheckBox("Enabled");
                w->setChecked(json.get<bool>());
                connect(w, &QCheckBox::stateChanged, this, setChecked);
                return w;
            }
            case nlohmann::json::value_t::number_integer:
            case nlohmann::json::value_t::number_unsigned:
            {
                QSpinBox* w = new QSpinBox();
                w->setMinimum(std::numeric_limits<int>::lowest());
                w->setMaximum(std::numeric_limits<int>::max());
                w->setValue(json.get<int>());
                connect(w, qOverload<int>(&QSpinBox::valueChanged), this, setChecked);
                return w;
            }
            case nlohmann::json::value_t::number_float:
            {
                QDoubleSpinBox* w = new QDoubleSpinBox();
                w->setMinimum(std::numeric_limits<double>::lowest());
                w->setMaximum(std::numeric_limits<double>::max());
                w->setValue(json.get<double>());
                connect(w, qOverload<double>(&QDoubleSpinBox::valueChanged), this, setChecked);
                return w;
            }
            case nlohmann::json::value_t::null:
            case nlohmann::json::value_t::object:
            case nlohmann::json::value_t::array:
                return nullptr;
 
            default:
                return nullptr;
        }
    }
 
    void
    LayerInfoTree::updateValueWidget(const nlohmann::json& json, QWidget* widget) const
    {
        switch (json.type())
        {
            case nlohmann::json::value_t::string:
            {
                QLineEdit* w = dynamic_cast<QLineEdit*>(widget);
                ARMARX_CHECK_NOT_NULL(w);
                w->setText(json.get<std::string>().c_str());
            }
            break;
            case nlohmann::json::value_t::boolean:
            {
                QCheckBox* w = dynamic_cast<QCheckBox*>(widget);
                ARMARX_CHECK_NOT_NULL(w);
                w->setChecked(json.get<bool>());
            }
            break;
            case nlohmann::json::value_t::number_integer:
            case nlohmann::json::value_t::number_unsigned:
            {
                QSpinBox* w = dynamic_cast<QSpinBox*>(widget);
                ARMARX_CHECK_NOT_NULL(w);
                w->setValue(json.get<int>());
            }
            break;
            case nlohmann::json::value_t::number_float:
            {
                QDoubleSpinBox* w = dynamic_cast<QDoubleSpinBox*>(widget);
                ARMARX_CHECK_NOT_NULL(w);
                w->setValue(json.get<double>());
            }
            break;
            case nlohmann::json::value_t::null:
            case nlohmann::json::value_t::object:
            case nlohmann::json::value_t::array:
            default:
                break;
        }
    }
 
    bool
    LayerInfoTree::isMetaKey(const std::string& key)
    {
        return key.substr(0, 2) == "__" && key.substr(key.size() - 2) == "__";
    }
 
    void
    LayerInfoTree::addShowMoreItem()
    {
        ARMARX_CHECK_NULL(showMoreItem)
            << "There should not be a showMoreItem when this function is called.";
 
        auto* layer = this->layers->findLayer(this->layerID);
        if (layer == nullptr)
        {
            ARMARX_WARNING << "No layer with ID '" << this->layerID.first << "/"
                           << this->layerID.second << "' found";
            return;
        }
 
        std::stringstream ss;
        ss << "Showing " << widget->topLevelItemCount() << " of " << layer->elements.size()
           << " elements.";
 
        // Add a new item.
        QTreeWidgetItem* item = new QTreeWidgetItem(QStringList{"", ss.str().c_str()});
        widget->addTopLevelItem(item);
 
        QPushButton* button = new QPushButton("Show more");
        widget->setItemWidget(item, 0, button);
 
        connect(button,
                &QPushButton::pressed,
                [this, layer]()
                {
                    maxElementCount += maxElementCountDefault;
                    this->updateLayerElements(layer->elements);
                });
 
        this->showMoreItem = item;
    }
 
} // namespace armarx