flea-qml 0.0.0-stage → 0.1.0

package/ui/boot/Commons/I18n.qml

@@ -0,0 +1,118 @@
+pragma Singleton
+import QtQuick
+import Quickshell
+import Quickshell.Io
+import "Plural.js" as Plural
+import "Numbers.js" as Numbers
+
+// Display-language strings for the shell. The selected code lives in
+// ~/.config/omarchy/language (omarchy-language owns it); a missing file
+// means English. Strings come from default/i18n/<code>/shell.json layered
+// over the English catalog, so a missing translation falls back to English
+// per string. Use as I18n.t("common.search"), with .arg(...) for %1 holes,
+// and I18n.tn(key, count).arg(I18n.formatNumber(count)) for an
+// entry with plural forms.
+// The language file is watched, so switching language under Setup
+// re-renders the shell without a restart.
+QtObject {
+  id: root
+
+  readonly property string omarchyPath: Quickshell.env("OMARCHY_PATH")
+  readonly property string configHome: Quickshell.env("XDG_CONFIG_HOME") || (Quickshell.env("HOME") + "/.config")
+
+  readonly property string language: languageCode(languageFile.text())
+  readonly property var localeSettings: parseCatalog(registryFile.text())[root.language] || ({})
+  readonly property string formatLocale: localeSettings.formatLocale || "en-US"
+  // From the registry: how numbers are written and which way text runs.
+  readonly property string decimal: localeSettings.decimal || "."
+  readonly property string zeroDigit: localeSettings.zeroDigit || "0"
+  readonly property bool rightToLeft: localeSettings.direction === "rtl"
+
+  // Reading text() makes blockLoading take effect on the first lookup.
+  // These bindings also rebuild the maps when a watched catalog changes.
+  readonly property var englishStrings: parseCatalog(englishCatalogFile.text())
+  readonly property var languageStrings: parseCatalog(languageCatalogFile.text())
+  readonly property var strings: {
+    var merged = ({})
+    for (var k in root.englishStrings) merged[k] = root.englishStrings[k]
+    for (var k2 in root.languageStrings) merged[k2] = root.languageStrings[k2]
+    return merged
+  }
+
+  // The optional fallback is what imperative callers (the JS models) pass
+  // as their English text: for a key the catalogs do not carry, they keep
+  // sensible English instead of a raw key.
+  function t(key, fallback) {
+    var value = root.strings[key]
+    if (value && typeof value === "object") value = value.other
+    if (typeof value === "string" && value.length > 0) return value
+    return fallback !== undefined ? fallback : key
+  }
+
+  // The form of a plural entry for count, by the language's plural rules
+  // (Plural.js). The English entry answers when the translation has none.
+  function tn(key, count, fallback) {
+    var value = Plural.pick(root.languageStrings[key], root.language, count)
+    if (typeof value !== "string" || value.length === 0) value = Plural.pick(root.englishStrings[key], "en", count)
+    if (typeof value === "string" && value.length > 0) return value
+    return fallback !== undefined ? fallback : key
+  }
+
+  // A number with the language's decimal separator and digits, ungrouped:
+  // formatNumber(13.14, 1) is "13,1" in Danish. Pass decimals to round;
+  // without them the value is written as it is.
+  function formatNumber(value, decimals) {
+    return Numbers.format(value, decimals, root.decimal, root.zeroDigit)
+  }
+
+  function parseCatalog(raw) {
+    try {
+      var parsed = JSON.parse(raw || "{}")
+      return (parsed && typeof parsed === "object" && !Array.isArray(parsed)) ? parsed : ({})
+    } catch (e) {
+      return ({})
+    }
+  }
+
+  function languageCode(raw) {
+    var code = String(raw || "").trim()
+    if (!/^[a-z]{2,3}(-[A-Za-z]{2})?$/.test(code)) code = "en"
+    return code
+  }
+
+  // The catalogs are small local files, read synchronously so the first
+  // binding to call t() already gets the string rather than the raw key.
+  property FileView languageFile: FileView {
+    // OMARCHY_LANGUAGE_FILE overrides the location, as it does for
+    // omarchy-i18n, so tests can pin a language whatever the machine uses.
+    path: Quickshell.env("OMARCHY_LANGUAGE_FILE") || (root.configHome + "/omarchy/language")
+    watchChanges: true
+    printErrors: false
+    blockLoading: true
+    onFileChanged: reload()
+  }
+
+  property FileView englishCatalogFile: FileView {
+    path: root.omarchyPath + "/default/i18n/en/shell.json"
+    watchChanges: true
+    printErrors: false
+    blockLoading: true
+    onFileChanged: reload()
+  }
+
+  property FileView languageCatalogFile: FileView {
+    path: root.omarchyPath + "/default/i18n/" + root.language + "/shell.json"
+    watchChanges: true
+    printErrors: false
+    blockLoading: true
+    onFileChanged: reload()
+  }
+
+  property FileView registryFile: FileView {
+    path: root.omarchyPath + "/default/i18n/locales.json"
+    watchChanges: true
+    printErrors: false
+    blockLoading: true
+    onFileChanged: reload()
+  }
+}

package/ui/boot/Commons/InputDevices.qml

@@ -0,0 +1,112 @@
+pragma Singleton
+import QtQuick
+import Quickshell
+import Quickshell.Io
+
+// Input devices arriving and leaving, which Hyprland raises no event for. Every
+// device the kernel sees, from a USB keyboard to a Bluetooth one pairing, adds
+// and removes its nodes under /dev/input, and udev records it under
+// /run/udev/data once it has finished with it, which is when libinput hands it
+// to Hyprland. One watch on both serves the whole shell instead of each bar
+// asking Hyprland on a timer.
+Singleton {
+  id: root
+
+  signal changed()
+
+  // Tests point this at a fixture root, the way OMARCHY_PROC_ROOT and
+  // OMARCHY_SYS_ROOT stand in for /proc and /sys.
+  readonly property string fixtureRoot: Quickshell.env("OMARCHY_INPUT_ROOT") || ""
+  readonly property string devDir: fixtureRoot + "/dev"
+  readonly property string inputDir: devDir + "/input"
+  readonly property string udevDir: fixtureRoot + "/run/udev/data"
+
+  // inotifywait is restarted when it ends. One that keeps ending at once (an
+  // exhausted inotify limit, say) is retried less and less often, down to once
+  // a minute, rather than given up on: nothing else would notice a device.
+  property real startedAt: 0
+  property int quickExits: 0
+  // Whether the watch has stayed up, which the keyboard widget falls back to
+  // asking on a timer without.
+  readonly property bool healthy: quickExits === 0
+
+  // /dev is watched beside /dev/input for one thing: /dev/input being created
+  // again after it went away with the last device, when the watch on the old
+  // directory is gone and has to be set up on the new one. udev's records for
+  // input devices are the c13: entries, character major 13.
+  Process {
+    id: watcher
+    command: ["bash", "-c",
+      "dirs=(\"$2\"); for dir in \"$1\" \"$3\"; do [[ -d $dir ]] && dirs+=(\"$dir\"); done; "
+        + "exec inotifywait -m -q -e create,delete,delete_self,moved_to --format '%w|%e|%f' \"${dirs[@]}\"",
+      "input-devices", root.inputDir, root.devDir, root.udevDir]
+    running: true
+    // Whatever arrived or left while no watch was set up went unseen, so read
+    // the seat again once a watch is: at start, after a watch that had been
+    // up, and once a failing one has stayed up a second. A watch failing at
+    // once announces nothing, or each retry would ask Hyprland from every bar.
+    onRunningChanged: {
+      if (!running) return
+      root.startedAt = Date.now()
+      if (root.quickExits === 0) root.announce()
+      else recovered.restart()
+    }
+    stdout: SplitParser {
+      onRead: function(line) {
+        var fields = String(line).split("|")
+        var dir = fields[0].replace(/\/$/, "")
+        if (dir === root.devDir) {
+          if (fields[2] === "input" && fields[1].indexOf("CREATE") !== -1) {
+            watcher.running = false
+            root.announce()
+          }
+        } else if (dir === root.udevDir) {
+          if (String(fields[2]).indexOf("c13:") === 0) root.announce()
+        } else {
+          root.announce()
+        }
+      }
+    }
+    onExited: {
+      root.quickExits = Date.now() - root.startedAt < 1000 ? root.quickExits + 1 : 0
+      restart.interval = Math.min(60000, 1000 * Math.pow(2, Math.max(0, root.quickExits - 4)))
+      restart.start()
+    }
+  }
+
+  // A device brings several nodes at once, so announce it once the burst has
+  // settled, and again a few seconds on in case udev's record of it was what
+  // lagged.
+  function announce() {
+    settle.restart()
+    followUp.restart()
+  }
+
+  Timer {
+    id: settle
+    interval: 500
+    onTriggered: root.changed()
+  }
+
+  Timer {
+    id: followUp
+    interval: 3000
+    onTriggered: root.changed()
+  }
+
+  Timer {
+    id: recovered
+    interval: 1000
+    onTriggered: {
+      if (!watcher.running) return
+      root.quickExits = 0
+      root.announce()
+    }
+  }
+
+  Timer {
+    id: restart
+    interval: 1000
+    onTriggered: watcher.running = true
+  }
+}

package/ui/boot/Commons/InputMethodState.qml

@@ -0,0 +1,38 @@
+pragma Singleton
+import QtQuick
+import Quickshell
+import Quickshell.Io
+
+Singleton {
+  id: root
+  property var state: ({})
+
+  function cycle(back) {
+    if (!watcher.running) return false
+    watcher.write(back ? "cycle back\n" : "cycle\n")
+    return true
+  }
+
+  // One reader and pending selection for every monitor's keyboard widget.
+  Process {
+    id: watcher
+    command: ["/usr/bin/python3", Quickshell.env("OMARCHY_PATH") + "/default/input-methods/indicator.py"]
+    running: true
+    stdinEnabled: true
+    stdout: SplitParser {
+      onRead: data => {
+        try { root.state = JSON.parse(data) } catch (e) {}
+      }
+    }
+    onExited: {
+      root.state = ({})
+      restart.restart()
+    }
+  }
+
+  Timer {
+    id: restart
+    interval: 5000
+    onTriggered: watcher.running = true
+  }
+}

package/ui/boot/Commons/IpcRegistry.qml

@@ -0,0 +1,77 @@
+pragma Singleton
+import QtQuick
+import Quickshell
+import Quickshell.Io
+
+// Every ShellIpc handler, so the shell can answer an omarchy-shell call over
+// its own socket instead of through a qs ipc client started per call. It
+// answers only what qs ipc would: the first live, enabled handler for a
+// target, and only the functions that handler declares. Those are allowed by
+// name, never inferred from what a function call happens to reach: QObject
+// methods such as destroy() are callable but not enumerable.
+Singleton {
+  id: root
+
+  property var handlers: []
+
+  // A bare handler's own functions (signals and hooks such as targetChanged),
+  // which qs ipc never exposes and neither may the socket.
+  readonly property var builtins: functionNames(bareHandler)
+
+  IpcHandler {
+    id: bareHandler
+    enabled: false
+  }
+
+  function functionNames(object) {
+    var names = []
+    for (var key in object) {
+      if (typeof object[key] === "function") names.push(key)
+    }
+    return names
+  }
+
+  function register(handler) {
+    if (handlers.indexOf(handler) === -1) handlers.push(handler)
+  }
+
+  function unregister(handler) {
+    var index = handlers.indexOf(handler)
+    if (index !== -1) handlers.splice(index, 1)
+  }
+
+  function handlerFor(target) {
+    for (var i = 0; i < handlers.length; i++) {
+      var handler = handlers[i]
+      if (handler && handler.enabled && handler.target === target) return handler
+    }
+    return null
+  }
+
+  // { ran: true, output } once the function ran; { ran: false } when it did
+  // not (unknown target or function, wrong argument count), so the caller
+  // can ask qs ipc for its exact answer without running anything twice.
+  // The functions a handler declares: what it enumerates beyond a bare
+  // handler, less property change signals.
+  function declaredFunctions(handler) {
+    return functionNames(handler).filter(function(name) {
+      return builtins.indexOf(name) === -1 && !/Changed$/.test(name)
+    })
+  }
+
+  function call(target, method, args) {
+    var handler = handlerFor(target)
+    if (!handler) return { ran: false }
+    if (declaredFunctions(handler).indexOf(method) === -1) return { ran: false }
+    if (handler[method].length !== args.length) return { ran: false }
+
+    var result
+    try {
+      result = handler[method].apply(handler, args)
+    } catch (error) {
+      console.warn("ipc " + target + " " + method + " failed: " + error)
+      return { ran: true, output: "" }
+    }
+    return { ran: true, output: result === undefined || result === null ? "" : String(result) }
+  }
+}

package/ui/boot/Commons/Numbers.js

@@ -0,0 +1,19 @@
+// A number written with a language's decimal separator and digits from the
+// registry, ungrouped: format(13.14, 1, ",", "0") is "13,1". Without
+// decimals the value is written as it is. default/i18n/plural.jq's
+// localize_number does the same for omarchy-i18n.
+function format(value, decimals, decimal, zeroDigit) {
+  var number = Number(value)
+  if (!isFinite(number)) return String(value)
+  var text = decimals === undefined ? String(number) : number.toFixed(decimals)
+  if (decimal && decimal !== ".") text = text.replace(".", decimal)
+  if (zeroDigit && zeroDigit !== "0") {
+    var zero = zeroDigit.charCodeAt(0)
+    text = text.replace(/[0-9]/g, function(digit) { return String.fromCharCode(zero + digit.charCodeAt(0) - 48) })
+  }
+  return text
+}
+
+if (typeof module !== "undefined") {
+  module.exports = { format: format }
+}

package/ui/boot/Commons/Plural.js

@@ -0,0 +1,91 @@
+// CLDR cardinal plural categories for whole counts, per Omarchy language
+// code. A plural catalog entry is an object keyed by these categories
+// ({ "one": "%1 file", "other": "%1 files" }); every language needs "other",
+// plus whichever categories its counts can reach. default/i18n/plural.jq
+// holds the same rules for omarchy-i18n, and i18n-test.sh keeps the two
+// in agreement.
+
+function within(value, low, high) {
+  return value >= low && value <= high
+}
+
+function category(code, count) {
+  var n = Math.abs(Math.trunc(Number(count) || 0))
+  var n10 = n % 10
+  var n100 = n % 100
+  var millions = n !== 0 && n % 1000000 === 0
+
+  switch (String(code || "")) {
+  case "ja": case "ko": case "zh-CN": case "zh-TW": case "th": case "vi": case "id": case "ms":
+    return "other"
+  case "hi": case "bn": case "fa": case "si":
+    return n <= 1 ? "one" : "other"
+  case "fr": case "pt-BR":
+    return n <= 1 ? "one" : millions ? "many" : "other"
+  case "ca": case "es-MX": case "it": case "pt":
+    return n === 1 ? "one" : millions ? "many" : "other"
+  case "fil":
+    return (n10 === 4 || n10 === 6 || n10 === 9) ? "other" : "one"
+  case "is":
+    return n10 === 1 && n100 !== 11 ? "one" : "other"
+  case "cs": case "sk":
+    return n === 1 ? "one" : within(n, 2, 4) ? "few" : "other"
+  case "pl":
+    if (n === 1) return "one"
+    return within(n10, 2, 4) && !within(n100, 12, 14) ? "few" : "many"
+  case "ru": case "uk":
+    if (n10 === 1 && n100 !== 11) return "one"
+    return within(n10, 2, 4) && !within(n100, 12, 14) ? "few" : "many"
+  case "hr": case "sr":
+    if (n10 === 1 && n100 !== 11) return "one"
+    return within(n10, 2, 4) && !within(n100, 12, 14) ? "few" : "other"
+  case "sl":
+    if (n100 === 1) return "one"
+    if (n100 === 2) return "two"
+    return within(n100, 3, 4) ? "few" : "other"
+  case "lt":
+    if (within(n100, 11, 19)) return "other"
+    return n10 === 1 ? "one" : n10 >= 2 ? "few" : "other"
+  case "lv":
+    if (n10 === 0 || within(n100, 11, 19)) return "zero"
+    return n10 === 1 ? "one" : "other"
+  case "ro":
+    if (n === 1) return "one"
+    return n === 0 || within(n100, 1, 19) ? "few" : "other"
+  case "ar":
+    if (n <= 2) return ["zero", "one", "two"][n]
+    return within(n100, 3, 10) ? "few" : within(n100, 11, 99) ? "many" : "other"
+  case "he":
+    return n === 1 ? "one" : n === 2 ? "two" : "other"
+  case "ga":
+    if (n <= 2) return n === 0 ? "other" : n === 1 ? "one" : "two"
+    return within(n, 3, 6) ? "few" : within(n, 7, 10) ? "many" : "other"
+  default:
+    return n === 1 ? "one" : "other"
+  }
+}
+
+var ORDER = ["zero", "one", "two", "few", "many", "other"]
+
+// The categories a translation of a plural entry must provide.
+function categories(code) {
+  var seen = { other: true }
+  for (var n = 0; n <= 1000; n++) seen[category(code, n)] = true
+  seen[category(code, 1000000)] = true
+  return ORDER.filter(function(name) { return seen[name] })
+}
+
+// The string for a count from a plural entry, or the entry itself when it
+// is a plain string. A translation missing a category falls back to its
+// "other" form.
+function pick(entry, code, count) {
+  if (typeof entry === "string") return entry
+  if (!entry || typeof entry !== "object") return undefined
+  var form = entry[category(code, count)]
+  if (typeof form === "string" && form.length > 0) return form
+  return typeof entry.other === "string" ? entry.other : undefined
+}
+
+if (typeof module !== "undefined") {
+  module.exports = { category: category, categories: categories, pick: pick }
+}

package/ui/boot/Commons/ShellIpc.qml

@@ -0,0 +1,12 @@
+import QtQuick
+import Quickshell.Io
+
+// An IpcHandler the shell can also answer over its own socket (see
+// IpcRegistry), so omarchy-shell reaches it without a qs ipc client. qs ipc
+// still reaches it as before.
+IpcHandler {
+  id: handler
+
+  Component.onCompleted: IpcRegistry.register(handler)
+  Component.onDestruction: IpcRegistry.unregister(handler)
+}