ZLogReclinkModel.cpp

Go to the documentation of this file.

#include "ZLogReclinkModel.h"
#include "ZLogMap.h"
#include "ZTableModel.h"
#include <QSortFilterProxyModel>
#include <QAbstractItemModel>

namespace Zbl {

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZLogReclinkModel)

bool ZLogReclinkModel::m_initialized = false;


ZLogReclinkModel::ZLogReclinkModel(QSharedPointer<ZblLogReclinkData> data, QObject *parent) :
    QAbstractListModel(parent)
{
    zDebug() << "Constructing ZLogReclinkModel object";

    registerLoggedObject();

    m_d = data;
}

ZLogReclinkModel::~ZLogReclinkModel()
{
    zDebug() << "Destroying ZLogReclinkModel object";

}


void ZLogReclinkModel::registerLoggedObject()
{
    if(!m_initialized)
    {
        ZBL_REGISTER_LOGGED_OBJECT
        ZBL_REGISTER_LOGGED_CATEGORY(ZblLogReclinkData::m_log)
        m_initialized = true;
    }
}


#if 0
ZTableModel* ZLogReclinkModel::zModel()
{
    return m_model;
}


void ZLogReclinkModel::insertLink(
        quint64 recordID,
        quint64 seekPosition,
        const QString& messageText)
{
    ZDataRow cellBuf;

    cellBuf.append(recordID);
    cellBuf.append(seekPosition);
    cellBuf.append(messageText);

    zDebug() << "inserting log record link: " << cellBuf;

    m_model->appendCells(cellBuf);
}


QObject* ZLogReclinkModel::model()
{
    return m_proxy;
}
#endif



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

    int count = -1;

    ZBL_SLOT_BEGIN_TRY

    count = m_d->zModel()->rowCount(QModelIndex());

    ZBL_SLOT_END_RETURN(count,  -1,
    Z_FAC_JS, ZLogReclinkModel::rowCount, rowCount failed)

    return 0;

}

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

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

#if 1

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

        ZBL_SLOT_BEGIN_TRY
        //ZBL_SLOT_END_RETURN(m_d->model()->data(index, role),  QVariant(),
        ZBL_SLOT_END_RETURN(m_d->zModel()->data(index, role),  QVariant(),
        Z_FAC_JS, ZLogReclinkModel::data, data failed)

#endif


    return QVariant();

}


QHash<int, QByteArray> ZLogReclinkModel::roleNames() const
{
    QHash<int, QByteArray> retval;

    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(m_d->zModel()->roleNames(),  retval,
    Z_FAC_JS, ZLogReclinkModel::roleNames, roleNames failed)

    return retval;
}

QVariant ZLogReclinkModel::getData(int index, int role)
{
     return m_d->getData(index, role);
}

#if 0
QVariant ZLogReclinkModel::getData(int index, const QString& roleName)
{
    return QVariant("no");

}
#endif

QVariantMap ZLogReclinkModel::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<ZLogReclinkModel*>(this),"roleMap",
                                  Qt::BlockingQueuedConnection,
                                   Q_RETURN_ARG(QVariantMap, map));
    }

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

}

QVariant ZLogReclinkModel::getValue(int role, int row)
{
    // TBD: index should be translated into proxy model index!!!!! or asynchronous random updates
    // will not be sorted
    QVariant value;

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

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        value = m_d->getData(row, role);
    }
    else
    {
        QMetaObject::invokeMethod(const_cast<ZLogReclinkModel*>(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, ZLogReclinkModel::getValue, getValue failed)
}

QVariant ZLogReclinkModel::getValue(int role, int row, int column)
{
    // TBD: index should be translated into proxy model index!!!!! or asynchronous random updates
    // will not be sorted

    QVariant value;

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

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        value = m_d->getData(row, role);
    }
    else
    {
        QMetaObject::invokeMethod(const_cast<ZLogReclinkModel*>(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, ZLogReclinkModel::getValue, getValue failed)
}

void ZLogReclinkModel::invalidateModel()
{
    ZBL_SLOT_BEGIN_TRY



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


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



} // Zbl