ArnQml.hpp

Go to the documentation of this file.

// Copyright (C) 2010-2022 Michael Wiklund.
// All rights reserved.
// Contact: arnlib@wiklunden.se
//
// This file is part of the ArnLib - Active Registry Network.
// Parts of ArnLib depend on Qt and/or other libraries that have their own
// licenses. Usage of these other libraries is subject to their respective
// license agreements.
//
// GNU Lesser General Public License Usage
// This file may be used under the terms of the GNU Lesser General Public
// License version 2.1 as published by the Free Software Foundation and
// appearing in the file LICENSE_LGPL.txt included in the packaging of this
// file. In addition, as a special exception, you may use the rights described
// in the Nokia Qt LGPL Exception version 1.1, included in the file
// LGPL_EXCEPTION.txt in this package.
//
// GNU General Public License Usage
// Alternatively, this file may be used under the terms of the GNU General Public
// License version 3.0 as published by the Free Software Foundation and appearing
// in the file LICENSE_GPL.txt included in the packaging of this file.
//
// Other Usage
// Alternatively, this file may be used in accordance with the terms and conditions
// contained in a signed written agreement between you and Michael Wiklund.
//
// This program 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.
//

#ifndef ARNQML_HPP
#define ARNQML_HPP

#include "ArnLib_global.hpp"
#include "ArnInterface.hpp"
#include "ArnItem.hpp"
#include "ArnMonitor.hpp"
#include "ArnRpc.hpp"
#include "XStringMap.hpp"
#include <QNetworkReply>
#include <QNetworkAccessManager>
#include <QVariantMap>

#if QT_VERSION >= 0x050000
#  include <QtQml>
#  include <QQmlParserStatus>
#  include <QQmlNetworkAccessManagerFactory>
#  include <QQmlEngine>
#  define QML_QUICK_TYPE        2
#  define QML_ENGINE            QQmlEngine
#  define QML_PARSER_STATUS     QQmlParserStatus
#  define QML_NETACC_FACTORY    QQmlNetworkAccessManagerFactory
#  define QML_LIST_PROPERTY     QQmlListProperty
#else
#  include <QtDeclarative>
#  include <QDeclarativeParserStatus>
#  include <QDeclarativeNetworkAccessManagerFactory>
#  include <QDeclarativeEngine>
#  define QML_Qt4
#  define QML_QUICK_TYPE        1
#  define QML_ENGINE            QDeclarativeEngine
#  define QML_PARSER_STATUS     QDeclarativeParserStatus
#  define QML_NETACC_FACTORY    QDeclarativeNetworkAccessManagerFactory
#  define QML_LIST_PROPERTY     QDeclarativeListProperty
#endif

class QJSEngine;
class ArnNetworkAccessManagerFactory;



class ARNLIBSHARED_EXPORT ArnQml : public QObject
{
    Q_OBJECT
public:
    struct UseFlags {
        enum E {
            ArnLib  = 0x01,
            MSystem = 0x02,
            MQt     = 0x04,
            All     = 0xff
        };
        MQ_DECLARE_FLAGS( UseFlags)
    };


    static void  setup( QML_ENGINE* qmlEngine, UseFlags flags = UseFlags::ArnLib);

    static ArnQml&  instance();


    static QString  arnRootPath();


    static void  setArnRootPath( const QString& path);

    static QObject *constructorArnInterface( QML_ENGINE* engine, QJSEngine* scriptEngine);

private:
    ArnQml();
    ArnQml( const ArnQml&);
    ~ArnQml();
    ArnQml&  operator=( const ArnQml&);

    QString  _arnRootPath;
    ArnNetworkAccessManagerFactory*  _arnNetworkAccessManagerFactory;
    UseFlags  _regedUse;
};

MQ_DECLARE_OPERATORS_FOR_FLAGS( ArnQml::UseFlags)



class  ArnItemQml : public ArnItem, public QML_PARSER_STATUS
{
    Q_OBJECT

#ifdef QML_Qt4
    Q_INTERFACES( QDeclarativeParserStatus)
#else
    Q_INTERFACES( QQmlParserStatus)
#endif

    Q_PROPERTY( QString variantType  READ variantType        WRITE setVariantType      NOTIFY variantTypeChanged)
    Q_PROPERTY( bool useUuid         READ useUuid            WRITE setUseUuid          NOTIFY dummyNotifier)
    Q_PROPERTY( QString path         READ path               WRITE setPath             NOTIFY pathChanged)
    Q_PROPERTY( ArnInterface::DataType  type
                                     READ type                                         NOTIFY valueChanged)
    Q_PROPERTY( QVariant variant     READ toVariant          WRITE setVariant          NOTIFY valueChanged)
    Q_PROPERTY( QString string       READ toString           WRITE setValue            NOTIFY valueChanged)
    Q_PROPERTY( QByteArray bytes     READ toByteArray        WRITE setValue            NOTIFY valueChanged)
#ifdef ARNREAL_FLOAT
    Q_PROPERTY( float num            READ toReal             WRITE setValue            NOTIFY valueChanged)
#else
    Q_PROPERTY( double num           READ toReal             WRITE setValue            NOTIFY valueChanged)
#endif
    Q_PROPERTY( int intNum           READ toInt              WRITE setValue            NOTIFY valueChanged)
    Q_PROPERTY( bool biDirMode       READ isBiDirMode        WRITE setBiDirMode        NOTIFY dummyNotifier)
    Q_PROPERTY( bool pipeMode        READ isPipeMode         WRITE setPipeMode         NOTIFY dummyNotifier)
    Q_PROPERTY( bool saveMode        READ isSaveMode         WRITE setSaveMode         NOTIFY dummyNotifier)
    Q_PROPERTY( bool masterMode      READ isMaster           WRITE setMaster           NOTIFY dummyNotifier)
    Q_PROPERTY( bool autoDestroyMode READ isAutoDestroy      WRITE setAutoDestroy      NOTIFY dummyNotifier)
    Q_PROPERTY( bool atomicOpProvider
                                     READ isAtomicOpProvider WRITE setAtomicOpProvider NOTIFY dummyNotifier)
    Q_PROPERTY( bool ignoreSameValue READ isIgnoreSameValue  WRITE setIgnoreSameValue  NOTIFY dummyNotifier)
    Q_PROPERTY( int delay            READ delay              WRITE setDelay            NOTIFY dummyNotifier)
    // Q_PROPERTY( bool smTemplate     READ isTemplate    WRITE setTemplate)

public slots:

    void  setBits( int mask, int value)
    {ArnItemB::setBits( mask, value);}


    void  addIntNum( int value)
    {ArnItemB::addValue( value);}


#ifdef ARNREAL_FLOAT
    void  addNum( float value)
#else
    void  addNum( double value)
#endif
    {ArnItemB::addValue( value);}


    void  addMode( ArnInterface::ObjectMode mode)
    {ArnItemB::addMode( Arn::ObjectMode::fromInt( mode));}

    ArnInterface::ObjectMode  getMode()  const
    {return ArnInterface::ObjectMode( ArnItemB::getMode().toInt());}

public:
    explicit ArnItemQml( QObject* parent = arnNullptr);

    QString  variantType()  const;
    void  setVariantType( const QString& typeName);

    QString  path()  const;

    ArnInterface::DataType  type()  const
    {return ArnInterface::DataType( ArnItem::type().toInt());}

    void  setPath( const QString& path);

    void  setVariant( const QVariant& value);

    void  setBiDirMode( bool isBiDirMode);
    void  setPipeMode( bool isPipeMode);
    void  setMaster( bool isMaster);
    void  setAutoDestroy( bool isAutoDestroy);
    void  setSaveMode( bool isSaveMode);
    void  setAtomicOpProvider( bool isAtomicOpPv);
    // bool  isTemplate() const;
    // void  setTemplate( bool isTemplate);

    bool  useUuid()  const;
    void  setUseUuid( bool useUuid);

    virtual void  classBegin();
    virtual void  componentComplete();

signals:
    void  valueChanged();
    void  pathChanged();
    void  variantTypeChanged();
    void  dummyNotifier();

protected:
    virtual void  itemUpdated( const ArnLinkHandle& handleData, const QByteArray* value = arnNullptr);
    virtual void  itemCreatedBelow( const QString& path);
    virtual void  itemModeChangedBelow( const QString& path, uint linkId, Arn::ObjectMode mode);
    virtual void  timerEvent( QTimerEvent* ev);

private:
    bool  _isCompleted;
    QString  _path;
    int  _variantType;
    bool  _useUuid;
};



class ArnMonitorQml : public ArnMonitor, public QML_PARSER_STATUS
{
    Q_OBJECT

#ifdef QML_Qt4
    Q_INTERFACES( QDeclarativeParserStatus)
#else
    Q_INTERFACES( QQmlParserStatus)
#endif

    Q_PROPERTY( QString clientId     READ clientId     WRITE setClientId     NOTIFY dummyNotifier)
    Q_PROPERTY( QString monitorPath  READ monitorPath  WRITE setMonitorPath  NOTIFY pathChanged)
public slots:

    void  reStart();

public:
    explicit ArnMonitorQml( QObject* parent = arnNullptr);

    void  setClientId( const QString& id);
    QString  clientId() const;
    void  setMonitorPath( const QString& path);
    QString  monitorPath() const;

    virtual void classBegin();
    virtual void componentComplete();

signals:
    void  pathChanged();
    void  dummyNotifier();

protected:
    virtual QString  outPathConvert( const QString& path);
    virtual QString  inPathConvert( const QString& path);

private:
    bool  _isCompleted;
    QString  _path;
    QString  _clientId;
};



class ArnSapiQml : public ArnRpc, public QML_PARSER_STATUS
{
    Q_OBJECT

#ifdef QML_Qt4
    Q_INTERFACES( QDeclarativeParserStatus)
#else
    Q_INTERFACES( QQmlParserStatus)
#endif

    Q_PROPERTY( QString pipePath    READ pipePath           WRITE setPipePath        NOTIFY pathChanged)
    Q_PROPERTY( Mode mode           READ mode               WRITE setMode            NOTIFY dummyNotifier)
    Q_PROPERTY( QObject* receiver   READ receiver           WRITE setReceiver        NOTIFY dummyNotifier)


    Q_PROPERTY( int heartBeatSend   READ getHeartBeatSend   WRITE setHeartBeatSend   NOTIFY dummyNotifier)


    Q_PROPERTY( int heartBeatCheck  READ getHeartBeatCheck  WRITE setHeartBeatCheck  NOTIFY dummyNotifier)
public:
    enum Mode {
        Provider       = ArnRpc::Mode::Provider,
        AutoDestroy    = ArnRpc::Mode::AutoDestroy,
        UuidPipe       = ArnRpc::Mode::UuidPipe,
        NoDefaultArgs  = ArnRpc::Mode::NoDefaultArgs,
        SendSequence   = ArnRpc::Mode::SendSequence,
        CheckSequence  = ArnRpc::Mode::CheckSequence,
        NamedArg       = ArnRpc::Mode::NamedArg,
        NamedTypedArg  = ArnRpc::Mode::NamedTypedArg,
        UseDefaultCall = ArnRpc::Mode::UseDefaultCall,
        UuidAutoDestroy = int(UuidPipe) | int(AutoDestroy)
    };
    Q_ENUMS( Mode)

public slots:
    bool  isHeartBeatOk()
    {return ArnRpc::isHeartBeatOk();}

public:
    explicit ArnSapiQml( QObject* parent = arnNullptr);

    void  setPipePath( const QString& path);
    QString  pipePath() const;

    Mode  mode()  const
    {return Mode( ArnRpc::mode().toInt());}
    void  setMode( Mode m)
    {ArnRpc::setMode( ArnRpc::Mode::fromInt(m));}

    virtual void classBegin();
    virtual void componentComplete();

signals:
    void  pathChanged();
    void  dummyNotifier();

private:
    bool  _isCompleted;
    QString  _path;
    QString  _sendPrefix;
    QString  _providerPrefix;
    QString  _requesterPrefix;
};


namespace Arn {

class  XStringMapQml : public QObject, public QML_PARSER_STATUS, public XStringMap
{
    Q_OBJECT

#ifdef QML_Qt4
    Q_INTERFACES( QDeclarativeParserStatus)
#else
    Q_INTERFACES( QQmlParserStatus)
#endif

    Q_PROPERTY( QString xstring      READ toXStringString    WRITE fromXString         NOTIFY dummyNotifier)
    Q_PROPERTY( int size             READ size                                         NOTIFY dummyNotifier)

    // XStringMap&  addNum( const QString& key, int val);
    // XStringMap&  addNum( const QString& key, uint val);
    // XStringMap&  addNum( const QString& key, double val, int precision = -1);
    // XStringMap&  operator+=( const XStringMap& other);
    // XStringMap&  operator+=( const QVariantMap& other);
    // QByteArray  info();

public slots:

    void  clear()
    {XStringMap::clear( true);}

    int  indexOf( const QString& key, int from = 0)  const
    {return XStringMap::indexOf( key, from);}

    int  indexOfValue( const QString& value, int from = 0)  const
    {return XStringMap::indexOfValue( value, from);}

    QObject*  add( const QString& key, const QString& val)
    {XStringMap::add( key, val); return this;}

    QObject*  add( QObject* other);

    QObject*  set( int i, const QString& val)
    {XStringMap::set( i, val); return this;}

    QObject*  set( const QString& key, const QString& val)
    {XStringMap::set( key, val); return this;}

    QString  key( int i, const QString& def = QString())  const
    {return XStringMap::keyString( i, def);}

    QString  key( const QString& value, const QString& def = QString())  const
    {return XStringMap::keyString( value, def);}

    QString  value( int i, const QString& def = QString())  const
    {return XStringMap::valueString( i, def);}

    QString  value( const QString& key, const QString& def = QString())  const
    {return XStringMap::valueString( key, def);}

    QObject*  remove( int index)
    {XStringMap::remove( index); return this;}

    QObject*  remove( const QString& key)
    {XStringMap::remove( key); return this;}

    QObject*  removeValue( const QString& val)
    {XStringMap::removeValue( val); return this;}

    void  setEmptyKeysToValue()
    {XStringMap::setEmptyKeysToValue();}

    QStringList  keys()  const
    {return XStringMap::keys();}

    QStringList  values()  const
    {return XStringMap::values();}

    MQVariantMap  toMap()  const
    {return XStringMap::toVariantMap( true);}

public:
    explicit XStringMapQml( QObject* parent = arnNullptr);

    virtual void  classBegin();
    virtual void  componentComplete();

signals:
    void  dummyNotifier();

protected:

private:
    bool  _isCompleted;
};


class QmlMSys : public QObject
{
    Q_OBJECT

public:
    Q_PROPERTY( int quickTypeRun  READ quickTypeRun)

public slots:
    QVariantMap  xstringToEnum( const QString& xstring);

public:
    explicit QmlMSys( QObject* parent = arnNullptr);

    int  quickTypeRun();
};
}


class ArnNetworkReply : public QNetworkReply
{
    Q_OBJECT
public:
    explicit ArnNetworkReply( QObject* parent = arnNullptr);

    void  setOperation( QNetworkAccessManager::Operation operation)
    { QNetworkReply::setOperation( operation);}

    void  setRequest( const QNetworkRequest& request)
    { QNetworkReply::setRequest( request);}

    void  setUrl( const QUrl& url)
    { QNetworkReply::setUrl( url);}

    bool  isFinished()  const;
    qint64  bytesAvailable()  const;
    bool  isSequential()  const;
    qint64  size()  const;

    void  setup( const QString& path);
    QByteArray  data()  const;
    void  setData( const QByteArray& data);

protected:
    virtual void  abort();
    virtual qint64  readData( char *data, qint64 maxlen);

private slots:
    void  postSetup();
    void  dataArived();

private:
    QString  _arnPath;
    QByteArray  _data;
    int  _readPos;
    bool  _isFinished;
    ArnItem  _arnItem;
};


class ArnNetworkAccessManager : public QNetworkAccessManager
{
    Q_OBJECT
public:
    explicit ArnNetworkAccessManager( QObject* parent = arnNullptr);

protected:
    virtual QNetworkReply*  createRequest( Operation op, const QNetworkRequest &request, QIODevice *outgoingData);

private slots:

private:
};


class ArnNetworkAccessManagerFactory : public QML_NETACC_FACTORY
{
public:
    virtual QNetworkAccessManager*  create( QObject *parent);
};

#endif // ARNQML_HPP