ZLogViewport.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2015 Bob Dinitto
 *
 * Filename:   ZLogViewport.cpp
 * Created on: 11/22/2015
 * 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 <QtQml>
#include "ZLogViewport.h"
#include "ZblLogReader.h"
#include "ZTableModel.h"
#include "ZblLogManager.h"
#include "ZLogReader.h"
#include "ZblLogBkSearch.h"

namespace Zbl {

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZLogViewport)

const qint64 ZLogViewport::m_minimumRecordSize = 1024;
const qint64 ZLogViewport::m_maximumRecordSize = 65536;

int ZLogViewport::m_roleSeekIndex = -1;
int ZLogViewport::m_roleByteCount = -1;
int ZLogViewport::m_roleBookmarks = -1;

ZLogViewport::ZLogViewport(
        ZblLogReader* reader,
        qint64 recordCount,
        QObject* parent,
        bool background) :
    QObject(parent),
    m_reader(reader),
    m_optimalCount(recordCount),
    m_assumeRecordSize(-1),
    m_currentSearch(0),
    m_motionLock(false),
    m_listener(0)
{
    // TBD: calling zLogMan to create the log buffer binds the log reader
    // application to reading only log files from it's own version of the log
    // file output format. should there be a versioning system?
    // what about supporting alternate file formats, such as binary or custom?

    m_model = zLogMan.createLogBufferModel(this);


    m_model->addRole(m_roleSeekIndex, "seekIndex");
    m_model->addRole(m_roleByteCount, "byteCount");
    m_model->addRole(m_roleBookmarks, "bookmarks");

    static bool zLogViewportInitialized = false;

    if(!zLogViewportInitialized)
    {
        ZBL_REGISTER_LOGGED_OBJECT
        zLogViewportInitialized = true;
    }

    if(!background)
    {
        // foreground viewport gets 2 columns and a selection map

        m_model->setColumnCount(2); // add column for rich text markup

        // listen for updates to master mark list

        ZLogReader* logReader = qobject_cast<ZLogReader*>(parent);

        if(logReader)
        {
            // TBD: should ZblViewport owner make connection instead of embedding knowledge
            // about the viewport container here?

            m_selectionMap = new ZLogMap(logReader);

            connect(logReader, &ZLogReader::bookmarksUpdated, this, &ZLogViewport::onUpdateBookmarks);
        }

        QList<int> roles;

        m_currentSearch = getZReader()->getZSearch("",0,roles);
    }
    else
    {
        // background viewport gets one column, no selection map

        m_model->setColumnCount(1);
    }

    m_listener = this;

    //connect(this, &ZLogViewport::rowMatched, this, &ZLogViewport::onRowMatched);
}

void ZLogViewport::registerType()
{
    qmlRegisterUncreatableType<ZLogViewport>
            ("org.zuble.qml", 1, 0,
             "ZLogViewport",
             "Use ZLogReader to create ZLogViewport objects.");

    qint64 nextRole = zLogMan.getLogBufferRoleCount();
    m_roleSeekIndex = nextRole++;
    m_roleByteCount = nextRole++;
    m_roleBookmarks = nextRole++;

}


void ZLogViewport::onUpdateBookmarks()
{
    zDebug() << "Viewport was notified of log marks updated.";

    // TBD: UPDATE VIEWPORT MODEL WITH BOOKMARK INFO!!!!!

    ZLogReader* reader = getZReader();

    const int modelRowCount = m_model->modelRowCount();

    for(int i=0; i < modelRowCount; i++)
    {

        qint64 recordID = m_model->getValue(ZblLogManager::LogFieldRecordNum, i).toLongLong();

        m_model->putValue(m_roleBookmarks, i, QVariant(reader->getBookmarkNames(recordID)));
    }
}


QObject* ZLogViewport::getModel()
{
    return m_model;
}

QObject* ZLogViewport::getSelection()
{
    return m_selectionMap;
}

QObject* ZLogViewport::getCurrentSearch()
{
    return new ZLogSearch(m_currentSearch, getZReader());
}

bool ZLogViewport::setCurrentSearch(QObject *search)
{
    ZLogSearch* zSearch = qobject_cast<ZLogSearch*>(search);

    if(!zSearch)
    {
        zWarning() << "Programming error: search parameter must be a ZLogSearch object.";
        return false;
    }

    if(!zSearch->getZSearch()->validateReader(getZReader()))
    {
        zWarning() << "Programming error: specified ZLogSearch object is not from this viewport's log file.";
        return false;
    }

#if 0

    if(m_currentSearch)
        QObject::disconnect(m_currentSearch->getSearcher(), &ZblLogBkSearch::markupUpdated, this, &ZLogViewport::onMarkupCompleted);
#endif

    m_currentSearch = zSearch->m_search;

    //connect(m_currentSearch->getSearcher(), &ZblLogBkSearch::markupUpdated, this, &ZLogViewport::onMarkupCompleted);

    //connect( m_currentSearch->getSearcher(), SIGNAL(markupUpdated(ZLogViewport*, ZblLogSearchList)),
             //SLOT(onMarkupCompleted(ZLogViewport*, ZblLogSearchList)));

    return true;
}


zblLogSearchPtr ZLogViewport::getZSearch()
{
    return m_currentSearch;
}


QObject* ZLogViewport::getCurrentSearchlinks()
{
    return NULL;

}

QObject* ZLogViewport::getCurrentBookmarklinks()
{
    return NULL;
}

#if 0
QVariant ZLogViewport::getCurrentSearchParams()
{
    QVariant searchParams;

    if(m_currentSearch)
        searchParams = ZblLogSearchParams::fromSearch(m_currentSearch.data());
    else
        searchParams = QVariant::fromValue<ZblLogSearchParams>(ZblLogSearchParams());

    return searchParams;
}
#endif

ZblLogSearchParams ZLogViewport::getSearchParameters()
{
    if(m_currentSearch)
        return m_currentSearch->getSearchParameters();
    else
        return ZblLogSearchParams();
}

bool ZLogViewport::getLock()
{
    return m_motionLock;
}

void ZLogViewport::setLock(bool locked)
{
    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        m_motionLock = locked;
    }
    else
    {
        QMetaObject::invokeMethod(this, "setLock",
                                  Qt::BlockingQueuedConnection,
                                  Q_ARG(bool,locked));
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, getValue, getValue failed)
}


ZTableModel* ZLogViewport::getZModel()
{
    return m_model;
}

int ZLogViewport::getSeekIndexRole()
{
    return m_roleSeekIndex;
}

int ZLogViewport::getByteCountRole()
{
    return m_roleByteCount;

}
int ZLogViewport::getBookmarksRole()
{
    return m_roleBookmarks;
}

int ZLogViewport::getRecordSize()
{
    return m_assumeRecordSize;
}

void ZLogViewport::putRecordSize(int size)
{
    if(size < 1024)
        size = 1024;
    else if(size > 1024 * 64)
        size = 1024 * 64;

    m_assumeRecordSize = size;
}


QObject* ZLogViewport::getReader()
{
    return getZReader();
}

ZLogReader* ZLogViewport::getZReader()
{
    ZLogReader* reader = qobject_cast<ZLogReader*>(parent());

    if(!reader)
    {
        //zWarning() << "Programming error: ZLogViewport parent is not "
        //              "of class ZLogReader.";
        return NULL;
    }

    return reader;
}

qint64 ZLogViewport::getRecordSeekPos(qint64 recordID)
{
    const int rowCount = m_model->modelRowCount();

    for(qint64 i=0; i < rowCount; i++)
    {
        int nextID = m_model->getValue(ZblLogManager::LogFieldRecordNum, i).toInt();

        if(nextID == recordID)
        {
            qint64 nextPos = m_model->getValue(m_roleSeekIndex, i).toInt();
            return nextPos;
        }

    }
    return -1;
}

qint64 ZLogViewport::getRecordModelRow(qint64 recordID)
{
    const int rowCount = m_model->modelRowCount();

    const int firstID = m_model->getValue(ZblLogManager::LogFieldRecordNum, 0).toInt();
    const int lastID = m_model->getValue(ZblLogManager::LogFieldRecordNum, rowCount-1).toInt();

    if(recordID < firstID || recordID > lastID)
        return -1;

    for(qint64 i=0; i < rowCount; i++)
    {
        int nextID = m_model->getValue(ZblLogManager::LogFieldRecordNum, i).toInt();

        if(nextID == recordID)
            return i;
    }

    return -1;
}



#if 0

int ZLogViewport::getSelectionType()
{
    return ZLogMap::Selection;
}

int ZLogViewport::getSearchType()
{
    return ZLogMap::Search;
}

int ZLogViewport::getBookmarkType()
{
    return ZLogMap::Bookmark;
}

int ZLogViewport::getInvalidType()
{
    return ZLogMap::Invalid;
}

int ZLogViewport::getAllType()
{
    return ZLogMap::Selection | ZLogMap::Search | ZLogMap::Bookmark;
}
#endif

#if 0
qint64 ZLogViewport::insertMark(qint64 recordID,
                  qint64 seekPosition,
                  int markType,
                  QVariant name ,
                  QVariant note)
{
    return m_selectionMap->insertMark(recordID, -1, seekPosition);
}
QList<QObject*> ZLogViewport::getMarks(qint64 recordID, int markTypes)
{
    QList<QObject*> marks;

    const int count = m_mapList.count();

    for(int i=0; i<count; i++)
    {
        ZLogMap* nextMap = m_mapList.at(i);

        if((nextMap->getMarkType() | markTypes) && nextMap->hasMark(recordID))
            marks.append(nextMap);
    }

    return marks;
}

int ZLogViewport::getMarkTypes(qint64 recordID)
{

    ZLogMap::MarkTypes markTypes = ZLogMap::Invalid;

    const int count = m_mapList.count();

    for(int i=0; i<count; i++)
    {
        ZLogMap* nextMap = m_mapList.at(i);

        ZLogMap::MarkType nextType = nextMap->getMarkType();

        if(nextType && markTypes)
            continue;

        if(nextMap->hasMark(recordID))
            markTypes |= nextType;

        if(markTypes == (ZLogMap::Selection | ZLogMap::Searchmap | ZLogMap::Bookmark))
            break;
    }

    return markTypes;

}
#endif


void ZLogViewport::timerEvent(QTimerEvent * event)
{
    killTimer(m_timerID);

    m_model->truncate(m_optimalCount, true);

    m_timerID = startTimer(2000);
}

ZLogViewport *ZLogViewport::getListener() const
{
    return m_listener;
}

void ZLogViewport::setListener(ZLogViewport *listener)
{
    // TBD: still need listener?
    m_listener = listener;
}

qint64 ZLogViewport::getMaxRecordCount()
{
    return m_optimalCount;
}


void ZLogViewport::loadRecords(
        qint64 seekPosition,
        qint64 recordCount)

{
    ZBL_SLOT_BEGIN_TRY

    if(m_motionLock)
        throw ZblException("ZLogViewport::loadRecordByIndex - can't load "
                       "viewport while background operation in progress.");

    QVariantMap empty;

    const bool markupColumn = m_model->modelColumnCount() > 1;

    ZblLogSearchParams searchParams = getSearchParameters();

    QMetaObject::invokeMethod(m_reader, "loadViewport",
                              Qt::QueuedConnection,
                              Q_ARG(QObject*, this),
                              Q_ARG(qint64, seekPosition), // record index
                              Q_ARG(qint64, recordCount), // viewport size
                              Q_ARG(ZblLogSearchParams, searchParams),
                              Q_ARG(bool, markupColumn),
                              Q_ARG(QVariantMap, empty));

    ZBL_SLOT_END_VOID(Z_FAC_JS, loadRecords, loadRecords failed)
}

void ZLogViewport::move(
        qint64 recordCount,
        bool forward)
{
    ZBL_SLOT_BEGIN_TRY

    if(m_motionLock)
        throw ZblException("ZLogViewport::loadRecordByIndex - can't load "
                       "viewport while background operation in progress.");

    qint64 seekIndex;

    const int rowCount = m_model->rowCount();

    if(!rowCount)
    {
        zWarning() << "Can't move zero length viewport.";
        return;
    }
    else if(forward)
    {
        seekIndex = getNextPageLocation();
    }
    else
    {
        seekIndex = getCurrentLocation();
    }

    ZblLogSearchParams searchParams = getSearchParameters();

    const bool loadMarkupColumn = m_model->modelColumnCount() > 1;

    zDebug() << "Moving viewport, forward = " << forward
             << ", recordCount = " << recordCount
             << ", seekIndex = " << seekIndex;

    QMetaObject::invokeMethod(m_reader, "move",
                              Qt::QueuedConnection,
                              Q_ARG(QObject*, this),
                              Q_ARG(qint64, recordCount),
                              Q_ARG(qint64, seekIndex),
                              Q_ARG(bool, forward),
                              Q_ARG(ZblLogSearchParams, searchParams),
                              Q_ARG(bool, loadMarkupColumn));

    ZBL_SLOT_END_VOID(Z_FAC_JS, move, move failed)

}

bool ZLogViewport::markupText()
{
    zDebug() << "ZLogViewport::markupText";

    if(m_currentSearch.isNull())
        return false;


    if(m_motionLock)
    {
        zDebug() << "Programming error - Can't search while background "
                    "operation is in progress.";

        return false;
    }

    setLock(true);

    //TBD: don't search if a search is already in progress
    //      validate roles exist in viewport model
    // validate type
    // validate phrase

    ZblLogSearchParams searchParams(getSearchParameters());

    connect(m_currentSearch->getSearcher(), &ZblLogBkSearch::markupUpdated,
            this, &ZLogViewport::onMarkupCompleted);

    QMetaObject::invokeMethod(m_currentSearch->getSearcher(), "markupViewport",
                              Qt::QueuedConnection,
                              Q_ARG(QObject*, this),
                              Q_ARG(ZblLogSearchParams, searchParams));

    zDebug() << "ZLogViewport::markupText returning";

    return true;
}


bool ZLogViewport::markupText(
        QList<int> roles,
        QString searchPhrase,
        int type)
{
    zDebug() << "ZLogViewport::markupText roles="
             << roles << "; phrase="
             << searchPhrase << "; type=" << type;

    if(m_currentSearch.isNull())
        return false;


    if(m_motionLock)
    {
        zDebug() << "Programming error - Can't search while background "
                    "operation is in progress.";

        return false;
    }

    setLock(true);

    //TBD: don't search if a search is already in progress
    //      validate roles exist in viewport model
    // validate type
    // validate phrase

    //QObject* funky = NULL;

    //ZblLogSearchParams searchParams(getSearchParameters());

    //QObject* searcher = m_currentSearch->getSearcher();

    connect(m_currentSearch->getSearcher(), &ZblLogBkSearch::markupUpdated,
            this, &ZLogViewport::onMarkupCompleted);

    ZblLogSearchParams searchParams(
                ZblLogSearch::SearchDirectionForward, 0, roles, searchPhrase, type);

    QMetaObject::invokeMethod(m_currentSearch->getSearcher(), "markupViewport",
                              Qt::QueuedConnection,
                              Q_ARG(QObject*, this),
                              Q_ARG(ZblLogSearchParams, searchParams));

    zDebug() << "ZLogViewport::markupText returning";

    return true;
}

void ZLogViewport::onMarkupCompleted(ZLogViewport* viewport, ZblLogSearchList rowsFound)
{
    zDebug() << "ZLogViewport::onMarkupCompleted";

    if(viewport != this)
    {
        zDebug() << "Not mine! viewport=" << viewport << "; this=" << this;

        return;
    }

    m_searchLinks = rowsFound;

    m_model->invalidateModel();

    setLock(false);

    emit markupUpdated();
}



void ZLogViewport::onRowMatched(
        qint64 modelRow,
        QList<int> modelRoles,
        QList<QString> markupText)
{

    if(!m_currentSearch)
        return;

    zDebug() << "Search row matched - row =" << modelRow << ", modelRoles ="
             << modelRoles << ", markupText =" << markupText;

    const int nextRecordID = m_model->getValue(ZblLogManager::LogFieldRecordNum, modelRow).toInt();
    const int nextSeekPos = m_model->getValue(m_roleSeekIndex, modelRow).toInt();

    m_currentSearch->insertMark(nextRecordID, nextRecordID, nextSeekPos);

    //  TBD: update reclinkmodel here!!!

    //m_reclinks.insertLink(nextRecordID, nextSeekPos, "hello world" );


    for(int i=0; i < modelRoles.size(); i++)
    {
        int nextRole = modelRoles.at(i);

        m_currentSearch->addRoleFound(nextRole);

        m_model->putValue(nextRole, modelRow, 1, markupText.at(i));
    }

}

void ZLogViewport::onSearchDeleteRequested(QObject* searchObject)
{
#if 0
    ZLogSearch* search = qobject_cast<ZLogSearch*>(searchObject);

    if(!search)
        zWarning() << "Invalid object passed to method. Object should be of "
                      "class Zbl::ZLogSearch";

    if(m_currentSearch == search)
    {
        zDebug() << "Releasing current search: " << search;

        QList<int> roles;
        m_currentSearch = getZReader()->getSearch("",0,roles);
    }
#endif
}


int ZLogViewport::getSearchDirForward()
{
    return ZblLogSearch::SearchDirectionForward;
}

int ZLogViewport::getSearchDirBackward()
{
    return ZblLogSearch::SearchDirectionBackward;
}

int ZLogViewport::getSearchDirBoth()
{
    return ZblLogSearch::SearchDirectionBoth;
}

qint64 ZLogViewport::getCurrentLocation()
{
    return m_model->getValue(m_roleSeekIndex, 0).toLongLong();
}

int ZLogViewport::getCurrentID()
{
    return -1;
}

qint64 ZLogViewport::getActiveLocation()
{
    return -1;
}

int ZLogViewport::getActiveID()
{
    return -1;
}

qint64 ZLogViewport::getNextPageLocation()
{
    const qint64 rowCount = m_model->rowCount();

    if(!rowCount)
    {
        zWarning() << "Zero length viewport.";
        return 0;
    }

    const qint64 lastRow = rowCount - 1;
    qint64 seekIndex = m_model->getValue(m_roleSeekIndex, lastRow).toInt();
    seekIndex += m_model->getValue(m_roleByteCount, lastRow).toInt();
    return seekIndex;

}





} // Zbl