qqmlsettings.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qqmlsettings_p.h"
#include <qcoreevent.h>
#include <qcoreapplication.h>
#include <qloggingcategory.h>
#include <qsettings.h>
#include <qpointer.h>
#include <qjsvalue.h>
#include <qqmlinfo.h>
#include <qdebug.h>
#include <qhash.h>
 
QT_BEGIN_NAMESPACE
 
 
Q_LOGGING_CATEGORY(lcSettings, "qt.labs.settings")
 
static const int settingsWriteDelay = 500;
 
class QQmlSettingsPrivate
{
    Q_DECLARE_PUBLIC(QQmlSettings)
 
public:
    QQmlSettingsPrivate();
 
    QSettings *instance() const;
 
    void init();
    void reset();
 
    void load();
    void store();
 
    void _q_propertyChanged();
    QVariant readProperty(const QMetaProperty &property) const;
 
    QQmlSettings *q_ptr = nullptr;
    int timerId = 0;
    bool initialized = false;
    QString category;
    QString fileName;
    mutable QPointer<QSettings> settings;
    QHash<const char *, QVariant> changedProperties;
};
 
QQmlSettingsPrivate::QQmlSettingsPrivate() {}
 
QSettings *QQmlSettingsPrivate::instance() const
{
    if (!settings) {
        QQmlSettings *q = const_cast<QQmlSettings*>(q_func());
        settings = fileName.isEmpty() ? new QSettings(q) : new QSettings(fileName, QSettings::IniFormat, q);
        if (settings->status() != QSettings::NoError) {
            // TODO: can't print out the enum due to the following error:
            // error: C2666: 'QQmlInfo::operator <<': 15 overloads have similar conversions
            qmlWarning(q) << "Failed to initialize QSettings instance. Status code is: " << int(settings->status());
 
            if (settings->status() == QSettings::AccessError) {
                QVector<QString> missingIdentifiers;
                if (QCoreApplication::organizationName().isEmpty())
                    missingIdentifiers.append(QLatin1String("organizationName"));
                if (QCoreApplication::organizationDomain().isEmpty())
                    missingIdentifiers.append(QLatin1String("organizationDomain"));
                if (QCoreApplication::applicationName().isEmpty())
                    missingIdentifiers.append(QLatin1String("applicationName"));
 
                if (!missingIdentifiers.isEmpty())
                    qmlWarning(q) << "The following application identifiers have not been set: " << missingIdentifiers;
            }
            return settings;
        }
 
        if (!category.isEmpty())
            settings->beginGroup(category);
        if (initialized)
            q->d_func()->load();
    }
    return settings;
}
 
void QQmlSettingsPrivate::init()
{
    if (!initialized) {
        qCDebug(lcSettings) << "QQmlSettings: stored at" << instance()->fileName();
        load();
        initialized = true;
    }
}
 
void QQmlSettingsPrivate::reset()
{
    if (initialized && settings && !changedProperties.isEmpty())
        store();
    delete settings;
}
 
void QQmlSettingsPrivate::load()
{
    Q_Q(QQmlSettings);
    const QMetaObject *mo = q->metaObject();
    const int offset = mo->propertyOffset();
    const int count = mo->propertyCount();
 
    // don't save built-in properties if there aren't any qml properties
    if (offset == 1)
        return;
 
    for (int i = offset; i < count; ++i) {
        QMetaProperty property = mo->property(i);
        const QString propertyName = QString::fromUtf8(property.name());
 
        const QVariant previousValue = readProperty(property);
        const QVariant currentValue = instance()->value(propertyName,
                                                        previousValue);
 
        if (!currentValue.isNull() && (!previousValue.isValid()
                || (currentValue.canConvert(previousValue.metaType())
                    && previousValue != currentValue))) {
            property.write(q, currentValue);
            qCDebug(lcSettings) << "QQmlSettings: load" << property.name() << "setting:" << currentValue << "default:" << previousValue;
        }
 
        // ensure that a non-existent setting gets written
        // even if the property wouldn't change later
        if (!instance()->contains(propertyName))
            _q_propertyChanged();
 
        // setup change notifications on first load
        if (!initialized && property.hasNotifySignal()) {
            static const int propertyChangedIndex = mo->indexOfSlot("_q_propertyChanged()");
            QMetaObject::connect(q, property.notifySignalIndex(), q, propertyChangedIndex);
        }
    }
}
 
void QQmlSettingsPrivate::store()
{
    QHash<const char *, QVariant>::const_iterator it = changedProperties.constBegin();
    while (it != changedProperties.constEnd()) {
        instance()->setValue(QString::fromUtf8(it.key()), it.value());
        qCDebug(lcSettings) << "QQmlSettings: store" << it.key() << ":" << it.value();
        ++it;
    }
    changedProperties.clear();
}
 
void QQmlSettingsPrivate::_q_propertyChanged()
{
    Q_Q(QQmlSettings);
    const QMetaObject *mo = q->metaObject();
    const int offset = mo->propertyOffset();
    const int count = mo->propertyCount();
    for (int i = offset; i < count; ++i) {
        const QMetaProperty &property = mo->property(i);
        const QVariant value = readProperty(property);
        changedProperties.insert(property.name(), value);
        qCDebug(lcSettings) << "QQmlSettings: cache" << property.name() << ":" << value;
    }
    if (timerId != 0)
        q->killTimer(timerId);
    timerId = q->startTimer(settingsWriteDelay);
}
 
QVariant QQmlSettingsPrivate::readProperty(const QMetaProperty &property) const
{
    Q_Q(const QQmlSettings);
    QVariant var = property.read(q);
    if (var.metaType() == QMetaType::fromType<QJSValue>())
        var = var.value<QJSValue>().toVariant();
    return var;
}
 
QQmlSettings::QQmlSettings(QObject *parent)
    : QObject(parent), d_ptr(new QQmlSettingsPrivate)
{
    Q_D(QQmlSettings);
    d->q_ptr = this;
}
 
QQmlSettings::~QQmlSettings()
{
    Q_D(QQmlSettings);
    d->reset(); // flush pending changes
}
 
QString QQmlSettings::category() const
{
    Q_D(const QQmlSettings);
    return d->category;
}
 
void QQmlSettings::setCategory(const QString &category)
{
    Q_D(QQmlSettings);
    if (d->category != category) {
        d->reset();
        d->category = category;
        if (d->initialized)
            d->load();
    }
}
 
QString QQmlSettings::fileName() const
{
    Q_D(const QQmlSettings);
    return d->fileName;
}
 
void QQmlSettings::setFileName(const QString &fileName)
{
    Q_D(QQmlSettings);
    if (d->fileName != fileName) {
        d->reset();
        d->fileName = fileName;
        if (d->initialized)
            d->load();
    }
}
 
QVariant QQmlSettings::value(const QString &key, const QVariant &defaultValue) const
{
    Q_D(const QQmlSettings);
    return d->instance()->value(key, defaultValue);
}
 
void QQmlSettings::setValue(const QString &key, const QVariant &value)
{
    Q_D(const QQmlSettings);
    d->instance()->setValue(key, value);
    qCDebug(lcSettings) << "QQmlSettings: setValue" << key << ":" << value;
}
 
void QQmlSettings::sync()
{
    Q_D(QQmlSettings);
    d->instance()->sync();
}
 
void QQmlSettings::classBegin()
{
}
 
void QQmlSettings::componentComplete()
{
    Q_D(QQmlSettings);
    d->init();
    qmlWarning(this) << "The Settings type from Qt.labs.settings is deprecated"
                        " and will be removed in a future release. Please use "
                        "the one from QtCore instead.";
}
 
void QQmlSettings::timerEvent(QTimerEvent *event)
{
    Q_D(QQmlSettings);
    if (event->timerId() == d->timerId) {
        killTimer(d->timerId);
        d->timerId = 0;
 
        d->store();
    }
    QObject::timerEvent(event);
}
 
QT_END_NAMESPACE
 
#include "moc_qqmlsettings_p.cpp"