#include "settings.h"
-const int VERSION = 1;
+const int VERSION = 1; /// Settings version for backwords/forwards incompatible changes
+
+// This is used if no VersionMinor key exists, e.g. upgrading from a Quassel version before this
+// change. This shouldn't be increased from 1; instead, change the logic in Core::Core() and
+// QtUiApplication::init() to handle upgrading and downgrading.
+const int VERSION_MINOR_INITIAL = 1; /// Initial settings version for compatible changes
QHash<QString, QVariant> Settings::settingsCache;
QHash<QString, SettingsChangeNotifier *> Settings::settingsChangeNotifier;
}
+uint Settings::versionMinor()
+{
+ // Don't cache this value; ignore the group
+ create_qsettings;
+ // '0' means new configuration, anything else indicates an existing configuration. Application
+ // initialization should check this value and manage upgrades/downgrades, e.g. in Core::Core()
+ // and QtUiApplication::init().
+ uint verMinor = s.value("Config/VersionMinor", 0).toUInt();
+
+ // As previous Quassel versions didn't implement this, we need to check if any settings other
+ // than Config/Version exist. If so, assume it's version 1.
+ if (verMinor == 0 && s.allKeys().count() > 1) {
+ // More than 1 key exists, but version's never been set. Assume and set version 1.
+ setVersionMinor(VERSION_MINOR_INITIAL);
+ return VERSION_MINOR_INITIAL;
+ } else {
+ return verMinor;
+ }
+}
+
+
+void Settings::setVersionMinor(const uint versionMinor)
+{
+ // Don't cache this value; ignore the group
+ create_qsettings;
+ // Set the value directly.
+ s.setValue("Config/VersionMinor", versionMinor);
+}
+
+
QStringList Settings::allLocalKeys()
{
create_qsettings;
return cacheValue(normKey);
}
+bool Settings::localKeyExists(const QString &key)
+{
+ QString normKey = normalizedKey(group, key);
+ if (isCached(normKey))
+ return true;
+
+ create_qsettings;
+ return s.contains(normKey);
+}
+
void Settings::removeLocalKey(const QString &key)
{
//! Sets up notification and calls the given slot to set the initial value
void initAndNotify(const QString &key, QObject *receiver, const char *slot, const QVariant &defaultValue = QVariant());
+ /**
+ * Get the major configuration version
+ *
+ * This indicates the backwards/forwards incompatible version of configuration.
+ *
+ * @return Major configuration version (the X in XX.YY)
+ */
virtual uint version();
+ /**
+ * Get the minor configuration version
+ *
+ * This indicates the backwards/forwards compatible version of configuration.
+ *
+ * @see Settings::setVersionMinor()
+ * @return Minor configuration version (the Y in XX.YY)
+ */
+ virtual uint versionMinor();
+
+ /**
+ * Set the minor configuration version
+ *
+ * When making backwards/forwards compatible changes, call this with the new version number.
+ * This does not implement any upgrade logic; implement that when checking Settings::version(),
+ * e.g. in Core::Core() and QtUiApplication::init().
+ *
+ * @param[in] versionMinor New minor version number
+ */
+ virtual void setVersionMinor(const uint versionMinor);
+
protected:
inline Settings(QString group_, QString appName_) : group(group_), appName(appName_) {}
inline virtual ~Settings() {}
virtual void setLocalValue(const QString &key, const QVariant &data);
virtual const QVariant &localValue(const QString &key, const QVariant &def = QVariant());
+ /**
+ * Gets if a key exists in settings
+ *
+ * @param[in] key ID of local settings key
+ * @returns True if key exists in settings, otherwise false
+ */
+ virtual bool localKeyExists(const QString &key);
+
virtual void removeLocalKey(const QString &key);
QString group;
// MIGRATION end
- // check settings version
- // so far, we only have 1
- QtUiSettings s;
- if (s.version() != 1) {
- qCritical() << "Invalid client settings version, terminating!";
+ // Settings upgrade/downgrade handling
+ if (!migrateSettings()) {
+ qCritical() << "Could not load or upgrade client settings, terminating!";
return false;
}
}
+bool QtUiApplication::migrateSettings()
+{
+ // --------
+ // Check major settings version. This represents incompatible changes between settings
+ // versions. So far, we only have 1.
+ QtUiSettings s;
+ uint versionMajor = s.version();
+ if (versionMajor != 1) {
+ qCritical() << qPrintable(QString("Invalid client settings version '%1'")
+ .arg(versionMajor));
+ return false;
+ }
+
+ // --------
+ // Check minor settings version, handling upgrades/downgrades as needed
+ // Current minor version
+ const uint VERSION_MINOR_CURRENT = 2;
+ // Stored minor version
+ uint versionMinor = s.versionMinor();
+
+ if (versionMinor == VERSION_MINOR_CURRENT) {
+ // At latest version, no need to migrate defaults or other settings
+ return true;
+ } else if (versionMinor == 0) {
+ // New configuration, store as current version
+ qDebug() << qPrintable(QString("Set up new client settings v%1.%2")
+ .arg(versionMajor).arg(VERSION_MINOR_CURRENT));
+ s.setVersionMinor(VERSION_MINOR_CURRENT);
+
+ // Update the settings stylesheet for first setup. We don't know if older content exists,
+ // if the configuration got erased separately, etc.
+ QtUiStyle qtUiStyle;
+ qtUiStyle.generateSettingsQss();
+ return true;
+ } else if (versionMinor < VERSION_MINOR_CURRENT) {
+ // We're upgrading - apply the neccessary upgrades from each interim version
+ // curVersion will never equal VERSION_MINOR_CURRENT, as it represents the version before
+ // the most recent applySettingsMigration() call.
+ for (uint curVersion = versionMinor; curVersion < VERSION_MINOR_CURRENT; curVersion++) {
+ if (!applySettingsMigration(s, curVersion + 1)) {
+ // Something went wrong, time to bail out
+ qCritical() << qPrintable(QString("Could not migrate client settings from v%1.%2 "
+ "to v%1.%3")
+ .arg(versionMajor).arg(curVersion).arg(curVersion + 1));
+ // Keep track of the last successful upgrade to avoid repeating it on next start
+ s.setVersionMinor(curVersion);
+ return false;
+ }
+ }
+ // Migration successful!
+ qDebug() << qPrintable(QString("Successfully migrated client settings from v%1.%2 to "
+ "v%1.%3")
+ .arg(versionMajor).arg(versionMinor).arg(VERSION_MINOR_CURRENT));
+ // Store the new minor version
+ s.setVersionMinor(VERSION_MINOR_CURRENT);
+ return true;
+ } else {
+ // versionMinor > VERSION_MINOR_CURRENT
+ // The user downgraded to an older version of Quassel. Let's hope for the best.
+ // Don't change the minorVersion as the newer version's upgrade logic has already run.
+ qWarning() << qPrintable(QString("Client settings v%1.%2 is newer than latest known v%1.%3,"
+ " things might not work!")
+ .arg(versionMajor).arg(versionMinor).arg(VERSION_MINOR_CURRENT));
+ return true;
+ }
+}
+
+
+bool QtUiApplication::applySettingsMigration(QtUiSettings settings, const uint newVersion)
+{
+ switch (newVersion) {
+ // Version 0 and 1 aren't valid upgrade paths - one represents no version, the other is the
+ // oldest version. Ignore those, start from 2 and higher.
+ // Each missed version will be called in sequence. E.g. to upgrade from '1' to '3', this
+ // function will be called with '2', then '3'.
+ case 2:
+ {
+ // Use explicit scope via { ... } to avoid cross-initialization
+
+ // New default changes: sender <nick> brackets disabled, sender colors and sender CTCP
+ // colors enabled. Preserve the older default values for keys that haven't been saved.
+
+ // --------
+ // ChatView settings
+ const QString timestampFormatId = "ChatView/__default__/TimestampFormat";
+ if (!settings.valueExists(timestampFormatId)) {
+ // New default value is " hh:mm:ss", preserve old default of "[hh:mm:ss]"
+ settings.setValue(timestampFormatId, "[hh:mm:ss]");
+ }
+
+ const QString showSenderBracketsId = "ChatView/__default__/ShowSenderBrackets";
+ if (!settings.valueExists(showSenderBracketsId)) {
+ // New default is false, preserve previous behavior by setting to true
+ settings.setValue(showSenderBracketsId, true);
+ }
+ // --------
+
+ // --------
+ // QtUiStyle settings
+ QtUiStyleSettings settingsUiStyleColors("Colors");
+ const QString useSenderColorsId = "UseSenderColors";
+ if (!settingsUiStyleColors.valueExists(useSenderColorsId)) {
+ // New default is true, preserve previous behavior by setting to false
+ settingsUiStyleColors.setValue(useSenderColorsId, false);
+ }
+
+ const QString useSenderActionColorsId = "UseSenderActionColors";
+ if (!settingsUiStyleColors.valueExists(useSenderActionColorsId)) {
+ // New default is true, preserve previous behavior by setting to false
+ settingsUiStyleColors.setValue(useSenderActionColorsId, false);
+ }
+
+ // Update the settings stylesheet with old defaults
+ QtUiStyle qtUiStyle;
+ qtUiStyle.generateSettingsQss();
+ // --------
+
+ // Migration complete!
+ return true;
+ }
+ default:
+ // Something unexpected happened
+ return false;
+ }
+}
+
+
void QtUiApplication::commitData(QSessionManager &manager)
{
Q_UNUSED(manager)