Merge branch 'main' into 100-cli-autocompletion

Reviewed-on: #101
Reviewed-by: zach <zach@brohn.se>

Config/Config.qml

@@ -22,7 +22,6 @@ Singleton {
 	property alias notifs: adapter.notifs
 	property alias osd: adapter.osd
 	property alias overview: adapter.overview
-	property alias plugins: adapter.plugins
 	property bool recentlySaved: false
 	property alias screenshot: adapter.screenshot
 	property alias services: adapter.services
@@ -141,8 +140,7 @@ Singleton {
 			launcher: serializeLauncher(),
 			colors: serializeColors(),
 			dock: serializeDock(),
-			screenshot: serializeScreenshot(),
-			plugins: serializePlugins()
+			screenshot: serializeScreenshot()
 		};
 	}
 
@@ -216,6 +214,10 @@ Singleton {
 			},
 			idle: {
 				timeouts: general.idle.timeouts
+			},
+			battery: {
+				popupThresholds: general.battery.popupThresholds,
+				critPerc: general.battery.critPerc
 			}
 		};
 	}
@@ -291,13 +293,6 @@ Singleton {
 		};
 	}
 
-	function serializePlugins(): var {
-		return {
-			enabled: plugins.enabled,
-			entries: plugins.entries
-		};
-	}
-
 	function serializeScreenshot(): var {
 		return {
 			enable_pp: screenshot.enable_pp,
@@ -467,8 +462,6 @@ Singleton {
 			}
 			property Overview overview: Overview {
 			}
-			property PluginConfig plugins: PluginConfig {
-			}
 			property Screenshot screenshot: Screenshot {
 			}
 			property Services services: Services {

Config/General.qml

@@ -4,6 +4,8 @@ import Quickshell
 JsonObject {
 	property Apps apps: Apps {
 	}
+	property Battery battery: Battery {
+	}
 	property Color color: Color {
 	}
 	property string dateFormat: "ddd d MMM - hh:mm:ss"
@@ -19,6 +21,17 @@ JsonObject {
 		property list<string> playback: ["mpv"]
 		property list<string> terminal: ["kitty"]
 	}
+	component Battery: JsonObject {
+		property int critPerc: 5
+		property list<var> popupThresholds: [
+			{
+				perc: 20,
+				name: qsTr("Low battery"),
+				message: qsTr("Battery at %1%").arg(Battery.currentPerc * 100),
+				icon: "battery_android_frame_2"
+			},
+		]
+	}
 	component Color: JsonObject {
 		property int hyprsunsetTemp: 5000
 		property string mode: "dark"

Config/PluginConfig.qml

@@ -1,11 +0,0 @@
-import Quickshell.Io
-
-JsonObject {
-	property bool enabled: false
-	property list<var> entries: [
-		{
-			id: "Plugin",
-			enabled: false
-		},
-	]
-}

Daemons/Battery.qml

@@ -0,0 +1,46 @@
+import Quickshell
+import Quickshell.Services.UPower
+import QtQuick
+import ZShell
+import qs.Config
+import qs.Components.Toast
+
+Scope {
+	id: root
+
+	readonly property real currentPerc: UPower.displayDevice.percentage
+	readonly property list<var> popupThresholds: [...Config.general.battery.popupThresholds].sort((a, b) => b.perc - a.perc)
+
+	Connections {
+		function onOnBatteryChanged(): void {
+			if (UPower.onBattery) {
+				if (Config.utilities.toasts.chargingChanged)
+					Toaster.toast(qsTr("Charger unplugged"), qsTr("Battery is discharging"), "power_off");
+			} else {
+				if (Config.utilities.toasts.chargingChanged)
+					Toaster.toast(qsTr("Charger plugged in"), qsTr("Battery is charging"), "power");
+				for (const level of root.popupThresholds)
+					level.warned = false;
+			}
+		}
+
+		target: UPower
+	}
+
+	Connections {
+		function onPercentageChanged(): void {
+			if (!UPower.onBattery)
+				return;
+
+			const p = UPower.displayDevice.percentage * 100;
+			for (const perc of root.popupThresholds) {
+				if (p <= perc.perc && !perc.warned) {
+					perc.warned = true;
+					Toaster.toast(perc.title ?? qsTr("Battery warning"), perc.message ?? qsTr("Battery perc is low"), perc.icon ?? "battery_android_alert", perc.critical ? Toast.Error : Toast.Warning);
+				}
+			}
+		}
+
+		target: UPower.displayDevice
+	}
+}

Drawers/Windows.qml

@@ -35,7 +35,7 @@ Variants {
 			property var root: Quickshell.shellDir
 
 			WlrLayershell.exclusionMode: ExclusionMode.Ignore
-			WlrLayershell.keyboardFocus: visibilities.dock || visibilities.launcher || visibilities.sidebar || visibilities.dashboard || visibilities.settings || visibilities.resources ? WlrKeyboardFocus.OnDemand : WlrKeyboardFocus.None
+			// WlrLayershell.keyboardFocus: visibilities.dock || visibilities.launcher || visibilities.sidebar || visibilities.dashboard || visibilities.settings || visibilities.resources ? WlrKeyboardFocus.OnDemand : WlrKeyboardFocus.None
 			color: "transparent"
 			contentItem.focus: true
 			mask: visibilities.isDrawing ? null : region

Extensions/FetchPlugins.qml

@@ -1,18 +0,0 @@
-pragma Singleton
-
-import Quickshell
-import ZShell.Models
-
-Singleton {
-	id: root
-
-	property alias plugins: plugins.entries
-
-	FileSystemModel {
-		id: plugins
-
-		nameFilters: ["*.qml"]
-		path: Quickshell.env("HOME") + "/.config/zshell"
-		recursive: false
-	}
-}

Extensions/LoadExtensions.qml

@@ -1,17 +0,0 @@
-import Quickshell
-import QtQuick
-import ZShell.Models
-import qs.Config
-
-Repeater {
-	model: FetchPlugins.plugins
-
-	LazyLoader {
-		required property FileSystemEntry modelData
-
-		activeAsync: Config.plugins.entries.some(p => {
-			return p.id === modelData.baseName && p.enabled;
-		})
-		source: modelData.path
-	}
-}

Modules/Launcher/Wrapper.qml

@@ -4,6 +4,7 @@ import Quickshell
 import QtQuick
 import qs.Components
 import qs.Config
+import qs.Modules.Launcher.Services
 
 Item {
 	id: root
@@ -19,26 +20,17 @@ Item {
 			max -= panels.popouts.nonAnimHeight;
 		return max;
 	}
+	property real offsetScale: shouldBeActive ? 0 : 1
 	required property var panels
 	required property ShellScreen screen
-	required property PersistentProperties visibilities
 	readonly property bool shouldBeActive: visibilities.launcher
-	property real offsetScale: shouldBeActive ? 0 : 1
+	required property PersistentProperties visibilities
 
-	onShouldBeActiveChanged: {
-		if (shouldBeActive) {
-			implicitHeight = Qt.binding(() => content.implicitHeight);
-			timer.stop();
-		} else {
-			implicitHeight = implicitHeight;
-		}
-	}
-
-	visible: offsetScale < 1
 	anchors.bottomMargin: (-implicitHeight - 5) * offsetScale
 	implicitHeight: content.implicitHeight
 	implicitWidth: content.implicitWidth || 400
 	opacity: 1 - offsetScale
+	visible: offsetScale < 1
 
 	Behavior on offsetScale {
 		Anim {
@@ -47,61 +39,26 @@ Item {
 		}
 	}
 
-	onMaxHeightChanged: timer.start()
-
-	Connections {
-		function onEnabledChanged(): void {
-			timer.start();
-		}
-
-		function onMaxShownChanged(): void {
-			timer.start();
-		}
-
-		target: Config.launcher
-	}
-
-	Connections {
-		function onValuesChanged(): void {
-			if (DesktopEntries.applications.values.length < Config.launcher.maxAppsShown)
-				timer.start();
-		}
-
-		target: DesktopEntries.applications
-	}
-
-	Timer {
-		id: timer
-
-		interval: Appearance.anim.durations.small
-
-		onRunningChanged: {
-			if (running && !root.shouldBeActive) {
-				content.visible = false;
-				content.active = true;
-			} else {
-				root.contentHeight = Math.min(root.maxHeight, content.implicitHeight);
-				content.active = Qt.binding(() => root.shouldBeActive || root.visible);
-				content.visible = true;
-			}
-		}
+	Component.onCompleted: Qt.callLater(() => Apps)
+	onShouldBeActiveChanged: {
+		if (shouldBeActive)
+			implicitHeight = Qt.binding(() => content.implicitHeight);
+		else
+			implicitHeight = implicitHeight;
 	}
 
 	Loader {
 		id: content
 
-		active: false
+		active: root.shouldBeActive || root.visible
 		anchors.horizontalCenter: parent.horizontalCenter
 		anchors.top: parent.top
+		asynchronous: true
 
 		sourceComponent: Content {
 			maxHeight: root.maxHeight
 			panels: root.panels
 			visibilities: root.visibilities
-
-			Component.onCompleted: root.contentHeight = implicitHeight
 		}
-
-		Component.onCompleted: timer.start()
 	}
 }

Modules/Settings/Categories.qml

@@ -116,12 +116,6 @@ Item {
 			key: "updates"
 			name: "Updates"
 		}
-
-		ListElement {
-			icon: "extension"
-			key: "plugins"
-			name: "Extensions"
-		}
 	}
 
 	CustomClippingRect {

Modules/Settings/Categories/Plugins.qml

@@ -1,18 +0,0 @@
-import qs.Modules.Settings.Controls
-import qs.Config
-
-SettingsPage {
-	SettingsSection {
-		sectionId: "Plugins"
-
-		SettingsHeader {
-			name: "Plugins"
-		}
-
-		SettingBarEntryList {
-			name: "Enable or disable plugins"
-			object: Config.plugins
-			setting: "entries"
-		}
-	}
-}

Modules/Settings/Content.qml

@@ -79,8 +79,6 @@ Item {
 				stack.push(screenshot);
 			else if (currentCategory === "updates")
 				stack.push(updates);
-			else if (currentCategory === "plugins")
-				stack.push(plugins);
 		}
 
 		target: root
@@ -247,11 +245,4 @@ Item {
 		Cat.SystemUpdates {
 		}
 	}
-
-	Component {
-		id: plugins
-
-		Cat.Plugins {
-		}
-	}
 }

Modules/Wallpaper/Wallpaper.qml

@@ -6,7 +6,7 @@ import qs.Modules.DesktopIcons
 
 Loader {
 	active: Config.background.enabled
-	asynchronous: true
+	asynchronous: false
 
 	sourceComponent: Variants {
 		model: Quickshell.screens

Plugins/ZShell/Models/filesystemmodel.cpp

@@ -7,464 +7,473 @@
 namespace ZShell::models {
 
 FileSystemEntry::FileSystemEntry(const QString& path, const QString& relativePath, QObject* parent)
-	: QObject(parent)
-	, m_fileInfo(path)
-	, m_path(path)
-	, m_relativePath(relativePath)
-	, m_isImageInitialised(false)
-	, m_mimeTypeInitialised(false) {
-}
+    : QObject(parent)
+    , m_fileInfo(path)
+    , m_path(path)
+    , m_relativePath(relativePath)
+    , m_isImageInitialised(false)
+    , m_mimeTypeInitialised(false) {}
 
 QString FileSystemEntry::path() const {
-	return m_path;
+    return m_path;
 };
 
 QString FileSystemEntry::relativePath() const {
-	return m_relativePath;
+    return m_relativePath;
 };
 
 QString FileSystemEntry::name() const {
-	return m_fileInfo.fileName();
+    return m_fileInfo.fileName();
 };
 
 QString FileSystemEntry::baseName() const {
-	return m_fileInfo.baseName();
+    return m_fileInfo.baseName();
 };
 
 QString FileSystemEntry::parentDir() const {
-	return m_fileInfo.absolutePath();
+    return m_fileInfo.absolutePath();
 };
 
 QString FileSystemEntry::suffix() const {
-	return m_fileInfo.completeSuffix();
+    return m_fileInfo.completeSuffix();
 };
 
 qint64 FileSystemEntry::size() const {
-	return m_fileInfo.size();
+    return m_fileInfo.size();
 };
 
 bool FileSystemEntry::isDir() const {
-	return m_fileInfo.isDir();
+    return m_fileInfo.isDir();
 };
 
 bool FileSystemEntry::isImage() const {
-	if (!m_isImageInitialised) {
-		QImageReader reader(m_path);
-		m_isImage = reader.canRead();
-		m_isImageInitialised = true;
-	}
-	return m_isImage;
+    if (!m_isImageInitialised) {
+        QImageReader reader(m_path);
+        m_isImage = reader.canRead();
+        m_isImageInitialised = true;
+    }
+    return m_isImage;
 }
 
 QString FileSystemEntry::mimeType() const {
-	if (!m_mimeTypeInitialised) {
-		static const QMimeDatabase s_db;
-		m_mimeType = s_db.mimeTypeForFile(m_path).name();
-		m_mimeTypeInitialised = true;
-	}
-	return m_mimeType;
+    if (!m_mimeTypeInitialised) {
+        const QMimeDatabase db;
+        m_mimeType = db.mimeTypeForFile(m_path).name();
+        m_mimeTypeInitialised = true;
+    }
+    return m_mimeType;
 }
 
 void FileSystemEntry::updateRelativePath(const QDir& dir) {
-	const auto relPath = dir.relativeFilePath(m_path);
-	if (m_relativePath != relPath) {
-		m_relativePath = relPath;
-		emit relativePathChanged();
-	}
+    const auto relPath = dir.relativeFilePath(m_path);
+    if (m_relativePath != relPath) {
+        m_relativePath = relPath;
+        emit relativePathChanged();
+    }
 }
 
 FileSystemModel::FileSystemModel(QObject* parent)
-	: QAbstractListModel(parent)
-	, m_recursive(false)
-	, m_watchChanges(true)
-	, m_showHidden(false)
-	, m_filter(NoFilter) {
-	connect(&m_watcher, &QFileSystemWatcher::directoryChanged, this, &FileSystemModel::watchDirIfRecursive);
-	connect(&m_watcher, &QFileSystemWatcher::directoryChanged, this, &FileSystemModel::updateEntriesForDir);
+    : QAbstractListModel(parent)
+    , m_recursive(false)
+    , m_watchChanges(true)
+    , m_showHidden(false)
+    , m_filter(NoFilter) {
+    connect(&m_watcher, &QFileSystemWatcher::directoryChanged, this, &FileSystemModel::watchDirIfRecursive);
+    connect(&m_watcher, &QFileSystemWatcher::directoryChanged, this, &FileSystemModel::updateEntriesForDir);
 }
 
 int FileSystemModel::rowCount(const QModelIndex& parent) const {
-	if (parent != QModelIndex()) {
-		return 0;
-	}
-	return static_cast<int>(m_entries.size());
+    if (parent != QModelIndex()) {
+        return 0;
+    }
+    return static_cast<int>(m_entries.size());
 }
 
 QVariant FileSystemModel::data(const QModelIndex& index, int role) const {
-	if (role != Qt::UserRole || !index.isValid() || index.row() >= m_entries.size()) {
-		return QVariant();
-	}
-	return QVariant::fromValue(m_entries.at(index.row()));
+    if (role != Qt::UserRole || !index.isValid() || index.row() >= m_entries.size()) {
+        return QVariant();
+    }
+    return QVariant::fromValue(m_entries.at(index.row()));
 }
 
 QHash<int, QByteArray> FileSystemModel::roleNames() const {
-	return { { Qt::UserRole, "modelData" } };
+    return { { Qt::UserRole, "modelData" } };
 }
 
 QString FileSystemModel::path() const {
-	return m_path;
+    return m_path;
 }
 
 void FileSystemModel::setPath(const QString& path) {
-	if (m_path == path) {
-		return;
-	}
+    if (m_path == path) {
+        return;
+    }
 
-	m_path = path;
-	emit pathChanged();
+    m_path = path;
+    emit pathChanged();
 
-	m_dir.setPath(m_path);
+    m_dir.setPath(m_path);
 
-	for (const auto& entry : std::as_const(m_entries)) {
-		entry->updateRelativePath(m_dir);
-	}
+    for (const auto& entry : std::as_const(m_entries)) {
+        entry->updateRelativePath(m_dir);
+    }
 
-	update();
+    update();
 }
 
 bool FileSystemModel::recursive() const {
-	return m_recursive;
+    return m_recursive;
 }
 
 void FileSystemModel::setRecursive(bool recursive) {
-	if (m_recursive == recursive) {
-		return;
-	}
+    if (m_recursive == recursive) {
+        return;
+    }
 
-	m_recursive = recursive;
-	emit recursiveChanged();
+    m_recursive = recursive;
+    emit recursiveChanged();
 
-	update();
+    update();
 }
 
 bool FileSystemModel::watchChanges() const {
-	return m_watchChanges;
+    return m_watchChanges;
 }
 
 void FileSystemModel::setWatchChanges(bool watchChanges) {
-	if (m_watchChanges == watchChanges) {
-		return;
-	}
+    if (m_watchChanges == watchChanges) {
+        return;
+    }
 
-	m_watchChanges = watchChanges;
-	emit watchChangesChanged();
+    m_watchChanges = watchChanges;
+    emit watchChangesChanged();
 
-	update();
+    update();
 }
 
 bool FileSystemModel::showHidden() const {
-	return m_showHidden;
+    return m_showHidden;
 }
 
 void FileSystemModel::setShowHidden(bool showHidden) {
-	if (m_showHidden == showHidden) {
-		return;
-	}
+    if (m_showHidden == showHidden) {
+        return;
+    }
 
-	m_showHidden = showHidden;
-	emit showHiddenChanged();
+    m_showHidden = showHidden;
+    emit showHiddenChanged();
 
-	update();
+    update();
 }
 
 bool FileSystemModel::sortReverse() const {
-	return m_sortReverse;
+    return m_sortReverse;
 }
 
 void FileSystemModel::setSortReverse(bool sortReverse) {
-	if (m_sortReverse == sortReverse) {
-		return;
-	}
+    if (m_sortReverse == sortReverse) {
+        return;
+    }
 
-	m_sortReverse = sortReverse;
-	emit sortReverseChanged();
+    m_sortReverse = sortReverse;
+    emit sortReverseChanged();
 
-	update();
+    update();
 }
 
 FileSystemModel::Filter FileSystemModel::filter() const {
-	return m_filter;
+    return m_filter;
 }
 
 void FileSystemModel::setFilter(Filter filter) {
-	if (m_filter == filter) {
-		return;
-	}
+    if (m_filter == filter) {
+        return;
+    }
 
-	m_filter = filter;
-	emit filterChanged();
+    m_filter = filter;
+    emit filterChanged();
 
-	update();
+    update();
 }
 
 QStringList FileSystemModel::nameFilters() const {
-	return m_nameFilters;
+    return m_nameFilters;
 }
 
 void FileSystemModel::setNameFilters(const QStringList& nameFilters) {
-	if (m_nameFilters == nameFilters) {
-		return;
-	}
+    if (m_nameFilters == nameFilters) {
+        return;
+    }
 
-	m_nameFilters = nameFilters;
-	emit nameFiltersChanged();
+    m_nameFilters = nameFilters;
+    emit nameFiltersChanged();
 
-	update();
+    update();
 }
 
 QQmlListProperty<FileSystemEntry> FileSystemModel::entries() {
-	return QQmlListProperty<FileSystemEntry>(this, &m_entries);
+    return QQmlListProperty<FileSystemEntry>(this, &m_entries);
 }
 
 void FileSystemModel::watchDirIfRecursive(const QString& path) {
-	if (m_recursive && m_watchChanges) {
-		const auto currentDir = m_dir;
-		const bool showHidden = m_showHidden;
-		auto future = QtConcurrent::run([showHidden, path]() {
-				QDir::Filters filters = QDir::Dirs | QDir::NoDotAndDotDot;
-				if (showHidden) {
-					filters |= QDir::Hidden;
-				}
+    if (m_recursive && m_watchChanges) {
+        const auto currentDir = m_dir;
+        const bool showHidden = m_showHidden;
+        const auto future = QtConcurrent::run([showHidden, path]() {
+            QDir::Filters filters = QDir::Dirs | QDir::NoDotAndDotDot;
+            if (showHidden) {
+                filters |= QDir::Hidden;
+            }
 
-				QDirIterator iter(path, filters, QDirIterator::Subdirectories);
-				QStringList dirs;
-				while (iter.hasNext()) {
-					dirs << iter.next();
-				}
-				return dirs;
-			});
-		future.then(this, [currentDir, showHidden, this](const QStringList& paths) {
-				if (currentDir == m_dir && showHidden == m_showHidden && !paths.isEmpty()) {
-					// Ignore if dir or showHidden has changed
-					m_watcher.addPaths(paths);
-				}
-			});
-	}
+            QDirIterator iter(path, filters, QDirIterator::Subdirectories);
+            QStringList dirs;
+            while (iter.hasNext()) {
+                dirs << iter.next();
+            }
+            return dirs;
+        });
+        const auto watcher = new QFutureWatcher<QStringList>(this);
+        connect(watcher, &QFutureWatcher<QStringList>::finished, this, [currentDir, showHidden, watcher, this]() {
+            const auto paths = watcher->result();
+            if (currentDir == m_dir && showHidden == m_showHidden && !paths.isEmpty()) {
+                // Ignore if dir or showHidden has changed
+                m_watcher.addPaths(paths);
+            }
+            watcher->deleteLater();
+        });
+        watcher->setFuture(future);
+    }
 }
 
 void FileSystemModel::update() {
-	updateWatcher();
-	updateEntries();
+    updateWatcher();
+    updateEntries();
 }
 
 void FileSystemModel::updateWatcher() {
-	if (!m_watcher.directories().isEmpty()) {
-		m_watcher.removePaths(m_watcher.directories());
-	}
+    if (!m_watcher.directories().isEmpty()) {
+        m_watcher.removePaths(m_watcher.directories());
+    }
 
-	if (!m_watchChanges || m_path.isEmpty()) {
-		return;
-	}
+    if (!m_watchChanges || m_path.isEmpty()) {
+        return;
+    }
 
-	m_watcher.addPath(m_path);
-	watchDirIfRecursive(m_path);
+    m_watcher.addPath(m_path);
+    watchDirIfRecursive(m_path);
 }
 
 void FileSystemModel::updateEntries() {
-	if (m_path.isEmpty()) {
-		if (!m_entries.isEmpty()) {
-			beginResetModel();
-			qDeleteAll(m_entries);
-			m_entries.clear();
-			endResetModel();
-			emit entriesChanged();
-		}
+    if (m_path.isEmpty()) {
+        if (!m_entries.isEmpty()) {
+            beginResetModel();
+            qDeleteAll(m_entries);
+            m_entries.clear();
+            endResetModel();
+            emit entriesChanged();
+        }
 
-		return;
-	}
+        return;
+    }
 
-	for (auto& future : m_futures) {
-		future.cancel();
-	}
-	m_futures.clear();
+    for (auto& future : m_futures) {
+        future.cancel();
+    }
+    m_futures.clear();
 
-	updateEntriesForDir(m_path);
+    updateEntriesForDir(m_path);
 }
 
 void FileSystemModel::updateEntriesForDir(const QString& dir) {
-	const auto recursive = m_recursive;
-	const auto showHidden = m_showHidden;
-	const auto filter = m_filter;
-	const auto nameFilters = m_nameFilters;
+    const auto recursive = m_recursive;
+    const auto showHidden = m_showHidden;
+    const auto filter = m_filter;
+    const auto nameFilters = m_nameFilters;
 
-	QSet<QString> oldPaths;
-	for (const auto& entry : std::as_const(m_entries)) {
-		oldPaths << entry->path();
-	}
+    QSet<QString> oldPaths;
+    for (const auto& entry : std::as_const(m_entries)) {
+        oldPaths << entry->path();
+    }
 
-	auto future = QtConcurrent::run([=](QPromise<QPair<QSet<QString>, QSet<QString> > >& promise) {
-			const auto flags = recursive ? QDirIterator::Subdirectories : QDirIterator::NoIteratorFlags;
+    const auto future = QtConcurrent::run([=](QPromise<QPair<QSet<QString>, QSet<QString>>>& promise) {
+        const auto flags = recursive ? QDirIterator::Subdirectories : QDirIterator::NoIteratorFlags;
 
-			std::optional<QDirIterator> iter;
+        std::optional<QDirIterator> iter;
 
-			if (filter == Images) {
-				QStringList extraNameFilters = nameFilters;
-				const auto formats = QImageReader::supportedImageFormats();
-				for (const auto& format : formats) {
-					extraNameFilters << "*." + format;
-				}
+        if (filter == Images) {
+            QStringList extraNameFilters = nameFilters;
+            const auto formats = QImageReader::supportedImageFormats();
+            for (const auto& format : formats) {
+                extraNameFilters << "*." + format;
+            }
 
-				QDir::Filters filters = QDir::Files;
-				if (showHidden) {
-					filters |= QDir::Hidden;
-				}
+            QDir::Filters filters = QDir::Files;
+            if (showHidden) {
+                filters |= QDir::Hidden;
+            }
 
-				iter.emplace(dir, extraNameFilters, filters, flags);
-			} else {
-				QDir::Filters filters;
+            iter.emplace(dir, extraNameFilters, filters, flags);
+        } else {
+            QDir::Filters filters;
 
-				if (filter == Files) {
-					filters = QDir::Files;
-				} else if (filter == Dirs) {
-					filters = QDir::Dirs | QDir::NoDotAndDotDot;
-				} else {
-					filters = QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot;
-				}
+            if (filter == Files) {
+                filters = QDir::Files;
+            } else if (filter == Dirs) {
+                filters = QDir::Dirs | QDir::NoDotAndDotDot;
+            } else {
+                filters = QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot;
+            }
 
-				if (showHidden) {
-					filters |= QDir::Hidden;
-				}
+            if (showHidden) {
+                filters |= QDir::Hidden;
+            }
 
-				if (nameFilters.isEmpty()) {
-					iter.emplace(dir, filters, flags);
-				} else {
-					iter.emplace(dir, nameFilters, filters, flags);
-				}
-			}
+            if (nameFilters.isEmpty()) {
+                iter.emplace(dir, filters, flags);
+            } else {
+                iter.emplace(dir, nameFilters, filters, flags);
+            }
+        }
 
-			QSet<QString> newPaths;
-			while (iter->hasNext()) {
-				if (promise.isCanceled()) {
-					return;
-				}
+        QSet<QString> newPaths;
+        while (iter->hasNext()) {
+            if (promise.isCanceled()) {
+                return;
+            }
 
-				QString path = iter->next();
+            QString path = iter->next();
 
-				if (filter == Images) {
-					QImageReader reader(path);
-					if (!reader.canRead()) {
-						continue;
-					}
-				}
+            if (filter == Images) {
+                QImageReader reader(path);
+                if (!reader.canRead()) {
+                    continue;
+                }
+            }
 
-				newPaths.insert(path);
-			}
+            newPaths.insert(path);
+        }
 
-			if (promise.isCanceled()) {
-				return;
-			}
+        if (promise.isCanceled() || newPaths == oldPaths) {
+            return;
+        }
 
-			promise.addResult(qMakePair(oldPaths - newPaths, newPaths - oldPaths));
-		});
+        promise.addResult(qMakePair(oldPaths - newPaths, newPaths - oldPaths));
+    });
 
-	if (m_futures.contains(dir)) {
-		m_futures[dir].cancel();
-	}
-	m_futures.insert(dir, future);
+    if (m_futures.contains(dir)) {
+        m_futures[dir].cancel();
+    }
+    m_futures.insert(dir, future);
 
-	future
-	.then(this,
-	      [dir, this](QPair<QSet<QString>, QSet<QString> > result) {
-			m_futures.remove(dir);
-			if (!result.first.isEmpty() || !result.second.isEmpty()) {
-				applyChanges(result.first, result.second);
-			}
-		})
-	.onCanceled(this, [dir, this]() {
-			m_futures.remove(dir);
-		});
+    const auto watcher = new QFutureWatcher<QPair<QSet<QString>, QSet<QString>>>(this);
+
+    connect(watcher, &QFutureWatcher<QPair<QSet<QString>, QSet<QString>>>::finished, this, [dir, watcher, this]() {
+        m_futures.remove(dir);
+
+        if (!watcher->future().isResultReadyAt(0)) {
+            watcher->deleteLater();
+            return;
+        }
+
+        const auto result = watcher->result();
+        applyChanges(result.first, result.second);
+
+        watcher->deleteLater();
+    });
+
+    watcher->setFuture(future);
 }
 
 void FileSystemModel::applyChanges(const QSet<QString>& removedPaths, const QSet<QString>& addedPaths) {
-	QList<int> removedIndices;
-	for (int i = 0; i < m_entries.size(); ++i) {
-		if (removedPaths.contains(m_entries[i]->path())) {
-			removedIndices << i;
-		}
-	}
-	std::sort(removedIndices.begin(), removedIndices.end(), std::greater<int>());
+    QList<int> removedIndices;
+    for (int i = 0; i < m_entries.size(); ++i) {
+        if (removedPaths.contains(m_entries[i]->path())) {
+            removedIndices << i;
+        }
+    }
+    std::sort(removedIndices.begin(), removedIndices.end(), std::greater<int>());
 
-	// Batch remove old entries
-	int start = -1;
-	int end = -1;
-	for (int idx : std::as_const(removedIndices)) {
-		if (start == -1) {
-			start = idx;
-			end = idx;
-		} else if (idx == end - 1) {
-			end = idx;
-		} else {
-			beginRemoveRows(QModelIndex(), end, start);
-			for (int i = start; i >= end; --i) {
-				m_entries.takeAt(i)->deleteLater();
-			}
-			endRemoveRows();
+    // Batch remove old entries
+    int start = -1;
+    int end = -1;
+    for (int idx : std::as_const(removedIndices)) {
+        if (start == -1) {
+            start = idx;
+            end = idx;
+        } else if (idx == end - 1) {
+            end = idx;
+        } else {
+            beginRemoveRows(QModelIndex(), end, start);
+            for (int i = start; i >= end; --i) {
+                m_entries.takeAt(i)->deleteLater();
+            }
+            endRemoveRows();
 
-			start = idx;
-			end = idx;
-		}
-	}
-	if (start != -1) {
-		beginRemoveRows(QModelIndex(), end, start);
-		for (int i = start; i >= end; --i) {
-			m_entries.takeAt(i)->deleteLater();
-		}
-		endRemoveRows();
-	}
+            start = idx;
+            end = idx;
+        }
+    }
+    if (start != -1) {
+        beginRemoveRows(QModelIndex(), end, start);
+        for (int i = start; i >= end; --i) {
+            m_entries.takeAt(i)->deleteLater();
+        }
+        endRemoveRows();
+    }
 
-	// Create new entries
-	QList<FileSystemEntry*> newEntries;
-	for (const auto& path : addedPaths) {
-		newEntries << new FileSystemEntry(path, m_dir.relativeFilePath(path), this);
-	}
-	std::sort(newEntries.begin(), newEntries.end(), [this](const FileSystemEntry* a, const FileSystemEntry* b) {
-			return compareEntries(a, b);
-		});
+    // Create new entries
+    QList<FileSystemEntry*> newEntries;
+    for (const auto& path : addedPaths) {
+        newEntries << new FileSystemEntry(path, m_dir.relativeFilePath(path), this);
+    }
+    std::sort(newEntries.begin(), newEntries.end(), [this](const FileSystemEntry* a, const FileSystemEntry* b) {
+        return compareEntries(a, b);
+    });
 
-	// Batch insert new entries
-	int insertStart = -1;
-	QList<FileSystemEntry*> batchItems;
-	for (const auto& entry : std::as_const(newEntries)) {
-		const auto it = std::lower_bound(
-			m_entries.begin(), m_entries.end(), entry, [this](const FileSystemEntry* a, const FileSystemEntry* b) {
-				return compareEntries(a, b);
-			});
-		const auto row = static_cast<int>(it - m_entries.begin());
+    // Batch insert new entries
+    int insertStart = -1;
+    QList<FileSystemEntry*> batchItems;
+    for (const auto& entry : std::as_const(newEntries)) {
+        const auto it = std::lower_bound(
+            m_entries.begin(), m_entries.end(), entry, [this](const FileSystemEntry* a, const FileSystemEntry* b) {
+                return compareEntries(a, b);
+            });
+        const auto row = static_cast<int>(it - m_entries.begin());
 
-		if (insertStart == -1) {
-			insertStart = row;
-			batchItems << entry;
-		} else if (row == insertStart + batchItems.size()) {
-			batchItems << entry;
-		} else {
-			beginInsertRows(QModelIndex(), insertStart, insertStart + static_cast<int>(batchItems.size()) - 1);
-			for (int i = 0; i < batchItems.size(); ++i) {
-				m_entries.insert(insertStart + i, batchItems[i]);
-			}
-			endInsertRows();
+        if (insertStart == -1) {
+            insertStart = row;
+            batchItems << entry;
+        } else if (row == insertStart + batchItems.size()) {
+            batchItems << entry;
+        } else {
+            beginInsertRows(QModelIndex(), insertStart, insertStart + static_cast<int>(batchItems.size()) - 1);
+            for (int i = 0; i < batchItems.size(); ++i) {
+                m_entries.insert(insertStart + i, batchItems[i]);
+            }
+            endInsertRows();
 
-			insertStart = row;
-			batchItems.clear();
-			batchItems << entry;
-		}
-	}
-	if (!batchItems.isEmpty()) {
-		beginInsertRows(QModelIndex(), insertStart, insertStart + static_cast<int>(batchItems.size()) - 1);
-		for (int i = 0; i < batchItems.size(); ++i) {
-			m_entries.insert(insertStart + i, batchItems[i]);
-		}
-		endInsertRows();
-	}
+            insertStart = row;
+            batchItems.clear();
+            batchItems << entry;
+        }
+    }
+    if (!batchItems.isEmpty()) {
+        beginInsertRows(QModelIndex(), insertStart, insertStart + static_cast<int>(batchItems.size()) - 1);
+        for (int i = 0; i < batchItems.size(); ++i) {
+            m_entries.insert(insertStart + i, batchItems[i]);
+        }
+        endInsertRows();
+    }
 
-	emit entriesChanged();
+    emit entriesChanged();
 }
 
 bool FileSystemModel::compareEntries(const FileSystemEntry* a, const FileSystemEntry* b) const {
-	if (a->isDir() != b->isDir()) {
-		return m_sortReverse ^ a->isDir();
-	}
-	const auto cmp = a->relativePath().localeAwareCompare(b->relativePath());
-	return m_sortReverse ? cmp > 0 : cmp < 0;
+    if (a->isDir() != b->isDir()) {
+        return m_sortReverse ^ a->isDir();
+    }
+    const auto cmp = a->relativePath().localeAwareCompare(b->relativePath());
+    return m_sortReverse ? cmp > 0 : cmp < 0;
 }
 
 } // namespace ZShell::models

Plugins/ZShell/Models/filesystemmodel.hpp

@@ -13,136 +13,136 @@
 namespace ZShell::models {
 
 class FileSystemEntry : public QObject {
-Q_OBJECT
-QML_ELEMENT
-        QML_UNCREATABLE("FileSystemEntry instances can only be retrieved from a FileSystemModel")
+    Q_OBJECT
+    QML_ELEMENT
+    QML_UNCREATABLE("FileSystemEntry instances can only be retrieved from a FileSystemModel")
 
-Q_PROPERTY(QString path READ path CONSTANT)
-Q_PROPERTY(QString relativePath READ relativePath NOTIFY relativePathChanged)
-Q_PROPERTY(QString name READ name CONSTANT)
-Q_PROPERTY(QString baseName READ baseName CONSTANT)
-Q_PROPERTY(QString parentDir READ parentDir CONSTANT)
-Q_PROPERTY(QString suffix READ suffix CONSTANT)
-Q_PROPERTY(qint64 size READ size CONSTANT)
-Q_PROPERTY(bool isDir READ isDir CONSTANT)
-Q_PROPERTY(bool isImage READ isImage CONSTANT)
-Q_PROPERTY(QString mimeType READ mimeType CONSTANT)
+    Q_PROPERTY(QString path READ path CONSTANT)
+    Q_PROPERTY(QString relativePath READ relativePath NOTIFY relativePathChanged)
+    Q_PROPERTY(QString name READ name CONSTANT)
+    Q_PROPERTY(QString baseName READ baseName CONSTANT)
+    Q_PROPERTY(QString parentDir READ parentDir CONSTANT)
+    Q_PROPERTY(QString suffix READ suffix CONSTANT)
+    Q_PROPERTY(qint64 size READ size CONSTANT)
+    Q_PROPERTY(bool isDir READ isDir CONSTANT)
+    Q_PROPERTY(bool isImage READ isImage CONSTANT)
+    Q_PROPERTY(QString mimeType READ mimeType CONSTANT)
 
 public:
-explicit FileSystemEntry(const QString& path, const QString& relativePath, QObject* parent = nullptr);
+    explicit FileSystemEntry(const QString& path, const QString& relativePath, QObject* parent = nullptr);
 
-[[nodiscard]] QString path() const;
-[[nodiscard]] QString relativePath() const;
-[[nodiscard]] QString name() const;
-[[nodiscard]] QString baseName() const;
-[[nodiscard]] QString parentDir() const;
-[[nodiscard]] QString suffix() const;
-[[nodiscard]] qint64 size() const;
-[[nodiscard]] bool isDir() const;
-[[nodiscard]] bool isImage() const;
-[[nodiscard]] QString mimeType() const;
+    [[nodiscard]] QString path() const;
+    [[nodiscard]] QString relativePath() const;
+    [[nodiscard]] QString name() const;
+    [[nodiscard]] QString baseName() const;
+    [[nodiscard]] QString parentDir() const;
+    [[nodiscard]] QString suffix() const;
+    [[nodiscard]] qint64 size() const;
+    [[nodiscard]] bool isDir() const;
+    [[nodiscard]] bool isImage() const;
+    [[nodiscard]] QString mimeType() const;
 
-void updateRelativePath(const QDir& dir);
+    void updateRelativePath(const QDir& dir);
 
 signals:
-void relativePathChanged();
+    void relativePathChanged();
 
 private:
-const QFileInfo m_fileInfo;
+    const QFileInfo m_fileInfo;
 
-const QString m_path;
-QString m_relativePath;
+    const QString m_path;
+    QString m_relativePath;
 
-mutable bool m_isImage;
-mutable bool m_isImageInitialised;
+    mutable bool m_isImage;
+    mutable bool m_isImageInitialised;
 
-mutable QString m_mimeType;
-mutable bool m_mimeTypeInitialised;
+    mutable QString m_mimeType;
+    mutable bool m_mimeTypeInitialised;
 };
 
 class FileSystemModel : public QAbstractListModel {
-Q_OBJECT
-QML_ELEMENT
+    Q_OBJECT
+    QML_ELEMENT
 
-Q_PROPERTY(QString path READ path WRITE setPath NOTIFY pathChanged)
-Q_PROPERTY(bool recursive READ recursive WRITE setRecursive NOTIFY recursiveChanged)
-Q_PROPERTY(bool watchChanges READ watchChanges WRITE setWatchChanges NOTIFY watchChangesChanged)
-Q_PROPERTY(bool showHidden READ showHidden WRITE setShowHidden NOTIFY showHiddenChanged)
-Q_PROPERTY(bool sortReverse READ sortReverse WRITE setSortReverse NOTIFY sortReverseChanged)
-Q_PROPERTY(Filter filter READ filter WRITE setFilter NOTIFY filterChanged)
-Q_PROPERTY(QStringList nameFilters READ nameFilters WRITE setNameFilters NOTIFY nameFiltersChanged)
+    Q_PROPERTY(QString path READ path WRITE setPath NOTIFY pathChanged)
+    Q_PROPERTY(bool recursive READ recursive WRITE setRecursive NOTIFY recursiveChanged)
+    Q_PROPERTY(bool watchChanges READ watchChanges WRITE setWatchChanges NOTIFY watchChangesChanged)
+    Q_PROPERTY(bool showHidden READ showHidden WRITE setShowHidden NOTIFY showHiddenChanged)
+    Q_PROPERTY(bool sortReverse READ sortReverse WRITE setSortReverse NOTIFY sortReverseChanged)
+    Q_PROPERTY(Filter filter READ filter WRITE setFilter NOTIFY filterChanged)
+    Q_PROPERTY(QStringList nameFilters READ nameFilters WRITE setNameFilters NOTIFY nameFiltersChanged)
 
-Q_PROPERTY(QQmlListProperty<ZShell::models::FileSystemEntry> entries READ entries NOTIFY entriesChanged)
+    Q_PROPERTY(QQmlListProperty<ZShell::models::FileSystemEntry> entries READ entries NOTIFY entriesChanged)
 
 public:
-enum Filter {
-	NoFilter,
-	Images,
-	Files,
-	Dirs
-};
-Q_ENUM(Filter)
+    enum Filter {
+        NoFilter,
+        Images,
+        Files,
+        Dirs
+    };
+    Q_ENUM(Filter)
 
-explicit FileSystemModel(QObject* parent = nullptr);
+    explicit FileSystemModel(QObject* parent = nullptr);
 
-int rowCount(const QModelIndex& parent = QModelIndex()) const override;
-QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
-QHash<int, QByteArray> roleNames() const override;
+    int rowCount(const QModelIndex& parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
+    QHash<int, QByteArray> roleNames() const override;
 
-[[nodiscard]] QString path() const;
-void setPath(const QString& path);
+    [[nodiscard]] QString path() const;
+    void setPath(const QString& path);
 
-[[nodiscard]] bool recursive() const;
-void setRecursive(bool recursive);
+    [[nodiscard]] bool recursive() const;
+    void setRecursive(bool recursive);
 
-[[nodiscard]] bool watchChanges() const;
-void setWatchChanges(bool watchChanges);
+    [[nodiscard]] bool watchChanges() const;
+    void setWatchChanges(bool watchChanges);
 
-[[nodiscard]] bool showHidden() const;
-void setShowHidden(bool showHidden);
+    [[nodiscard]] bool showHidden() const;
+    void setShowHidden(bool showHidden);
 
-[[nodiscard]] bool sortReverse() const;
-void setSortReverse(bool sortReverse);
+    [[nodiscard]] bool sortReverse() const;
+    void setSortReverse(bool sortReverse);
 
-[[nodiscard]] Filter filter() const;
-void setFilter(Filter filter);
+    [[nodiscard]] Filter filter() const;
+    void setFilter(Filter filter);
 
-[[nodiscard]] QStringList nameFilters() const;
-void setNameFilters(const QStringList& nameFilters);
+    [[nodiscard]] QStringList nameFilters() const;
+    void setNameFilters(const QStringList& nameFilters);
 
-[[nodiscard]] QQmlListProperty<FileSystemEntry> entries();
+    [[nodiscard]] QQmlListProperty<FileSystemEntry> entries();
 
 signals:
-void pathChanged();
-void recursiveChanged();
-void watchChangesChanged();
-void showHiddenChanged();
-void sortReverseChanged();
-void filterChanged();
-void nameFiltersChanged();
-void entriesChanged();
+    void pathChanged();
+    void recursiveChanged();
+    void watchChangesChanged();
+    void showHiddenChanged();
+    void sortReverseChanged();
+    void filterChanged();
+    void nameFiltersChanged();
+    void entriesChanged();
 
 private:
-QDir m_dir;
-QFileSystemWatcher m_watcher;
-QList<FileSystemEntry*> m_entries;
-QHash<QString, QFuture<QPair<QSet<QString>, QSet<QString> > > > m_futures;
+    QDir m_dir;
+    QFileSystemWatcher m_watcher;
+    QList<FileSystemEntry*> m_entries;
+    QHash<QString, QFuture<QPair<QSet<QString>, QSet<QString>>>> m_futures;
 
-QString m_path;
-bool m_recursive;
-bool m_watchChanges;
-bool m_showHidden;
-bool m_sortReverse = false;
-Filter m_filter;
-QStringList m_nameFilters;
+    QString m_path;
+    bool m_recursive;
+    bool m_watchChanges;
+    bool m_showHidden;
+    bool m_sortReverse;
+    Filter m_filter;
+    QStringList m_nameFilters;
 
-void watchDirIfRecursive(const QString& path);
-void update();
-void updateWatcher();
-void updateEntries();
-void updateEntriesForDir(const QString& dir);
-void applyChanges(const QSet<QString>& removedPaths, const QSet<QString>& addedPaths);
-[[nodiscard]] bool compareEntries(const FileSystemEntry* a, const FileSystemEntry* b) const;
+    void watchDirIfRecursive(const QString& path);
+    void update();
+    void updateWatcher();
+    void updateEntries();
+    void updateEntriesForDir(const QString& dir);
+    void applyChanges(const QSet<QString>& removedPaths, const QSet<QString>& addedPaths);
+    [[nodiscard]] bool compareEntries(const FileSystemEntry* a, const FileSystemEntry* b) const;
 };
 
 } // namespace ZShell::models

cli/src/zshell/__init__.py

@@ -1,16 +1,53 @@
 from __future__ import annotations
+import sys
+from pathlib import Path
+
+import click
 import typer
+from typer._completion_shared import install, _get_shell_name
 from zshell.subcommands import shell, scheme, screenshot, wallpaper, record
 
-app = typer.Typer()
+app = typer.Typer(name="zshell-cli", add_completion=False)
 
 app.add_typer(shell.app, name="shell")
 app.add_typer(scheme.app, name="scheme")
 app.add_typer(screenshot.app, name="screenshot")
 app.add_typer(wallpaper.app, name="wallpaper")
 app.add_typer(record.app, name="record")
-# app.add_typer(preset.app, name="preset")
+
+
+def _completion_installed() -> bool:
+    shell = _get_shell_name()
+    match shell:
+        case "zsh":
+            return (Path.home() / ".zfunc" / "_zshell-cli").exists()
+        case "bash":
+            return (Path.home() / ".bash_completions" / "zshell-cli.sh").exists()
+        case "fish":
+            return (Path.home() / ".config" / "fish" / "completions" / "zshell-cli.fish").exists()
+    return False
+
+
+def _install_completion() -> None:
+    if _completion_installed():
+        click.echo("zshell-cli: Shell completion already installed.")
+        raise typer.Exit()
+    shell = _get_shell_name()
+    if shell is None:
+        click.echo("zshell-cli: Unable to detect shell type.", err=True)
+        raise typer.Exit(code=1)
+    try:
+        _, path = install(prog_name="zshell-cli")
+        click.secho(f"zshell-cli: Shell completion installed ({shell}: {path})", fg="green")
+        click.echo("zshell-cli: Restart your shell or source the file to enable tab-completion.")
+    except Exception:
+        pass
 
 
 def main() -> None:
+    if "--install-autocomplete" in sys.argv:
+        _install_completion()
+        return
+    if sys.stdout.isatty() and not _completion_installed():
+        click.echo("zshell-cli: Tip: run with --install-autocomplete for tab completion.", err=True)
     app()

cli/src/zshell/subcommands/record.py

@@ -18,8 +18,7 @@ TEMP_RECORDING = STATE_DIR / "recording.mp4"
 REPLAY_RECORDING = STATE_DIR / "replay.mp4"
 NOTIF_ID_FILE = STATE_DIR / "notifid.txt"
 
-RECORDINGS_DIR = os.getenv("ZSHELL_RECORDINGS_DIR",
-                           str(Path(HOME) / "Videos/Recordings"))
+RECORDINGS_DIR = os.getenv("ZSHELL_RECORDINGS_DIR", str(Path(HOME) / "Videos/Recordings"))
 
 
 def _read_extra_args() -> list[str]:
@@ -36,7 +35,7 @@ def _is_recording() -> bool:
     return subprocess.run(["pidof", RECORDER], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode == 0
 
 
-def _notify(summary: str, body: str = "", actions: list = None, timeout: int = 5000) -> Optional[int]:
+def _notify(summary: str, body: str = "", actions: list | None = None, timeout: int = 5000) -> Optional[int]:
     args = ["notify-send", summary, body, "-t", str(timeout), "-p"]
     if actions:
         for action in actions:
@@ -49,14 +48,12 @@ def _notify(summary: str, body: str = "", actions: list = None, timeout: int = 5
 
 
 def _close_notification(notif_id: int):
-    subprocess.run(["notify-send", "--close", str(notif_id)],
-                   stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    subprocess.run(["notify-send", "--close", str(notif_id)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
 
 def _get_monitors() -> list[dict]:
     try:
-        res = subprocess.run(["hyprctl", "monitors", "-j"],
-                             capture_output=True, text=True)
+        res = subprocess.run(["hyprctl", "monitors", "-j"], capture_output=True, text=True)
         return json.loads(res.stdout)
     except Exception:
         return []
@@ -92,6 +89,7 @@ def _slurp_region() -> Optional[str]:
 
 def _parse_geometry(geometry: str) -> Optional[tuple[int, int, int, int]]:
     import re
+
     match = re.match(r"(\d+)x(\d+)\+(\d+)\+(\d+)", geometry)
     if match:
         return int(match.group(3)), int(match.group(4)), int(match.group(1)), int(match.group(2))
@@ -139,8 +137,7 @@ def start_recording(region: Optional[str], sound: bool):
     cmd.extend(extra_args)
     cmd.extend(["-o", str(TEMP_RECORDING)])
 
-    subprocess.Popen(cmd, start_new_session=True,
-                     stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    subprocess.Popen(cmd, start_new_session=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
     notif_id = _notify("Recording started", f"Saving to {TEMP_RECORDING}")
     if notif_id is not None:
@@ -148,14 +145,12 @@ def start_recording(region: Optional[str], sound: bool):
 
     time.sleep(1)
     if not _is_recording():
-        _notify("Recording failed",
-                "Check gpu-screen-recorder output.", timeout=5000)
+        _notify("Recording failed", "Check gpu-screen-recorder output.", timeout=5000)
         raise typer.Exit(code=1)
 
 
 def stop_recording(clipboard: bool):
-    subprocess.run(["pkill", "-f", RECORDER],
-                   stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    subprocess.run(["pkill", "-f", RECORDER], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
     for _ in range(50):
         if not _is_recording():
@@ -178,30 +173,31 @@ def stop_recording(clipboard: bool):
         NOTIF_ID_FILE.unlink()
 
     if clipboard:
-        subprocess.run(["wl-copy", "--type", "text/uri-list", f"file://{final_path}"],
-                       stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        subprocess.run(
+            ["wl-copy", "--type", "text/uri-list", f"file://{final_path}"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
 
     _notify("Recording stopped", f"Saved to {final_path}", timeout=5000)
 
 
 def toggle_pause():
-    subprocess.run(["pkill", "-USR2", "-f", RECORDER],
-                   stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    subprocess.run(["pkill", "-USR2", "-f", RECORDER], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
     typer.echo("Toggled pause.")
 
 
 @app.command()
 def record(
     region: Optional[str] = typer.Option(
-        None, "--region", "-r",
+        None,
+        "--region",
+        "-r",
         help="Record a region. Use 'slurp' (or omit value) to select interactively, or give 'WxH+X+Y'.",
     ),
-    sound: bool = typer.Option(
-        False, "--sound", "-s", help="Record audio from default output."),
-    pause: bool = typer.Option(
-        False, "--pause", "-p", help="Toggle pause/resume."),
-    clipboard: bool = typer.Option(
-        False, "--clipboard", "-c", help="Copy the final recording path to clipboard."),
+    sound: bool = typer.Option(False, "--sound", "-s", help="Record audio from default output."),
+    pause: bool = typer.Option(False, "--pause", "-p", help="Toggle pause/resume."),
+    clipboard: bool = typer.Option(False, "--clipboard", "-c", help="Copy the final recording path to clipboard."),
 ):
     """Start or stop a screen recording with gpu-screen-recorder."""
     if pause:

cli/src/zshell/subcommands/scheme.py

@@ -2,6 +2,7 @@ import typer
 import json
 import shutil
 import os
+import sys
 import re
 import subprocess
 
@@ -15,11 +16,61 @@ from materialyoucolor.score.score import Score
 from materialyoucolor.dynamiccolor.material_dynamic_colors import MaterialDynamicColors
 from materialyoucolor.hct.hct import Hct
 from materialyoucolor.utils.color_utils import argb_from_rgb
-from materialyoucolor.utils.math_utils import difference_degrees, rotation_direction, sanitize_degrees_double
+from materialyoucolor.utils.math_utils import (
+    difference_degrees,
+    rotation_direction,
+    sanitize_degrees_double,
+)
 
 app = typer.Typer()
 
 
+def _complete_scheme_name(incomplete):
+    schemes = [
+        "fruit-salad",
+        "expressive",
+        "monochrome",
+        "rainbow",
+        "tonal-spot",
+        "neutral",
+        "fidelity",
+        "content",
+        "vibrant",
+    ]
+    return [s for s in schemes if incomplete in s]
+
+
+def _complete_preset(incomplete):
+    results = []
+    for sid, meta in list_schemes().items():
+        for v in meta.variants:
+            preset = f"{sid}:{v.id}"
+            if incomplete in preset:
+                results.append((preset, f"{meta.name} - {v.name}"))
+    return results
+
+
+def _complete_mode(incomplete):
+    return [m for m in ("dark", "light") if incomplete in m]
+
+
+def _complete_accent(ctx, incomplete):
+    preset_val = ctx.params.get("preset")
+    if preset_val:
+        try:
+            p_scheme, p_variant = resolve_preset(preset_val)
+            for v in list_schemes()[p_scheme].variants:
+                if v.id == p_variant:
+                    return [a for a in v.accents if incomplete in a]
+        except (ValueError, KeyError):
+            pass
+    all_accents = set()
+    for meta in list_schemes().values():
+        for v in meta.variants:
+            all_accents.update(v.accents)
+    return [a for a in sorted(all_accents) if incomplete in a]
+
+
 @app.command()
 def list_presets(
     json_format: bool = typer.Option(False, "--json", help="Output in JSON format"),
@@ -30,7 +81,7 @@ def list_presets(
         for sid, meta in sorted(schemes.items()):
             variants = {}
             for v in meta.variants:
-                entry = {"modes": sorted(v.modes)}
+                entry: dict[str, Any] = {"modes": sorted(v.modes)}
                 if v.accents:
                     entry["accents"] = sorted(v.accents)
                     entry["default_accent"] = sorted(v.accents)[0]
@@ -55,14 +106,35 @@ def list_presets(
 
 @app.command()
 def generate(
-    image_path: Optional[Path] = typer.Option(None, help="Path to source image. Required for image mode."),
-    scheme: Optional[str] = typer.Option(
-        None, help="Color scheme algorithm to use for image mode. Ignored in preset mode."
+    image_path: Optional[Path] = typer.Option(
+        None, help="Path to source image. Required for image mode."
+    ),
+    scheme: Optional[str] = typer.Option(
+        None,
+        help="Color scheme algorithm to use for image mode. Ignored in preset mode.",
+        autocompletion=_complete_scheme_name,
+    ),
+    preset: Optional[str] = typer.Option(
+        None,
+        help="Name of a premade scheme in this format: <scheme>:<variant>",
+        autocompletion=_complete_preset,
+    ),
+    mode: Optional[str] = typer.Option(
+        None,
+        help="Mode of the preset scheme (dark or light).",
+        autocompletion=_complete_mode,
+    ),
+    accent: Optional[str] = typer.Option(
+        None,
+        help="Accent for schemes that support it (e.g. mauve).",
+        autocompletion=_complete_accent,
     ),
-    preset: Optional[str] = typer.Option(None, help="Name of a premade scheme in this format: <scheme>:<variant>"),
-    mode: Optional[str] = typer.Option(None, help="Mode of the preset scheme (dark or light)."),
-    accent: Optional[str] = typer.Option(None, help="Accent for schemes that support it (e.g. mauve)."),
 ):
+    if not any([image_path, scheme, preset, mode, accent]):
+        print(
+            "Hint: use --preset <scheme>:<variant> or --image-path <path>",
+            file=sys.stderr,
+        )
 
     HOME = str(os.getenv("HOME"))
     OUTPUT = Path(HOME + "/.local/state/zshell/scheme.json")
@@ -200,11 +272,15 @@ def generate(
     def harmonize(from_hct: Hct, to_hct: Hct, tone_boost: float) -> Hct:
         diff = difference_degrees(from_hct.hue, to_hct.hue)
         rotation = min(diff * 0.8, 100)
-        output_hue = sanitize_degrees_double(from_hct.hue + rotation * rotation_direction(from_hct.hue, to_hct.hue))
+        output_hue = sanitize_degrees_double(
+            from_hct.hue + rotation * rotation_direction(from_hct.hue, to_hct.hue)
+        )
         tone = max(0.0, min(100.0, from_hct.tone * (1 + tone_boost)))
         return Hct.from_hct(output_hue, from_hct.chroma, tone)
 
-    def terminal_palette(colors: dict[str, str], mode: str, variant: str) -> dict[str, str]:
+    def terminal_palette(
+        colors: dict[str, str], mode: str, variant: str
+    ) -> dict[str, str]:
         light = mode.lower() == "light"
 
         key_hex = (
@@ -236,7 +312,7 @@ def generate(
 
         image = Image.open(image_path)
         image = image.convert("RGB")
-        image.thumbnail(size, Image.NEAREST)
+        image.thumbnail(size, Image.Resampling.NEAREST)
 
         thumbnail_file.parent.mkdir(parents=True, exist_ok=True)
         image.save(thumbnail_path, "JPEG")
@@ -268,8 +344,15 @@ def generate(
         is_dark = ""
 
         with Image.open(image_path) as img:
-            img.thumbnail((1, 1), Image.LANCZOS)
-            hct = Hct.from_int(argb_from_rgb(*img.getpixel((0, 0))))
+            img.thumbnail((1, 1), Image.Resampling.LANCZOS)
+            px = img.getpixel((0, 0))
+            if isinstance(px, (int, float)):
+                r = g = b = int(px)
+            elif px is not None:
+                r, g, b = int(px[0]), int(px[1]), int(px[2])
+            else:
+                r = g = b = 0
+            hct = Hct.from_int(argb_from_rgb(r, g, b))
             is_dark = "light" if hct.tone > 50 else "dark"
 
         return is_dark
@@ -431,6 +514,8 @@ def generate(
 
             raw = tpl_path.read_text(encoding="utf-8")
             out_path, body = split_directive_and_body(raw)
+            if out_path is None:
+                continue
 
             out_path.parent.mkdir(parents=True, exist_ok=True)
 
@@ -484,23 +569,30 @@ def generate(
         with CONFIG.open() as f:
             config = json.load(f)
 
-        scheme = scheme or config["colors"]["schemeType"]
+        scheme_type = config["colors"].get("schemeType", "fruit-salad")
+        scheme = scheme or scheme_type
+        assert isinstance(scheme, str)
         config_mode = config["general"]["color"]["mode"]
         smart = bool(config["general"]["color"].get("smart", False))
         scheme_class = get_scheme_class(scheme)
 
+        p_variant = "default"
         if preset:
             p_scheme, p_variant = resolve_preset(preset)
             schemes = list_schemes()
             if accent and p_scheme in schemes:
                 meta = schemes[p_scheme]
-                var_accents = next((v.accents for v in meta.variants if v.id == p_variant), ())
+                var_accents = next(
+                    (v.accents for v in meta.variants if v.id == p_variant), ()
+                )
                 if accent not in var_accents:
                     available = ", ".join(var_accents) if var_accents else "none"
                     raise typer.BadParameter(
                         f"Accent '{accent}' not available for '{p_scheme}:{p_variant}'. Available accents: {available}"
                     )
-            palette_obj = get_palette(p_scheme, p_variant, mode or config_mode, accent=accent)
+            palette_obj = get_palette(
+                p_scheme, p_variant, mode or config_mode, accent=accent
+            )
             colors = palette_obj.colors
             effective_mode = palette_obj.mode
             name = palette_obj.scheme

cli/src/zshell/subcommands/shell.py

@@ -51,6 +51,7 @@ def show():
     result = subprocess.run(args + ["ipc"] + ["show"], capture_output=True)
     if result.returncode != 0:
         raise click.ClickException(result.stderr.decode().strip())
+    sys.stdout.write(result.stdout.decode())
     sys.stderr.write(result.stderr.decode())
 
 

cli/src/zshell/subcommands/wallpaper.py

@@ -34,9 +34,9 @@ def lockscreen(
         return
 
     if size[0] < 3840 or size[1] < 2160:
-        img = img.resize((size[0] // 2, size[1] // 2), Image.NEAREST)
+        img = img.resize((size[0] // 2, size[1] // 2), Image.Resampling.NEAREST)
     else:
-        img = img.resize((size[0] // 4, size[1] // 4), Image.NEAREST)
+        img = img.resize((size[0] // 4, size[1] // 4), Image.Resampling.NEAREST)
 
     img = img.filter(ImageFilter.GaussianBlur(blur_amount))
 

shell.qml

@@ -6,15 +6,20 @@
 //@ pragma Env QT_SCALE_FACTOR_ROUNDING_POLICY=Round
 //@ pragma DropExpensiveFonts
 import Quickshell
-import qs.Extensions
+import Quickshell.Services.UPower
 import qs.Modules
 import qs.Modules.Wallpaper
 import qs.Modules.Lock
 import qs.Drawers
 import qs.Helpers
 import qs.Modules.Polkit
+import qs.Daemons
 
 ShellRoot {
+	id: root
+
+	readonly property bool laptop: UPower.displayDevice.isLaptopBattery
+
 	settings.watchFiles: true
 
 	Windows {
@@ -40,6 +45,10 @@ ShellRoot {
 	Polkit {
 	}
 
-	LoadExtensions {
+	LazyLoader {
+		activeAsync: root.laptop
+
+		component: Battery {
+		}
 	}
 }