ZLogViewport.h

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2015 Bob Dinitto
 *
 * Filename:   ZLogViewport.h
 * 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
 *
 */

#ifndef ZLOGVIEWPORT_H
#define ZLOGVIEWPORT_H

#include <QObject>
#include <QVariant>
#include <QPointer>
#include "ZblLogMark.h"
#include "ZLogMap.h"
#include "ZblLogSearch.h"
#include "zglobal.h"
#include "ZLogReclinkModel.h"
#include "ZblLogSearchParams.h"

namespace Zbl {

class ZTableModel;
class ZblLogReader;
class ZLogReader;
class ZblLogSearchParams;

class ZLogViewport : public QObject
{
    friend class ZLogReader;
    friend class ZblLogReader;

    typedef QPointer<ZblLogReader> zblLogReaderPtr;
    //typedef QPointer<ZblLogBkSearch> zblLogSearcherPtr;

    Q_OBJECT
private:
    Q_DISABLE_COPY(ZLogViewport)

public:

    explicit ZLogViewport(
            ZblLogReader* reader,
            qint64 recordCount,
            QObject* parent = 0,
            bool background = false);

    Q_PROPERTY(qint64 currentLocation READ getCurrentLocation)

    
    Q_PROPERTY(int currentID READ getCurrentID)

    Q_PROPERTY(int activeLocation READ getActiveID)

    Q_PROPERTY(int activeID READ getActiveID)





    Q_PROPERTY(int seekIndexRole READ getSeekIndexRole)

    Q_PROPERTY(int byteCountRole READ getByteCountRole)

    Q_PROPERTY(int bookmarksRole READ getBookmarksRole)


    Q_PROPERTY(int assumeRecordSize READ getRecordSize WRITE putRecordSize)

    Q_PROPERTY(bool locked READ getLock)


    Q_PROPERTY(bool searchDirectionForward READ getSearchDirForward CONSTANT)

    Q_PROPERTY(bool searchDirectionBackward READ getSearchDirBackward CONSTANT)

    Q_PROPERTY(bool searchDirectionBoth READ getSearchDirBoth CONSTANT)


    static void registerType();


    Q_INVOKABLE void loadRecords(
            qint64 seekPosition,
            qint64 recordCount);

    Q_INVOKABLE void move(
            qint64 recordCount,
            bool forward);



    ZTableModel* getZModel();

    ZLogReader* getZReader();


    zblLogSearchPtr getZSearch();


    qint64 getMaxRecordCount();

    // role constants for accessing the model

    static int getSeekIndexRole();

    static int getByteCountRole();


    static int getBookmarksRole();

    int getRecordSize();

    void putRecordSize(int size);

    bool getLock();

    int getSearchDirForward();
    int getSearchDirBackward();
    int getSearchDirBoth();

    qint64 getCurrentLocation();
    int getCurrentID();
    qint64 getActiveLocation();
    int getActiveID();
    qint64 getNextPageLocation();




#if 0

    // mark type constants

    int getSelectionType();

    int getSearchType();

    int getBookmarkType();

    int getInvalidType();

    int getAllType();
#endif




    ZLogViewport *getListener() const;

    void setListener(ZLogViewport *listener);

signals:

    void loadComplete(bool endOfData, QString errorMsg, QVariantMap context);

    void moveComplete(qint64 rowsFound,
                      qint64 rowsStored,
                      bool endOfData,
                      QString errorMsg);


    void findComplete(
            qint64 recordID,
            qint64 seekPos,
            QList<int>columns);

    void searchComplete();


    void markupUpdated();



    void rowMatched(
            qint64 modelRow,
            QList<int> modelRoles,
            QList<QString> markupText);



public slots:

    QObject* getModel();

    QObject* getSelection();

    QObject* getCurrentSearch();

    bool setCurrentSearch(QObject* search);


    QObject* getReader();

    qint64 getRecordSeekPos(qint64 recordID);

    qint64 getRecordModelRow(qint64 recordID);

    QObject* getCurrentSearchlinks();

    QObject* getCurrentBookmarklinks();

    bool markupText();


    bool markupText(
            QList<int> roles,
            QString searchPhrase,
            int type);

    void setLock(bool locked);

    void onRowMatched(
            qint64 modelRow,
            QList<int> modelRoles,
            QList<QString> markupText);

    void onMarkupCompleted(ZLogViewport* viewport, ZblLogSearchList rowsFound);



protected:

    ZBL_DECLARE_LOGGED_OBJECT

#if 0

    QVariant getCurrentSearchParams();

#endif

    ZblLogSearchParams getSearchParameters();


    void onUpdateBookmarks();

    virtual void timerEvent(QTimerEvent * event);


    void onSearchDeleteRequested(QObject* searchObject);




    ZTableModel* m_model;

    zblLogReaderPtr m_reader;  // TBD: why QPointer?


    //ZblLogMark m_rootMark; // TBD: need this?

    qint64 m_optimalCount;

    qint64 m_assumeRecordSize;

    static const qint64 m_minimumRecordSize;

    static const qint64 m_maximumRecordSize;

    int m_timerID;

    static int m_roleSeekIndex;

     static int m_roleByteCount;

     static int m_roleBookmarks;

    ZLogMap*  m_selectionMap;

    zblLogSearchPtr  m_currentSearch;

    bool m_motionLock;

    ZLogViewport* m_listener;


    ZblLogMark m_logMark;


    ZblLogSearchList m_searchLinks;

};

} // Zbl

#endif // ZLOGVIEWPORT_H