ZTableModel.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2013, 2014  Bob Dinitto
 *
 * Filename:   ZTableModel.cpp
 * Created on: 11/9/2014
 * Author:     Bob Dinitto
 *
 * Zuble is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include <QVariant>
#include "ZTableModel.h"
#include "ZblException.h"
#include "zglobal.h"
#include "ZApplication.h"
#include <QtQml>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QHashIterator>

namespace Zbl
{

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZTableModel)

ZTableModel::ZTableModel(QObject *parent) :
    QAbstractTableModel(parent)
{

}

void ZTableModel::registerLogCategory()
{
    ZBL_REGISTER_LOGGED_OBJECT
}

void ZTableModel::registerType()
{
    qmlRegisterType<ZTableModel>
            ("org.zuble.qml", 1, 0, "ZTableModel");
}

int ZTableModel::getUserRole()
{
    return Qt::UserRole;
}



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

    int count = -1;

    ZBL_SLOT_BEGIN_TRY

    count = m_model.rowCount(NULL);
    ZBL_SLOT_END_RETURN(count,  -1,
    Z_FAC_JS, ZblTableModel::rowCount, rowCount failed)

}

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

    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(m_model.columnCount(NULL),  -1,
    Z_FAC_JS, ZblTableModel::columnCount, columnCount failed)

}

QVariant ZTableModel::data(
        const QModelIndex & index,
        int role) const
{

    //qDebug() << "ZTableModel::data role/row/col" << role << index.row() << index.column();

       // Check boudaries
       if(index.column() < 0 ||
               columnCount() <= index.column() ||
               index.row() < 0 ||
               rowCount() <= index.row())
       {
           qDebug() << "ZTableModel::data - Warning out of bounds: " << index.row() << ", " << index.column();
           return QVariant();
       }

       ZBL_SLOT_BEGIN_TRY
       ZBL_SLOT_END_RETURN(m_model.data(role,index.row(), index.column()),  QVariant(),
       Z_FAC_JS, ZblTableModel::data, data failed)

    return QVariant();

}


QHash<int, QByteArray> ZTableModel::roleNames() const
{

    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(m_model.roleNames(),  (QHash<int, QByteArray>()),
    Z_FAC_JS, ZTableModel::roleNames, roleNames failed)

}

void ZTableModel::clearRoles()
{
    // TBD: NOT THREAD SAFE!!!!!

    ZBL_SLOT_BEGIN_TRY
    beginResetModel();
    m_model.clearRoles();
    endResetModel();
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZblTableModel::clearRoles, clearRoles failed)
}

void ZTableModel::clearData()
{
    // TBD: NOT THREAD SAFE!!!!!

    ZBL_SLOT_BEGIN_TRY
    beginResetModel();
    m_model.clearData();
    endResetModel();
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZblTableModel::clearData, clearData failed)
}

void ZTableModel::dumpModelData() const
{
    // TBD: NOT THREAD SAFE!!!!!

    ZBL_SLOT_BEGIN_TRY
    QList<QByteArray> names = roleNames().values();

    QByteArray nextValue;

    qDebug("dumping model role names");

    for(int i=0; i<names.length();i++)
    {
        nextValue = names.at(i);
        qDebug("name=%s",nextValue.constData());
    }
    m_model.dumpModelData();
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZblTableModel::dumpModelData, dumpModelData failed)
}



void ZTableModel::putValue(int role, int row, const QVariant& value)
{
    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {

        //QString strValue(value.toString());
        //QString strAddress(ZApplication::getCurrentThreadAddress());

        m_model.setData(role, row, 0, value);

        emit tableModified(role, row);

        QVector<int> modifiedRole;
        modifiedRole.append(role);
        QModelIndex index = createIndex(row, 0);

        emit dataChanged(index, index, modifiedRole);
    }
    else
    {
        //QString strValue(value.toString());
        //QString strAddress(ZApplication::getCurrentThreadAddress());

        QVariant valueCopy(value);

        QMetaObject::invokeMethod(this,"putValue",
                                  Qt::BlockingQueuedConnection,
                                  Q_ARG(int, role),
                                  Q_ARG(int, row),
                                  Q_ARG(QVariant, valueCopy)
                                  );
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::put, put failed)
}

void ZTableModel::putValue(int role, int row, int column, const QVariant& value)
{
    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {

        //QString strValue(value.toString());
        //QString strAddress(ZApplication::getCurrentThreadAddress());

        m_model.setData(role, row, column, value);

        emit tableModified(role, row);

        QVector<int> modifiedRole;
        modifiedRole.append(role);
        QModelIndex index = createIndex(row, column);

        emit dataChanged(index, index, modifiedRole);
    }
    else
    {
        //QString strValue(value.toString());
        //QString strAddress(ZApplication::getCurrentThreadAddress());

        QVariant valueCopy(value);

        QMetaObject::invokeMethod(this,"putValue",
                                  Qt::BlockingQueuedConnection,
                                  Q_ARG(int, role),
                                  Q_ARG(int, row),
                                  Q_ARG(int, column),
                                  Q_ARG(QVariant, valueCopy)
                                  );
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::put, put failed)
}



void ZTableModel::appendRow( QVariant data )
{
    ZBL_SLOT_BEGIN_TRY

            //TBD: can we eliminate invokeMethod here since it's
            // called by appendRow(ZRoleRow)?

    if(inObjectThread(this))
    {
        if(data.canConvert<Zbl::ZRoleRow>())
        {
            ZRoleRow roleRow = data.value<Zbl::ZRoleRow>();

            appendRow(roleRow);
        }
    }
    else
    {
        //QMap<int, QList<QVariant > > dataCopy = data;

        QMetaObject::invokeMethod(this,"appendRow",
                                  Qt::QueuedConnection,
                                  Q_ARG( QVariant, data ) );

    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::appendRow, appendRow failed)

}
void ZTableModel::appendRows(QVariant data)
{
    ZBL_SLOT_BEGIN_TRY

            //TBD: can we eliminate invokeMethod here since it's
            // called by appendRows(ZRoleRowList)?

    if(inObjectThread(this))
    {
        if(data.canConvert<Zbl::ZRoleRowList>())
        {
            ZRoleRowList roleRows = data.value<Zbl::ZRoleRowList>();

            appendRows(roleRows);
        }
    }
    else
    {
        QMetaObject::invokeMethod(this,"appendRows",
                                  Qt::QueuedConnection,
                                  Q_ARG( QVariant, data ) );
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::appendRows, appendRows failed)

}

void ZTableModel::appendRow(ZRoleRow roleRow)
{
    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        int insertIndex = m_model.rowCount();

        beginInsertRows(QModelIndex(), insertIndex, insertIndex);

        m_model.appendRow(roleRow);

        endInsertRows();
    }
    else
    {
        QMetaObject::invokeMethod(this,"appendRow",
                                  Qt::QueuedConnection,
                                  Q_ARG( ZRoleRow, roleRow ) );
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::appendRow, appendRow failed)

}

int ZTableModel::appendRowIndex(ZRoleRow roleRow)
{
    int insertIndex = -1;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        insertIndex = m_model.rowCount();

        beginInsertRows(QModelIndex(), insertIndex, insertIndex);

        m_model.appendRow(roleRow);

        endInsertRows();
    }
    else
    {
        QMetaObject::invokeMethod(this,"appendRowIndex",
                                  Qt::BlockingQueuedConnection,
                                  Q_RETURN_ARG(int, insertIndex),
                                  Q_ARG(ZRoleRow, roleRow));
    }

    ZBL_SLOT_END_RETURN(insertIndex,  insertIndex,
    Z_FAC_JS, ZTableModel::appendRowIndex, appendRowIndex failed)
}

void ZTableModel::appendRows(ZRoleRowList roleRowList)
{
    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        int insertIndex = m_model.rowCount();

        beginInsertRows(QModelIndex(), insertIndex, insertIndex+roleRowList.count()-1);

        m_model.appendRows(roleRowList);

        endInsertRows();
    }
    else
    {
        QMetaObject::invokeMethod(this,"appendRows",
                                  Qt::QueuedConnection,
                                  Q_ARG( ZRoleRowList, roleRowList ) );
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::appendRows, appendRows failed)

}

void ZTableModel::appendMissingRow(
        QVariant roleRow,
        const QString& keyText,
        int keyColumn)

{

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        if(roleRow.canConvert<Zbl::ZRoleRow>())
        {
            ZRoleRow zRow = roleRow.value<Zbl::ZRoleRow>();

            appendMissingRow(zRow, keyText, keyColumn);
        }

    }
    else
    {
        QMetaObject::invokeMethod(this,"appendMissingRow",
                                  Qt::QueuedConnection,
                                  Q_ARG(QVariant, roleRow),
                                  Q_ARG(const QString&, keyText),
                                  Q_ARG(int, keyColumn));
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::appendMissingRow,
                      appendMissingRow failed)
}

void ZTableModel::appendMissingRow(
        ZRoleRow roleRow,
        const QString& keyText,
        int keyColumn)

{
    int foundRow = -1;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        foundRow = m_model.findNextItemRow(
                    0, keyText, keyColumn, true, true, true);

        if(foundRow == -1)
           appendRow(roleRow);
    }
    else
    {
        QVariant row = QVariant::fromValue<ZRoleRow>(roleRow);

        QMetaObject::invokeMethod(this,"appendMissingRow",
                                  Qt::QueuedConnection,
                                  Q_ARG(QVariant, row),
                                  Q_ARG(const QString&, keyText),
                                  Q_ARG(int, keyColumn));
    }

    ZBL_SLOT_END_VOID(
    Z_FAC_JS, ZTableModel::appendMissingRow, appendMissingRow failed)
}






void ZTableModel::prependRow( QVariant data )
{
    ZBL_SLOT_BEGIN_TRY

            //TBD: can we eliminate invokeMethod here since it's
            // called by appendRow(ZRoleRow)?

    if(inObjectThread(this))
    {
        if(data.canConvert<Zbl::ZRoleRow>())
        {
            ZRoleRow roleRow = data.value<Zbl::ZRoleRow>();

            prependRow(roleRow);
        }
    }
    else
    {
        //QMap<int, QList<QVariant > > dataCopy = data;

        QMetaObject::invokeMethod(this,"prependRow",
                                  Qt::QueuedConnection,
                                  Q_ARG( QVariant, data ) );

    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::prependRow, prependRow failed)

}
void ZTableModel::prependRows(QVariant data)
{
    ZBL_SLOT_BEGIN_TRY

            //TBD: can we eliminate invokeMethod here since it's
            // called by prependRows(ZRoleRowList)?

    if(inObjectThread(this))
    {
        if(data.canConvert<Zbl::ZRoleRowList>())
        {
            ZRoleRowList roleRows = data.value<Zbl::ZRoleRowList>();

            prependRows(roleRows);
        }
    }
    else
    {
        QMetaObject::invokeMethod(this,"prependRows",
                                  Qt::QueuedConnection,
                                  Q_ARG( QVariant, data ) );
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::prependRows, prependRows failed)

}

void ZTableModel::prependRow(ZRoleRow roleRow)
{
    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        //int insertIndex = m_model.rowCount();

        beginInsertRows(QModelIndex(), 0, 0); // TBD: should we expose column index?

        m_model.prependRow(roleRow);

        endInsertRows();
    }
    else
    {
        QMetaObject::invokeMethod(this,"prependRow",
                                  Qt::QueuedConnection,
                                  Q_ARG( ZRoleRow, roleRow ) );
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::prependRow, prependRow failed)

}

void ZTableModel::prependRows(ZRoleRowList roleRowList)
{
    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        //int insertIndex = m_model.rowCount();

        beginInsertRows(QModelIndex(), 0, roleRowList.count()-1);

        m_model.prependRows(roleRowList);

        endInsertRows();
    }
    else
    {
        QMetaObject::invokeMethod(this,"prependRows",
                                  Qt::QueuedConnection,
                                  Q_ARG( ZRoleRowList, roleRowList ) );
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::prependRows, prependRows failed)

}




void ZTableModel::removeRow(int row)
{
    removeRows(row, 1);
}

void ZTableModel::removeRows(int row, int count)
{
    // WARNING: Infinite loop! Don't generate log messages in this method!

    ZBL_SLOT_BEGIN_TRY

     //zDebug() << "removeRows - row=" << row << ", count=" << count;

    if(inObjectThread(this))
    {
        beginRemoveRows(QModelIndex(), row, row+count-1);

        //blockSignals(true);

        m_model.removeRows(row, count);

        //blockSignals(false);

        endRemoveRows();


    }
    else
    {
        QMetaObject::invokeMethod(this,"removeRows",
                                  Qt::QueuedConnection,
                                  Q_ARG( int, row ),
                                  Q_ARG( int, count ) );
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::removeRows, removeRows failed)
}

void ZTableModel::truncate(int rowCount, bool removeFromFront)
{
    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        const int modelCount = m_model.rowCount();

        int removeCount = modelCount - rowCount;

        if(removeCount > 0)
        {
            if(removeFromFront)
                removeRows(0, removeCount);
            else
            {
                int firstRow = modelCount - removeCount;
                if(firstRow < 0)
                {
                    removeCount = removeCount + firstRow;
                    firstRow = 0;
                }
                removeRows(firstRow, removeCount);
            }
        }

    }
    else
    {
        QMetaObject::invokeMethod(this,"truncate",
                                  Qt::QueuedConnection,
                                  Q_ARG( int, rowCount ),
                                  Q_ARG( bool, removeFromFront ) );
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::removeRows, removeRows failed)
}

bool ZTableModel::copyColumn(int fromColumn, int toColumn)
{
    ZBL_SLOT_BEGIN_TRY

    bool status = false;

    if(inObjectThread(this))
    {
        status = m_model.copyColumn(fromColumn, toColumn);
    }
    else
    {
        QMetaObject::invokeMethod(this,"copyColumn",
                                  Qt::BlockingQueuedConnection,
                                  Q_RETURN_ARG(bool, status),
                                  Q_ARG( int, fromColumn ),
                                  Q_ARG( int, toColumn ));
    }

    ZBL_SLOT_END_RETURN(status, false,
                Z_FAC_JS, ZTableModel::copyColumn, copyColumn failed)
}





ZRoleRow ZTableModel::coalesceCellRow(
        const ZDataRow cells,
        int startIndex,
        int columnCount,
        const QList<int> roles,
        int& nextIndex)
{
    ZRoleRow roleRow;

    const int roleCount = roles.count();

    if(!roleCount)
        return roleRow;

    const int cellCount = cells.count();

    if(!cellCount)
        return roleRow;

    const int stopIndex = startIndex + (roleCount*columnCount);

    if(stopIndex > cellCount)
        throw ZblException("Insufficient cells to coalesce a row.");

    for(int i=startIndex, r=0; i<stopIndex; i++)
    {
        roleRow[roles.at(r++)].push_back(cells.at(i));

        if(r >= roleCount)
            r = 0;
    }

    nextIndex = stopIndex;

    return roleRow;
}

ZRoleRowList ZTableModel::coalesceCellRows(
        const ZDataRow cells,
        int columnCount,
        const QList<int> roles)
{
    ZRoleRowList roleRowList;

    const int roleCount = roles.count();

    if(!roleCount)
        return roleRowList;

    const int cellCount = cells.count();

    if(!cellCount)
        return roleRowList;

    const int rowCount = cellCount / (roleCount*columnCount);

    if(rowCount < 1)
        return roleRowList;

    int nextIndex = 0;

    for(int i=0; i<rowCount; i++)
        roleRowList.append(coalesceCellRow(cells, nextIndex, columnCount, roles, nextIndex));

    return roleRowList;
}

void ZTableModel::appendCells(QVariant data, bool truncateModel)
{
    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {

        mergeCells(data, false, truncateModel);
    }
    else
    {
        QMetaObject::invokeMethod(this,"appendCells",
                                  Qt::QueuedConnection,
                                  Q_ARG( QVariant, data ),
                                  Q_ARG(bool, truncateModel));
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::appendCells, appendCells failed)

}

void ZTableModel::prependCells(QVariant data, bool truncateModel)
{
    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        mergeCells(data, true, truncateModel);
    }
    else
    {
        QMetaObject::invokeMethod(this,"prependCells",
                                  Qt::QueuedConnection,
                                  Q_ARG( QVariant, data ),
                                  Q_ARG(bool, truncateModel));
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::prependCells, prependCells failed)
}

void ZTableModel::mergeCells(QVariant data, bool front, bool truncateModel)
{

    const int startingRowCount = m_model.rowCount();
    int rowsAdded = 0;

    if(data.canConvert<Zbl::ZDataRow>())
    {
        ZDataRow cellData = data.value<Zbl::ZDataRow>();

        const int cellCount = cellData.count();

        const int roleCount = m_model.roleCount();

        if(!roleCount)
            throw ZblException("Invalid role count - data model must "
                               "contain at least one role.");

        const int colCount = m_model.columnCount();

        const int rowCount = cellCount / (roleCount*colCount);

        if(rowCount<1)
            throw ZblException("Invalid cell count - data cell count must "
                               "be at least 1 row of cells, "
                               "ie: roleCount * columnCount.");

        const int remainderCells = cellCount % (roleCount*colCount);

        if(remainderCells)
            throw ZblException("Invalid cell count - data cell count must "
                               "be modulo (roleCount * columnCount), "
                               "ie: an integral number of rows.");

        QList<int> roles = m_model.roles();

        int nextIndex = 0;

        if(rowCount == 1)
        {
            if(front)
                prependRow(coalesceCellRow(cellData, 0, colCount, roles, nextIndex));
            else
                appendRow(coalesceCellRow(cellData, 0, colCount, roles, nextIndex));
        }
        else
        {
            if(front)
                prependRows(coalesceCellRows(cellData, colCount, roles));
            else
                appendRows(coalesceCellRows(cellData, colCount, roles));
        }

        rowsAdded = rowCount;

    }
    else if(data.canConvert(QMetaType::QString))
    {
        QString oneCell = data.toString();

        if(m_model.roleCount() != 1 || m_model.columnCount() != 1)
            throw ZblException("Models with multiple roles or columns require "
                               "more than one cell to fill a row."
                               " Pass a string array containing (roleCount"
                               " * columnCount * rowCount) number of strings.");

        ZRoleRow roleRow;
        ZDataRow dataRow;

        dataRow.append(oneCell);

        QList<int> roleList = m_model.roles();

        roleRow.insert(roleList.at(0), dataRow);

        appendRow(roleRow);

        rowsAdded = 1;
    }

    // TBD: WARN AND RETURN IF NOT POSSIBLE TO MERGE CELLS.


    if(truncateModel && (startingRowCount!=0))
    {
        zDebug() << "Truncating to row count: " << startingRowCount;
        zDebug() << "Truncating front: " << front;
        truncate(startingRowCount, !front);
    }
}

int ZTableModel::modelRowCount() const
{
    int count = -1;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        count = m_model.rowCount();
    }
    else
    {
        QMetaObject::invokeMethod(const_cast<ZTableModel*>(this),"modelRowCount",
                                  Qt::BlockingQueuedConnection,
                                   Q_RETURN_ARG(int, count));
    }

    ZBL_SLOT_END_RETURN(count,  -1,
    Z_FAC_JS, ZTableModel::modelRowCount, modelRowCount failed)
}


int ZTableModel::modelColumnCount() const
{
    int count = -1;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        count = m_model.columnCount();
    }
    else
    {
        QMetaObject::invokeMethod(const_cast<ZTableModel*>(this),"modelColumnCount",
                                  Qt::BlockingQueuedConnection,
                                   Q_RETURN_ARG(int, count));
    }

    ZBL_SLOT_END_RETURN(count,  -1,
    Z_FAC_JS, ZTableModel::modelColumnCount, modelColumnCount failed)
}

void ZTableModel::sync()
{
    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        QCoreApplication::sendPostedEvents(this);
    }
    else
    {
        QMetaObject::invokeMethod(this,"sync",
                                  Qt::BlockingQueuedConnection);
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::sync, sync failed)
}

void ZTableModel::setColumnCount(int count)
{
    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        m_model.setColumnCount(count);
    }
    else
    {
        QMetaObject::invokeMethod(this,"setColumnCount",
                                  Qt::BlockingQueuedConnection,
                                  Q_ARG(int, count));

    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTableModel::setColumnCount, setColumnCount failed)
}

bool ZTableModel::addRole(int roleNumber)
{
    bool status;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        status = m_model.addRole(roleNumber);
    }
    else
    {
        QMetaObject::invokeMethod(this,"addRole",
                                  Qt::BlockingQueuedConnection,
                                   Q_RETURN_ARG(bool, status),
                                  Q_ARG(int,roleNumber));
    }

    ZBL_SLOT_END_RETURN(status,  false,
    Z_FAC_JS, ZTableModel::addRole, addRole failed)
}

bool ZTableModel::addRole(int roleNumber, const QString& roleName)
{
    bool status;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        status = m_model.addRole(roleNumber, roleName.toUtf8());
    }
    else
    {
        QMetaObject::invokeMethod(this,"addRole",
                                  Qt::BlockingQueuedConnection,
                                   Q_RETURN_ARG(bool, status),
                                  Q_ARG(int, roleNumber),
                                  Q_ARG(const QString&, roleName));
    }

    ZBL_SLOT_END_RETURN(status,  false,
    Z_FAC_JS, ZTableModel::addRole, addRole failed)
}

int ZTableModel::getRoleCount() const
{
    int count = 0;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        count = m_model.roleCount();
    }
    else
    {
        QMetaObject::invokeMethod(const_cast<ZTableModel*>(this),"getRoleCount",
                                  Qt::BlockingQueuedConnection,
                                   Q_RETURN_ARG(int, count));
    }

    ZBL_SLOT_END_RETURN(count,  0,
    Z_FAC_JS, ZTableModel::getRoleCount, getRoleCount failed)
}

QList<int> ZTableModel::roles() const
{
    QList<int> roleList;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        roleList = m_model.roles();
    }
    else
    {
        QMetaObject::invokeMethod(const_cast<ZTableModel*>(this),"roles",
                                  Qt::BlockingQueuedConnection,
                                   Q_RETURN_ARG(QList<int>, roleList));
    }

    ZBL_SLOT_END_RETURN(roleList,  QList<int>(),
    Z_FAC_JS, ZTableModel::roles, roles failed)
}

QVariantMap ZTableModel::roleMap() const
{
    QVariantMap map;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        QHash<int, QByteArray> hash = roleNames();

        QList<int> keys = hash.keys();

        const int keyCount = keys.size();

        for(int i=0; i<keyCount; i++)
        {
            const int nextRole = keys.at(i);

            map.insert(QString::fromUtf8(hash.value(nextRole)), QVariant(nextRole));
        }

    }
    else
    {
        QMetaObject::invokeMethod(const_cast<ZTableModel*>(this),"roleMap",
                                  Qt::BlockingQueuedConnection,
                                   Q_RETURN_ARG(QVariantMap, map));
    }

    ZBL_SLOT_END_RETURN(map,  QVariantMap(),
    Z_FAC_JS, ZTableModel::roleMap, roleMap failed)

}




QVariant ZTableModel::getValue(int role, int row)
{
    QVariant value;

    //if(role < 0 || row < 0)
    //    return value;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        value = m_model.data(role, row, 0);
    }
    else
    {
        QMetaObject::invokeMethod(const_cast<ZTableModel*>(this),"getValue",
                                  Qt::BlockingQueuedConnection,
                                  Q_RETURN_ARG(QVariant, value),
                                  Q_ARG(int,role),
                                  Q_ARG(int,row));
    }

    ZBL_SLOT_END_RETURN(value,  false,
    Z_FAC_JS, ZTableModel::getValue, getValue failed)
}

QVariant ZTableModel::getValue(int role, int row, int column)
{
    QVariant value;

    //if(role < 0 || row < 0)
    //    return value;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        value = m_model.data(role, row, column);
    }
    else
    {
        QMetaObject::invokeMethod(const_cast<ZTableModel*>(this),"getValue",
                                  Qt::BlockingQueuedConnection,
                                  Q_RETURN_ARG(QVariant, value),
                                  Q_ARG(int,role),
                                  Q_ARG(int,row),
                                  Q_ARG(int,column));
    }

    ZBL_SLOT_END_RETURN(value,  false,
    Z_FAC_JS, ZTableModel::getValue, getValue failed)
}

QVariant ZTableModel::getTableColumnRows(
        QList<int> roles,
        int startRow,
        int col,
        int rowCount)
{
    QVariant value;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        value = m_model.getTableColumnRows( roles, startRow, col, rowCount);
    }
    else
    {
        QMetaObject::invokeMethod(const_cast<ZTableModel*>(this),"getTableColumnRows",
                                  Qt::BlockingQueuedConnection,
                                  Q_RETURN_ARG(QVariant, value),
                                  Q_ARG(QList<int> ,roles),
                                  Q_ARG(int,startRow),
                                  Q_ARG(int,col),
                                  Q_ARG(int,rowCount));
    }

    ZBL_SLOT_END_RETURN(value,  QVariant(),
    Z_FAC_JS, ZTableModel::getTableColumnRows, getTableColumnRows failed)

}


void ZTableModel::putTableColumnRows(
        QVariant rows,
        int startRow,
        int col)
{
    ZBL_SLOT_BEGIN_TRY

    insertTableColumnRows(rows, startRow, col, false);

    ZBL_SLOT_END_VOID(Z_FAC_JS,
    ZTableModel::putTableColumnRows, putTableColumnRows failed)
}

void ZTableModel::sendTableColumnRows(
        QVariant rows,
        int startRow,
        int col)
{
    ZBL_SLOT_BEGIN_TRY

    insertTableColumnRows(rows, startRow, col, true);

    ZBL_SLOT_END_VOID(Z_FAC_JS,
    ZTableModel::sendTableColumnRows, sendTableColumnRows failed)
}

void ZTableModel::insertTableColumnRows(
        QVariant rows,
        int startRow,
        int col,
        bool asynchronous)
{
    if(!asynchronous && inObjectThread(this))
    {
        m_model.putTableColumnRows(rows, startRow, col);
    }
    else
    {
        Qt::ConnectionType connectType = asynchronous ? Qt::QueuedConnection : Qt::BlockingQueuedConnection;

        QMetaObject::invokeMethod(const_cast<ZTableModel*>(this),"putTableColumnRows",
                                  connectType,
                                  Q_ARG(QVariant, rows),
                                  Q_ARG(int, startRow),
                                  Q_ARG(int, col));
    }
}



int ZTableModel::findNextItemRow(
        int startRow,
        const QString& text,
        int column,
        bool caseSensitive,
        bool forwardDirection,
        bool keySearch) const
{
    int foundRow = -1;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        foundRow = m_model.findNextItemRow(
                    startRow, text, column, caseSensitive,
                    forwardDirection, keySearch );
    }
    else
    {
        QMetaObject::invokeMethod(const_cast<ZTableModel*>(this),"findNextItemRow",
                                  Qt::BlockingQueuedConnection,
                                  Q_RETURN_ARG(int, foundRow),
                                  Q_ARG(int, startRow),
                                  Q_ARG(const QString&,text),
                                  Q_ARG(int, column),
                                  Q_ARG(bool, caseSensitive),
                                  Q_ARG(bool, forwardDirection),
                                  Q_ARG(bool, keySearch));
    }

    ZBL_SLOT_END_RETURN(foundRow,  -1,
    Z_FAC_JS, ZTableModel::findNextItemRow, findNextItemRow failed)

}

void ZTableModel::putJsonData(QJsonObject data/*, bool putRoles*/)
{
    /* {"roles": {
    *     "col-0-role-number":"col-0-role-name",
    *     "col-1-role-number":"col-1-role-name",
    *     "col-2-role-number":"col-2-role-name"
    *     }
    *  "data-rows": [
    *    ["row-0-col-0-value","row-0-col-1-value","row-0-col-2-value"]
    *    ["row-1-col-0-value","row-1-col-1-value","row-1-col-2-value"]
    *   ]}
    */

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        QJsonValue roleValue = data.value("roles");

        if(roleValue.isUndefined())
            throw ZblException("JSON object is missing \"roles\" value.");

        if(!roleValue.isObject())
            throw ZblException("JSON object \"roles\" value should be an object of number/name pairs.");

        QJsonValue dataValue = data.value("data-rows");

        if(dataValue.isUndefined())
            throw ZblException("JSON object is missing \"data-rows\" value.");

        if(!dataValue.isArray())
            throw ZblException("JSON object \"data-rows\" value should be an array of row arrays.");


        QJsonObject jRoles;
        jRoles = roleValue.toObject();

        QJsonArray jData;
        jData = dataValue.toArray();

        QStringList roleKeys = jRoles.keys();
        const int roleCount = roleKeys.count();

        clearRoles();

        for(int i=0; i<roleCount; i++)
        {
            QString strNextRoleKey = roleKeys.at(i);
            int nextRoleKey = strNextRoleKey.toInt();

            QJsonValue nextRoleValue(jRoles.value(strNextRoleKey));

            m_model.addRole(nextRoleKey, nextRoleValue.toVariant().toByteArray());
        }

        const int rowCount = jData.count();

        for(int j=0; j<rowCount; j++)
        {
            QJsonValue nextRowValue = jData.at(j);

            if(!nextRowValue.isArray())
            {
                zWarning() << "WARNING: Invalid data: data rows array should "
                              "contain only arrays of data cells.";
            }

            QJsonArray jNextRow = nextRowValue.toArray();

            QVariantList nextRowList = jNextRow.toVariantList();

            ZRoleRow roleRow;

            for(int k=0; k<roleCount; k++)
            {
                QVariant nextDataValue = nextRowList.at(k);

                QString strNextRoleKey = roleKeys.at(k);

                int nextRoleKey = strNextRoleKey.toInt();

                //QString nextRoleValue = jRoles.at(nextRoleKey);

                QVariantList nextRowCell;
                nextRowCell.append(nextDataValue);

                roleRow.insert(nextRoleKey,nextRowCell);
            }

            appendRow(roleRow);
        }

    }
    else
    {
        QMetaObject::invokeMethod(this,"putJsonData",
                                  Qt::BlockingQueuedConnection,
                                  Q_ARG(QJsonObject, data));
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS,
                      ZTableModel::putJsonData, putJsonData failed)
}


QJsonObject ZTableModel::getJsonData() const
{
    /* {"roles": {
    *     "col-0-role-number":"col-0-role-name",
    *     "col-1-role-number":"col-1-role-name",
    *     "col-2-role-number":"col-2-role-name"
    *     }
    *  "data-rows": [
    *    ["row-0-col-0-value","row-0-col-1-value","row-0-col-2-value"]
    *    ["row-1-col-0-value","row-1-col-1-value","row-1-col-2-value"]
    *   ]}
    */

    ZBL_SLOT_BEGIN_TRY

    QJsonObject modelObject;

    if(inObjectThread(this))
    {
        QJsonObject jRoles;
        QHash<int, QByteArray> roles(roleNames());
        QHashIterator<int, QByteArray> it(roles);

        while(it.hasNext())
        {
            it.next();

            jRoles.insert(QString::number(it.key()),
                          QJsonValue(QString::fromLatin1(it.value())));
        }

        QJsonArray jData;
        const int rows = rowCount();
        //const int cols = columnCount();
        QStringList roleKeys = jRoles.keys();
        const int roleCount = roleKeys.count();

        for(int r=0; r<rows; r++)
        {
            QJsonArray rowData;

            for(int v=0; v<roleCount; v++)
            {
                QString roleKey = roleKeys.at(v);

                QJsonValue roleValue = jRoles.value(roleKey);

                QJsonValue::Type valueType = roleValue.type();

                QString strRoleValue = roleValue.toString();

                int nextRole = roleKey.toInt();

                rowData.append(QJsonValue::fromVariant(
                                   m_model.data(nextRole, r, 0)));
            }

            jData.append(rowData);
        }


        modelObject.insert("roles", QJsonValue(jRoles));
        modelObject.insert("data-rows", QJsonValue(jData));

    }
    else
    {
        QMetaObject::invokeMethod(const_cast<ZTableModel*>(this),"getJsonData",
                                  Qt::BlockingQueuedConnection,
                                  Q_RETURN_ARG(QJsonObject, modelObject));
    }

    ZBL_SLOT_END_RETURN(modelObject,  QJsonObject(),
    Z_FAC_JS, ZTableModel::getJsonData, getJsonData failed)

}

void ZTableModel::moveModelToThread(QThread* targetThread)
{
    ZBL_SLOT_BEGIN_TRY

    if(!targetThread)
            throw ZblException("Invalid argument: targetThread is NULL!");

    if(this->thread() != targetThread)
    {
        if(inObjectThread(this))
        {
            moveToThread(targetThread);
        }
        else
        {
            QMetaObject::invokeMethod(this,"moveModelToThread",
                                      Qt::BlockingQueuedConnection,
                                      Q_ARG(QThread*, targetThread));
        }

   }
    ZBL_SLOT_END_VOID(Z_FAC_JS,
                      ZTableModel::moveModelToThread, moveModelToThread failed)
}

void ZTableModel::invalidateModel()
{
    ZBL_SLOT_BEGIN_TRY



    if(inObjectThread(this))
    {
        beginResetModel();
        endResetModel();
    }
    else
    {
        QMetaObject::invokeMethod(this,"invalidateModel",
                                  Qt::BlockingQueuedConnection
                                  );
    }


    ZBL_SLOT_END_VOID(Z_FAC_JS,
                      ZTableModel::invalidateModel, invalidateModel failed)
}

} // Zbl