test_sdk/script/gtl_scr_engine_table_model.cpp

#include "gtl_scr_engine_table_model.h"

namespace gtl
{
    namespace scr
    {
        engine_table_model::engine_table_model(QObject *parent)
            : QAbstractTableModel(parent)
            , _rows(0)
            , _cols(0)
        {
            _horz_header = new engine_table_model_header(this);
            _vert_header = new engine_table_model_header(this);
        }

        QVariant engine_table_model::headerData(int section, Qt::Orientation orientation, int role) const
        {
            // FIXME: Implement me!

            if(role == Qt::DisplayRole)
            {
                if(orientation == Qt::Vertical)
                    return _vert_header->text(section);
                else
                    return _horz_header->text(section);
            }

            return QVariant();
        }

        int engine_table_model::rowCount(const QModelIndex &parent) const
        {
            if (parent.isValid())
                return 0;


            return _rows;
        }

        int engine_table_model::columnCount(const QModelIndex &parent) const
        {
            if (parent.isValid())
                return 0;

            // FIXME: Implement me!
            return _cols;
        }

        QVariant engine_table_model::data(const QModelIndex &index, int role) const
        {
            if (!index.isValid())
                return QVariant();

            if(role == Qt::DisplayRole)
            {
                QObject* value_object = _values.value(index);
                if(is_gtl_math_analog_value(value_object))
                {
                    return static_cast<gtl::math::analog_value*>(value_object)->value();
                }
            }

            return QVariant();
        }

        void engine_table_model::clear()
        {
            _vert_header->clear();
            _horz_header->clear();
            _values.clear();
        }

        bool engine_table_model::is_gtl_math_analog_value(QObject *obj) const
        {
            if(obj == NULL)
                return false;

            const QMetaObject* meta_object = obj->metaObject();
            while(meta_object)
            {
                if(QString(meta_object->className()) == "gtl::math::analog_value")
                    return true;

                meta_object = meta_object->superClass();
            }

            return false;
        }

        engine_table_model_header *engine_table_model::vert_header()
        {
            return _vert_header;
        }

        engine_table_model_header *engine_table_model::horz_header()
        {
            return _horz_header;
        }


        void engine_table_model::init(int rows, int cols)
        {
            beginResetModel();

            _rows = rows;
            _cols = cols;

            endResetModel();
        }

        void engine_table_model::set_cell_value(int row, int col, QJSValue value_object)
        {
            QObject* obj = value_object.toQObject();

            if(is_gtl_math_analog_value(obj))
            {
                QModelIndex idx = index(row, col);
                _values[idx] = obj;
                connect(static_cast<gtl::math::analog_value*>(obj), &gtl::math::analog_value::value_changed, this, &engine_table_model::value_changed);

                emit dataChanged(idx, idx, QList<int>() << Qt::DisplayRole);
            }
            else
            {
                qDebug() << "error set_cell_value : value_object is not gtl::math::analog_value object";
            }
        }

        void engine_table_model::value_changed()
        {
            QModelIndex idx = _values.key(sender());
            emit dataChanged(idx, idx, QList<int>() << Qt::DisplayRole);
        }

        engine_table_model_header::engine_table_model_header(QObject *parent)
            : QObject(parent)
        {

        }

        QString engine_table_model_header::text(int idx) const
        {
            return _text[idx];
        }

        void engine_table_model_header::clear()
        {
            _text.clear();
        }

        void engine_table_model_header::set_text(int idx, QString text)
        {
            _text[idx] = text;
        }

    }
}