256 lines
8.4 KiB
C++
256 lines
8.4 KiB
C++
/*
|
|
* Sailfin: a Jellyfin client written using Qt
|
|
* Copyright (C) 2021 Chris Josten and the Sailfin Contributors
|
|
*
|
|
* This library 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
|
|
*/
|
|
|
|
/***************************************************************************
|
|
** Copyright (C) 2014 Jolla Mobile <andrew.den.exter@jollamobile.com>
|
|
**
|
|
** This library is free software; you can redistribute it and/or
|
|
** modify it 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 included in the packaging
|
|
** of this file.
|
|
**
|
|
****************************************************************************/
|
|
|
|
|
|
#include "JellyfinQt/qobjectsettingswrapper.h"
|
|
|
|
#ifndef USE_MLITE
|
|
#include <QDebug>
|
|
#include <QMetaProperty>
|
|
#include <QMetaObject>
|
|
#include <QSettings>
|
|
|
|
namespace Jellyfin {
|
|
class QObjectSettingsWrapperPrivate {
|
|
Q_DECLARE_PUBLIC(QObjectSettingsWrapper);
|
|
public:
|
|
explicit QObjectSettingsWrapperPrivate(QObjectSettingsWrapper *parent);
|
|
virtual ~QObjectSettingsWrapperPrivate() {}
|
|
void readValue(const QMetaProperty &prop);
|
|
void resolveProperties(QByteArray path);
|
|
|
|
QSettings m_settings;
|
|
int propertyOffset = -1;
|
|
int notifyIndex = -1;
|
|
QString path;
|
|
QByteArray absolutePath;
|
|
QObjectSettingsWrapper *scope = nullptr;
|
|
QObjectSettingsWrapper *q_ptr = nullptr;
|
|
QList<QObjectSettingsWrapper *> children;
|
|
};
|
|
|
|
QObjectSettingsWrapper::QObjectSettingsWrapper(QObject *parent,
|
|
BindOption bindOption)
|
|
: QObject(parent),
|
|
d_ptr(new QObjectSettingsWrapperPrivate(this)){
|
|
|
|
if (bindOption == DontBindProperties)
|
|
resolveMetaObject(metaObject()->propertyCount());
|
|
}
|
|
|
|
QObjectSettingsWrapper::QObjectSettingsWrapper(const QString &path,
|
|
QObject *parent,
|
|
BindOption bindOption)
|
|
: QObject(parent),
|
|
d_ptr(new QObjectSettingsWrapperPrivate(this)){
|
|
|
|
d_ptr->path = path;
|
|
|
|
if (bindOption == DontBindProperties)
|
|
resolveMetaObject(metaObject()->propertyCount());
|
|
}
|
|
|
|
QObjectSettingsWrapper::~QObjectSettingsWrapper() {}
|
|
|
|
bool QObjectSettingsWrapper::isSynchronous() const {
|
|
return true;
|
|
}
|
|
|
|
void QObjectSettingsWrapper::setSynchronous(bool synchronous) {
|
|
Q_UNUSED(synchronous)
|
|
// NOOP
|
|
}
|
|
|
|
void QObjectSettingsWrapper::setPath(const QString &path) {
|
|
Q_D(QObjectSettingsWrapper);
|
|
if (d->path != path) {
|
|
const bool isAbsolute = d->path.startsWith("/");
|
|
d->path = path;
|
|
emit pathChanged();
|
|
|
|
// If the new path is absolute connect to the changed signal and read the initial values,
|
|
// if it's relative and the parent scope is valid just read the initial values.
|
|
if (d->path.isEmpty() ||d->propertyOffset < 0) {
|
|
// No path or the object is not yet resolved, so don't do any of the following things.
|
|
} else if (isAbsolute) {
|
|
d->resolveProperties(QByteArray());
|
|
} else if (d->scope && !d->scope->d_func()->absolutePath.isEmpty()) {
|
|
d->resolveProperties(d->scope->d_func()->absolutePath);
|
|
}
|
|
}
|
|
}
|
|
|
|
QString QObjectSettingsWrapper::path() const {
|
|
Q_D(const QObjectSettingsWrapper);
|
|
return d_ptr->m_settings.group();
|
|
}
|
|
|
|
QObjectSettingsWrapper *QObjectSettingsWrapper::scope() const {
|
|
Q_D(const QObjectSettingsWrapper);
|
|
return d->scope;
|
|
}
|
|
|
|
void QObjectSettingsWrapper::setScope(QObjectSettingsWrapper *scope) {
|
|
Q_D(QObjectSettingsWrapper);
|
|
const bool isAbsolute = d->path.startsWith("/");
|
|
if (d->scope) {
|
|
d->scope->d_func()->children.removeAll(this);
|
|
}
|
|
d->scope = scope;
|
|
|
|
if (d->scope) {
|
|
d->scope->d_func()->children.append(this);
|
|
|
|
// If the path is relative and the new scope is valid read the initial values.
|
|
if (!d->path.isEmpty() && !isAbsolute && !d->scope->d_func()->absolutePath.isEmpty()) {
|
|
d->resolveProperties(d->scope->d_func()->absolutePath);
|
|
}
|
|
}
|
|
|
|
emit scopeChanged();
|
|
}
|
|
|
|
QVariant QObjectSettingsWrapper::value(const QString &key, const QVariant &defaultValue, int typeHint) const {
|
|
Q_UNUSED(typeHint)
|
|
Q_D(const QObjectSettingsWrapper);
|
|
const QByteArray absoluteKey = !key.startsWith(QLatin1Char('/'))
|
|
? d->absolutePath + key.toUtf8()
|
|
: key.toUtf8();
|
|
QVariant value = d->m_settings.value(absoluteKey, defaultValue);
|
|
return value.isValid() ? value : defaultValue;
|
|
}
|
|
|
|
void QObjectSettingsWrapper::setValue(const QString &key, const QVariant &value) {
|
|
Q_D(QObjectSettingsWrapper);
|
|
if (d->absolutePath.isEmpty() || key.isEmpty()) return;
|
|
|
|
const QByteArray absoluteKey = !key.startsWith(QLatin1Char('/'))
|
|
? d->absolutePath + key.toUtf8()
|
|
: key.toUtf8();
|
|
d->m_settings.setValue(absoluteKey, value);
|
|
}
|
|
|
|
void QObjectSettingsWrapper::sync() {
|
|
// NOOP
|
|
}
|
|
|
|
void QObjectSettingsWrapper::clear() {
|
|
Q_D(QObjectSettingsWrapper);
|
|
d->m_settings.clear();
|
|
}
|
|
|
|
|
|
void QObjectSettingsWrapper::resolveMetaObject(int propertyOffset) {
|
|
Q_D(QObjectSettingsWrapper);
|
|
qDebug() << "Resolving meta object";
|
|
|
|
if (d->propertyOffset >= 0) return;
|
|
|
|
const int propertyChangedIndex = staticMetaObject.indexOfMethod("propertyChanged()");
|
|
Q_ASSERT(propertyChangedIndex != -1);
|
|
|
|
const QMetaObject * const metaObject = this->metaObject();
|
|
|
|
if (propertyOffset < 0) {
|
|
propertyOffset = staticMetaObject.propertyCount();
|
|
}
|
|
d->propertyOffset = propertyOffset;
|
|
qDebug() << "Property offset: " << propertyOffset << ", total properties: " << metaObject->propertyCount();
|
|
|
|
for (int i = propertyOffset; i < metaObject->propertyCount(); i++) {
|
|
const QMetaProperty prop = metaObject->property(i);
|
|
qDebug() << "Encountered prop " << prop.name();
|
|
if (prop.hasNotifySignal()) {
|
|
QMetaObject::connect(this,
|
|
prop.notifySignalIndex(),
|
|
this,
|
|
propertyChangedIndex,
|
|
Qt::UniqueConnection);
|
|
}
|
|
}
|
|
|
|
if (d->path.startsWith("/")) {
|
|
d->resolveProperties("");
|
|
} else if (d->scope && !d->path.isEmpty() && !d->scope->d_func()->absolutePath.isEmpty()) {
|
|
d->resolveProperties(d->scope->d_func()->absolutePath);
|
|
}
|
|
}
|
|
|
|
void QObjectSettingsWrapper::propertyChanged() {
|
|
Q_D(QObjectSettingsWrapper);
|
|
|
|
const int notifyIndex = senderSignalIndex();
|
|
if (notifyIndex == d->notifyIndex) return;
|
|
|
|
const QMetaObject * const metaObject = this->metaObject();
|
|
|
|
for (int i = d->propertyOffset; i < metaObject->propertyCount(); i++) {
|
|
const QMetaProperty prop = metaObject->property(i);
|
|
if (prop.notifySignalIndex() == notifyIndex) {
|
|
qDebug() << "Property changed, name: " << prop.name();
|
|
d->m_settings.setValue(d->absolutePath + prop.name(), prop.read(this));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Private
|
|
|
|
QObjectSettingsWrapperPrivate::QObjectSettingsWrapperPrivate(QObjectSettingsWrapper *parent)
|
|
: q_ptr(parent),
|
|
m_settings(QSettings(parent)) {
|
|
|
|
}
|
|
|
|
void QObjectSettingsWrapperPrivate::resolveProperties(QByteArray scopePath) {
|
|
absolutePath = scopePath + path.toUtf8() + '/';
|
|
Q_Q(QObjectSettingsWrapper);
|
|
|
|
const QMetaObject * const metaObject = q->metaObject();
|
|
for (int i = propertyOffset; i < metaObject->propertyCount(); i++) {
|
|
readValue(metaObject->property(i));
|
|
}
|
|
}
|
|
|
|
void QObjectSettingsWrapperPrivate::readValue(const QMetaProperty &prop) {
|
|
Q_Q(QObjectSettingsWrapper);
|
|
const QVariant value = m_settings.value(absolutePath + prop.name(), prop.type());
|
|
if (value.isValid()) {
|
|
notifyIndex = prop.notifySignalIndex();
|
|
prop.write(q, value);
|
|
notifyIndex = -1;
|
|
}
|
|
}
|
|
|
|
} // NS Jellyfin
|
|
|
|
#endif
|
|
|