ZSettings.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2015 Bob Dinitto
 *
 * Filename:   ZSettings.cpp
 * Created on: 5/16/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 "ZSettings.h"
#include "ZApplication.h"
#include <QtQml>
#include <QJsonDocument>
//#include <QXmlQuery>
#include "ZxQuery.h"
#include "ZFileSystemWatcher.h"
#include "ZblApp.h" // debug


namespace Zbl
{

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZSettings)

const QString ZSettings::m_ext = "zbl";

QSettings::Format ZSettings::m_format = QSettings::InvalidFormat;

QVariant ZSettings::m_tags;

qint64 ZSettings::m_maxFileSize = 1024 * 1000;

ZSettings::bundleMap ZSettings::m_bundles;

ZFileSystemWatcher* ZSettings::m_watcher = nullptr;


ZSettings::ZSettings(QObject *parent) :
    QObject(parent), m_s(nullptr), m_watching(false)
{
    //zDebug() << "ZSettings::ZSettings";

    if(!m_watcher)
    {
        m_format = QSettings::registerFormat(m_ext, readFunc, writeFunc);
        m_watcher = new ZFileSystemWatcher();

        // Because QSettings deletes/recreates files on Linux
        m_watcher->setRestoreDeletedFiles(true);
    }

    QMetaObject::Connection connection = connect(m_watcher,
    &ZFileSystemWatcher::fileChanged, this, &ZSettings::onFileChanged);

    if(!connection)
        zCritical() << "Settings object watcher connection failed.";
}

ZSettings::~ZSettings()
{
    //zDebug() << "ZSettings::~ZSettings";
    if(m_watching)
        setFileWatcher(false);
}


void ZSettings::registerType()
{

    qmlRegisterType<ZSettings>("org.zuble.qml", 1, 0, "ZSettings");
}

void ZSettings::onFileChanged(const QString &path)
{
    zDebug() << "SETTINGS FILE MODIFIED SIGNAL FOR THREAD:" <<
                ZblApp::zInstance().getCurrentThreadAddress() <<
                " PATH=" << path;

    if(path == m_s->fileName())
    {
        zDebug() << "EMITTING SETTINGS FILE MODIFIED! PATH=" << m_s->fileName();
        m_s->sync();
        emit settingsModified(path);
    }
    else
    {
        zDebug() << "NOT MODIFIED! ACTUAL PATH=" << m_s->fileName();
    }

    zDebug() << "DUMPING FILE WATCHER PATHS: ";
    foreach( QString path, m_watcher->files())
    {
        zDebug() << path;
    }

}

void ZSettings::zInit()
{
    ZBL_REGISTER_LOGGED_OBJECT

    createTags();
}

void ZSettings::createTags()
{
    if(!m_tags.isNull())
        return;

    QVariantMap map;

    map.insert("UserScope", QSettings::UserScope);
    map.insert("SystemScope", QSettings::SystemScope);

    map.insert("NoError", QSettings::NoError);
    map.insert("AccessError", QSettings::AccessError);
    map.insert("FormatError", QSettings::FormatError);

    m_tags = QVariant::fromValue(map);
}

QVariant ZSettings::getTags()
{
    return m_tags;
}

QString ZSettings::getFileName() const
{
    QString ret;

    ZBL_SLOT_BEGIN_TRY
    validateStatus();

    if(!m_s)
    {
        zWarning() << "ZSettings::getFileName - WARNING: settings object not opened.";
    }
    else
    {
        ret = m_s->fileName();
    }

    return m_s->fileName();
    ZBL_SLOT_END_RETURN(ret,  ret,
    Z_FAC_JS, ZSettings::getFileName, getFileName failed)
}


bool ZSettings::readFunc(QIODevice &device, QSettings::SettingsMap &map)
{
    //zDebug() << "readFunc enetered";

    dumpMap(map);

    // device -> QByteArray

    // should we test for error conditions?

    QByteArray bytes = device.read(m_maxFileSize);

    // should we test for error conditions?

    if(bytes.isNull() || bytes.isEmpty())
    {
        zWarning() << "ZSettings::readFunc - can't read from settings device.";
        return true; // TBD: should return false here?
        //return false;
    }

    // QByteArray -> doc

    QJsonParseError error;
    QJsonDocument doc(QJsonDocument::fromJson(bytes, &error));

    if(doc.isNull() || error.error != QJsonParseError::NoError)
    {
        zCritical() << "ZSettings::readFunc - ERROR parsing JSON file: "
                       << error.errorString();

        return false;
    }


    // doc -> map

    QVariant vMap(doc.toVariant());

    map = vMap.toMap();

    // TBD: test document integrity here?
    // should we test for error conditions?


    return true;
}

bool ZSettings::writeFunc(QIODevice &device, const QSettings::SettingsMap &map)
{
    zDebug() << "ZSettings::writeFunc enetered";

    dumpMap(map);

    // map -> doc

    // TBD: check for valid qvariant?

    QVariant vMap(map);

    QJsonDocument doc(QJsonDocument::fromVariant(vMap));

    // doc -> QByteArray

    QByteArray bytes(doc.toJson());

    // QByteArray -> device

    qint64 status = device.write(bytes);

    if(status == -1)
    {
        zCritical() << "ZSettings::writeFunc - an error occurred writing to "
                       "the settings device: " << device.errorString();

        return false;
    }


    return true;

}

void ZSettings::dumpMap(const QSettings::SettingsMap &map)
{
    QList<QString> keys;

    keys = map.keys();

    zDebug() << "ZSettings begin dumping map...";

    for(int i=0; i<keys.count(); i++)
    {
        QString key(keys.at(i));
        QVariant value(map.value(key));

        zDebug() << "value type is: " << value.typeName();

        if(value.type() == QVariant::Map)
        {
            dumpGroup(key,value);

        }
        else
        {
            zDebug() << "key=" << key << ", value=" << value.toString();
        }
    }

    zDebug() << "ZSettings end dumping map.";

}

void ZSettings::dumpGroup(const QString& groupKey, const QVariant& group)
{
    zDebug() << "begin group " + groupKey;

    QVariantMap map = group.toMap();

    QList<QString> keys = map.keys();

    for(int i=0; i<map.count(); i++)
    {
        QString key(keys.at(i));
        QVariant value(map.value(key));

        if(value.type() == QVariant::Map)
        {
            dumpGroup(key, value);

        }
        else
        {
            zDebug() << "key=" << key << ", value=" << value.toString();
        }
    }
    zDebug() << "end group " + groupKey;

}

bool ZSettings::open(int scope,
          const QString& application,
          const QString& organization)
{
    QSettings::Scope scp = QSettings::Scope(scope);

    if(m_s != nullptr)
    {
        zWarning() << "Programming error: object is already opened.";

        return false;
    }

    if(scp != QSettings::UserScope && scp != QSettings::SystemScope)
    {
        zWarning() << "Invalid scope: " << scope
                      << " opening settings in User scope...";

        scp = QSettings::UserScope;
    }

    ZBL_SLOT_BEGIN_TRY

    QString org;

    if(organization.isEmpty())
        org = QCoreApplication::organizationName();
    else
        org = organization;

    QString app;

    if(application.isEmpty())
        app = QCoreApplication::applicationName();
    else
        app = application;

    //zDebug() << "Opening settings file for organization: "
    //              << org << ", application: " << app;

    m_s = new QSettings(m_format, scp, org, app, this);

    QString filePath = m_s->fileName();

    ensureFileExists(filePath);

    //m_s->sync();

#if 0


    //QString filePath = m_s->fileName();

    //zDebug() << "Settings filename = " << filePath;

    if(QFile::exists(filePath))
    {
        //zDebug() << "settings file exists";
    }
    else
    {
        //zDebug() << "settings file DOES NOT exist";

    }
#endif



    if(!validateOpen())
    {
        zCritical() << "Failed to open organization: "
                      << org << ", application: " << app;

        throw ZblException("Can't open settings.");
    }

    ZBL_SLOT_END_RETURN(true,  false,
    Z_FAC_JS, ZSettings::open, open failed)
}

bool ZSettings::setFileWatcher(bool enabled)
{
    validateWatcher();
    bool ret = false;

    if(enabled && !m_watching)
    {
        ret = m_watcher->addPath(m_s->fileName());
        if(ret) //TBD: report failure?
            m_watching = true;
    }
    else if(!enabled && m_watching)
    {
        ret = m_watcher->removePath(m_s->fileName()); // TBD: report failure?
        m_watching = false;
    }
    return ret;
}


bool ZSettings::ensureFileExists(const QString& filePath)
{
    if(QFile::exists(filePath))
    {
        zDebug() << "Settings file exists: " << filePath;
        return true;
    }

    // TBD: check for and create lock file first - or block waiting for lock file!

    QFile file(filePath);

    bool status = file.open(QIODevice::WriteOnly | QIODevice::Text);

    if(!status)
    {
        zWarning() << "Can't open empty settings file: " << filePath
                      << " -- Error message: " << file.errorString();
        return false;
    }

    QString emptyJSONObject("{}");

    qint64 bytesOut = file.write(emptyJSONObject.toUtf8());

    if(bytesOut == -1)
    {
        zWarning() << "Can't write to empty settings file: " << filePath
                      << " -- Error message: " << file.errorString();
        return false;
    }

    file.flush();

    file.close();


    if(QFile::exists(filePath))
    {
        zDebug() << "Created empty settings file: " << filePath;

        return true;
    }
    else
    {
        zDebug() << "FAILED to create empty settings file: " << filePath;
        return false;
    }
}


bool ZSettings::open(const QString& filePath)
{
    if(m_s != nullptr)
    {
        zWarning() << "Programming error: object is already opened.";

        return false;
    }

    ZBL_SLOT_BEGIN_TRY

    QString realPath(ZApplication::resolvePath(filePath, false));

    //zDebug() << "Opening settings file: " << realPath;

    if(realPath.isEmpty())
        throw ZblException("Can't open empty settings file path.");

    m_s = new QSettings(realPath, m_format, this);

    if(!validateOpen())
    {
        zCritical() << "Failed to open settings file: "
                      << realPath;

        throw ZblException("Can't open settings.");
    }

    ZBL_SLOT_END_RETURN(true,  false,
    Z_FAC_JS, ZSettings::open, open failed)
}


bool ZSettings::open(const SettingsBundle& settingsBundle)
{
    if(!settingsBundle.m_dataPath.isEmpty())
        return open(settingsBundle.m_dataPath);
    else
        return open(settingsBundle.m_scope, settingsBundle.m_application,
                    settingsBundle.m_organization);
}

bool ZSettings::validateOpen()
{
    QString filePath = m_s->fileName();

    QSettings::Status status = m_s->status();

    if(status != QSettings::NoError)
    {

        if(status == QSettings::AccessError)
            zCritical() << "ERROR: Can't access settings file: " << filePath;
        else if(status == QSettings::FormatError)
            zCritical() << "ERROR: Settings file has invalid format: " << filePath;
        else
            zCritical() << "ERROR: Unknown failure type from QSettings: " << filePath;

        m_s->deleteLater();

        m_s = nullptr;

       return false;
    }

    return true;
}

bool ZSettings::containsBundle(const QString& id)
{
    return m_bundles.contains(id);
}

bool ZSettings::insertBundle(
        const QString& id,
        const QString& metaPath,
        QSettings::Scope scope,
        const QString organization,
        const QString application)
{
    if(m_bundles.contains(id))
        m_bundles.remove(id);

    QString org = organization;

    if(org.isEmpty())
        org = ZApplication::getOrganization();

    QString app = application;

    if(app.isEmpty())
        app = ZApplication::getAppName();

    SettingsBundle bundle(metaPath,
                          scope,
                          org,
                          app);

    bool ret = realizeSettings(id, bundle);

    if(!ret)
    {
        zCritical() << "ZSettings::insertBundle can't load settings bundle id: "
                 << id;
    }
    else
    {
        m_bundles.insert(id, bundle);

        if(Zblcore::isInitialized())
            emit zApp.settingsBundleAvailable(id);
    }

    return ret;
}

bool ZSettings::insertBundle(
        const QString& id,
        const QString& meta,
        const QString& dataPath,
        bool metaAtomic)

{
    bool ret = false;

    if(m_bundles.contains(id))
    {
        zDebug() << "Replacing bundle id: " << id;

        m_bundles.remove(id);
    }

    SettingsBundle bundle;

    bundle.m_dataPath = ZApplication::resolvePath(dataPath, false);

    if(metaAtomic)
    {
        bundle.m_metaData = meta;
    }
    else
    {
        bundle.m_metaPath = meta;
    }
    ret = realizeSettings(id, bundle);

    if(!ret)
    {
        zCritical() << "ZSettings::insertBundle can't load settings bundle id: "
                 << id;
    }
    else
    {
        m_bundles.insert(id, bundle);

        if(Zblcore::isInitialized())
            emit zApp.settingsBundleAvailable(id);
    }

    return ret;
}

bool ZSettings::insertBundle(const QString& id, QVariant bundle)
{
    //zDebug() << "Sorry insertBundle for Javascript not yet implemented...";

    return false;
}


QVariant ZSettings::getBundle(const QString& id)
{
    QVariant ret;

    if(m_bundles.contains(id))
    {
        const SettingsBundle& bundle = m_bundles.value(id);

        QVariantMap vm;
        vm.insert("metaPath", bundle.m_metaPath);
        vm.insert("dataPath", bundle.m_dataPath);
        vm.insert("application", bundle.m_application);
        vm.insert("organization", bundle.m_organization);
        ret = QVariant::fromValue(vm);
    }
    return ret;
}

ZSettings* ZSettings::getBundleSettings(const QString& id)
{
    ZSettings* zSet = nullptr;

    try
    {

        if(!m_bundles.contains(id))
        {
            zWarning() << "Invalid bundle ID: " << id;

            return zSet;
        }

        const SettingsBundle& bundle = m_bundles.value(id);

        zSet = new ZSettings();

        if(!bundle.m_dataPath.isEmpty())
        {
            QString dataPath = bundle.m_dataPath;

            if(QDir::isRelativePath(dataPath))
                dataPath = ZApplication::getDataPath() + dataPath;

            dataPath = QDir::cleanPath(dataPath);

            if(!zSet->open(dataPath))
                throw ZblException(QString(
               "Can't open settings data for path: %1").arg(dataPath));
        }
        else
        {
            QString org = bundle.m_organization;
            QString app = bundle.m_application;
            QSettings::Scope scope;

            if(org.isEmpty())
                org = QCoreApplication::organizationName();

            if(app.isEmpty())
                app = ZApplication::getAppName();

            if(bundle.m_scope == QSettings::SystemScope)
                scope = QSettings::SystemScope;
            else
                scope = QSettings::UserScope;

            if(!zSet->open(scope, app, org))
            {
                throw ZblException(QString(
                "Can't open settings data for orgainzation/app: %1/%2").arg(org).arg(app));
            }

        }

    }
    catch(...)
    {
        if(zSet != nullptr)
            delete zSet;

        throw;
    }

    return zSet;
}

QString ZSettings::getBundleMetapath(const QString& id)
{
    if(!m_bundles.contains(id))
        throw ZblException(QString("Invalid bundle ID: %1").arg(id));

    return m_bundles.value(id).m_metaPath;
}

QString ZSettings::getBundleMetadata(const QString& id)
{
    if(!m_bundles.contains(id))
        throw ZblException(QString("Invalid bundle ID: %1").arg(id));

    return m_bundles.value(id).m_metaData;
}



QVariant ZSettings::getAllBundles()
{
    QVariantMap ret;

    QStringList keys(m_bundles.keys());

    const int keyCount = keys.count();

    for(int i=0; i<keyCount; i++)
    {
        const QString nextKey = keys.at(i);
        ret.insert(nextKey, getBundle(nextKey));
    }

    return QVariant::fromValue(ret);
}


bool ZSettings::hasBundle(const QString& id) const
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(containsBundle(id),  false,
    Z_FAC_JS, ZSettings::hasBundle, hasBundle failed)
}

QVariant ZSettings::bundle(const QString& id) const
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(getBundle(id),  false,
    Z_FAC_JS, ZSettings::bundle, bundle failed)
}

QVariant ZSettings::allBundles() const
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(getAllBundles(),  false,
    Z_FAC_JS, ZSettings::allBundles, allBundles failed)
}

bool ZSettings::mapConfigSettings(const char* configFilePath)
{

    // locate zblconfig file

    if(!configFilePath)
    {
        zWarning() << "FAILED - invalid configuration file path: NULL";
        return false;
    }

    //zDebug() << "Mapping configuration settings resources: "
    //            << configFilePath;


    QFile cfg(configFilePath);

    if(!cfg.exists())
    {
        zWarning() << QString(
       "ABORTING - Nonexistent configuration file: %1").arg(configFilePath);
        return false;
    }

    // create query

    QXmlQuery xq;

    QUrl url(QUrl::fromLocalFile(configFilePath));

    //zDebug() << "Setting XQuery focus to config file: " << url.path();

    // id
    // metaPath
    // dataPath
    // scope
    // org
    // app

    static const int x_operation = 0;
    static const int x_id = 1;
    static const int x_metaPath = 2;
    static const int x_dataPath = 3;
    static const int x_scope = 3;
    static const int x_org = 4;
    static const int x_app = 5;

    QString query = "declare default element namespace 'http://zuble.org/schema/zuble/zblconfig'; \n"

            "declare function local:if-empty( \n"
            "$node as node()?, $value as xs:anyAtomicType) as xs:string* \n"
            "{ if(string($node) != '') then string($node) else $value };"
            "declare function local:appSettings($s as element()?) as xs:string* \n"
            "{ ('=app', \n"
            " local:if-empty($s/@xml:id,' '), \n"
            " local:if-empty($s/meta_path,' '), \n"
            " local:if-empty($s/setting-data/@scope,' '), \n"
            " local:if-empty($s/setting-data/organization,' '), \n"
            " local:if-empty($s/setting-data/application,' ')) }; \n"
            "declare function local:pathSettings($s as element()?) as xs:string* \n"
            "{ ('=path', \n"
            " local:if-empty($s/@xml:id,' '), \n"
            " local:if-empty($s/meta_path,' '), \n"
            " local:if-empty($s/data_path,' ')) }; \n"

    "for $bundle in /zblconfig/settings/setting_bundle \n"
    " let $app := $bundle/setting-data/application \n"
    " let $path := $bundle/data_path \n"
    " return (if($path) then local:pathSettings($bundle) \n"
    " else if($app) then local:appSettings($bundle) else '=invalid')";

    bool status = xq.setFocus(url);

    if(!status)
    {
         zCritical() <<
         QString("QXmlQuery can't load configuration file: %1").arg(
         url.path().toUtf8().constData());

         return false;
    }

    //zDebug() << "Query=" << query;

    xq.setQuery(query);

    if(!xq.isValid())
    {
        zWarning() << QString("Programming ERROR: invalid XQuery: %1").arg(query.toUtf8().constData());

        return false;
    }

    // evaluate results

    QStringList xmlResults;

    xq.evaluateTo(&xmlResults);

    const int count = xmlResults.count();

    //zDebug() << "Dumping XQuery evaluation results ++++++++++++++++++++++++++";

    //for(int x=0; x<count; x++)

    //    zDebug() << xmlResults.at(x).toUtf8().constData();

    //    qDebug("Evaluated to: %s", xmlResults.at(x).toUtf8().constData());

    //zDebug() << "End dumping XQuery evaluation results ++++++++++++++++++++++++++";

    for(int j=0; j<count;j++)
    {
        const QString op = xmlResults[j+x_operation];

        if(op == "=app")
        {
            //zDebug() << "found app";

            insertBundle(
                    xmlResults[j+x_id],
                    xmlResults[j+x_metaPath],
                    textToScope(xmlResults[j+x_scope]),
                    xmlResults[j+x_org],
                    xmlResults[j+x_app]);

            j+= x_app;
        }
        else if(op == "=path")
        {
            //zDebug() << "found path";
            
            insertBundle(
                    xmlResults[j+x_id],
                    xmlResults[j+x_metaPath],
                    rectifySettingsDataPath(xmlResults[j+x_dataPath]));
            
            j+= x_dataPath;
        }
        else if(op == "=invalid")
        {
            //zDebug() << "found invalid";
            j++;
        }
        else
        {
            //zDebug() << "found badness";
            j++;

        }

    }



    return true;


}

QString ZSettings::rectifySettingsDataPath(const QString& dataPath)
{
    // paths are relative to home directory, not current directory

    QString ret(QDir::cleanPath(ZApplication::resolvePath(dataPath, false)));

    if(QDir::isAbsolutePath(ret))
        return ret;

    QDir home(QDir::home());

    return home.filePath(ret);
}


bool ZSettings::realizeSettings(const QString& id, const SettingsBundle& settingsBundle)
{
    static const int keyIx = 0;
    static const int valueIx = 1;

    ZxQuery settingQuery;

    QString settingsMetafilePath;

    if(settingsBundle.m_metaPath.isEmpty())
    {
#if 0
        settingsMetafilePath = "Query text: ";
        settingsMetafilePath += settingsBundle.m_metaData.left(30);
        settingsMetafilePath += "...";

        //zDebug() << "Initializing application settings ID: "
        //         << id << " from metadata: " << settingsMetafilePath;
#endif
        settingQuery.setFocusText(settingsBundle.m_metaData);
    }
    else
    {

        settingsMetafilePath = settingsBundle.m_metaPath;

        //zDebug() << "Initializing application settings ID: "
        //         << id << " from metafile: " << settingsMetafilePath;

        settingQuery.setFocusUrl(settingsMetafilePath);
    }

    if(zThreadErr.isError())
    {
        zCritical() << "XQuery can't load application settings metadata file: "
                        << settingsMetafilePath;

        return false;
    }

    static const QString query =
            "declare default element namespace "
            "'http://zuble.org/schema/zuble/settings';  \n"
            " for $setting in /appsettings/settings/setting \n"
            " let $key := concat(xs:string($setting/@group), "
            " \"/\", xs:string($setting/@xml:id)) \n"
            " let $value := xs:string($setting/default) \n"
            " return (($key,$value))";


    settingQuery.setQueryText(query);

    if(zThreadErr.isError())
    {
        zCritical() << "Zuble internal programming ERROR: settings query is invalid.";
        return false;
    }

    QStringList data = settingQuery.evaluateToStringList();

    if(zThreadErr.isError())
    {
        zCritical() << "ERROR: Can't process application settings metadata file: "
                    << settingsMetafilePath
                    << ", Error message = "
                    << zThreadErr.getErrorMessage();
        return false;
    }

    const int count = data.size();

    if(count%2)
    {
        zCritical() << "WARNING: Invalid data in application settings metadata file: "
                       << settingsMetafilePath;
        return false;
    }

    ZSettings zSet;

    if(!zSet.open(settingsBundle))
    {
        zCritical() << "WARNING: Can't open application settings data for settings bundle ID: "
                       << id;
        return false;
    }

    bool needSync = false;

    for(int i=0; i<count; i += 2)
    {
        QString key(data.at(i+keyIx));

        if(!zSet.contains(key))
        {
            QString value(data.at(i+valueIx));

            zSet.setValue(key,value);

            needSync = true;

            //zDebug() << "Creating default application setting key: "
            //     << key << ", value: " << value;
        }

        //zDebug() << "data[" << i << "] = " << data.at(i);
    }

    //if(needSync)
    //    zSet.sync();

    //zDebug() << "Completed initializing application settings ID: "
    //         << id << " from metafile: " << settingsMetafilePath;

    return true;

}

QString ZSettings::scopeToText(QSettings::Scope scope)
{
    if(scope == QSettings::SystemScope)
        return QString("system");
    else if(scope == QSettings::UserScope)
        return QString("user");
    else
        return QString();
}

QSettings::Scope ZSettings::textToScope(const QString& text)
{
    QString lc = text.toLower();

    if(lc == "system")
        return QSettings::SystemScope;
    else if(lc == "user")
        return QSettings::UserScope;
    else
        return QSettings::Scope(-1);
}

void ZSettings::clear()
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    m_s->clear();
    ZBL_SLOT_END_VOID(Z_FAC_JS,ZSettings::clear, clear failed)
}

void ZSettings::sync()
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    m_s->sync();
    ZBL_SLOT_END_VOID(Z_FAC_JS,ZSettings::sync, sync failed)
}

int ZSettings::status() const
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    ZBL_SLOT_END_RETURN(static_cast<int>(m_s->status()),  -1,
    Z_FAC_JS, ZSettings::status, status failed)
}

void ZSettings::setValue(const QString &key, const QVariant &value)
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    QString settingName = QString("%1/%2").arg(m_s->group(), key);
    QVariant oldValue = m_s->value(key);

    if(oldValue != value)
    {
        m_s->setValue(key, value);
        emit updateValue(m_s->fileName(), settingName, oldValue, value);
    }
    ZBL_SLOT_END_VOID(Z_FAC_JS,ZSettings::setValue, setValue failed)
}

QVariant ZSettings::value(const QString &key, const QVariant &defaultValue) const
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    ZBL_SLOT_END_RETURN(m_s->value(key, defaultValue),  QVariant(),
    Z_FAC_JS, ZSettings::value, value failed)
}


void ZSettings::remove(const QString &key)
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    m_s->remove(key);
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZSettings::remove, remove failed)
}

bool ZSettings::contains(const QString &key) const
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    ZBL_SLOT_END_RETURN(m_s->contains(key),  false,
    Z_FAC_JS, ZSettings::contains, contains failed)
}

void ZSettings::beginGroup(const QString &prefix)
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    m_s->beginGroup(prefix);
    ZBL_SLOT_END_VOID(Z_FAC_JS,ZSettings::beginGroup, beginGroup failed)
}

void ZSettings::endGroup()
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    m_s->endGroup();
    ZBL_SLOT_END_VOID(Z_FAC_JS,ZSettings::endGroup, endGroup failed)
}

QString ZSettings::group() const
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    ZBL_SLOT_END_RETURN(m_s->group(),  QString(),
    Z_FAC_JS, ZSettings::group, group failed)
}

int ZSettings::beginReadArray(const QString &prefix)
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    ZBL_SLOT_END_RETURN(m_s->beginReadArray(prefix),  -1,
    Z_FAC_JS, ZSettings::beginReadArray, beginReadArray failed)
}

void ZSettings::beginWriteArray(const QString &prefix, int size)
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    m_s->beginWriteArray(prefix, size);
    ZBL_SLOT_END_VOID(Z_FAC_JS,ZSettings::beginWriteArray, beginWriteArray failed)
}

void ZSettings::endArray()
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    m_s->endArray();
    ZBL_SLOT_END_VOID(Z_FAC_JS,ZSettings::endArray, endArray failed)
}

void ZSettings::setArrayIndex(int i)
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    m_s->setArrayIndex(i);
    ZBL_SLOT_END_VOID(Z_FAC_JS,ZSettings::setArrayIndex, setArrayIndex failed)
}

QStringList ZSettings::getAllKeys() const
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    ZBL_SLOT_END_RETURN(m_s->allKeys(),  QStringList(),
    Z_FAC_JS, ZSettings::getAllKeys, getAllKeys failed)
}

QStringList ZSettings::getChildKeys() const
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    ZBL_SLOT_END_RETURN(m_s->childKeys(),  QStringList(),
    Z_FAC_JS, ZSettings::getAllKeys, getAllKeys failed)
}

QStringList ZSettings::getChildGroups() const
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    ZBL_SLOT_END_RETURN(m_s->childGroups(),  QStringList(),
    Z_FAC_JS, ZSettings::getChildGroups, getChildGroups failed)
}

bool ZSettings::getWritable() const
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    ZBL_SLOT_END_RETURN(m_s->isWritable(),  false,
    Z_FAC_JS, ZSettings::getWritable, getWritable failed)
}

int ZSettings::getFormat() const
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    ZBL_SLOT_END_RETURN(m_s->format(),  false,
    Z_FAC_JS, ZSettings::getFormat, getFormat failed)
}

int ZSettings::getScope() const
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    ZBL_SLOT_END_RETURN(m_s->scope(),  false,
    Z_FAC_JS, ZSettings::getScope, getScope failed)
}

QString ZSettings::getOrganizationName() const
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    ZBL_SLOT_END_RETURN(m_s->organizationName(),  QString(),
    Z_FAC_JS, ZSettings::getOrganizationName, getOrganizationName failed)
}

QString ZSettings::getApplicationName() const
{
    ZBL_SLOT_BEGIN_TRY
    validateStatus();
    ZBL_SLOT_END_RETURN(m_s->applicationName(),  QString(),
    Z_FAC_JS, ZSettings::getApplicationName, getApplicationName failed)
}


} // Zbl