flea-qml 0.0.0-stage → 0.2.0

package/ui/WindowDrag.qml

@@ -0,0 +1,35 @@
+import QtQuick
+
+// The pointer's title bar: ui/shell.qml asks for no decorations, so nothing in this tree ever asked
+// the compositor to move the window and only its own Super bind could.
+Item {
+    id: root
+
+    // The caller's path editor is up, and a press that travels there selects text rather than moves.
+    required property bool editing
+    // False while something covers the chrome, so a drag that starts on it moves nothing beneath.
+    property bool inputLive: true
+
+    anchors.fill: parent
+
+    DragHandler {
+        id: move
+
+        // A handler and not a MouseArea, so a press that does not travel stays a click on the button,
+        // crumb or path under the pointer, and target is null because the move belongs to the window.
+        target: null
+        acceptedButtons: Qt.LeftButton
+        // Well under Qt's own 10, because a title bar reads a few pixels of travel as intent.
+        dragThreshold: 4
+        enabled: !root.editing && root.inputLive
+
+        onActiveChanged: {
+            if (!move.active)
+                return
+            // The same attached route ui/CardScroll.qml and ui/Ipc.qml take, so no window is threaded in.
+            var window = root.Window.window
+            if (window)
+                window.startSystemMove()
+        }
+    }
+}

package/ui/boot/Commons/AudioNodes.qml

@@ -0,0 +1,50 @@
+pragma Singleton
+import QtQuick
+import Quickshell
+import Quickshell.Io
+import "AudioNodesModel.js" as Model
+
+// Which PipeWire nodes the audio panel and the microphone widget leave out:
+// the shell's own level meters, and the nodes a platform's audio processing
+// adds, which its platform package names in the fixed platform root (see
+// Model.parsePlatformAudio). No environment variable moves that file, and most
+// machines have none, so nothing of theirs is left out.
+Singleton {
+  id: root
+
+  // Read synchronously at startup (the FileView blocks loading), then kept
+  // current by its load handlers below. Binding this to the missing flag
+  // the handlers write — as it was — loops on every shell start.
+  property var hints: Model.parsePlatformAudio(hintsFile.text())
+
+  // Whether the platform's hints hide a node, given the names of every node
+  // now in the graph (for a "replaced" node).
+  function platformHides(name, nodeNames) {
+    return Model.platformHidesNode(name, hints, nodeNames)
+  }
+
+  function isShellLevelMeter(name) {
+    return Model.isShellLevelMeter(name)
+  }
+
+  FileView {
+    id: hintsFile
+
+    // A file that went away hints nothing, whatever text() still holds.
+    property bool missing: false
+
+    path: "/usr/share/omarchy-platform/audio.json"
+    blockLoading: true
+    watchChanges: true
+    printErrors: false
+    onLoaded: {
+      missing = false
+      root.hints = Model.parsePlatformAudio(text())
+    }
+    onLoadFailed: {
+      missing = true
+      root.hints = Model.parsePlatformAudio("")
+    }
+    onFileChanged: reload()
+  }
+}

package/ui/boot/Commons/AudioNodesModel.js

@@ -0,0 +1,96 @@
+// Audio node rules the bar and the audio panel share. Plain functions, so the
+// tests load this file in Node.
+
+// The level meter the shell runs itself: Quickshell's peak monitor stream,
+// named after the shell or after its stream depending on the PipeWire version.
+// It is not an app using the input.
+function isShellLevelMeter(name) {
+  var value = String(name || "")
+  return value === "quickshell" || value === "quickshell-peak-monitor"
+}
+
+function wholeNamePattern(pattern) {
+  if (typeof pattern !== "string" || pattern === "") return null
+  try {
+    return new RegExp("^(?:" + pattern + ")$")
+  } catch (e) {
+    return null
+  }
+}
+
+// A platform's audio hints, which its own package ships in the platform root
+// (/usr/share/omarchy-platform/audio.json, read by AudioNodes.qml; Omarchy
+// ships none): nodes of its audio processing that are neither devices nor apps.
+//
+//   { "hidden": ["<pattern>", ...],
+//     "replaced": [{ "node": "<pattern>", "by": "<pattern>" }, ...] }
+//
+// A pattern is a regular expression matched against a whole node.name. A
+// hidden node is never listed as an output, an input or an app stream, and
+// never counts as a recording; a replaced node is hidden while a node matching
+// "by" exists. Missing or malformed text means no hints, and an invalid pattern
+// or entry is skipped.
+function parsePlatformAudio(text) {
+  var hints = { hidden: [], replaced: [] }
+  var data = null
+  try {
+    data = JSON.parse(String(text || ""))
+  } catch (e) {
+    return hints
+  }
+  if (!data || typeof data !== "object" || Array.isArray(data)) return hints
+
+  var hidden = Array.isArray(data.hidden) ? data.hidden : []
+  for (var i = 0; i < hidden.length; i++) {
+    var pattern = wholeNamePattern(hidden[i])
+    if (pattern) hints.hidden.push(pattern)
+  }
+
+  var replaced = Array.isArray(data.replaced) ? data.replaced : []
+  for (var j = 0; j < replaced.length; j++) {
+    var entry = replaced[j]
+    if (!entry || typeof entry !== "object") continue
+    var node = wholeNamePattern(entry.node)
+    var by = wholeNamePattern(entry.by)
+    if (node && by) hints.replaced.push({ node: node, by: by })
+  }
+  return hints
+}
+
+// Whether the platform's hints hide a node, given the names of every node now
+// in the graph (for "replaced").
+function platformHidesNode(name, hints, nodeNames) {
+  var value = String(name || "")
+  if (value === "" || !hints) return false
+  var hidden = hints.hidden || []
+  for (var i = 0; i < hidden.length; i++)
+    if (hidden[i].test(value)) return true
+
+  var replaced = hints.replaced || []
+  var names = Array.isArray(nodeNames) ? nodeNames : []
+  for (var j = 0; j < replaced.length; j++) {
+    if (!replaced[j].node.test(value)) continue
+    for (var k = 0; k < names.length; k++) {
+      var other = String(names[k] || "")
+      if (other !== value && replaced[j].by.test(other)) return true
+    }
+  }
+  return false
+}
+
+// `wpctl get-volume <id>` prints "Volume: 0.50", with " [MUTED]" when muted, on
+// the same cubic scale as PwNodeAudio.volume.
+function parseWpctlVolume(text) {
+  var match = /^Volume:\s+([0-9]+(?:\.[0-9]+)?)(\s+\[MUTED\])?$/.exec(String(text || "").trim())
+  if (!match) return null
+  return { volume: parseFloat(match[1]), muted: !!match[2] }
+}
+
+if (typeof module !== "undefined") {
+  module.exports = {
+    isShellLevelMeter: isShellLevelMeter,
+    parsePlatformAudio: parsePlatformAudio,
+    platformHidesNode: platformHidesNode,
+    parseWpctlVolume: parseWpctlVolume
+  }
+}

package/ui/boot/Commons/Border.qml

@@ -0,0 +1,243 @@
+pragma Singleton
+import QtQuick
+import qs.Commons as Commons
+import "BorderGeometry.js" as Geometry
+
+// Central border-spec factory for shell surfaces and controls. A spec carries
+// color, optional gradient, and top/right/bottom/left widths so renderers can
+// choose the cheap Rectangle path or the Shape-ring path without duplicating
+// theme parsing logic.
+QtObject {
+  id: root
+
+  function none() {
+    return flat("transparent", 0)
+  }
+
+  function flat(color, width) {
+    return {
+      color: color || "transparent",
+      widths: Geometry.parseWidthSpec(width, 0),
+      gradient: { colors: [], angle: 0, enabled: false },
+    }
+  }
+
+  function value(section, key) {
+    var v = Commons.Color.shellValues[section + "." + key]
+    return (v === undefined || v === null) ? "" : v
+  }
+
+  function valueOr(section, keys) {
+    for (var i = 0; i < keys.length; i++) {
+      var v = value(section, keys[i])
+      if (String(v).length > 0) return v
+    }
+    return ""
+  }
+
+  function resolveValueRef(raw) {
+    var s = String(raw || "").replace(/^\s+|\s+$/g, "")
+    var seen = {}
+    while (s.match(/^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/) && !seen[s]) {
+      seen[s] = true
+      var next = Commons.Color.shellValues[s]
+      if (next === undefined || next === null || String(next).length === 0) break
+      s = String(next).replace(/^\s+|\s+$/g, "")
+    }
+    return s
+  }
+
+  function alpha(section, key, fallback) {
+    var raw = value(section, key)
+    if (String(raw).length === 0) return fallback
+    var n = Number(raw)
+    return isFinite(n) ? Geometry.clampAlpha(n) : fallback
+  }
+
+  function cssColor(color, opacity) {
+    var a = opacity === undefined || opacity === null ? 1 : Geometry.clampAlpha(opacity)
+    if (color && typeof color === "object" && color.r !== undefined) {
+      if (typeof Qt !== "undefined" && Qt.rgba) {
+        return Qt.rgba(color.r, color.g, color.b, (color.a === undefined ? 1 : color.a) * a)
+      }
+      return "#"
+        + Geometry.padHex(color.r * 255)
+        + Geometry.padHex(color.g * 255)
+        + Geometry.padHex(color.b * 255)
+        + Geometry.padHex((color.a === undefined ? 1 : color.a) * a * 255)
+    }
+
+    var s = String(color || "").replace(/^\s+|\s+$/g, "")
+    var role = s.toLowerCase()
+    if (role === "foreground" || role === "text") return cssColor(Commons.Color.foreground, a)
+    if (role === "accent") return cssColor(Commons.Color.accent, a)
+    if (role === "urgent") return cssColor(Commons.Color.urgent, a)
+    if (role === "background") return cssColor(Commons.Color.background, a)
+    if (role === "transparent") return "transparent"
+    return Geometry.canonicalColor(s, a)
+  }
+
+  function resolvedGradient(raw, fallbackColor, opacity) {
+    var s = String(raw || "").replace(/^\s+|\s+$/g, "")
+    if (s.length === 0) return { colors: [], angle: 0, enabled: false }
+
+    var parts = s.split(/\s+/)
+    var colors = []
+    var angle = 0
+    for (var i = 0; i < parts.length; i++) {
+      if (parts[i].match(/^-?\d+(?:\.\d+)?deg$/)) angle = Number(parts[i].replace(/deg$/, ""))
+      else colors.push(cssColor(parts[i], opacity))
+    }
+    if (colors.length === 0) colors.push(cssColor(fallbackColor, opacity))
+    return { colors: colors, angle: angle, enabled: colors.length > 1 }
+  }
+
+  function sameColor(a, b) {
+    if (typeof Qt === "undefined" || !Qt.color) return String(a) === String(b)
+    var ca = typeof a === "string" ? Qt.color(a) : a
+    var cb = typeof b === "string" ? Qt.color(b) : b
+    if (!ca || !cb || ca.r === undefined || cb.r === undefined) return String(a) === String(b)
+    return Math.round(ca.r * 255) === Math.round(cb.r * 255)
+      && Math.round(ca.g * 255) === Math.round(cb.g * 255)
+      && Math.round(ca.b * 255) === Math.round(cb.b * 255)
+      && Math.round((ca.a === undefined ? 1 : ca.a) * 255) === Math.round((cb.a === undefined ? 1 : cb.a) * 255)
+  }
+
+  function localOrSurfaceSpec(section, token, localColor, defaultColor, fallbackWidth, alphaKey) {
+    if (!sameColor(localColor, defaultColor)) return flat(localColor, fallbackWidth)
+    return surfaceSpec(section, token, localColor, fallbackWidth, alphaKey)
+  }
+
+  function surfaceWidths(section, token, fallbackWidth) {
+    var base = valueOr(section, token === "border" ? ["border-width"] : [token + "-width", "border-width"])
+    var widths = Geometry.parseWidthSpec(base, fallbackWidth)
+    return Geometry.withSideOverrides(
+      widths,
+      valueOr(section, token === "border" ? ["border-width-top"] : [token + "-width-top", "border-width-top"]),
+      valueOr(section, token === "border" ? ["border-width-right"] : [token + "-width-right", "border-width-right"]),
+      valueOr(section, token === "border" ? ["border-width-bottom"] : [token + "-width-bottom", "border-width-bottom"]),
+      valueOr(section, token === "border" ? ["border-width-left"] : [token + "-width-left", "border-width-left"])
+    )
+  }
+
+  function borderValue(raw, fallbackColor, opacity, legacyGradientRaw) {
+    var fallback = cssColor(fallbackColor, opacity)
+    var primaryRaw = String(raw || "").replace(/^\s+|\s+$/g, "")
+    var primary = resolvedGradient(primaryRaw.length > 0 ? primaryRaw : fallbackColor, fallbackColor, opacity)
+    var color = primary.colors.length > 0 ? primary.colors[0] : fallback
+    var gradient = primary.enabled ? primary : { colors: [], angle: 0, enabled: false }
+
+    // Backward compatibility for existing configs written during the separate
+    // border-gradient experiment. New configs put solid colors and gradients in
+    // the same border token.
+    if (!gradient.enabled && String(legacyGradientRaw || "").replace(/^\s+|\s+$/g, "").length > 0) {
+      var legacy = resolvedGradient(legacyGradientRaw, color, opacity)
+      if (legacy.enabled) gradient = legacy
+    }
+
+    return { color: color, gradient: gradient }
+  }
+
+  function surfaceSpec(section, token, fallbackColor, fallbackWidth, alphaKey) {
+    var opacity = alpha(section, alphaKey || token + "-alpha", 1.0)
+    var legacyGradientRaw = valueOr(section, token === "border" ? ["border-gradient"] : [token + "-gradient", "border-gradient"])
+    var resolved = borderValue(resolveValueRef(value(section, token)), fallbackColor, opacity, legacyGradientRaw)
+
+    return {
+      color: resolved.color,
+      widths: surfaceWidths(section, token, fallbackWidth),
+      gradient: resolved.gradient,
+    }
+  }
+
+  function hyprlandActiveSpec(fallbackColor, fallbackWidth) {
+    var raw = value("hyprland", "active-border")
+    var opacity = alpha("hyprland", "active-border-alpha", 1.0)
+
+    // Existing generated themes predate [hyprland] and already keep the active
+    // border under [notifications]. Use it as the compatibility source until
+    // the next theme refresh writes the shared token.
+    if (String(raw).length === 0) {
+      raw = value("notifications", "border")
+      opacity = alpha("notifications", "border-alpha", opacity)
+    }
+
+    var resolved = borderValue(resolveValueRef(raw), fallbackColor, opacity, "")
+    return {
+      color: resolved.color,
+      widths: Geometry.parseWidthSpec(value("hyprland", "active-border-width"), fallbackWidth),
+      gradient: resolved.gradient,
+    }
+  }
+
+  function controlPrefix(state) {
+    if (state === "hover" || state === "hot") return "hover-cursor"
+    return state || "normal"
+  }
+
+  function controlColor(prefix, foreground, accent, urgent) {
+    if (prefix === "focus") return Style.focusStateColor(foreground, accent, urgent)
+    if (prefix === "hover-cursor") return Style.hoverStateColor(foreground, accent, urgent)
+    if (prefix === "selected") return Style.selectedStateColor(foreground, accent, urgent)
+    return Style.normalStateColor(foreground, accent, urgent)
+  }
+
+  function controlAlpha(prefix) {
+    if (prefix === "focus") return Style.focusBorderAlpha
+    if (prefix === "hover-cursor") return Style.hoverBorderAlpha
+    if (prefix === "selected") return Style.selectedBorderAlpha
+    return Style.normalBorderAlpha
+  }
+
+  function controlFallbackWidth(prefix) {
+    if (prefix === "focus") return Style.focusBorderWidth
+    if (prefix === "hover-cursor") return Style.hoverBorderWidth
+    if (prefix === "selected") return Style.selectedBorderWidth
+    return Style.normalBorderWidth
+  }
+
+  function controlWidths(state) {
+    var prefix = controlPrefix(state)
+    var fallbackWidth = controlFallbackWidth(prefix)
+    var base = Style.styleOverrides[prefix + "-border-width"]
+    var widths = Geometry.parseWidthSpec(base, fallbackWidth)
+    return Geometry.withSideOverrides(
+      widths,
+      Style.styleOverrides[prefix + "-border-width-top"],
+      Style.styleOverrides[prefix + "-border-width-right"],
+      Style.styleOverrides[prefix + "-border-width-bottom"],
+      Style.styleOverrides[prefix + "-border-width-left"]
+    )
+  }
+
+  function controlHasWidth(state) {
+    return Geometry.maxWidth(controlWidths(state)) > 0
+  }
+
+  function controlSpec(state, foreground, accent, urgent) {
+    var prefix = controlPrefix(state)
+    var resolved = borderValue(
+      Style.styleOverrides[prefix + "-border"],
+      controlColor(prefix, foreground, accent, urgent),
+      controlAlpha(prefix),
+      Style.styleOverrides[prefix + "-border-gradient"]
+    )
+
+    return { color: resolved.color, widths: controlWidths(prefix), gradient: resolved.gradient }
+  }
+
+  function withWidth(spec, width) {
+    if (!spec) return flat("transparent", 0)
+    return { color: spec.color, gradient: spec.gradient, widths: Geometry.parseWidthSpec(width, 0) }
+  }
+
+  function isNone(spec) { return !spec || Geometry.maxWidth(spec.widths) <= 0 }
+  function needsOverlay(spec) { return Geometry.needsOverlay(spec) }
+  function canUseNative(spec) { return Geometry.canUseNative(spec) }
+  function top(spec) { return spec && spec.widths ? spec.widths.top : 0 }
+  function right(spec) { return spec && spec.widths ? spec.widths.right : 0 }
+  function bottom(spec) { return spec && spec.widths ? spec.widths.bottom : 0 }
+  function left(spec) { return spec && spec.widths ? spec.widths.left : 0 }
+  function uniformWidth(spec) { return spec && spec.widths ? spec.widths.top : 0 }
+  function color(spec) { return spec ? spec.color : "transparent" }
+}