Luigit
repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by admin

quickshell/nuguland/Niri.qml

Raw
import QtQuick
import Quickshell
import Quickshell.Io
import "niri.js" as NiriState

Item {
    id: root

    readonly property bool available: String(Quickshell.env("NIRI_SOCKET") || "").length > 0
    // Output poll cadence; isolated fixtures shorten it, production keeps 5 s.
    property int outputPollMs: 5000
    property bool ready: false
    property bool windowsInitialized: false
    property bool workspacesInitialized: false
    property bool streamFailed: false
    property int retryDelay: 250
    property string lastError: ""
    property string outputError: ""
    property bool outputsPending: false
    property bool outputsFinished: false
    property var workspaces: []
    readonly property var visibleWorkspaces: displayWorkspaces(workspaces)
    property var windows: []
    property var outputs: ({})
    property var focusedWindow: null
    property string overviewState: "unknown"
    property var actionQueue: []
    readonly property var focusedWindowRecord: windowById(focusedWindow)
    readonly property string focusedTitle: focusedWindowRecord ? (focusedWindowRecord.title || "") : ""
    readonly property string focusedAppId: focusedWindowRecord ? (focusedWindowRecord.app_id || focusedWindowRecord.appId || "") : ""
    readonly property string focusedOutputName: focusedOutputNameFromWorkspaces(workspaces)
    readonly property string keybindConfigPath: {
        const xdg = String(Quickshell.env("XDG_CONFIG_HOME") || "");
        const home = String(Quickshell.env("HOME") || "");
        return (xdg.length > 0 ? xdg : home + "/.config") + "/niri/cfg/keybinds.kdl";
    }
    property var workspaceShortcuts: ({})

    function refresh() {
        if (!available || query.running)
            return;

        reconnect.stop();
        resetStream();
        streamFailed = false;
        lastError = "";
        query.exec(["niri", "msg", "--json", "event-stream"]);
    }

    function resetStream() {
        ready = false;
        windowsInitialized = false;
        workspacesInitialized = false;
        windows = [];
        workspaces = [];
        focusedWindow = null;
        overviewState = "unknown";
    }

    function streamDisconnected() {
        resetStream();
        if (lastError.length === 0)
            lastError = "event stream disconnected";
        if (!available || reconnect.running)
            return;
        reconnect.interval = retryDelay;
        retryDelay = Math.min(retryDelay * 2, 8000);
        reconnect.start();
    }

    function failStream(message) {
        lastError = message;
        ready = false;
        streamFailed = true;
        query.signal(9);
    }

    function refreshOutputs() {
        if (!available)
            return;
        if (outputQuery.running) {
            outputsPending = true;
            return;
        }
        outputsPending = false;
        outputsFinished = false;
        outputQuery.exec(["niri", "msg", "--json", "outputs"]);
    }

    function applyOutputs(text, code, status) {
        try {
            const inventory = NiriState.parseOutputs(text, code, status);
            if (JSON.stringify(outputs) !== JSON.stringify(inventory))
                outputs = inventory;
            outputError = "";
        } catch (error) {
            outputError = String(error);
        }
    }

    function action(args) {
        const list = Array.isArray(args) ? args : [String(args)];
        actionQueue = actionQueue.concat([["niri", "msg", "action"].concat(list.map(String))]);
        dispatchNextAction();
    }

    function dispatchNextAction() {
        if (actionProc.running || actionQueue.length === 0)
            return;
        const command = actionQueue[0];
        actionQueue = actionQueue.slice(1);
        // Process.exec terminates an already-running command; preserve rapid requests.
        actionProc.exec(command);
    }

    function focusWorkspace(ref) {
        action(["focus-workspace", String(ref)]);
    }

    function displayWorkspaces(items) {
        return (items || []).filter(workspace => {
            return workspace.name || workspace.is_focused || workspace.is_active || workspace.is_urgent || workspace.active_window_id !== null && workspace.active_window_id !== undefined;
        });
    }

    function focusedOutputNameFromWorkspaces(items) {
        const list = items || [];
        for (let i = 0; i < list.length; i++)
            if (list[i].is_focused)
                return String(list[i].output || "");

        return "";
    }

    function shortcutKey(sequence) {
        const parts = String(sequence || "").split("+");
        return parts.length > 0 ? parts[parts.length - 1] : "";
    }

    function parseWorkspaceShortcuts(text) {
        const map = ({});
        const re = /(?:^|\n)\s*([^\s{]+)[^{]*\{([^{}]*)\}/g;
        let match;
        while ((match = re.exec(String(text || ""))) !== null) {
            const focus = /\bfocus-workspace\s+(?:"([^"]+)"|([^\s}]+))/.exec(match[2]);
            if (!focus)
                continue;

            const name = String(focus[1] || focus[2] || "");
            if (name.length > 0 && !map[name])
                map[name] = shortcutKey(match[1]);
        }
        return map;
    }

    function reloadWorkspaceShortcuts() {
        workspaceShortcuts = parseWorkspaceShortcuts(keybindFile.text());
    }

    function workspaceShortcut(name) {
        return workspaceShortcuts[String(name || "")] || "";
    }

    // Group visible workspaces by output, each output's list idx-sorted, so the
    // single primary bar renders every monitor's workspaces in its own tray.
    // Pure: pass `items` for testing; defaults to the live workspace array.
    function groupWorkspaces(items) {
        const vis = displayWorkspaces(items === undefined ? workspaces : items);
        const byOutput = ({});
        const order = [];
        for (let i = 0; i < vis.length; i++) {
            const name = String(vis[i].output || "");
            if (!byOutput[name]) {
                byOutput[name] = [];
                order.push(name);
            }
            byOutput[name].push(Object.assign({}, vis[i], {
                "shortcut": workspaceShortcut(vis[i].name)
            }));
        }
        return order.map(name => {
            return {
                "output": name,
                "workspaces": byOutput[name].slice().sort((a, b) => Number(a.idx || 0) - Number(b.idx || 0))
            };
        });
    }

    // Installed niri's outputs request returns a name-keyed object.
    function outputList() {
        return Object.keys(outputs).map(name => outputs[name]);
    }

    // physical left-to-right order key for an output, from niri's logical x;
    // large fallback so unknown outputs sort last (stable, not hash order).
    function outputX(name) {
        const list = outputList();
        const want = String(name || "");
        for (let i = 0; i < list.length; i++) {
            if (String(list[i].name || "") === want) {
                const logical = list[i].logical || ({});
                return typeof logical.x === "number" ? logical.x : 1000000;
            }
        }
        return 1000000;
    }

    // live grouping for the bar, groups ordered by physical output position.
    function workspaceGroups() {
        return groupWorkspaces(workspaces).slice().sort((a, b) => outputX(a.output) - outputX(b.output));
    }

    function windowById(id) {
        if (id === null || id === undefined)
            return null;

        for (let i = 0; i < windows.length; i++) {
            if (windows[i].id === id)
                return windows[i];
        }
        return null;
    }

    function stateJson() {
        return JSON.stringify({
            "available": available,
            "ready": ready,
            "workspaceCount": workspaces.length,
            "windowCount": windows.length,
            "windows": windows,
            "outputCount": Object.keys(outputs).length,
            "outputError": outputError,
            "outputs": outputs,
            "workspaces": workspaces,
            "workspaceShortcuts": workspaceShortcuts,
            "overviewState": overviewState,
            "focusedWindow": focusedWindow,
            "focusedOutputName": focusedOutputName,
            "focusedAppId": focusedAppId,
            "focusedTitle": focusedTitle,
            "lastError": lastError
        });
    }

    function applyEvent(line) {
        if (streamFailed || String(line).trim().length === 0)
            return;
        try {
            const patch = NiriState.reduce(root, JSON.parse(line));
            if (patch === null)
                return;
            for (const key of Object.keys(patch))
                root[key] = patch[key];
            ready = windowsInitialized && workspacesInitialized && overviewState !== "unknown";
            if (ready)
                retryDelay = 250;
        } catch (error) {
            failStream(String(error));
        }
    }

    onReadyChanged: if (ready)
        refreshOutputs()

    Component.onCompleted: {
        refreshOutputs();
        refresh();
    }

    Connections {
        target: Quickshell

        function onScreensChanged() {
            Qt.callLater(root.refreshOutputs);
        }
    }

    // Niri has no OutputsChanged event. Qt screen notifications cover hotplug;
    // polling also catches compositor-only geometry changes. One query at a time.
    Timer {
        interval: root.outputPollMs
        running: root.available
        repeat: true
        onTriggered: root.refreshOutputs()
    }

    Timer {
        id: reconnect

        onTriggered: root.refresh()
    }

    Timer {
        interval: 5000
        running: query.running && !root.ready && !root.streamFailed
        onTriggered: root.failStream("event stream initialization timed out")
    }

    Timer {
        interval: 3000
        running: outputQuery.running
        onTriggered: outputQuery.signal(9)
    }

    FileView {
        id: keybindFile

        path: root.keybindConfigPath
        preload: true
        printErrors: false
        onLoaded: root.reloadWorkspaceShortcuts()
        onLoadFailed: root.workspaceShortcuts = ({})
    }

    Process {
        id: outputQuery

        onRunningChanged: {
            if (!running) {
                if (!root.outputsFinished)
                    root.outputError = "outputs query failed to start";
                if (root.outputsPending)
                    Qt.callLater(root.refreshOutputs);
            }
        }

        stdout: StdioCollector {
            id: outputStdout

            waitForEnd: true
        }
    }

    Process {
        id: query

        running: false
        onRunningChanged: if (!running)
            root.streamDisconnected()

        stdout: SplitParser {
            onRead: data => {
                return root.applyEvent(data);
            }
        }

        stderr: StdioCollector {
            onStreamFinished: {
                if (this.text.trim().length > 0 && !root.streamFailed)
                    root.lastError = this.text.trim();
            }
        }
    }

    Connections {
        target: outputQuery

        function onExited(code, status) {
            root.outputsFinished = true;
            root.applyOutputs(outputStdout.text, code, status);
        }
    }

    Connections {
        target: query

        function onExited(code) {
            if (!root.streamFailed)
                root.lastError = `event stream exited ${code}`;
        }
    }

    Process {
        id: actionProc

        onRunningChanged: if (!running)
            root.dispatchNextAction()

        stderr: StdioCollector {
            onStreamFinished: root.lastError = this.text
        }
    }
}