ZLogMap.cpp

Go to the documentation of this file.

#include "ZLogMap.h"
#include <QtQml>
#include "ZLogReader.h"

namespace Zbl
{

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZLogMap)

//qint64 ZLogMap::m_nextMarkID = 0;

//ZLogMap::ZLogMap(QObject* reader) : m_reader(NULL)

ZLogMap::ZLogMap(ZLogReader* reader) : QObject(NULL), m_reader(NULL)
{
    if(!reader)
    {
        zCritical() << "Programming error: reader parameter must be non-null!";

        return;
    }

    ZLogReader* rdr = qobject_cast<ZLogReader*>(reader);

    if(!rdr)
        zCritical() << "Programming error: reader parameter must be a pointer to a ZLogReader object!";
    else
        m_reader = rdr;

}

void ZLogMap::registerType()
{
    ZBL_REGISTER_LOGGED_OBJECT

    qmlRegisterUncreatableType<ZLogMap>
            ("org.zuble.qml", 1, 0, "ZLogMap",
             "Use ZLogViewport or ZLogReader to create ZLogMap objects.");
}

int ZLogMap::logMapType()
{
    return Selection;
}



ZLogReader* ZLogMap::getZReader() const
{
    return m_reader;
}

QObject* ZLogMap::getReader() const
{
    return m_reader;
}


#if 0
bool ZLogMap::createMapModel(ZTableModel* model)
{
    if(!model)
        return false;

    model->clearRoles();

    model->setColumnCount(1);

    model->addRole(FirstID, "rec_id");
    //model->addRole(LastID, "last_id");
    model->addRole(SeekPosition, "pos");
    //model->addRole(roleName, "name");
    //model->addRole(roleNote, "note");

    //appendModelRoles(model, roleFIRST_USER);

    return true;
}
#endif

#if 0
QObject* ZLogMap::getMarkModel()
{
    ZTableModel* model = new ZTableModel();

    createMapModel(model);

    QMap<qint64, MarkNode>::const_iterator it = m_map.begin();

    ZDataRow data;

    while(it != m_map.end())
    {
        // WARNING: the following data.append() calls are order dependent!

        data.append(it->m_recordID);
        //data.append(it->m_lastID);
        data.append(it->m_seekPos);

        // TBD: APPEND ROLES FOUND HERE?

        model->appendCells(data);
        it++;
    }

    return model;
    return NULL;

}
#endif

#if 0
bool ZLogMap::initializeFromModel(QObject* mapModel)
{

    ZTableModel* zModel = qobject_cast<ZTableModel*>(mapModel);

    if(!zModel)
    {
        zWarning() << "Programming error: You must pass a ZTableModel "
                      "object to this method.";
        return false;
    }

    // TBD: validate that model contains necessary roles!!!!

    // delete map and copy model data to map

    m_map.clear();

    const int rowCount = zModel->modelRowCount();

    for(int row=0; row < rowCount; row++)
    {
        const qint64 firstID = zModel->getValue(FirstID, row).toInt();
        //const qint64 lastID = zModel->getValue(LastID, row).toInt();
        const qint64 seekPos = zModel->getValue(SeekPosition, row).toInt();

        m_map.insert(firstID, MarkNode(firstID, lastID, seekPos));
    }

    return false;
}
#endif


void ZLogMap::insertMark(qint64 recordID,
                           qint64 lastRecordID,
                           qint64 seekPosition)
{
    zDebug() << "Insert mark, recordID: " << recordID
             << ", lastRecordID: " << lastRecordID
             << ", seekPosition: " << seekPosition;

    if(m_map.insertMark(recordID, lastRecordID, seekPosition))
        emit selectionUpdated();

}

void ZLogMap::clear()
{
    if(m_map.clear())
        emit selectionUpdated();
}

bool ZLogMap::hasMark(qint64 recordID)
{
    return m_map.hasMark(recordID);
}

bool ZLogMap::removeMark(qint64 recordID, qint64 lastRecordID)
{
    zDebug() << "Remove mark, recordID: " << recordID
             << ", lastRecordID: " << lastRecordID;

    bool retval = m_map.removeMark(recordID, lastRecordID);

    if(retval)
       emit selectionUpdated();

    return retval;
}

ZLogMap::MarkType ZLogMap::getMapType()
{
    return MarkType(logMapType());
}

qint64 ZLogMap::findNextMark(qint64 startID, bool forward) const
{
    return m_map.findNextMark(startID, forward);
}


} // Zbl