diff --git a/dotfiles/quickshell/HyprChrome/Widgets/HyprChromeShell.qml b/dotfiles/quickshell/HyprChrome/Widgets/HyprChromeShell.qml index 0e21110..93acdc6 100644 --- a/dotfiles/quickshell/HyprChrome/Widgets/HyprChromeShell.qml +++ b/dotfiles/quickshell/HyprChrome/Widgets/HyprChromeShell.qml @@ -9,6 +9,7 @@ import qs.HyprChrome.Widgets.Polkit import qs.HyprChrome.Widgets.Launcher import qs.HyprChrome.Widgets.Askpass import qs.HyprChrome.Widgets.Notifications +import qs.HyprChrome.Widgets.Luna // The hyprchrome shell: owns everything the rail's surfaces have to agree on, // and instantiates them. @@ -216,6 +217,25 @@ Scope { screen: shell.targetScreen } + // luna's voice-mode readout. Beside the notification stack rather than + // among the modals: it never takes the keyboard and raises no scrim, so + // it is deliberately NOT part of `modalOpen`. It does read `targetScreen`, + // which is what makes it belong to the shell at all. + LunaState { + id: lunaState + } + + LunaCall { + state: lunaState + targetScreen: shell.targetScreen + // Same source the backdrop uses. The rail's exclusive zone does NOT + // push this surface down on its own — measured: the bar occupies + // y 0..147 and the readout still landed at y=8 — so the offset is + // passed explicitly rather than left to the compositor. That makes + // the bar's height shell state by the usual rule: a second reader. + barHeight: bar.contentHeight + } + // Polkit authentication agent. It registers for this logind session on // creation, so it replaces hyprpolkitagent rather than coexisting with it — // only one agent may hold a session (see hosts/terra/home/hyprland.nix). diff --git a/dotfiles/quickshell/HyprChrome/Widgets/Luna/LunaCall.qml b/dotfiles/quickshell/HyprChrome/Widgets/Luna/LunaCall.qml new file mode 100644 index 0000000..fffb6a4 --- /dev/null +++ b/dotfiles/quickshell/HyprChrome/Widgets/Luna/LunaCall.qml @@ -0,0 +1,60 @@ +pragma ComponentBehavior: Bound + +import QtQuick +import Quickshell +import Quickshell.Wayland +import qs.HyprChrome.Widgets.Luna + +// Voice-mode surface: top-left, directly under the rail. +// +// Thin by design — the visuals are all in LunaIndicator so they stay +// headless-renderable. Anchoring top+left is enough to sit under the bar: +// the rail sets an exclusiveZone of its collapsed height, so the compositor +// places this below it without either surface knowing the other's metrics. +// +// NOT a modal. She never takes the keyboard — the whole point is that you +// keep working while talking — so this does not join the shell's `modalOpen` +// and raises no scrim. +PanelWindow { + id: window + + required property var state + required property var targetScreen + // The rail's settled height, from the shell. Not the compositor's job + // here: the bar's exclusive zone leaves this surface at the top of the + // output, so the gap is opened by hand. + required property real barHeight + + screen: window.targetScreen + visible: window.state.active + + anchors { top: true; left: true } + margins { left: 8; top: window.barHeight + 8 } + + implicitWidth: indicator.implicitWidth + implicitHeight: indicator.implicitHeight + + color: "transparent" + // Below the rail's own layer: this is a readout, not a surface that + // should ever cover the bar. + WlrLayershell.layer: WlrLayer.Top + // A readout that stole focus would break typing the moment she answered. + WlrLayershell.keyboardFocus: WlrKeyboardFocus.None + // Normal with a zero zone: reserve nothing of our own, but still RESPECT + // the rail's exclusion so the compositor places this under it. Ignore + // would skip other surfaces' zones too, which put it over the bar. + exclusionMode: ExclusionMode.Normal + exclusiveZone: 0 + + LunaIndicator { + id: indicator + anchors.fill: parent + + state: window.state.state + active: window.state.active + connected: window.state.connected + rms: window.state.rms + userText: window.state.userText + lunaText: window.state.lunaText + } +} diff --git a/dotfiles/quickshell/HyprChrome/Widgets/Luna/LunaIndicator.qml b/dotfiles/quickshell/HyprChrome/Widgets/Luna/LunaIndicator.qml new file mode 100644 index 0000000..78e4872 --- /dev/null +++ b/dotfiles/quickshell/HyprChrome/Widgets/Luna/LunaIndicator.qml @@ -0,0 +1,229 @@ +pragma ComponentBehavior: Bound + +import QtQuick +import QtQuick.Shapes +import qs.HyprChrome.Theme + +// The voice-mode readout: whether luna is listening, thinking or talking. +// +// Item-rooted with no window of its own so tools/quickshell-preview/render.sh +// can shoot it offscreen — the PanelWindow lives in LunaCall.qml. A standalone +// 3D avatar replaces the meter later; the states and their colours are the +// part that has to read correctly first. +Item { + id: root + + // Driven by LunaState; defaulted so the headless render and the + // DebugWindow can stage this without a daemon. + property string state: "idle" + property bool active: true + property bool connected: true + property real rms: 0 + property string userText: "" + property string lunaText: "" + + // Metrics are per-component in this tree; Theme carries colour and type only. + readonly property int pad: 8 + readonly property int chamfer: 10 + + implicitWidth: 260 + implicitHeight: content.implicitHeight + root.pad * 2 + + // Not readonly: a Behavior cannot attach to a readonly property, and the + // colour crossfade is what keeps state changes from snapping. + property color stateColor: { + if (!root.connected) + return Theme.disabled; + switch (root.state) { + case "listening": + return Theme.accent; + case "thinking": + return Theme.muted; + case "speaking": + return Theme.accentSoft; + default: + return Theme.raised; + } + } + + readonly property string stateLabel: { + if (!root.connected) + return "OFFLINE"; + switch (root.state) { + case "listening": + return "LISTENING"; + case "thinking": + return "THINKING"; + case "speaking": + return "SPEAKING"; + default: + return "READY"; + } + } + + Behavior on stateColor { + ColorAnimation { duration: 180 } + } + + // The card is ONE chamfered path, not a rectangle with a triangle drawn + // over its corner — that leaves the square border showing underneath and + // reads as an artifact rather than a cut. + Shape { + anchors.fill: parent + preferredRendererType: Shape.CurveRenderer + opacity: 0.96 + + ShapePath { + strokeWidth: 1 + strokeColor: root.stateColor + fillColor: Theme.surface + startX: 0 + startY: 0 + PathLine { x: root.width - root.chamfer; y: 0 } + PathLine { x: root.width; y: root.chamfer } + PathLine { x: root.width; y: root.height } + PathLine { x: 0; y: root.height } + PathLine { x: 0; y: 0 } + } + } + + Column { + id: content + anchors.fill: parent + anchors.margins: root.pad + spacing: root.pad + + Row { + spacing: root.pad + + // The one element that is alive while nothing else moves: a dot + // that breathes in listening and holds steady otherwise, so "the + // mic is open" is legible from across the room. + Rectangle { + id: dot + width: 8 + height: 8 + radius: 4 + anchors.verticalCenter: parent.verticalCenter + color: root.stateColor + + SequentialAnimation on opacity { + running: root.state === "listening" + loops: Animation.Infinite + alwaysRunToEnd: true + NumberAnimation { to: 0.25; duration: 700; easing.type: Easing.InOutQuad } + NumberAnimation { to: 1.0; duration: 700; easing.type: Easing.InOutQuad } + } + // An animation that stops mid-fade would leave the dot dim + // and looking half-dead. + onVisibleChanged: if (root.state !== "listening") opacity = 1 + } + + Text { + anchors.verticalCenter: parent.verticalCenter + text: "LUNA" + color: Theme.text + font.family: Theme.displayFont + font.pixelSize: 12 + font.letterSpacing: 2 + } + + Text { + anchors.verticalCenter: parent.verticalCenter + text: root.stateLabel + color: root.stateColor + font.family: Theme.microFont + font.pixelSize: 10 + font.letterSpacing: 1 + } + } + + // Level meter. Bars react to rms while listening or speaking; during + // thinking they run a sweep instead, because a dead meter and a + // crashed daemon look identical and her replies take seconds. + Row { + id: meter + width: parent.width + height: 22 + spacing: 2 + + readonly property int count: 24 + readonly property bool sweeping: root.state === "thinking" + property real phase: 0 + + NumberAnimation on phase { + running: meter.sweeping + loops: Animation.Infinite + from: 0 + to: 1 + duration: 1200 + } + + Repeater { + model: meter.count + + Rectangle { + required property int index + + width: (meter.width - (meter.count - 1) * meter.spacing) / meter.count + height: { + if (meter.sweeping) { + // A travelling bump rather than a bar graph. + const pos = index / (meter.count - 1); + const d = Math.abs(pos - meter.phase); + return 3 + 16 * Math.max(0, 1 - d * 6); + } + // Live whenever voice mode is on, not only once a + // trigger has fired: "is it hearing me at all" has to + // be answerable BEFORE anything happens, or a mic + // that is too quiet looks exactly like a broken one. + if (!root.active && root.state !== "speaking") + return 3; + // rms is small and non-linear; sqrt opens up the + // quiet end where speech actually sits. + const level = Math.min(1, Math.sqrt(root.rms) * 3.2); + // Centre bars taller, so it reads as a voice rather + // than a progress bar. + const centre = 1 - Math.abs(index / (meter.count - 1) - 0.5) * 1.6; + return 3 + 19 * level * Math.max(0.15, centre); + } + anchors.bottom: parent.bottom + color: root.stateColor + opacity: meter.sweeping ? 0.9 : 0.55 + 0.45 * (height / 22) + + Behavior on height { + enabled: !meter.sweeping + NumberAnimation { duration: 70; easing.type: Easing.OutQuad } + } + } + } + } + + // Captions: hers leads the audio (the daemon emits each sentence as + // it goes to the synthesiser), which is what makes a 5s reply feel + // like it has started. + Text { + width: parent.width + visible: root.userText !== "" + text: `> ${root.userText}` + color: Theme.muted + font.family: Theme.microFont + font.pixelSize: 10 + wrapMode: Text.WordWrap + maximumLineCount: 2 + elide: Text.ElideRight + } + + Text { + width: parent.width + visible: root.lunaText !== "" + text: root.lunaText + color: Theme.text + font.family: Theme.microFont + font.pixelSize: 11 + wrapMode: Text.WordWrap + maximumLineCount: 3 + elide: Text.ElideRight + } + } +} diff --git a/dotfiles/quickshell/HyprChrome/Widgets/Luna/LunaState.qml b/dotfiles/quickshell/HyprChrome/Widgets/Luna/LunaState.qml new file mode 100644 index 0000000..1e497aa --- /dev/null +++ b/dotfiles/quickshell/HyprChrome/Widgets/Luna/LunaState.qml @@ -0,0 +1,106 @@ +pragma ComponentBehavior: Bound + +import QtQuick +import Quickshell +import Quickshell.Io + +// Everything the Luna surfaces know, read off luna-voiced's unix socket +// (services/desktop/luna-voice.nix). +// +// Read-only on purpose: the key that toggles voice mode runs `luna-voice +// toggle` from Hyprland rather than writing here, so the toggle keeps working +// while the shell is reloading — and a QML error can never leave the mic on +// with nothing showing it. +// +// The daemon is a USER service that may start after the shell, restart under +// it, or not be installed at all, so a missing socket is a normal state and +// not an error: `reconnect` retries quietly and `connected` is what the +// widget shows. +QtObject { + id: root + + // "idle" | "listening" | "thinking" | "speaking" + property string state: "idle" + // Voice mode itself — the widget is only on screen while this is true. + property bool active: false + property bool connected: socket.connected + // Mic level while listening, her output level while speaking. Drives the + // only genuinely live part of the visuals. + property real rms: 0 + property string userText: "" + property string lunaText: "" + property string error: "" + + readonly property var socket: Socket { + id: socket + path: `${Quickshell.env("XDG_RUNTIME_DIR") ?? "/run/user/1000"}/luna-voiced.sock` + connected: true + + onConnectionStateChanged: { + if (!socket.connected) { + // A daemon that went away is not a daemon that is idle: reset + // rather than leave the last frame of a conversation frozen + // on screen. + root.active = false; + root.state = "idle"; + root.rms = 0; + } + } + + parser: SplitParser { + splitMarker: "\n" + onRead: line => root.ingest(line) + } + } + + // Retry forever, cheaply. Setting `connected` true on an already-open + // socket is a no-op, so this doubles as the initial connect. + readonly property var reconnect: Timer { + interval: 2000 + running: !socket.connected + repeat: true + onTriggered: socket.connected = true + } + + function ingest(line: string): void { + let msg; + try { + msg = JSON.parse(line); + } catch (e) { + return; // a half-written line is not worth a console error + } + + switch (msg.type) { + case "mode": + root.active = msg.active; + if (!msg.active) { + root.state = "idle"; + root.rms = 0; + } + break; + case "state": + root.state = msg.value; + // Level is only meaningful during the phase that produces it. + if (msg.value !== "listening" && msg.value !== "speaking") + root.rms = 0; + break; + case "amplitude": + root.rms = msg.rms; + break; + case "caption": + if (msg.speaker === "user") { + // A new user caption starts a turn, so it is what clears her + // last reply — NOT speech_start, which arrives after her + // first caption, not before it. + root.userText = msg.text; + root.lunaText = ""; + } else { + root.lunaText = msg.text; + } + break; + case "error": + root.error = msg.message; + break; + } + } +} diff --git a/dotfiles/quickshell/tests/LunaIndicatorHeadless.qml b/dotfiles/quickshell/tests/LunaIndicatorHeadless.qml new file mode 100644 index 0000000..37b72f3 --- /dev/null +++ b/dotfiles/quickshell/tests/LunaIndicatorHeadless.qml @@ -0,0 +1,55 @@ +import QtQuick +import qs.HyprChrome.Widgets.Luna + +// Offscreen render of every voice-mode state, plus the disconnected one — +// the states are the whole point of this widget, and a broken colour or a +// collapsed meter is invisible in a screenshot of just one of them. +// +// ./tools/quickshell-preview/render.sh \ +// tests/LunaIndicatorHeadless.qml \ +// .artifacts/quickshell-preview/luna.png 300 620 +Rectangle { + width: 300 + height: 620 + color: "#1b1d20" + + Column { + x: 20 + y: 20 + width: 260 + spacing: 14 + + LunaIndicator { + width: parent.width + state: "idle" + rms: 0.002 + } + + LunaIndicator { + width: parent.width + state: "listening" + rms: 0.08 + userText: "hey luna, are you there" + } + + LunaIndicator { + width: parent.width + state: "thinking" + userText: "what's the time?" + } + + LunaIndicator { + width: parent.width + state: "speaking" + rms: 0.14 + userText: "what's the time?" + lunaText: "It's 22:25 on Sunday night, chief. Shouldn't you be asleep?" + } + + LunaIndicator { + width: parent.width + state: "idle" + connected: false + } + } +}