Merge of all branches of Fabian PK (related to skills)

• Merge improved SkillManagerGUI from Tobias Bodmer
• Fix aron code generation for classes without members

@reister. YOu only need to review the changes to aron (Generator.cpp)

Depends on MR armarx-core!246 (merged)

Includes MR !285 (closed) and !320 (closed)

source/RobotAPI/gui-plugins/SkillManagerPlugin/aronTreeWidget/widgets/EditMatrixWidget.cpp

+#include "EditMatrixWidget.h"
+
+#include <QGridLayout>
+#include <QLabel>
+
+#include "ArmarXCore/core/exceptions/local/ExpressionException.h"
+#include "ArmarXCore/core/logging/Logging.h"
+
+#include "../../ColorPalettes.h"
+#include "../visitors/AronTreeWidgetCreator.h"
+#include "NDArrayHelper.h"
+
+namespace armarx
+{
+    EditMatrixWidget::EditMatrixWidget(long numRows,
+                                       long numCols,
+                                       aron::type::matrix::ElementType elemType,
+                                       QTreeWidgetItem* currentItem) :
+        CustomWidget(currentItem)
+    {
+        realRows = numRows;
+        realCols = numCols;
+        this->elemType = elemType;
+        // init surrounding layout
+        outerVerticalLayout = new QVBoxLayout();
+        innerHorizontalLayout = new QHBoxLayout();
+        outerVerticalLayout->addItem(innerHorizontalLayout);
+
+
+        QGridLayout* innerGrid = new QGridLayout();
+        const long createRows = std::min(numRows, MAX_ROWS_DISPLAY);
+        const long createCols = std::min(numCols, MAX_COLS_DISPLAY);
+
+        for (long i = 0; i < createRows * createCols; ++i)
+        {
+            auto* edit = new QLineEdit();
+            dispElements.push_back(edit);
+            int currRow = i / createCols;
+            int currCol = i % createCols;
+
+            innerGrid->addWidget(edit, currRow, currCol);
+            std::stringstream ss;
+            ss << "(" << currRow << ", " << currCol << ")";
+            std::string text = ss.str();
+
+            edit->setText(text.c_str());
+        }
+        innerHorizontalLayout->addItem(innerGrid);
+
+        // check, if we need to signal to the user, that not all elements are displayed.
+        if (numRows > MAX_ROWS_DISPLAY)
+        {
+            QLabel* fullLabel = new QLabel("...");
+            outerVerticalLayout->addWidget(fullLabel);
+        }
+        if (numCols > MAX_COLS_DISPLAY)
+        {
+            QLabel* fullLabel = new QLabel("...");
+            innerHorizontalLayout->addWidget(fullLabel);
+        }
+        setLayout(outerVerticalLayout);
+
+        // add hidden elements in vector
+        {
+            const auto hiddenCols = numCols - createCols;
+            // the 0th element holds all columns that are
+            // to the right of the displayed cols AND besides the displayed rows!
+            hiddenElems.push_back(std::vector<std::string>(hiddenCols * createRows, ""));
+
+            // add all rows that are hidden
+            for (long i = 0; i < numRows - createRows; ++i)
+            {
+                // add full cols; everything is hidden here
+                hiddenElems.push_back(std::vector<std::string>(numCols, ""));
+            }
+        }
+
+        for (size_t i = 0; i < dispElements.size(); ++i)
+        {
+            ARMARX_CHECK(connect(
+                dispElements[i], SIGNAL(editingFinished()), this, SLOT(matrixElementChanged())));
+        }
+    }
+
+    EditMatrixWidget*
+    EditMatrixWidget::DynamicCast(QWidget* elem)
+    {
+        return dynamic_cast<EditMatrixWidget*>(elem);
+    }
+
+    EditMatrixWidget*
+    EditMatrixWidget::DynamicCastAndCheck(QWidget* elem)
+    {
+        if (!elem)
+        {
+            return nullptr;
+        }
+        auto* casted = DynamicCast(elem);
+        ARMARX_CHECK_NOT_NULL(casted);
+        return casted;
+    }
+
+    void
+    EditMatrixWidget::setText(long row, long col, const std::string& str)
+    {
+        ARMARX_CHECK(row < realRows);
+        ARMARX_CHECK(col < realCols);
+        auto dispCols = getDisplayedCols();
+        auto dispRows = getDisplayedRows();
+        if (row < dispRows && col < dispCols)
+        {
+            dispElements[row * dispCols + col]->setText(str.c_str());
+            dispElements[row * dispCols + col]->setCursorPosition(0);
+        }
+        else if (row < dispRows)
+        {
+            long idx = row * (realCols - dispCols) + col - dispCols;
+            hiddenElems.at(0).at(idx) = str;
+        }
+        else
+        {
+            hiddenElems.at(row - dispRows + 1).at(col) = str;
+        }
+    }
+
+    std::string
+    EditMatrixWidget::getText(long row, long col)
+    {
+        ARMARX_CHECK(row < realRows);
+        ARMARX_CHECK(col < realCols);
+        const auto dispRows = getDisplayedRows();
+        const auto dispCols = getDisplayedCols();
+        if (row < dispRows && col < dispCols)
+        {
+            auto txt = dispElements.at(row * dispCols + col)->text();
+            return txt.toStdString();
+        }
+        else if (row < getDisplayedRows())
+        {
+            // the stuff besides the displayed rows
+            long idx = row * (realCols - dispCols) + col - dispCols;
+            return hiddenElems.at(0).at(idx);
+        }
+        else
+        {
+            // stuff beneath displayed rows
+            return hiddenElems.at(row - dispRows + 1).at(col);
+        }
+    }
+
+    void
+    EditMatrixWidget::highlightUnparsableEntries()
+    {
+        auto dispRows = getDisplayedRows();
+        auto dispCols = getDisplayedCols();
+        for (long row = 0; row < dispRows; ++row)
+        {
+            for (long col = 0; col < dispCols; ++col)
+            {
+                auto parsed = parseElement(row, col);
+                if (parsed.empty())
+                {
+                    dispElements.at(row * dispCols + col)
+                        ->setPalette(gui_color_palette::getErrorPalette());
+                }
+                else
+                {
+                    dispElements.at(row * dispCols + col)
+                        ->setPalette(gui_color_palette::getNormalPalette());
+                }
+            }
+        }
+    }
+
+    bool
+    EditMatrixWidget::hasParseErrors()
+    {
+        // also parse the hidden stuff!
+        for (long row = 0; row < realRows; ++row)
+        {
+            for (long col = 0; col < realCols; ++col)
+            {
+                auto parsed = parseElement(row, col);
+                if (parsed.empty())
+                {
+                    if (row >= getDisplayedRows() || col >= getDisplayedCols())
+                    {
+                        ARMARX_ERROR
+                            << "Programming error! Could not parse content in EditMatrixWidget "
+                               "that was set programatically from inside the SkillManagerPlugin. "
+                               "The error occured in row "
+                            << row << " and col " << col << ".";
+                    }
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    std::vector<unsigned char>
+    EditMatrixWidget::parseElement(long row, long col)
+    {
+        std::string str = getText(row, col);
+        try
+        {
+            switch (elemType)
+            {
+                case armarx::aron::type::matrix::INT16:
+                    return NDArrayHelper::toByteVector<int16_t>(str);
+
+                case armarx::aron::type::matrix::INT32:
+                    return NDArrayHelper::toByteVector<int32_t>(str);
+
+                case armarx::aron::type::matrix::INT64:
+                    return NDArrayHelper::toByteVector<int64_t>(str);
+
+                case armarx::aron::type::matrix::FLOAT32:
+                    return NDArrayHelper::toByteVector<float>(str);
+
+                case armarx::aron::type::matrix::FLOAT64:
+                    return NDArrayHelper::toByteVector<double>(str);
+            }
+        }
+        catch (const simox::error::SimoxError& err)
+        {
+            return {};
+        }
+        return {};
+    }
+
+    long
+    EditMatrixWidget::getDisplayedRows() const
+    {
+        return std::min(realRows, MAX_ROWS_DISPLAY);
+    }
+    long
+    EditMatrixWidget::getDisplayedCols() const
+    {
+        return std::min(realCols, MAX_COLS_DISPLAY);
+    }
+    void
+    EditMatrixWidget::matrixElementChanged()
+    {
+        blockSignals(true);
+        highlightUnparsableEntries();
+        blockSignals(false);
+        emit elemChanged(overlayingItem, 1);
+    }
+} // namespace armarx