AronTreeWidgetCreator.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * \package    RobotAPI::gui-plugins::SkillManagerMonitorWidgetController
 * \author     Raphael Grimm ( raphael dot grimm at kit dot edu )
 * \date       2020
 * \copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include <string>
 
#include "../widgets/EditMatrixWidget.h"
#include "../widgets/IntEnumWidget.h"
#include "../widgets/QuaternionWidget.h"
 
// base class
#include "AronTreeWidgetCreator.h"
 
// data
#include <QComboBox>
 
#include "../AronTreeWidgetItem.h"
#include "../Data.h"
#include "../ListDictHelper.h"
#include "AronTreeWidgetContextMenu.h"
 
namespace armarx
{
 
    AronTreeWidgetCreatorVisitor::AronTreeWidgetCreatorVisitor(QTreeWidgetItem* parentInstance) :
        parentOfCreatedObj(parentInstance)
    {
        // The parent of the root aron Tree Widget will not be aron type.
        // there an explicit setTopLevelWidget() is required.
        auto* aronParent = AronTreeWidgetItem::DynamicCast(parentInstance);
        if (aronParent)
        {
            toplevelWidget = aronParent->treeWidget();
        }
    }
 
    std::string
    AronTreeWidgetCreatorVisitor::generateUniqueKeyFromSet(std::set<std::string>&& usedKeys)
    {
        size_t num = 0;
        while (true)
        {
            std::string proposedName = this->defaultMapKeyName + std::to_string(num);
            auto it = usedKeys.find(proposedName);
            if (it == usedKeys.end())
            {
                break;
            }
            ++num;
        }
        return this->defaultMapKeyName + std::to_string(num);
    }
 
    void
    AronTreeWidgetCreatorVisitor::insertNewTreeViewWidget(Input& i, const std::string& defaul)
    {
        ARMARX_CHECK_NOT_NULL(i);
 
        auto key = i->getPath().getLastElement();
        bool isDictChild = false;
        // edit key, to be a unique string, if the parent is a dict
        auto* aronParent = AronTreeWidgetItem::DynamicCast(parentOfCreatedObj);
        if (aronParent && aronParent->aronType->getDescriptor() == aron::type::Descriptor::DICT)
        {
            isDictChild = true;
            std::set<std::string> usedKeys;
            for (int i = 0; i < parentOfCreatedObj->childCount(); ++i)
            {
                auto* sibling = AronTreeWidgetItem::DynamicCast(parentOfCreatedObj->child(i));
                if (sibling)
                {
                    usedKeys.insert(sibling->text(0).toStdString());
                }
            }
            key = generateUniqueKeyFromSet(std::move(usedKeys));
        }
        // if it's a list -> choose the right number
        else if (aronParent &&
                 aronParent->aronType->getDescriptor() == aron::type::Descriptor::LIST)
        {
            key = std::to_string(parentOfCreatedObj->childCount());
        }
 
        createdQWidgetItem =
            new AronTreeWidgetItem(isDictChild, editableValue, QString::fromStdString(key), i);
 
        if (i->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            createdQWidgetItem->setCheckState(1, Qt::CheckState::Unchecked);
        }
        createdQWidgetItem->setText(1, QString::fromStdString(defaul));
        createdQWidgetItem->setText(2, QString::fromStdString(i->getShortName()));
        createdQWidgetItem->setText(
            3,
            QString::fromStdString(
                aron_tree_widget::constantes::
                    ITEM_EMPTY_MESSAGE) /*QString::fromStdString(i->getDefaultFromString())*/);
 
        if (editableValue || isDictChild)
        {
            createdQWidgetItem->setFlags(createdQWidgetItem->flags() | Qt::ItemIsEditable);
        }
        parentOfCreatedObj->addChild(createdQWidgetItem);
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::ObjectPtr& i)
    {
        ARMARX_CHECK_NOT_NULL(i);
 
        auto key = i->getObjectName();
        if (i->getPath().hasElement())
        {
            key = i->getPath().getLastElement();
        }
 
        createdQWidgetItem =
            new AronTreeWidgetItem(editableValue, false, QString::fromStdString(key), i);
 
        if (i->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            createdQWidgetItem->setCheckState(1, Qt::CheckState::Unchecked);
        }
 
        parentOfCreatedObj->addChild(createdQWidgetItem);
 
        for (const auto& [key, value] : i->getMemberTypes())
        {
            AronTreeWidgetCreatorVisitor v(createdQWidgetItem);
            aron::type::visit(v, value);
 
            assert(v.createdQWidgetItem);
        }
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::DictPtr& i)
    {
        ARMARX_CHECK_NOT_NULL(i);
 
        insertNewTreeViewWidget(i, "");
        // The DictType has only one member, its key-type. This also must be present
        ARMARX_CHECK_EQUAL(i->getChildren().size(), 1);
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::PairPtr& pair)
    {
        // create default, uneditable tree widget item.
        insertNewTreeViewWidget(pair, "");
        // attach two children
        ARMARX_CHECK(pair->getChildren().size() == 2);
        for (size_t i = 0; i < 2; ++i)
        {
            AronTreeWidgetCreatorVisitor v(createdQWidgetItem);
            aron::type::visit(v, pair->getChildren()[i]);
            if (v.createdQWidgetItem)
            {
                std::string descr = "p[" + std::to_string(i) + "]";
                v.createdQWidgetItem->setText(0, descr.c_str());
            }
        }
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::TuplePtr& tuple)
    {
        // CAUTION; UNTESTED
        // create default, uneditable tree widget item.
        insertNewTreeViewWidget(tuple, "");
        // attach all children
        for (size_t i = 0; i < tuple->getChildren().size(); ++i)
        {
            AronTreeWidgetCreatorVisitor v(createdQWidgetItem);
            aron::type::visit(v, tuple->getChildren()[i]);
            if (v.createdQWidgetItem)
            {
                std::string descr = "tup[" + std::to_string(i) + "]";
                v.createdQWidgetItem->setText(0, descr.c_str());
            }
        }
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::ListPtr& i)
    {
        insertNewTreeViewWidget(i, "");
        auto txt = misc::generateNumElementsText(0);
        createdQWidgetItem->setText(1, txt);
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::NDArrayPtr& i)
    {
        insertNewTreeViewWidget(i, "");
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::MatrixPtr& i)
    {
        editableValue = false;
        insertNewTreeViewWidget(i, "");
        // special code to print the type of base type used
        QString type = "";
        switch (i->getElementType())
        {
            case armarx::aron::type::matrix::UINT8:
                type = "<uint8>";
                break;
            case armarx::aron::type::matrix::UINT16:
                type = "<uint16>";
                break;
            case armarx::aron::type::matrix::UINT32:
                type = "<uint32>";
                break;
            case armarx::aron::type::matrix::INT8:
                type = "<int8>";
                break;
            case armarx::aron::type::matrix::INT16:
                type = "<int16>";
                break;
            case armarx::aron::type::matrix::INT32:
                type = "<int32>";
                break;
            case armarx::aron::type::matrix::INT64:
                type = "<int64>";
                break;
            case armarx::aron::type::matrix::FLOAT32:
                type = "<float>";
                break;
            case armarx::aron::type::matrix::FLOAT64:
                type = "<double>";
                break;
        }
        type = createdQWidgetItem->text(2) + type;
        createdQWidgetItem->setText(2, type);
 
        // Widget fiddling source: https://blog.manash.io/quick-qt-6-how-to-add-qpushbutton-or-widgets-to-a-qtreewidget-as-qtreewidgetitem-2ae9f54c0e5f
        // overlay custom widget in column 1
        auto* toplevelWidget = createdQWidgetItem->treeWidget();
        EditMatrixWidget* matWidget = new EditMatrixWidget(
            i->getRows(), i->getCols(), i->getElementType(), createdQWidgetItem);
        toplevelWidget->setItemWidget(createdQWidgetItem, 1, matWidget);
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::QuaternionPtr& i)
    {
        editableValue = false;
        insertNewTreeViewWidget(i, "");
        // special code to print the type of base type used
        QString type = "";
        switch (i->getElementType())
        {
            case armarx::aron::type::quaternion::FLOAT32:
                type = "<float>";
                break;
            case armarx::aron::type::quaternion::FLOAT64:
                type = "<double>";
                break;
        }
        type = createdQWidgetItem->text(2) + type;
        createdQWidgetItem->setText(2, type);
 
        auto* toplevelWidget = createdQWidgetItem->treeWidget();
        QuaternionWidget* quatWidget =
            new QuaternionWidget(i->getElementType(), createdQWidgetItem);
        toplevelWidget->setItemWidget(createdQWidgetItem, 1, quatWidget);
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::ImagePtr& i)
    {
        insertNewTreeViewWidget(i, "");
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::PointCloudPtr& i)
    {
        insertNewTreeViewWidget(i, "");
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::IntEnumPtr& i)
    {
        editableValue = false;
        ARMARX_CHECK_NOT_NULL(i);
        ARMARX_CHECK_GREATER(i->getAcceptedValueNames().size(), 0);
 
        insertNewTreeViewWidget(i, "");
        IntEnumWidget* widget = new IntEnumWidget(i, createdQWidgetItem);
        createdQWidgetItem->treeWidget()->setItemWidget(createdQWidgetItem, 1, widget);
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::IntPtr& i)
    {
        editableValue = true;
        insertNewTreeViewWidget(i, "0");
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::LongPtr& i)
    {
        editableValue = true;
        insertNewTreeViewWidget(i, "0");
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::FloatPtr& i)
    {
        editableValue = true;
        insertNewTreeViewWidget(i, "0.0");
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::DoublePtr& i)
    {
        editableValue = true;
        insertNewTreeViewWidget(i, "0.0");
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::BoolPtr& i)
    {
        editableValue = true;
        insertNewTreeViewWidget(i, "false");
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitAronVariant(const aron::type::StringPtr& i)
    {
        insertNewTreeViewWidget(i, "");
    }
 
    void
    AronTreeWidgetCreatorVisitor::visitUnknown(Input&)
    {
        ARMARX_WARNING_S << "Received an unknown type when trying to create a tree view widget for "
                            "a skill argument type.";
    }
 
    void
    AronTreeWidgetCreatorVisitor::setTopLevelWidget(QTreeWidget* widget)
    {
        toplevelWidget = widget;
    }
} // namespace armarx