EditMatrixWidget.cpp

Go to the documentation of this file.

#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::UINT8:
                    return NDArrayHelper::toByteVector<uint8_t>(str);
 
                case armarx::aron::type::matrix::UINT16:
                    return NDArrayHelper::toByteVector<uint16_t>(str);
 
                case armarx::aron::type::matrix::UINT32:
                    return NDArrayHelper::toByteVector<uint32_t>(str);
 
                case armarx::aron::type::matrix::INT8:
                    return NDArrayHelper::toByteVector<int8_t>(str);
 
                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