dashboard

Helpers/Hypr.qml

@@ -57,18 +57,9 @@ Singleton {
 
     Component.onCompleted: reloadDynamicConfs()
 
-    function updateActiveWindow(): void {
-        root.desktopName = root.applicationDir + root.activeToplevel?.lastIpcObject.class + ".desktop";
-    }
-
-    Connections {
-        target: Hyprland
-
-        function onRawEvent( event: HyprlandEvent ): void {
-            if ( event.name === "activewindow" ) {
-            }
-        }
-    }
+    // function updateActiveWindow(): void {
+    //     root.desktopName = root.applicationDir + root.activeToplevel?.lastIpcObject.class + ".desktop";
+    // }
 
     Connections {
         target: Hyprland
@@ -84,20 +75,20 @@ Singleton {
             } else if (["workspace", "moveworkspace", "activespecial", "focusedmon"].includes(n)) {
                 Hyprland.refreshWorkspaces();
                 Hyprland.refreshMonitors();
-                Qt.callLater( root.updateActiveWindow );
+                // Qt.callLater( root.updateActiveWindow );
             } else if (["openwindow", "closewindow", "movewindow"].includes(n)) {
                 Hyprland.refreshToplevels();
                 Hyprland.refreshWorkspaces();
-                Qt.callLater( root.updateActiveWindow );
+                // Qt.callLater( root.updateActiveWindow );
             } else if (n.includes("mon")) {
                 Hyprland.refreshMonitors();
-                Qt.callLater( root.updateActiveWindow );
+                // Qt.callLater( root.updateActiveWindow );
             } else if (n.includes("workspace")) {
                 Hyprland.refreshWorkspaces();
-                Qt.callLater( root.updateActiveWindow );
+                // Qt.callLater( root.updateActiveWindow );
             } else if (n.includes("window") || n.includes("group") || ["pin", "fullscreen", "changefloatingmode", "minimize"].includes(n)) {
                 Hyprland.refreshToplevels();
-                Qt.callLater( root.updateActiveWindow );
+                // Qt.callLater( root.updateActiveWindow );
             }
         }
     }

Helpers/Players.qml

@@ -1,10 +1,123 @@
 pragma Singleton
 
 import Quickshell
+import Quickshell.Io
 import Quickshell.Services.Mpris
+import QtQml
+import ZShell
+import qs.Config
+import qs.Components
 
 Singleton {
-	id: root
+    id: root
 
     readonly property list<MprisPlayer> list: Mpris.players.values
+    readonly property MprisPlayer active: props.manualActive ?? list.find(p => getIdentity(p) === Config.services.defaultPlayer) ?? list[0] ?? null
+    property alias manualActive: props.manualActive
+
+    function getIdentity(player: MprisPlayer): string {
+        const alias = Config.services.playerAliases.find(a => a.from === player.identity);
+        return alias?.to ?? player.identity;
+    }
+
+    Connections {
+        target: active
+
+        function onPostTrackChanged() {
+            if (!Config.utilities.toasts.nowPlaying) {
+                return;
+            }
+        }
+    }
+
+    PersistentProperties {
+        id: props
+
+        property MprisPlayer manualActive
+
+        reloadableId: "players"
+    }
+
+    CustomShortcut {
+        name: "mediaToggle"
+        description: "Toggle media playback"
+        onPressed: {
+            const active = root.active;
+            if (active && active.canTogglePlaying)
+                active.togglePlaying();
+        }
+    }
+
+    CustomShortcut {
+        name: "mediaPrev"
+        description: "Previous track"
+        onPressed: {
+            const active = root.active;
+            if (active && active.canGoPrevious)
+                active.previous();
+        }
+    }
+
+    CustomShortcut {
+        name: "mediaNext"
+        description: "Next track"
+        onPressed: {
+            const active = root.active;
+            if (active && active.canGoNext)
+                active.next();
+        }
+    }
+
+    CustomShortcut {
+        name: "mediaStop"
+        description: "Stop media playback"
+        onPressed: root.active?.stop()
+    }
+
+    IpcHandler {
+        target: "mpris"
+
+        function getActive(prop: string): string {
+            const active = root.active;
+            return active ? active[prop] ?? "Invalid property" : "No active player";
+        }
+
+        function list(): string {
+            return root.list.map(p => root.getIdentity(p)).join("\n");
+        }
+
+        function play(): void {
+            const active = root.active;
+            if (active?.canPlay)
+                active.play();
+        }
+
+        function pause(): void {
+            const active = root.active;
+            if (active?.canPause)
+                active.pause();
+        }
+
+        function playPause(): void {
+            const active = root.active;
+            if (active?.canTogglePlaying)
+                active.togglePlaying();
+        }
+
+        function previous(): void {
+            const active = root.active;
+            if (active?.canGoPrevious)
+                active.previous();
+        }
+
+        function next(): void {
+            const active = root.active;
+            if (active?.canGoNext)
+                active.next();
+        }
+
+        function stop(): void {
+            root.active?.stop();
+        }
+    }
 }

Helpers/SystemInfo.qml

@@ -0,0 +1,84 @@
+pragma Singleton
+
+import qs.Config
+import Quickshell
+import Quickshell.Io
+import QtQuick
+
+Singleton {
+    id: root
+
+    property string osName
+    property string osPrettyName
+    property string osId
+    property list<string> osIdLike
+    property string osLogo
+    property bool isDefaultLogo: true
+
+    property string uptime
+    readonly property string user: Quickshell.env("USER")
+    readonly property string wm: Quickshell.env("XDG_CURRENT_DESKTOP") || Quickshell.env("XDG_SESSION_DESKTOP")
+    readonly property string shell: Quickshell.env("SHELL").split("/").pop()
+
+    FileView {
+        id: osRelease
+
+        path: "/etc/os-release"
+        onLoaded: {
+            const lines = text().split("\n");
+
+            const fd = key => lines.find(l => l.startsWith(`${key}=`))?.split("=")[1].replace(/"/g, "") ?? "";
+
+            root.osName = fd("NAME");
+            root.osPrettyName = fd("PRETTY_NAME");
+            root.osId = fd("ID");
+            root.osIdLike = fd("ID_LIKE").split(" ");
+
+            const logo = Quickshell.iconPath(fd("LOGO"), true);
+            if (Config.general.logo) {
+                root.osLogo = Quickshell.iconPath(Config.general.logo, true) || "file://" + Paths.absolutePath(Config.general.logo);
+                root.isDefaultLogo = false;
+            } else if (logo) {
+                root.osLogo = logo;
+                root.isDefaultLogo = false;
+            }
+        }
+    }
+
+    Connections {
+        target: Config.general
+
+        function onLogoChanged(): void {
+            osRelease.reload();
+        }
+    }
+
+    Timer {
+        running: true
+        repeat: true
+        interval: 15000
+        onTriggered: fileUptime.reload()
+    }
+
+    FileView {
+        id: fileUptime
+
+        path: "/proc/uptime"
+        onLoaded: {
+            const up = parseInt(text().split(" ")[0] ?? 0);
+
+            const days = Math.floor(up / 86400);
+            const hours = Math.floor((up % 86400) / 3600);
+            const minutes = Math.floor((up % 3600) / 60);
+
+            let str = "";
+            if (days > 0)
+                str += `${days} day${days === 1 ? "" : "s"}`;
+            if (hours > 0)
+                str += `${str ? ", " : ""}${hours} hour${hours === 1 ? "" : "s"}`;
+            if (minutes > 0 || !str)
+                str += `${str ? ", " : ""}${minutes} minute${minutes === 1 ? "" : "s"}`;
+            root.uptime = str;
+        }
+    }
+}

Helpers/SystemUsage.qml

@@ -0,0 +1,222 @@
+pragma Singleton
+
+import Quickshell
+import Quickshell.Io
+import QtQuick
+import qs.Config
+
+Singleton {
+    id: root
+
+    property real cpuPerc
+    property real cpuTemp
+    readonly property string gpuType: Config.gpuType.toUpperCase() || autoGpuType
+    property string autoGpuType: "NONE"
+    property real gpuPerc
+    property real gpuTemp
+    property real memUsed
+    property real memTotal
+    readonly property real memPerc: memTotal > 0 ? memUsed / memTotal : 0
+    property real storageUsed
+    property real storageTotal
+    property real storagePerc: storageTotal > 0 ? storageUsed / storageTotal : 0
+
+    property real lastCpuIdle
+    property real lastCpuTotal
+
+    property int refCount
+
+    function formatKib(kib: real): var {
+        const mib = 1024;
+        const gib = 1024 ** 2;
+        const tib = 1024 ** 3;
+
+        if (kib >= tib)
+            return {
+                value: kib / tib,
+                unit: "TiB"
+            };
+        if (kib >= gib)
+            return {
+                value: kib / gib,
+                unit: "GiB"
+            };
+        if (kib >= mib)
+            return {
+                value: kib / mib,
+                unit: "MiB"
+            };
+        return {
+            value: kib,
+            unit: "KiB"
+        };
+    }
+
+    Timer {
+        running: root.refCount > 0
+        interval: 3000
+        repeat: true
+        triggeredOnStart: true
+        onTriggered: {
+            stat.reload();
+            meminfo.reload();
+            storage.running = true;
+            gpuUsage.running = true;
+            sensors.running = true;
+        }
+    }
+
+    FileView {
+        id: stat
+
+        path: "/proc/stat"
+        onLoaded: {
+            const data = text().match(/^cpu\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/);
+            if (data) {
+                const stats = data.slice(1).map(n => parseInt(n, 10));
+                const total = stats.reduce((a, b) => a + b, 0);
+                const idle = stats[3] + (stats[4] ?? 0);
+
+                const totalDiff = total - root.lastCpuTotal;
+                const idleDiff = idle - root.lastCpuIdle;
+                root.cpuPerc = totalDiff > 0 ? (1 - idleDiff / totalDiff) : 0;
+
+                root.lastCpuTotal = total;
+                root.lastCpuIdle = idle;
+            }
+        }
+    }
+
+    FileView {
+        id: meminfo
+
+        path: "/proc/meminfo"
+        onLoaded: {
+            const data = text();
+            root.memTotal = parseInt(data.match(/MemTotal: *(\d+)/)[1], 10) || 1;
+            root.memUsed = (root.memTotal - parseInt(data.match(/MemAvailable: *(\d+)/)[1], 10)) || 0;
+        }
+    }
+
+    Process {
+        id: storage
+
+        command: ["sh", "-c", "df | grep '^/dev/' | awk '{print $1, $3, $4}'"]
+        stdout: StdioCollector {
+            onStreamFinished: {
+                const deviceMap = new Map();
+
+                for (const line of text.trim().split("\n")) {
+                    if (line.trim() === "")
+                        continue;
+
+                    const parts = line.trim().split(/\s+/);
+                    if (parts.length >= 3) {
+                        const device = parts[0];
+                        const used = parseInt(parts[1], 10) || 0;
+                        const avail = parseInt(parts[2], 10) || 0;
+
+                        // Only keep the entry with the largest total space for each device
+                        if (!deviceMap.has(device) || (used + avail) > (deviceMap.get(device).used + deviceMap.get(device).avail)) {
+                            deviceMap.set(device, {
+                                used: used,
+                                avail: avail
+                            });
+                        }
+                    }
+                }
+
+                let totalUsed = 0;
+                let totalAvail = 0;
+
+                for (const [device, stats] of deviceMap) {
+                    totalUsed += stats.used;
+                    totalAvail += stats.avail;
+                }
+
+                root.storageUsed = totalUsed;
+                root.storageTotal = totalUsed + totalAvail;
+            }
+        }
+    }
+
+    Process {
+        id: gpuTypeCheck
+
+        running: !Config.gpuType
+        command: ["sh", "-c", "if command -v nvidia-smi &>/dev/null && nvidia-smi -L &>/dev/null; then echo NVIDIA; elif ls /sys/class/drm/card*/device/gpu_busy_percent 2>/dev/null | grep -q .; then echo GENERIC; else echo NONE; fi"]
+        stdout: StdioCollector {
+            onStreamFinished: root.autoGpuType = text.trim()
+        }
+    }
+
+    Process {
+        id: gpuUsage
+
+        command: root.gpuType === "GENERIC" ? ["sh", "-c", "cat /sys/class/drm/card*/device/gpu_busy_percent"] : root.gpuType === "NVIDIA" ? ["nvidia-smi", "--query-gpu=utilization.gpu,temperature.gpu", "--format=csv,noheader,nounits"] : ["echo"]
+        stdout: StdioCollector {
+            onStreamFinished: {
+                if (root.gpuType === "GENERIC") {
+                    const percs = text.trim().split("\n");
+                    const sum = percs.reduce((acc, d) => acc + parseInt(d, 10), 0);
+                    root.gpuPerc = sum / percs.length / 100;
+                } else if (root.gpuType === "NVIDIA") {
+                    const [usage, temp] = text.trim().split(",");
+                    root.gpuPerc = parseInt(usage, 10) / 100;
+                    root.gpuTemp = parseInt(temp, 10);
+                } else {
+                    root.gpuPerc = 0;
+                    root.gpuTemp = 0;
+                }
+            }
+        }
+    }
+
+    Process {
+        id: sensors
+
+        command: ["sensors"]
+        environment: ({
+                LANG: "C.UTF-8",
+                LC_ALL: "C.UTF-8"
+            })
+        stdout: StdioCollector {
+            onStreamFinished: {
+                let cpuTemp = text.match(/(?:Package id [0-9]+|Tdie):\s+((\+|-)[0-9.]+)(°| )C/);
+                if (!cpuTemp)
+                    // If AMD Tdie pattern failed, try fallback on Tctl
+                    cpuTemp = text.match(/Tctl:\s+((\+|-)[0-9.]+)(°| )C/);
+
+                if (cpuTemp)
+                    root.cpuTemp = parseFloat(cpuTemp[1]);
+
+                if (root.gpuType !== "GENERIC")
+                    return;
+
+                let eligible = false;
+                let sum = 0;
+                let count = 0;
+
+                for (const line of text.trim().split("\n")) {
+                    if (line === "Adapter: PCI adapter")
+                        eligible = true;
+                    else if (line === "")
+                        eligible = false;
+                    else if (eligible) {
+                        let match = line.match(/^(temp[0-9]+|GPU core|edge)+:\s+\+([0-9]+\.[0-9]+)(°| )C/);
+                        if (!match)
+                            // Fall back to junction/mem if GPU doesn't have edge temp (for AMD GPUs)
+                            match = line.match(/^(junction|mem)+:\s+\+([0-9]+\.[0-9]+)(°| )C/);
+
+                        if (match) {
+                            sum += parseFloat(match[2]);
+                            count++;
+                        }
+                    }
+                }
+
+                root.gpuTemp = count > 0 ? sum / count : 0;
+            }
+        }
+    }
+}

Helpers/Weather.qml

@@ -1,8 +1,9 @@
 pragma Singleton
 
-import qs.Config
 import Quickshell
 import QtQuick
+import ZShell
+import qs.Config
 
 Singleton {
     id: root