ZblApp.h

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2013, 2014  Bob Dinitto
 *
 * ZblApp.h
 *
 *  Created on: Feb 3, 2013
 *      Author: Bob Dinitto   bob@ninzo.com
 *
 * 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 ZBLAPP_H
#define ZBLAPP_H

#include "zblcore_global.h"
#include "zglobal.h"
#include "ZblPlugin.h"
#include <QObject>
#include <QQmlEngine>
#include <QJSEngine>
//#include <QFileDialog>
//#include <QMessageBox>
#include <QReadWriteLock>
#include <QThreadStorage>

namespace Zbl
{

// map of background script objects
class ZScriptThread;
typedef QMap<QString, ZScriptThread*> ZScriptMap;

class ZBLCORESHARED_EXPORT ZblApp : public QObject
{
    Q_OBJECT
    Q_ENUMS(QStandardButton)

    
    class TimerMethodCall
    {
    public:
        TimerMethodCall(){}
        TimerMethodCall(const QJSValue& func, const QJSValue& arg)
            : timerFunc(func), timerArg(arg){}
        TimerMethodCall(const TimerMethodCall& source)
        {timerFunc = source.timerFunc;timerArg = source.timerArg;}

        QJSValue timerFunc;
        QJSValue timerArg;

    };

    typedef QHash<int, TimerMethodCall> timerHash;
    typedef QList<int> timerKeys;

    class AppPtr
    {
    public:
        AppPtr(ZblApp* app){m_app = app;}

        ZblApp* m_app;
    };

public:

#if 0

    // This enum allows Zuble applications to display some Qt dialog boxes.

    enum QStandardButton {
        // keep this in sync with QDialogButtonBox::StandardButton and QMessageDialogOptions::StandardButton
        BtnNoButton           = QMessageBox::NoButton,
        BtnOk                 = QMessageBox::Ok,
        BtnSave               = QMessageBox::Save,
        BtnSaveAll            = QMessageBox::SaveAll,
        BtnOpen               = QMessageBox::Open,
        BtnYes                = QMessageBox::Yes,
        BtnYesToAll           = QMessageBox::YesToAll,
        BtnNo                 = QMessageBox::No,
        BtnNoToAll            = QMessageBox::NoToAll,
        BtnAbort              = QMessageBox::Abort,
        BtnRetry              = QMessageBox::Retry,
        BtnIgnore             = QMessageBox::Ignore,
        BtnClose              = QMessageBox::Close,
        BtnCancel             = QMessageBox::Cancel,
        BtnDiscard            = QMessageBox::Discard,
        BtnHelp               = QMessageBox::Help,
        BtnApply              = QMessageBox::Apply,
        BtnReset              = QMessageBox::Reset,
        BtnRestoreDefaults    = QMessageBox::RestoreDefaults,
};
    Q_DECLARE_FLAGS(QStandardButtons, QStandardButton)


#endif

    Q_PROPERTY(QVariant tags READ getAppTags CONSTANT)

    
    Q_PROPERTY(QString errorMessage READ errorMessage)


    Q_PROPERTY(QString rootPath READ getRootPath NOTIFY appPathsChanged)

    Q_PROPERTY(QString mainQmlPath READ getMainQmlPath NOTIFY appPathsChanged)

#if 0

    Q_PROPERTY(QString codePath READ getCodePath)

    
    Q_PROPERTY(QString dataPath READ getDataPath)

#endif


 public:

    explicit ZblApp(QJSEngine *scriptEngine,
                    ZScriptThread* container = nullptr,
                    QObject* parent = nullptr);

    virtual ~ZblApp();

    static ZblApp& zInstance();

    static  QObject* getSingletonType(
            QQmlEngine *engine, QJSEngine *scriptEngine);

    static int registerSingletonType();

    QJSEngine& engine();


    QString errorMessage();


    QVariant getAppTags();

    QString getRootPath();

    QString getMainQmlPath();


#if 0

    QString getCodePath();

    QString getDataPath();
#endif


    Q_INVOKABLE bool isResourcePath(const QString& path);

    Q_INVOKABLE void addLibraryPath(const QString& path);


    Q_INVOKABLE QString resolveAppPath(const QString& path, bool includeUrlScheme = true);

    Q_INVOKABLE QString resolveHomePath(const QString& path, bool includeUrlScheme = true);

    Q_INVOKABLE QString resolvePath(const QString& path, bool includeUrlScheme = true);


#if 0

    Q_INVOKABLE QVariant showInfo(QWidget * parent,
                                         const QString & title,
                                         const QString & text,
                                         int buttons = ZblApp::BtnOk,
                                         int defaultButton = ZblApp::BtnNoButton);

#endif

    Q_INVOKABLE bool isInMainThread();

#if 0

    Q_INVOKABLE void sync();
#endif

    Q_INVOKABLE void sleep(unsigned long milliseconds);


    Q_INVOKABLE void sleepEvents(unsigned long milliseconds);


    Q_INVOKABLE QVariant getAppData(int dataKey);

    Q_INVOKABLE QVariant getAppName();

    Q_INVOKABLE void status(const QString& text);

    Q_INVOKABLE QObject* newAppSettings(int scope,
                                        const QString& application,
                                        const QString& organization);

    Q_INVOKABLE QObject* newByteArray();

    Q_INVOKABLE QObject* newDataStream(QObject* byteArray);

    Q_INVOKABLE QObject* newDir();

    Q_INVOKABLE QObject* newFile();

    Q_INVOKABLE QObject* newFileSystemWatcher();

    Q_INVOKABLE QObject* newTableModel();

    Q_INVOKABLE QObject* newTextStream(const QString& text);

    Q_INVOKABLE QObject* newLogReader();

    Q_INVOKABLE QObject* newObject(const QString& sprocketUri, const QString& objectName);

    Q_INVOKABLE QObject* newProcess();

    Q_INVOKABLE QObject* newMailbox();

    Q_INVOKABLE QObject* newMailslot();

    Q_INVOKABLE QObject* newMap();

    Q_INVOKABLE QObject* newMessageQueue();

    Q_INVOKABLE QObject* newSchemaValidator();

    Q_INVOKABLE QObject* newScopedMap();

    Q_INVOKABLE QObject* newSettingsFile(const QString& filePath);

    Q_INVOKABLE QObject* newThread();

    Q_INVOKABLE QObject* newXmlQuery();

    Q_INVOKABLE QObject* bundleSettings(const QString& bundleID);

    Q_INVOKABLE QString bundleMetapath(const QString& bundleID);

    Q_INVOKABLE QString bundleMetadata(const QString& bundleID);

    Q_INVOKABLE bool import(
            const QString& sprocketUri, int versionMajor, int versionMinor);

    Q_INVOKABLE bool mapResource(
            const QString& uri,
            int versionMajor,
            int versionMinor,
            const QString& fileName);


    Q_INVOKABLE bool registerResource(
            const QString& uri, int versionMajor, int versionMinor);


    Q_INVOKABLE bool mapPluginResources(const QString& fileName, bool qmlregister = false);

    Q_INVOKABLE bool loadPlugin(const char* fileName, bool load = false);

#if 0

    //Q_INVOKABLE bool loadResource(
    //        const QString& resourceUri, int versionMajor, int versionMinor);

#endif

    Q_INVOKABLE QStringList getApplicationArguments();

    Q_INVOKABLE QStringList getSystemEnvironment();

    Q_INVOKABLE bool isInterruptRequested();


    Q_INVOKABLE QString getCurrentThreadAddress();

    Q_INVOKABLE QString getObjectThreadAddress(QObject* object);

     Q_INVOKABLE QObject* getLogBuffer();

     Q_INVOKABLE QObject* getLogRules();


signals:

    void statusAvailable(const QString& text);

    void appPathsChanged();


    void settingsBundleAvailable(QString bundleId);


    void exit(int returnCode);




public slots:



    // begin test methods

    void throwAnException();

    void throwDeeperException();

    void catchDeeperException();

    QVariant returnAnException();

    void throwException();

    // end test methods




    QJSValue error();

    void setError(QJSValue theObject);

    bool isError();

    void clearError();


    QJSValue convertEvaluateError(const QJSValue& evaluateError);

    QVariant include(const QString& fileUrl);


    //TBD: reverse timerArgument and milliseconds and give timerArgument a default value

    int startTimerInterval(
            QJSValue timerFunction,
            QJSValue timerArgument,
            int milliseconds);

    void stopTimerInterval(int timerID);

    void stopAllTimers();


    void collectGarbage();


    void alert(const QString signalID, QVariant payload, bool wait = false);



    void quit();



    QString readLine();

    void print(const QString& text, bool newLine=true);

    void printErr(const QString& text, bool newLine=true);


    void onDestroyed(QObject* obj); // Experimental



private slots:

    void exitApp(int returnCode = 0);


protected:


    ZBL_DECLARE_LOGGED_OBJECT

    virtual void timerEvent(QTimerEvent * event);

    void createTags();

    static QThreadStorage<AppPtr*> m_zApp;

    static QReadWriteLock m_lock;

    QJSEngine* m_engine;

    ZScriptThread* m_container;


    static QVariant m_tags;

    timerHash m_scriptTimers;


    factoryMap m_factories;


};

inline QJSEngine& ZblApp::engine()
{
    if(!m_engine)
        throw ZblException("ZblApp::engine - ERROR: missing javascript engine");

    return *m_engine;
}


} // Zbl


#endif // ZBLAPP_H