Zblcore.cpp

Go to the documentation of this file.

/*
* Zuble - A run-time system for QML/Javascript applications
* Copyright (C) 2013, 2014  Bob Dinitto
*
* Filename:   Zblcore.cpp
* Created on: 11/9/2014
* 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 "Zblcore.h"

#include <QQmlContext>
#include <QtQml>
//#include <QTemporaryFile>
#include "ZblApp.h"
#include "ZApplication.h"
#include "ZblThreadErr.h"
#include "ZScriptThread.h"
#include "ZxQuery.h"
#include "ZxResultItems.h"
#include "ZxItem.h"
#include "ZSchemaValidator.h"
#include "ZDir.h"
#include "ZFile.h"
#include "ZByteArray.h"
#include "ZTextStream.h"
#include "ZDataStream.h"
#include "ZioDevice.h"
#include "ZTableModel.h"
#include "ZblCog.h"
#include "ZblLogManager.h"
#include "ZSettings.h"
#include "ZFileSystemWatcher.h"
#include "ZLogReader.h"
#include "ZMessageQueue.h"
#include "ZMailbox.h"
#include "ZMailslot.h"
#include "ZMap.h"
#include "ZTableColumn.h"
#include "ZTableColumnList.h"
#include "ZLogViewport.h"
#include "ZLogMap.h"
#include "ZScopedMap.h"
#include "ZAndGate.h"
#include "zblcore_global.h"
#include "zglobal.h"
#include "ZblLogOutput.h"
#include "ZProcess.h"


//#include "ZblLogMessage.h"
//#include <QMetaType>
//#include <QtQml>


namespace Zbl
{

ZApplication* Zblcore::m_zApp = nullptr;

ZBL_DEFINE_LOGGED_OBJECT(Zbl::Zblcore)

Zblcore::Zblcore(QObject* parent)
    : QQmlExtensionPlugin(parent)
{
    zDebug() << "Zblcore::Zblcore";

    if(m_zApp)
        throw ZblException(
          "Zbl::Zblcore::Zblcore programming error: "
                "only one instance of Zblcore class should exist per linux process!");

    qRegisterMetaType<Zbl::ZRoleRow>(); // TBD: need this?

   // qRegisterMetaType<ZScriptThread::AlertConversion>(); // TBD: need this?

    ZblThreadErr::zInit();

    ZSettings::zInit();

    QString logProfilePath = ZblLogManager::createTemporaryLogProfile("~startup-profile-XXXXXX");

    loadLogModules();

    ZSettings::insertBundle("current-log-profile",
                             ZblLogManager::getLogSettingsMetadata(),
                             logProfilePath, true);

    ZblLogManager& logMan = ZblLogManager::zInit(nullptr);


    m_zApp = new ZApplication(&logMan);

    m_zApp->zInit();

    logMan.setApplicationObject(m_zApp);

    //logMan.updateMessageHandlerStatus();

    ZBL_REGISTER_LOGGED_OBJECT

    zDebug() << "Log Manager initialized";

    ZblCog::zInit(&logMan);

    zDebug() << "Cog initialized";

    if(!inObjectThread(qApp))
    {
        QThread* guiThread = qApp->thread();

        zDebug() << "Moving Zuble core objects to GUI thread.";

        logMan.moveToThread(guiThread);

        zDebug() << "Core objects move to GUI thread complete.";
    }
}

Zblcore::~Zblcore()
{
    zDebug() << "Zblcore::~Zblcore";
}

bool Zblcore::isInitialized()
{
   return m_zApp ? true : false;
}

bool Zblcore::registerResource(
        const char* uri, int versionMajor, int versionMinor)
{
    zDebug() << "Zblcore::registerResource";

    if(!uri)
        return false;

    return zCog.registerResource(uri, versionMajor, versionMinor);

}

bool Zblcore::mapResource(
        const char* uri,
        int versionMajor,
        int versionMinor,
        const char* fileName)
{
    zDebug() << "Zblcore::mapResource";

    if(!uri || !fileName)
        return false;

    return zCog.mapResource(uri, versionMajor, versionMinor, fileName);
}

bool Zblcore::mapConfigResources(const char* configFilePath)
{
    if(!configFilePath)
        return false;

    zDebug() << "Zblcore::mapResource: " << configFilePath;

    return zCog.mapConfigResources(configFilePath);
}

bool Zblcore::mapPluginResources(const char* fileName, bool qmlRegister)
{
    zDebug() << "Zblcore::mapPluginResources";

    return zCog.mapPluginResources(fileName, qmlRegister);
}

void Zblcore::initializeEngine(QQmlEngine * engine, const char* uri)
{
    Q_UNUSED(engine)

    zDebug() << "Zblcore::initializeEngine, uri: " << uri;
}

void Zblcore::registerTypes(const char* uri)
{

#if 0
    zDebug() << "Zblcore::registerTypes, uri: " << uri;

    qDebug() << "Zblcore::registerTypes thread: "
             << ZApplication::getObjectThreadAddress(this);
#endif

    // In case Zblcore constructor and registerTypes are called in different
    // threads.

    ZblThreadErr::zInit();

    ZApplication::debugCompareThreadAddress("Zblcore::registerTypes", this);


    //Q_ASSERT(uri == QLatin1String("TimeExample"));
    //qmlRegisterType<TimeModel>(uri, 1, 0, "Time");

    ZblApp::registerSingletonType();
    ZScriptThread::registerType();
    ZSettings::registerType();
    ZxQuery::registerType();
    ZxResultItems::registerType();
    ZxItem::registerType();
    ZSchemaValidator::registerType();
    ZDir::registerType();
    ZFile::registerType();
    ZByteArray::registerType();
    ZTextStream::registerType();
    ZDataStream::registerType();
    ZioDevice::registerType();
    ZTableModel::registerType();
    ZFileSystemWatcher::registerType();
    ZLogReader::registerType();
    ZMessageQueue::registerType();
    ZMap::registerType();
    ZMailbox::registerType();
    ZMailslot::registerType();
    ZTableColumnList::registerType();
    ZTableColumn::registerType();
    ZLogViewport::registerType();
    ZLogMap::registerType();
    ZScopedMap::registerType();
    ZAndGate::registerType();
    ZProcess::registerType();

    bool status = qmlProtectModule(uri, 1);

    if(!status)
        qWarning("Zblcore::registerTypes - Warning: QML module %s could not "
                 "be protected.", uri);
}

bool  Zblcore::mapConfigSettings(const char* fileName)
{
    zDebug() << "Zblcore::mapConfigSettings";

    return ZSettings::mapConfigSettings(fileName);
}

ZApplication& Zblcore::zApplication()
{
    if(!m_zApp)
        throw ZblException(
          "Zbl::Zblcore::zInstance programming error: "
                "embedded ZApplication object not initialized!");

    return *m_zApp;
}

void Zblcore::loadLogModules()
{
    ZblLogOutput::zLogModuleList modules;

    ZblLogOutput* tmpOut = new ZblLogFormatPlainText(this);
    modules.append(tmpOut);

    tmpOut = new ZblLogFormatPlainText(this);
    modules.append(tmpOut);

    tmpOut = new ZblLogToHistory(this);
    modules.append(tmpOut);

    tmpOut = new ZblLogToStdout(this);
    modules.append(tmpOut);

    tmpOut = new ZblLogToTextFile(this);
    modules.append(tmpOut);

    qApp->setProperty("org_zuble_logModules",
                      QVariant::fromValue<Zbl::ZblLogOutput::zLogModuleList>(modules));


}


} // Zbl