feat: config object migration path and add new options to settings

Plugins/ZShell/Config/CMakeLists.txt

@@ -5,6 +5,7 @@ qml_module(ZShell-config
 		configobject.hpp configobject.cpp
 		configlist.hpp configlist.cpp
 		config.hpp config.cpp
+		migration.hpp migration.cpp
 		anim.hpp anim.cpp
 		tokens.hpp
 		appearance.hpp
@@ -13,6 +14,7 @@ qml_module(ZShell-config
 		clipboard.hpp
 		colors.hpp
 		dashboard.hpp
+		display.hpp
 		dock.hpp
 		general.hpp
 		launcher.hpp

Plugins/ZShell/Config/colors.hpp

@@ -22,6 +22,13 @@ class Colors : public ConfigObject {
 
 	CONFIG_SUBOBJECT(Presets, presets)
 	CFG_PROPERTY(QString, schemeType, QStringLiteral("fidelity"))
+	CFG_PROPERTY(bool, scheduleDark, false)
+	CFG_PROPERTY(int, scheduleDarkEnd, 600)
+	CFG_PROPERTY(int, scheduleDarkStart, 1140)
+	CFG_PROPERTY(bool, schemeGen, true)
+	CFG_PROPERTY(bool, neovimColors, false)
+	CFG_PROPERTY(QString, mode, QStringLiteral("dark"))
+	CFG_PROPERTY(bool, smart, false)
 
 	public:
 	explicit Colors(QObject* parent = nullptr)

Plugins/ZShell/Config/config.cpp

@@ -6,11 +6,13 @@
 #include "clipboard.hpp"
 #include "colors.hpp"
 #include "dashboard.hpp"
+#include "display.hpp"
 #include "dock.hpp"
 #include "general.hpp"
 #include "launcher.hpp"
 #include "llm.hpp"
 #include "lock.hpp"
+#include "migration.hpp"
 #include "notifs.hpp"
 #include "osd.hpp"
 #include "screenshot.hpp"
@@ -44,6 +46,7 @@ Config::Config(QObject* parent)
 	, m_clipboard(new Clipboard(this))
 	, m_colors(new Colors(this))
 	, m_dashboard(new Dashboard(this))
+	, m_display(new Display(this))
 	, m_dock(new Dock(this))
 	, m_general(new General(this))
 	, m_launcher(new Launcher(this))
@@ -111,11 +114,14 @@ void Config::loadSync() {
 	QJsonObject before;
 
 	bool existed = false;
+	bool migrated = false;
 
 	if (f.open(QIODevice::ReadOnly)) {
 		const auto doc = QJsonDocument::fromJson(f.readAll());
 		if (doc.isObject()) {
-			before = doc.object();
+			const QJsonObject raw = doc.object();
+			before = ConfigMigrations::apply(raw);
+			migrated = before != raw;
 			existed = true;
 		} else {
 			qInfo() << "Config: existing config at" << filePath()
@@ -130,7 +136,7 @@ void Config::loadSync() {
 	m_loading = false;
 
 	const auto after = toJson().toObject();
-	if (!existed || after != before) saveNow();
+	if (!existed || migrated || after != before) saveNow();
 }
 
 void Config::updateWatch() {
@@ -176,16 +182,18 @@ void Config::loadAsync() {
 		if (f.open(QIODevice::ReadOnly)) {
 			const auto doc = QJsonDocument::fromJson(f.readAll());
 			const bool valid = doc.isObject();
-			const QJsonObject before = valid ? doc.object() : QJsonObject();
+			const QJsonObject raw = valid ? doc.object() : QJsonObject();
+			const QJsonObject before = ConfigMigrations::apply(raw);
+			const bool migrated = valid && before != raw;
 
 			QMetaObject::invokeMethod(
 				this,
-				[this, valid, before]() {
+				[this, valid, migrated, before]() {
 					loadFromJson(QJsonValue(before));
 					m_loading = false;
 
 					const auto after = toJson().toObject();
-					if (!valid || after != before) saveNow();
+					if (!valid || migrated || after != before) saveNow();
 
 					if (m_reloadPending) m_reloadTimer.start();
 				},

Plugins/ZShell/Config/config.hpp

@@ -21,6 +21,7 @@ class Bar;
 class Clipboard;
 class Colors;
 class Dashboard;
+class Display;
 class Dock;
 class General;
 class Launcher;
@@ -44,6 +45,7 @@ class Config : public ConfigObject {
 	Q_MOC_INCLUDE("clipboard.hpp")
 	Q_MOC_INCLUDE("colors.hpp")
 	Q_MOC_INCLUDE("dashboard.hpp")
+	Q_MOC_INCLUDE("display.hpp")
 	Q_MOC_INCLUDE("dock.hpp")
 	Q_MOC_INCLUDE("general.hpp")
 	Q_MOC_INCLUDE("launcher.hpp")
@@ -62,6 +64,7 @@ class Config : public ConfigObject {
 	CONFIG_SUBOBJECT(Clipboard, clipboard)
 	CONFIG_SUBOBJECT(Colors, colors)
 	CONFIG_SUBOBJECT(Dashboard, dashboard)
+	CONFIG_SUBOBJECT(Display, display)
 	CONFIG_SUBOBJECT(Dock, dock)
 	CONFIG_SUBOBJECT(General, general)
 	CONFIG_SUBOBJECT(Launcher, launcher)

Plugins/ZShell/Config/display.hpp

@@ -0,0 +1,33 @@
+#pragma once
+#include "configobject.hpp"
+#include <qqmlintegration.h>
+
+namespace ZShell::config {
+
+class Nightlight : public ConfigObject {
+	Q_OBJECT
+	QML_ANONYMOUS
+
+	CFG_PROPERTY(bool, schedule, true)
+	CFG_PROPERTY(int, scheduleStart, 1200)
+	CFG_PROPERTY(int, scheduleEnd, 570)
+	CFG_PROPERTY(bool, useNative, true)
+	CFG_PROPERTY(int, fadeDuration, 2000)
+	CFG_PROPERTY(int, temp, 2600)
+
+	public:
+	explicit Nightlight(QObject* parent = nullptr) : ConfigObject(parent) {}
+};
+
+class Display : public ConfigObject {
+	Q_OBJECT
+	QML_ANONYMOUS
+
+	CONFIG_SUBOBJECT(Nightlight, nightlight)
+
+	public:
+	explicit Display(QObject* parent = nullptr)
+		: ConfigObject(parent), m_nightlight(new Nightlight(this)) {}
+};
+
+} // namespace ZShell::config

Plugins/ZShell/Config/general.hpp

@@ -91,28 +91,6 @@ class Battery : public ConfigObject {
 	explicit Battery(QObject* parent = nullptr) : ConfigObject(parent) {}
 };
 
-class ColorSettings : public ConfigObject {
-	Q_OBJECT
-	QML_ANONYMOUS
-
-	CFG_PROPERTY(int, hyprsunsetTemp, 2600)
-	CFG_PROPERTY(QString, mode, QStringLiteral("dark"))
-	CFG_PROPERTY(bool, neovimColors, false)
-	CFG_PROPERTY(bool, useNativeNightlight, true)
-	CFG_PROPERTY(int, nativeFadeDuration, 2000)
-	CFG_PROPERTY(bool, scheduleDark, false)
-	CFG_PROPERTY(int, scheduleDarkEnd, 600)
-	CFG_PROPERTY(int, scheduleDarkStart, 1140)
-	CFG_PROPERTY(bool, scheduleHyprsunset, true)
-	CFG_PROPERTY(int, scheduleHyprsunsetEnd, 570)
-	CFG_PROPERTY(int, scheduleHyprsunsetStart, 1200)
-	CFG_PROPERTY(bool, schemeGeneration, true)
-	CFG_PROPERTY(bool, smart, false)
-
-	public:
-	explicit ColorSettings(QObject* parent = nullptr) : ConfigObject(parent) {}
-};
-
 class Idle : public ConfigObject {
 	Q_OBJECT
 	QML_ANONYMOUS
@@ -137,7 +115,6 @@ class General : public ConfigObject {
 
 	CONFIG_SUBOBJECT(Apps, apps)
 	CONFIG_SUBOBJECT(Battery, battery)
-	CONFIG_SUBOBJECT(ColorSettings, color)
 	CFG_PROPERTY(QString, dateFormat, QStringLiteral("ddd d MMM - hh:mm:ss"))
 	CFG_PROPERTY(bool, desktopIcons, true)
 	CONFIG_SUBOBJECT(Idle, idle)
@@ -153,7 +130,6 @@ class General : public ConfigObject {
 		: ConfigObject(parent)
 		, m_apps(new Apps(this))
 		, m_battery(new Battery(this))
-		, m_color(new ColorSettings(this))
 		, m_idle(new Idle(this)) {}
 };
 

Plugins/ZShell/Config/migration.cpp

@@ -0,0 +1,123 @@
+#include "migration.hpp"
+
+#include <QDebug>
+
+namespace ZShell::config {
+
+namespace {
+
+// A stored value is "missing" if the path does not resolve to an entry.
+// Note: default-constructed QJsonValue is Null, not Undefined.
+bool isMissing(const QJsonValue& v) {
+	return v.isUndefined() || v.isNull();
+}
+
+QJsonValue valueAt(const QJsonObject& obj, const QStringList& path) {
+	QJsonObject cur = obj;
+
+	for (int i = 0; i < path.size() - 1; ++i) {
+		if (!cur.value(path.at(i)).isObject()) return QJsonValue::Undefined;
+		cur = cur.value(path.at(i)).toObject();
+	}
+
+	const QString key = path.last();
+	if (!cur.contains(key)) return QJsonValue::Undefined;
+	return cur.value(key);
+}
+
+QJsonObject placeAt(QJsonObject obj, QStringList path, const QJsonValue& value) {
+	const QString head = path.takeFirst();
+
+	if (path.isEmpty()) {
+		obj[head] = value;
+		return obj;
+	}
+
+	QJsonObject child = obj.value(head).isObject() ? obj.value(head).toObject()
+												   : QJsonObject();
+	obj[head] = placeAt(child, path, value);
+	return obj;
+}
+
+// Removes `path` from `obj`. Returns true if a value was removed.
+// Parent objects left empty are removed as well.
+bool removeAt(QJsonObject& obj, const QStringList& path) {
+	const QString head = path.first();
+
+	if (path.size() == 1) {
+		if (!obj.contains(head)) return false;
+		obj.remove(head);
+		return true;
+	}
+
+	if (!obj.value(head).isObject()) return false;
+
+	QJsonObject child = obj.value(head).toObject();
+	const bool removed = removeAt(child, path.mid(1));
+
+	if (child.isEmpty())
+		obj.remove(head);
+	else
+		obj[head] = child;
+
+	return removed;
+}
+
+} // namespace
+
+const QList<ConfigMigrationRule>& ConfigMigrations::rules() {
+	static const QList<ConfigMigrationRule> s_rules = {
+		migrate(
+			"general.color.scheduleHyprsunset", "display.nightlight.schedule"),
+		migrate(
+			"general.color.scheduleHyprsunsetStart",
+			"display.nightlight.scheduleStart"),
+		migrate(
+			"general.color.scheduleHyprsunsetEnd",
+			"display.nightlight.scheduleEnd"),
+		migrate("general.color.scheduleDark", "colors.scheduleDark"),
+		migrate("general.color.scheduleDarkStart", "colors.scheduleDarkStart"),
+		migrate("general.color.scheduleDarkEnd", "colors.scheduleDarkEnd"),
+		migrate("general.color.schemeGeneration", "colors.schemeGen"),
+		migrate(
+			"general.color.useNativeNightlight",
+			"display.nightlight.useNative"),
+		migrate(
+			"general.color.nativeFadeDuration",
+			"display.nightlight.fadeDuration"),
+		migrate("general.color.hyprsunsetTemp", "display.nightlight.temp"),
+		migrate("general.color.neovimColors", "colors.neovimColors"),
+		migrate("general.color.mode", "colors.mode"),
+		migrate("general.color.smart", "colors.smart"),
+	};
+	return s_rules;
+}
+
+QJsonObject ConfigMigrations::apply(const QJsonObject& json) {
+	QJsonObject obj = json;
+
+	for (const auto& rule : rules()) {
+		const QStringList from =
+			rule.from.split(QLatin1Char('.'), Qt::SkipEmptyParts);
+		const QStringList to =
+			rule.to.split(QLatin1Char('.'), Qt::SkipEmptyParts);
+
+		if (from.isEmpty() || to.isEmpty()) continue;
+
+		const QJsonValue oldValue = valueAt(obj, from);
+		if (isMissing(oldValue)) continue;
+
+		const bool targetExists = !isMissing(valueAt(obj, to));
+		if (!targetExists) obj = placeAt(obj, to, oldValue);
+
+		if (removeAt(obj, from)) {
+			qInfo() << "Config migration:" << rule.from << "->" << rule.to
+					<< (targetExists ? "(target already set, old value dropped)"
+									 : "(value moved)");
+		}
+	}
+
+	return obj;
+}
+
+} // namespace ZShell::config

Plugins/ZShell/Config/migration.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <QJsonObject>
+#include <QStringList>
+
+namespace ZShell::config {
+
+// A single migration rule: move the value stored at the dotted `from` path
+// to the dotted `to` path, then delete the old key (and any parent objects
+// left empty).
+//
+// Rules are applied to the raw JSON file on every load, before the schema
+// loads it. They are idempotent: once the old key is gone the rule never
+// fires again, so no version stamping is needed. Old rules can stay in the
+// table forever.
+//
+// WARNING: the target path must exist in the schema (i.e. a ConfigObject
+// property somewhere in the tree). If it does not, the migrated value is
+// loaded as an unknown key and silently dropped on the next save.
+struct ConfigMigrationRule {
+	QString from;
+	QString to;
+};
+
+// Helper for writing rules: migrate("general.color.foo", "display.bar.foo")
+inline ConfigMigrationRule migrate(const QString& from, const QString& to) {
+	return {from, to};
+}
+
+class ConfigMigrations {
+	public:
+	[[nodiscard]] static const QList<ConfigMigrationRule>& rules();
+
+	// Applies all rules to `json`, returning the migrated object.
+	[[nodiscard]] static QJsonObject apply(const QJsonObject& json);
+};
+
+} // namespace ZShell::config

Plugins/ZShell/Services/nightlightmanager.cpp

@@ -10,7 +10,6 @@ namespace ZShell::services {
 
 namespace {
 constexpr const char* NL_EVENT = "zshell-nightlight";
-constexpr int NEUTRAL_KELVIN = 6500;
 constexpr int RECONNECT_MS = 2000;
 } // namespace
 
@@ -404,7 +403,6 @@ void NightlightManager::handleEventLine(const QByteArray& line) {
 
 	if (line.left(sep) != NL_EVENT) return;
 
-	// data = enabled,animating,last,current
 	const auto fields = line.mid(sep + 2).split(',');
 	if (fields.size() < 4) return;