From 75223da3a241163a8ea04d198946d3e57e336894 Mon Sep 17 00:00:00 2001 From: Derek Ross Date: Fri, 30 Oct 2026 09:54:41 -0400 Subject: [PATCH] omamobile-omarchy 0.1.16: a glance view on the phone's lock (time, date, weather, notifications) The phone's lock opened straight on the PIN pad, so seeing the time or what came in meant unlocking. Patch 0023 puts a glance view in front of the PIN view on touch-only devices (the lock-keypad toggle): the time (system monospace, light, following the bar's clockFormat or the locale), the date, the home screen's last weather reading, and the notifications grouped by app, with the hint above the fingerprint mark. A swipe up, a tap above the sensor or a typed key (kept in the field) shows the PIN view, which is the lock as before plus a small clock. It comes back after 15 s with an empty field and no input, and whenever the lock is shown or the screen is woken through the lock's wake call. Only one view shows outside the short change: the other is visible: false, so nothing of the PIN view renders or takes touches under the glance, and only the lock's blurred wallpaper sits behind either. The lower third stays free of taps for the under-display sensor, and fingerprint unlock (the Service's PAM flow) is untouched. Everything is drawn with Omarchy's own parts and the applied theme: the lock colours, Style fonts, sizes and spacing, and the cards are Omarchy's NotificationCard used statically, which gains summaryLines, bodyLines and a detail label (defaults unchanged for toasts). The lock reads the notifications plugin's persisted toasts and history read-only, shows none while do-not-disturb is on (no toast shows then either), and the lock-hide-notification-text toggle replaces the text with the app name and "Unlock to read". Weather is read from ~/.local/state/omamobile/weather.json and hidden when absent or over 3 h old; the lock makes no network calls. On a computer the lock is unchanged. LockView's diff is one property block, a focus guard and a visible/opacity line on each PIN part, so it rebases with 0003, 0011 and 0014; the patch also applies on top of 0021 and 0022 from the open pull requests. test/lock-glance runs the patched LockView with Omarchy's real Commons and Ui under qmltestrunner (offscreen, Quickshell stubbed): glance first with no PIN part visible and the reverse, tap, swipe, sensor taps ignored, digits kept, the idle return, wake, grouping, the hide-text toggle, do-not-disturb, weather freshness, the clock format and an unchanged computer lock. Co-Authored-By: Claude Opus 5.5 --- ...a-glance-view-for-touch-only-devices.patch | 746 ++++++++++++++++++ packages/omamobile-omarchy/test/all | 2 +- packages/omamobile-omarchy/test/lock-glance | 26 + .../omamobile-omarchy/test/lock-glance.qml | 323 ++++++++ packages/omamobile-omarchy/test/patches.py | 35 + .../test/qml-stubs/Quickshell/Io/FileView.qml | 50 ++ .../test/qml-stubs/Quickshell/Io/Process.qml | 31 + .../Quickshell/Io/StdioCollector.qml | 8 + .../test/qml-stubs/Quickshell/Io/qmldir | 4 + .../test/qml-stubs/Quickshell/Quickshell.qml | 25 + .../test/qml-stubs/Quickshell/SystemClock.qml | 10 + .../test/qml-stubs/Quickshell/qmldir | 3 + packages/omamobile-omarchy/version | 2 +- 13 files changed, 1263 insertions(+), 2 deletions(-) create mode 100644 packages/omamobile-omarchy/patches/0023-lock-a-glance-view-for-touch-only-devices.patch create mode 100755 packages/omamobile-omarchy/test/lock-glance create mode 100644 packages/omamobile-omarchy/test/lock-glance.qml create mode 100644 packages/omamobile-omarchy/test/qml-stubs/Quickshell/Io/FileView.qml create mode 100644 packages/omamobile-omarchy/test/qml-stubs/Quickshell/Io/Process.qml create mode 100644 packages/omamobile-omarchy/test/qml-stubs/Quickshell/Io/StdioCollector.qml create mode 100644 packages/omamobile-omarchy/test/qml-stubs/Quickshell/Io/qmldir create mode 100644 packages/omamobile-omarchy/test/qml-stubs/Quickshell/Quickshell.qml create mode 100644 packages/omamobile-omarchy/test/qml-stubs/Quickshell/SystemClock.qml create mode 100644 packages/omamobile-omarchy/test/qml-stubs/Quickshell/qmldir diff --git a/packages/omamobile-omarchy/patches/0023-lock-a-glance-view-for-touch-only-devices.patch b/packages/omamobile-omarchy/patches/0023-lock-a-glance-view-for-touch-only-devices.patch new file mode 100644 index 000000000..c61f162e7 --- /dev/null +++ b/packages/omamobile-omarchy/patches/0023-lock-a-glance-view-for-touch-only-devices.patch @@ -0,0 +1,746 @@ +# Lock: a glance view on touch-only devices (the lock-keypad toggle), as a +# phone's lock screen opens: the time, the date, the home screen's last +# weather reading and the notifications, grouped by app, over the lock's +# blurred wallpaper. A swipe up, a tap above the fingerprint sensor or a +# typed key (kept in the field) moves to the PIN view, which is the lock as +# before plus a small clock. With an empty field and no input it comes back +# after 15 s, and whenever the lock is shown or the screen is woken (the +# wake call from 0009). Only one view shows outside the short change; the +# other is hidden, so nothing of the PIN view renders or takes touches under +# the glance. Fingerprint unlock is untouched and works from both. +# +# The cards are Omarchy's NotificationCard, static as the history uses it, +# one per app (newest three apps, the rest as "N more from A and B"), with +# three new card properties: summaryLines, bodyLines and a detail label. +# Read-only, from the notifications plugin's persisted toasts and history +# (~/.local/state/omarchy/notifications/*.json, history/*.json), none while +# do-not-disturb is on (notifications.json "dnd"), as no toast shows then. +# The toggle lock-hide-notification-text shows the app name and "Unlock to +# read" instead of the text. Weather comes from +# ~/.local/state/omamobile/weather.json, written by the phone shell's weather +# widget, and is hidden when absent or over 3 h old; the lock makes no +# network calls. The clock follows the bar's clockFormat (shell.json), else +# the locale. On a computer the lock is unchanged. +# +# Against Omarchy 4.0.6 (edge 4.0.6-1), after 0003, 0009, 0011, 0014 and +# 0017. +diff --git i/shell/plugins/lock/LockGlance.js w/shell/plugins/lock/LockGlance.js +new file mode 100644 +--- /dev/null ++++ w/shell/plugins/lock/LockGlance.js +@@ -0,0 +1,116 @@ ++.pragma library ++.import "../notifications/NotificationLogic.js" as NotificationLogic ++ ++// What the phone's lock shows at a glance (LockGlance.qml): the clock's ++// 12- or 24-hour choice, the notifications grouped by app, and the weather ++// line. Plain functions of their inputs, so the test can drive them. ++ ++// Up to this many apps get a card; the rest fold into one line. ++var MAX_GROUPS = 3 ++// Older notifications are not news on a lock screen. ++var MAX_AGE_MS = 24 * 60 * 60 * 1000 ++// A weather reading older than this is not shown. ++var WEATHER_MAX_AGE_MS = 3 * 60 * 60 * 1000 ++ ++// The phone bar's clockFormat (shell.json bar.clockFormat), as the home ++// screen's clock reads it: quoted literals ignored, an AM/PM marker or "h" ++// without "H" means 12-hour. Without one, the locale's short time format. ++function twelveHour(barFormat, localeFormat) { ++ var f = String(barFormat || "").replace(/'[^']*'/g, "") ++ if (!f) f = String(localeFormat || "").replace(/'[^']*'/g, "") ++ return /a/i.test(f) || (/h/.test(f) && !/H/.test(f)) ++} ++ ++// The large glance time leaves AM/PM out; the small clock over the PIN ++// view keeps it. ++function timeFormat(twelve, withMarker) { ++ return twelve ? (withMarker ? "h:mm AP" : "h:mm") : "HH:mm" ++} ++ ++function age(timestamp, now) { ++ var minutes = Math.floor(Math.max(0, Number(now) - Number(timestamp || 0)) / 60000) ++ if (minutes < 1) return "now" ++ if (minutes < 60) return minutes + "m" ++ return Math.floor(minutes / 60) + "h" ++} ++ ++function firstLine(text) { ++ var lines = String(text || "").split(/\r\n|\r|\n|/i) ++ for (var i = 0; i < lines.length; i++) if (lines[i].trim()) return lines[i].trim() ++ return "" ++} ++ ++// The persisted popup and history files (the notifications plugin's state, ++// one JSON line each, read together) as cards: newest first, one per app, ++// at most MAX_GROUPS, and what is left over. Omarchy's own action toasts ++// and bare notify-send pings are left out, as the notifications plugin ++// leaves them out of what it keeps while silenced. hideText shows the app ++// name and "Unlock to read" instead of the text, and no sender picture. ++function groups(raw, now, hideText) { ++ var rows = NotificationLogic.historyRows(raw, [], 1, 200) ++ var byApp = {} ++ var order = [] ++ for (var i = 0; i < rows.length; i++) { ++ var e = rows[i] ++ if (NotificationLogic.isEphemeralApp(e.app)) continue ++ if (Number(now) - Number(e.timestamp || 0) > MAX_AGE_MS) continue ++ var name = String(e.app || "").trim() || "Notifications" ++ var key = name.toLowerCase() ++ if (byApp[key]) { byApp[key].count += 1; continue } ++ byApp[key] = { ++ app: name, ++ appIcon: e.appIcon, ++ image: hideText ? "" : e.image, ++ glyph: e.glyph, ++ urgency: e.urgency, ++ timestamp: e.timestamp, ++ summary: hideText ? name : String(e.summary || ""), ++ body: hideText ? "Unlock to read" : firstLine(NotificationLogic.sanitizeBody(e.body, e.app, e.appIcon)), ++ count: 1, ++ file: NotificationLogic.popupFileName(e) ++ } ++ order.push(byApp[key]) ++ } ++ for (var j = 0; j < order.length; j++) { ++ var g = order[j] ++ g.detail = (g.count > 1 ? g.count + " new, " : "") + age(g.timestamp, now) ++ if (!g.summary) g.summary = g.app ++ } ++ return order ++} ++ ++// "6 more from Mail and GitHub" for the apps without a card. ++function moreText(rest) { ++ if (!rest || rest.length === 0) return "" ++ var n = 0 ++ var names = [] ++ for (var i = 0; i < rest.length; i++) { ++ n += rest[i].count ++ names.push(rest[i].app) ++ } ++ var from = names.length <= 2 ? names.join(" and ") ++ : names.slice(0, 2).join(", ") + " and " + (names.length - 2) + (names.length === 3 ? " other" : " others") ++ return n + " more from " + from ++} ++ ++// notifications.json's do-not-disturb flag: silenced notifications make no ++// toast, so the lock shows none either. ++function doNotDisturb(raw) { ++ var parsed = NotificationLogic.parseSettings(raw) ++ return parsed.dnd === true ++} ++ ++// The home screen weather widget's last reading, which omamobile-shell ++// keeps in ~/.local/state/omamobile/weather.json: ++// {"at": , "temperature": 12, "unit": "°C", "text": "Partly cloudy"} ++// Shown as "12°, partly cloudy"; nothing when absent, unreadable or older ++// than WEATHER_MAX_AGE_MS. The lock itself never asks the network. ++function weatherLine(raw, now) { ++ var w ++ try { w = JSON.parse(String(raw || "")) } catch (e) { return "" } ++ if (!w || typeof w.temperature !== "number" || !isFinite(w.temperature)) return "" ++ var at = Number(w.at || 0) ++ if (!(at > 0) || Number(now) - at > WEATHER_MAX_AGE_MS || at - Number(now) > 5 * 60 * 1000) return "" ++ var text = String(w.text || "").trim() ++ return Math.round(w.temperature) + "°" + (text ? ", " + text.charAt(0).toLowerCase() + text.slice(1) : "") ++} +diff --git i/shell/plugins/lock/LockGlance.qml w/shell/plugins/lock/LockGlance.qml +new file mode 100644 +--- /dev/null ++++ w/shell/plugins/lock/LockGlance.qml +@@ -0,0 +1,437 @@ ++import QtQuick ++import Quickshell ++import Quickshell.Io ++import qs.Commons ++import qs.Commons as Commons ++import qs.Ui ++import "../notifications/components" ++import "LockGlance.js" as Glance ++ ++// The lock's glance view on touch-only devices (the lock-keypad toggle): ++// the time, the date, the weather, the notifications grouped by app and a ++// hint, over the lock's own blurred wallpaper. A swipe up, a tap above the ++// fingerprint sensor or a typed key moves to the PIN view, which is the ++// lock as before plus a small clock; with no input it comes back after ++// 15 s, and whenever the lock is shown or the screen is woken. Fingerprint ++// unlock runs underneath either view, untouched. ++// ++// Read-only: the notifications plugin's persisted toasts and history, its ++// do-not-disturb flag, the lock-hide-notification-text toggle, the bar's ++// clock format and the home screen's last weather reading. Nothing here ++// acts on a notification or asks the network. ++// ++// On a computer (keypad off) it shows nothing and reads nothing. ++Item { ++ id: glance ++ ++ // The LockView this sits in. ++ property var lock: null ++ // Where the PIN view's own content starts (its hint or field), for the ++ // small clock above it. ++ property real pinTop: height * 0.2 ++ ++ readonly property bool active: !!lock && lock.keypad ++ property bool shown: true ++ readonly property bool showing: active && shown ++ // 1 with the glance up, 0 with the PIN view; animated in between. The ++ // view not in use is hidden (visible: false) once the change is over. ++ property real progress: showing ? 1 : 0 ++ Behavior on progress { NumberAnimation { duration: 220; easing.type: Easing.OutCubic } } ++ ++ readonly property string home: Quickshell.env("HOME") ++ property bool hideText: false ++ property bool doNotDisturb: false ++ property string barClockFormat: "" ++ property string notificationsRaw: "" ++ property string weatherRaw: "" ++ readonly property double now: clock.date.getTime() ++ readonly property bool twelveHour: Glance.twelveHour(barClockFormat, Qt.locale().timeFormat(Locale.ShortFormat)) ++ readonly property var groups: active ? Glance.groups(notificationsRaw, now, hideText) : [] ++ readonly property var shownGroups: groups.slice(0, Glance.MAX_GROUPS) ++ // How many of those cards fit above the hint (refit). ++ property int fitCount: Glance.MAX_GROUPS ++ readonly property string moreText: Glance.moreText(groups.slice(Math.min(fitCount, shownGroups.length))) ++ readonly property string weatherText: active ? Glance.weatherLine(weatherRaw, now) : "" ++ // Where the under-display sensor's part of the screen starts: nothing ++ // here reacts to a tap below it (LockView's keypadClearsSensor). ++ readonly property real sensorTop: lock && lock.keypadClearsSensor ? height - lock.keypadBottomMargin : height ++ property double lastActivity: Date.now() ++ property bool polling: true ++ ++ visible: active ++ ++ function show() { ++ if (!active || (lock && lock.authenticatingPassword)) return ++ shown = true ++ if (lock.passwordText.length > 0) lock.passwordTextEdited("") ++ noteActivity() ++ refresh() ++ glance.forceActiveFocus() ++ if (lock.inputEnabled) lock.foldKeyboard() ++ } ++ ++ function reveal() { ++ if (!showing) return ++ shown = false ++ pendingFocus = true ++ lock.wakeRequested() ++ } ++ ++ // The PIN view's field takes focus once it is shown again (an item that ++ // is not visible can't), which brings up the on-screen keyboard for a ++ // password as before. ++ property bool pendingFocus: false ++ onProgressChanged: { ++ if (pendingFocus && progress < 1) { ++ pendingFocus = false ++ Qt.callLater(lock.forcePasswordFocus) ++ } ++ } ++ ++ function noteActivity() { ++ lastActivity = Date.now() ++ if (!active) return ++ if (!polling) { ++ polling = true ++ refresh() ++ } ++ if (idleTimer.running) idleTimer.restart() ++ } ++ ++ function refresh() { ++ if (active && !notificationsProc.running) notificationsProc.running = true ++ } ++ ++ function refit() { ++ var avail = cardsArea.height ++ var gap = cardsColumn.spacing ++ var moreHeight = moreLabel.implicitHeight + gap ++ var used = 0 ++ var n = 0 ++ for (var i = 0; i < cardsRepeater.count; i++) { ++ var item = cardsRepeater.itemAt(i) ++ if (!item) break ++ var h = item.implicitHeight + (n > 0 ? gap : 0) ++ var needMore = i + 1 < groups.length ++ if (used + h + (needMore ? moreHeight : 0) > avail) break ++ used += h ++ n++ ++ } ++ fitCount = n ++ } ++ ++ onShownGroupsChanged: Qt.callLater(refit) ++ onHeightChanged: Qt.callLater(refit) ++ ++ // A typed key on the glance moves to the PIN view and keeps the key: a ++ // digit (or, for a password, any character) goes into the field. ++ Keys.onPressed: function(event) { ++ if (!showing) return ++ var t = event.text ++ var printable = t.length === 1 && t.charCodeAt(0) >= 32 && !(event.modifiers & Qt.ControlModifier) ++ if (printable && lock.inputEnabled && !lock.authenticatingPassword ++ && (!lock.padShown || (t >= "0" && t <= "9"))) { ++ if (lock.failureMessage.length > 0) lock.clearFailureRequested() ++ lock.passwordTextEdited(lock.passwordText + t) ++ } else if (!printable && event.key !== Qt.Key_Return && event.key !== Qt.Key_Enter ++ && event.key !== Qt.Key_Up && event.key !== Qt.Key_Space) { ++ return ++ } ++ reveal() ++ event.accepted = true ++ } ++ ++ Connections { ++ target: glance.lock ++ enabled: glance.active ++ function onInputEnabledChanged() { if (glance.lock.inputEnabled) glance.show() } ++ function onWakeSerialChanged() { glance.show() } ++ function onWakeRequested() { glance.noteActivity() } ++ // Text that reaches the field another way still shows the PIN view. ++ function onPasswordTextChanged() { if (glance.showing && glance.lock.passwordText.length > 0) glance.reveal() } ++ } ++ ++ Component.onCompleted: if (active) { refresh(); Qt.callLater(function() { if (glance.showing) glance.forceActiveFocus() }) } ++ onActiveChanged: if (active) refresh() ++ ++ // Back to the glance after 15 s on the PIN view with nothing typed. ++ Timer { ++ id: idleTimer ++ objectName: "lockGlanceIdle" ++ interval: 15000 ++ running: glance.active && !glance.shown && glance.lock.passwordText.length === 0 && !glance.lock.authenticatingPassword ++ onTriggered: glance.show() ++ } ++ ++ // The notification files have no change signal to watch, so they are read ++ // again every few seconds while the lock is in use, and not while it sits ++ // dark: the lock blanks the screen 10 s after the last input. ++ Timer { ++ id: pollTimer ++ interval: 5000 ++ repeat: true ++ running: glance.active && glance.polling ++ onTriggered: { ++ if (Date.now() - glance.lastActivity > 20000) glance.polling = false ++ else glance.refresh() ++ } ++ } ++ ++ SystemClock { ++ id: clock ++ precision: SystemClock.Minutes ++ } ++ ++ Process { ++ id: notificationsProc ++ command: ["bash", "-c", "shopt -s nullglob; set -- \"$1\"*.json \"$1\"history/*.json; (($#)) && awk 1 \"$@\" 2>/dev/null; true", ++ "--", glance.home + "/.local/state/omarchy/notifications/"] ++ stdout: StdioCollector { ++ waitForEnd: true ++ onStreamFinished: glance.notificationsRaw = String(text || "") ++ } ++ } ++ ++ FileView { ++ path: glance.active ? glance.home + "/.local/state/omarchy/toggles/lock-hide-notification-text" : "" ++ watchChanges: true ++ printErrors: false ++ onLoaded: glance.hideText = true ++ onLoadFailed: glance.hideText = false ++ onFileChanged: reload() ++ } ++ ++ FileView { ++ path: glance.active ? glance.home + "/.local/state/omarchy/notifications.json" : "" ++ watchChanges: true ++ printErrors: false ++ onLoaded: glance.doNotDisturb = Glance.doNotDisturb(text()) ++ onLoadFailed: glance.doNotDisturb = false ++ onFileChanged: reload() ++ } ++ ++ FileView { ++ path: glance.active ? glance.home + "/.local/state/omamobile/weather.json" : "" ++ watchChanges: true ++ printErrors: false ++ onLoaded: glance.weatherRaw = text() ++ onLoadFailed: glance.weatherRaw = "" ++ onFileChanged: reload() ++ } ++ ++ FileView { ++ path: glance.active ? glance.home + "/.config/omarchy/shell.json" : "" ++ watchChanges: true ++ printErrors: false ++ onLoaded: { ++ try { ++ var shell = JSON.parse(text() || "{}") ++ glance.barClockFormat = shell.bar && shell.bar.clockFormat ? String(shell.bar.clockFormat) : "" ++ } catch (e) { glance.barClockFormat = "" } ++ } ++ onLoadFailed: glance.barClockFormat = "" ++ onFileChanged: reload() ++ } ++ ++ // ---------------------------------------------------------------- PIN view ++ ++ // The time, small, above the PIN view's hint or field. ++ Text { ++ id: pinClock ++ objectName: "lockPinClock" ++ textFormat: Text.PlainText ++ anchors.horizontalCenter: parent.horizontalCenter ++ y: Math.max(Style.space(24), glance.pinTop - Style.space(22) - height) ++ visible: glance.progress < 1 ++ opacity: 1 - glance.progress ++ text: Qt.formatDateTime(clock.date, Glance.timeFormat(glance.twelveHour, true)) ++ color: Commons.Color.lock.text ++ font.family: Style.font.family ++ font.pixelSize: Style.font.display ++ } ++ ++ // ---------------------------------------------------------------- glance ++ ++ Item { ++ id: glanceLayer ++ objectName: "lockGlanceView" ++ anchors.fill: parent ++ visible: glance.progress > 0 ++ enabled: glance.showing ++ opacity: glance.progress ++ ++ Item { ++ id: content ++ anchors.fill: parent ++ // Follows a swipe a little, and rises as the PIN view comes in. ++ transform: Translate { ++ y: Math.min(0, swipe.dragY) * 0.4 - Style.space(40) * (1 - glance.progress) ++ } ++ ++ Column { ++ id: header ++ anchors.horizontalCenter: parent.horizontalCenter ++ y: Math.round(parent.height * 0.113) ++ width: Math.min(Style.space(380), parent.width - Style.space(32)) ++ spacing: 0 ++ ++ Text { ++ id: timeLabel ++ objectName: "lockGlanceTime" ++ width: parent.width ++ horizontalAlignment: Text.AlignHCenter ++ textFormat: Text.PlainText ++ text: Qt.formatDateTime(clock.date, Glance.timeFormat(glance.twelveHour, false)) ++ color: Commons.Color.lock.text ++ font.family: Style.font.family ++ font.weight: Font.Light ++ font.pixelSize: Math.round(Style.font.displayLarge * 3.7) ++ fontSizeMode: Text.HorizontalFit ++ minimumPixelSize: Style.font.display ++ } ++ ++ Text { ++ objectName: "lockGlanceDate" ++ width: parent.width ++ topPadding: Style.space(14) ++ horizontalAlignment: Text.AlignHCenter ++ textFormat: Text.PlainText ++ text: Qt.formatDate(clock.date, "dddd, MMMM d") ++ color: Commons.Color.lock.text ++ font.family: Style.font.family ++ font.pixelSize: Style.font.heading ++ elide: Text.ElideRight ++ } ++ ++ Text { ++ objectName: "lockGlanceWeather" ++ width: parent.width ++ topPadding: Style.space(6) ++ visible: glance.weatherText.length > 0 ++ horizontalAlignment: Text.AlignHCenter ++ textFormat: Text.PlainText ++ text: glance.weatherText ++ color: Commons.Color.lock.placeholder ++ font.family: Style.font.family ++ font.pixelSize: Style.font.title ++ elide: Text.ElideRight ++ } ++ } ++ ++ // Between the header and the hint; the cards that don't fit fold ++ // into the "more" line. ++ Item { ++ id: cardsArea ++ anchors.horizontalCenter: parent.horizontalCenter ++ y: header.y + header.height + Style.space(40) ++ width: header.width ++ height: Math.max(0, hint.y - Style.space(24) - y) ++ onHeightChanged: Qt.callLater(glance.refit) ++ visible: !glance.doNotDisturb ++ ++ Column { ++ id: cardsColumn ++ objectName: "lockGlanceCards" ++ width: parent.width ++ spacing: Style.space(10) ++ ++ Repeater { ++ id: cardsRepeater ++ model: glance.shownGroups ++ ++ NotificationCard { ++ required property var modelData ++ required property int index ++ objectName: "lockGlanceCard" ++ width: cardsColumn.width ++ visible: index < glance.fitCount ++ app: modelData.app ++ appIcon: modelData.appIcon ++ image: modelData.image ++ glyph: modelData.glyph ++ urgency: modelData.urgency ++ timestamp: modelData.timestamp ++ summary: modelData.summary ++ body: modelData.body ++ detail: modelData.detail ++ summaryLines: 1 ++ bodyLines: 1 ++ cornerRadius: Style.cornerRadius ++ fontFamily: Style.font.family ++ swipeEnabled: false ++ closeButtonShown: false ++ // No actions from the lock: a tap asks for the PIN. ++ onCardClicked: glance.reveal() ++ onImplicitHeightChanged: Qt.callLater(glance.refit) ++ } ++ } ++ ++ Text { ++ id: moreLabel ++ objectName: "lockGlanceMore" ++ width: parent.width ++ visible: glance.moreText.length > 0 ++ topPadding: Style.space(2) ++ horizontalAlignment: Text.AlignHCenter ++ textFormat: Text.PlainText ++ text: glance.moreText ++ color: Commons.Color.lock.placeholder ++ font.family: Style.font.family ++ font.pixelSize: Style.font.subtitle ++ elide: Text.ElideRight ++ } ++ ++ Text { ++ objectName: "lockGlanceQuiet" ++ width: parent.width ++ visible: glance.groups.length === 0 ++ horizontalAlignment: Text.AlignHCenter ++ textFormat: Text.PlainText ++ text: "No new notifications" ++ color: Commons.Color.lock.placeholder ++ font.family: Style.font.family ++ font.pixelSize: Style.font.title ++ } ++ } ++ } ++ ++ Text { ++ id: hint ++ objectName: "lockGlanceHint" ++ anchors.horizontalCenter: parent.horizontalCenter ++ width: parent.width - Style.space(32) ++ // Where the PIN view has its emergency call: above the sensor's ++ // fingerprint mark, or near the bottom without fingerprints. ++ y: glance.lock && glance.lock.keypadClearsSensor ? glance.sensorTop + Style.space(26) ++ : parent.height - (glance.lock ? glance.lock.keypadBottomMargin : 0) - height ++ textFormat: Text.PlainText ++ text: glance.lock && glance.lock.fingerprintConfigured ? "Touch the fingerprint sensor or swipe up" : "Swipe up to unlock" ++ color: Commons.Color.lock.text ++ font.family: Style.font.family ++ font.pixelSize: Style.font.subtitle ++ wrapMode: Text.WordWrap ++ horizontalAlignment: Text.AlignHCenter ++ } ++ } ++ ++ // Over everything, cards included (a card only asks for the PIN, like ++ // any tap): a swipe up from anywhere, or a tap above the sensor's part ++ // of the screen, shows the PIN view. A finger resting on the sensor ++ // does neither. ++ MouseArea { ++ id: swipe ++ objectName: "lockGlanceSwipe" ++ anchors.fill: parent ++ property real startY: 0 ++ property real dragY: 0 ++ onPressed: function(mouse) { startY = mouse.y; dragY = 0 } ++ onPositionChanged: function(mouse) { dragY = mouse.y - startY } ++ onReleased: function(mouse) { ++ var moved = mouse.y - startY ++ dragY = 0 ++ if (moved < -Style.space(60) || (Math.abs(moved) < Style.space(12) && mouse.y < glance.sensorTop)) glance.reveal() ++ } ++ onCanceled: dragY = 0 ++ } ++ } ++} +diff --git i/shell/plugins/lock/LockView.qml w/shell/plugins/lock/LockView.qml +--- i/shell/plugins/lock/LockView.qml ++++ w/shell/plugins/lock/LockView.qml +@@ -31,6 +31,13 @@ + // The ABC/123 switch in the field swaps either way, so a password with + // letters and digits can always be typed. + property bool passwordFirst: false ++ // The glance view (LockGlance.qml) over the PIN view on touch-only ++ // devices: the PIN view's parts fade in as it goes, and are hidden while it ++ // is up. The lock bumps wakeSerial when the screen is woken, which brings ++ // the glance back. ++ property int wakeSerial: 0 ++ readonly property real pinOpacity: 1 - glance.progress ++ readonly property bool pinVisible: glance.progress < 1 + property bool switchedInput: false + readonly property bool padShown: keypad && (passwordFirst === switchedInput) + readonly property real inputSwitchReserve: keypad ? Math.round(inputSwitch.implicitWidth + 12) : 0 +@@ -73,6 +80,10 @@ + } + + function forcePasswordFocus() { ++ if (glance.showing) { ++ glance.forceActiveFocus() ++ return ++ } + if (padShown) { + keypadKeys.forceActiveFocus() + return +@@ -200,7 +211,8 @@ + + Keypad { + id: numberPad +- visible: root.padShown ++ visible: root.padShown && root.pinVisible ++ opacity: root.pinOpacity + enabled: root.inputEnabled && !root.authenticatingPassword + anchors.horizontalCenter: parent.horizontalCenter + anchors.bottom: parent.bottom +@@ -226,6 +238,8 @@ + + BorderSurface { + id: inputField ++ visible: root.pinVisible ++ opacity: root.pinOpacity + width: root.fieldWidth + height: root.fieldHeight + anchors.horizontalCenter: parent.horizontalCenter +@@ -365,7 +379,8 @@ + anchors.bottomMargin: Style.space(18) + anchors.horizontalCenter: inputField.horizontalCenter + width: parent.width - Style.space(32) +- visible: root.keypadClearsSensor ++ visible: root.keypadClearsSensor && root.pinVisible ++ opacity: root.pinOpacity + text: root.padShown ? "Touch the fingerprint sensor or enter your PIN" + : "Touch the fingerprint sensor or enter your password" + color: Commons.Color.lock.text +@@ -383,9 +398,10 @@ + Item { + id: emergencyButton + objectName: "lockEmergencyCall" +- visible: root.keypad ++ visible: root.keypad && root.pinVisible ++ opacity: root.pinOpacity + anchors.horizontalCenter: parent.horizontalCenter +- anchors.top: numberPad.visible ? numberPad.bottom : inputField.bottom ++ anchors.top: root.padShown ? numberPad.bottom : inputField.bottom + anchors.topMargin: Style.space(20) + width: emergencyLabel.implicitWidth + Style.space(40) + height: Math.max(Style.space(44), emergencyLabel.implicitHeight + Style.space(16)) +@@ -411,5 +427,12 @@ + } + } + } ++ ++ LockGlance { ++ id: glance ++ anchors.fill: parent ++ lock: root ++ pinTop: root.keypadClearsSensor ? keypadHint.y : inputField.y ++ } + } + } +diff --git i/shell/plugins/lock/Service.qml w/shell/plugins/lock/Service.qml +--- i/shell/plugins/lock/Service.qml ++++ w/shell/plugins/lock/Service.qml +@@ -31,6 +31,9 @@ + property int failedAttempts: 0 + property string backgroundPath: "" + property int backgroundVersion: 0 ++ // Bumped by the wake call (a phone's power button): the lock's glance view ++ // comes back each time the screen is woken. ++ property int wakeSerial: 0 + property string lastEvent: "init" + property string lastEventAt: "" + property bool strandedLock: false +@@ -280,6 +283,7 @@ + + LockView { + keypad: root.keypad ++ wakeSerial: root.wakeSerial + id: lockView + anchors.fill: parent + backgroundPath: root.backgroundPath +@@ -548,6 +552,7 @@ + // it and re-arm the blank timer (a phone's power button). + function wake(): string { + if (!root.currentlyLocked()) return "unlocked" ++ root.wakeSerial += 1 + root.runWake() + return "ok" + } +diff --git i/shell/plugins/notifications/components/NotificationCard.qml w/shell/plugins/notifications/components/NotificationCard.qml +--- i/shell/plugins/notifications/components/NotificationCard.qml ++++ w/shell/plugins/notifications/components/NotificationCard.qml +@@ -27,6 +27,11 @@ + property int urgency: 1 + property double timestamp: 0 + property int cornerRadius: 0 ++ // A static summary (a phone's lock screen) keeps each card short, and ++ // says beside the summary how many there are and how old ("2 new, 5m"). ++ property int summaryLines: 2 ++ property int bodyLines: 3 ++ property string detail: "" + + // System monospace font injected by the container. + property string fontFamily: "" +@@ -300,7 +305,7 @@ + font.bold: true + wrapMode: Text.WordWrap + elide: Text.ElideRight +- maximumLineCount: 2 ++ maximumLineCount: root.summaryLines + } + + Text { +@@ -314,9 +319,19 @@ + font.pixelSize: Style.font.title + wrapMode: Text.WordWrap + elide: Text.ElideRight +- maximumLineCount: 3 ++ maximumLineCount: root.bodyLines + } + } ++ ++ Text { ++ textFormat: Text.PlainText ++ Layout.alignment: Qt.AlignTop ++ visible: root.detail.length > 0 ++ text: root.detail ++ color: root.dimColor ++ font.family: root.fontFamily ++ font.pixelSize: Style.font.bodySmall ++ } + } + + // Reply, then a field with Send and Cancel, each tall enough to tap on diff --git a/packages/omamobile-omarchy/test/all b/packages/omamobile-omarchy/test/all index 2a657a684..1357501a0 100755 --- a/packages/omamobile-omarchy/test/all +++ b/packages/omamobile-omarchy/test/all @@ -9,7 +9,7 @@ cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." fail() { printf 'not ok - %s\n' "$1" >&2; exit 1; } pass() { printf 'ok - %s\n' "$1"; } -for f in install omamobile-omarchy.install lib/update-bin/* lib/lock-pam test/update.sh test/lock-pam.sh; do +for f in install omamobile-omarchy.install lib/update-bin/* lib/lock-pam test/update.sh test/lock-pam.sh test/lock-glance; do bash -n "$f" || fail "$f parses" done for f in bin/omamobile-omarchy-patches bin/omamobile-update test/patches.py; do diff --git a/packages/omamobile-omarchy/test/lock-glance b/packages/omamobile-omarchy/test/lock-glance new file mode 100755 index 000000000..945a1b9e5 --- /dev/null +++ b/packages/omamobile-omarchy/test/lock-glance @@ -0,0 +1,26 @@ +#!/bin/bash +# SPDX-License-Identifier: MIT +# Patch 0023's glance view on the lock, offscreen in qmltestrunner: the +# patched LockView, LockGlance and NotificationCard with Omarchy's real +# Commons and Ui from the package (test/patches.py passes the patched +# shell directory), and Quickshell stubbed (test/qml-stubs). No compositor, +# no Quickshell, no session. Exits 77 without qmltestrunner. +# test/lock-glance SHELL_DIR +set -euo pipefail +here=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd) +shell=${1:?usage: lock-glance SHELL_DIR} +runner=$(command -v qmltestrunner6 || command -v /usr/lib/qt6/bin/qmltestrunner || command -v qmltestrunner || true) +[[ -n $runner ]] || { echo "lock-glance: no qmltestrunner" >&2; exit 77; } + +work=$(mktemp -d) +trap 'rm -rf "$work"' EXIT +mkdir -p "$work/qs" "$work/plugins" "$work/home/.local/state/omarchy/toggles" \ + "$work/home/.local/state/omamobile" "$work/home/.config/omarchy" +cp -r "$shell/Commons" "$shell/Ui" "$work/qs/" +cp -r "$shell/plugins/lock" "$shell/plugins/notifications" "$work/plugins/" +cp "$here/lock-glance.qml" "$work/tst_lock_glance.qml" +printf '.pragma library\nvar HOME = "%s"\n' "$work/home" > "$work/TestEnv.js" + +export QT_QPA_PLATFORM=offscreen QT_QUICK_BACKEND=software QML_DISABLE_DISK_CACHE=1 +export QML_XHR_ALLOW_FILE_READ=1 +exec "$runner" -import "$here/qml-stubs" -import "$work" -input "$work/tst_lock_glance.qml" diff --git a/packages/omamobile-omarchy/test/lock-glance.qml b/packages/omamobile-omarchy/test/lock-glance.qml new file mode 100644 index 000000000..be53da5a0 --- /dev/null +++ b/packages/omamobile-omarchy/test/lock-glance.qml @@ -0,0 +1,323 @@ +// SPDX-License-Identifier: MIT +// The lock's glance view (patch 0023) under qmltestrunner; test/lock-glance +// runs this against the patched Omarchy shell. A LockView as the lock +// Service makes it on a phone (keypad on, fingerprints set up), with the +// field's text kept here as the Service keeps it. +import QtQuick +import QtTest +import Quickshell +import "plugins/lock" +import "TestEnv.js" as TestEnv + +Item { + id: harness + width: 480 + height: 1040 + + property string password: "" + property var submitted: [] + property string notificationsRaw: "" + property var view: null + + readonly property string home: TestEnv.HOME + readonly property double minute: 60 * 1000 + + Component { + id: lockComponent + LockView { + anchors.fill: parent + keypad: true + fingerprintConfigured: true + inputEnabled: true + loadBackground: false + passwordText: harness.password + onPasswordTextEdited: function(value) { harness.password = value } + onSubmitPassword: function(value) { harness.submitted = harness.submitted.concat([value]) } + } + } + + function writeFile(rel, text) { + var files = Quickshell.files + files[home + "/" + rel] = text + Quickshell.files = files + Quickshell.diskChanged() + } + + function entry(app, ago, id, summary, body) { + var ts = test.glance().now - ago + return JSON.stringify({ id: id, originalId: id, app: app, appIcon: "", summary: summary, body: body, + image: "/tmp/avatar-" + id + ".png", glyph: "", urgency: 1, timestamp: ts }) + } + + TestCase { + id: test + name: "LockGlance" + when: windowShown + + function findAll(item, pred, out) { + out = out || [] + if (!item) return out + if (pred(item)) out.push(item) + var kids = item.children || [] + for (var i = 0; i < kids.length; i++) findAll(kids[i], pred, out) + return out + } + + function byName(name) { return findAll(harness.view, function(i) { return i.objectName === name }) } + function one(name) { var l = byName(name); verify(l.length > 0, "found " + name); return l[0] } + function glance() { return one("lockGlanceView").parent } + + // Everything of the PIN view that draws: the pad's digits, the field and + // its placeholder, the hint above it and the emergency call. + readonly property var pinTexts: ["1", "2", "5", "9", "0", "Enter PIN", "ABC", "Emergency call", + "Touch the fingerprint sensor or enter your PIN"] + function visiblePinParts() { + return findAll(harness.view, function(i) { + return i.visible && i.opacity > 0 && i.text !== undefined && pinTexts.indexOf(String(i.text)) >= 0 + && i.objectName !== "lockGlanceTime" + }).map(function(i) { return String(i.text) }) + } + function visibleGlanceParts() { + return findAll(harness.view, function(i) { + return i.visible && /^lockGlance(Time|Date|Hint|Card|Quiet|More)$/.test(i.objectName) + }).map(function(i) { return i.objectName }) + } + + function settle() { wait(400) } + + function init() { + harness.password = "" + harness.submitted = [] + harness.notificationsRaw = "" + Quickshell.vars = { HOME: harness.home } + Quickshell.responder = function(argv) { + var cmd = argv.join(" ") + return cmd.indexOf("/.local/state/omarchy/notifications/") >= 0 ? harness.notificationsRaw : null + } + writeFile(".local/state/omarchy/toggles/lock-hide-notification-text", "") + writeFile(".local/state/omarchy/notifications.json", "") + writeFile(".local/state/omamobile/weather.json", "") + writeFile(".config/omarchy/shell.json", "") + writeFile(".local/state/omarchy/toggles/credential-password", "") + harness.view = createTemporaryObject(lockComponent, harness) + verify(harness.view) + settle() + } + + function show() { + harness.view.wakeSerial += 1 + settle() + } + + function test_glance_first_and_alone() { + compare(glance().showing, true) + verify(one("lockGlanceView").visible) + verify(one("lockGlanceTime").visible) + compare(one("lockGlanceHint").text, "Touch the fingerprint sensor or swipe up") + compare(visiblePinParts(), [], "nothing of the PIN view shows under the glance") + compare(one("lockPinClock").visible, false) + compare(one("inputSwitch").visible, false) + compare(one("lockEmergencyCall").visible, false) + compare(one("keypadFingerprintHint").visible, false) + } + + function test_tap_shows_pin_view_alone() { + mouseClick(harness.view, 240, 300) + settle() + compare(glance().showing, false) + compare(one("lockGlanceView").visible, false, "the glance is hidden, not just transparent") + compare(visibleGlanceParts(), []) + verify(visiblePinParts().indexOf("5") >= 0, "the pad shows") + verify(visiblePinParts().indexOf("Enter PIN") >= 0, "the field shows") + verify(one("lockEmergencyCall").visible) + verify(one("lockPinClock").visible) + verify(one("lockPinClock").y < one("keypadFingerprintHint").y, "the small clock sits above the hint") + } + + function test_tap_on_the_sensor_does_nothing() { + mouseClick(harness.view, 240, 1040 - 120) + settle() + compare(glance().showing, true) + } + + function test_swipe_up() { + mousePress(harness.view, 240, 600) + for (var y = 590; y >= 400; y -= 10) mouseMove(harness.view, 240, y, -1, Qt.LeftButton) + mouseRelease(harness.view, 240, 400) + settle() + compare(glance().showing, false) + } + + function test_digit_on_glance_is_kept() { + harness.view.forcePasswordFocus() + verify(glance().activeFocus, "the glance holds the keys while it is up") + keyClick(Qt.Key_5) + settle() + compare(harness.password, "5") + compare(glance().showing, false) + keyClick(Qt.Key_7) + compare(harness.password, "57", "the next digit goes to the pad") + } + + function test_idle_returns_to_glance() { + var idle = findChild(glance(), "lockGlanceIdle") + verify(idle) + idle.interval = 800 + mouseClick(harness.view, 240, 300) + wait(100) + compare(glance().showing, false) + tryCompare(glance(), "showing", true, 3000) + settle() + compare(visiblePinParts(), []) + } + + function test_idle_waits_for_a_typed_pin() { + var idle = findChild(glance(), "lockGlanceIdle") + idle.interval = 300 + mouseClick(harness.view, 240, 300) + settle() + harness.password = "12" + wait(800) + compare(glance().showing, false, "a half-typed PIN keeps the PIN view") + } + + function test_wake_returns_to_glance_and_clears() { + mouseClick(harness.view, 240, 300) + settle() + harness.password = "12" + harness.view.wakeSerial += 1 + settle() + compare(glance().showing, true) + compare(harness.password, "") + compare(visiblePinParts(), []) + } + + function test_failed_attempt_keeps_pin_view() { + mouseClick(harness.view, 240, 300) + settle() + harness.view.authenticatingPassword = true + harness.view.authenticatingPassword = false + harness.view.failureMessage = "Authentication failed (1)" + settle() + compare(glance().showing, false) + } + + function test_notifications_grouped() { + harness.notificationsRaw = [ + entry("Messages", 2 * minute, 1, "Sam", "Running late\nsecond line"), + entry("Messages", 5 * minute, 2, "Sam", "Earlier"), + entry("Updates", 18 * minute, 3, "4 updates ready", "omamobile-shell and 3 more"), + entry("Calendar", 60 * minute, 4, "Standup at 10:00", "Video call"), + entry("Mail", 120 * minute, 5, "Invoice", "Attached"), + entry("Mail", 121 * minute, 6, "Invoice 2", "Attached"), + entry("GitHub", 150 * minute, 7, "New pull request", "tools"), + entry("omarchy-action", 1 * minute, 8, "Theme changed", ""), + entry("Old", 30 * 60 * minute, 9, "Yesterday's", "news") + ].join("\n") + "\n" + show() + var g = glance().groups + compare(g.length, 5, "one group per app, Omarchy's action toasts and old ones left out") + compare(g[0].app, "Messages") + compare(g[0].count, 2) + compare(g[0].detail, "2 new, 2m") + compare(g[0].body, "Running late", "one line of the newest body") + compare(g[2].detail, "1h") + var cards = byName("lockGlanceCard").filter(function(c) { return c.visible }) + compare(cards.length, 3) + compare(cards[0].summary, "Sam") + compare(cards[0].bodyLines, 1) + compare(cards[0].swipeEnabled, false) + compare(cards[0].closeButtonShown, false) + compare(one("lockGlanceMore").text, "3 more from Mail and GitHub") + compare(one("lockGlanceQuiet").visible, false) + var hint = one("lockGlanceHint") + var last = cards[2] + verify(last.mapToItem(harness, 0, last.height).y < hint.mapToItem(harness, 0, 0).y, "the cards stay above the hint") + // A card asks for the PIN, nothing else (the pad folds the on-screen + // keyboard, as before). + Quickshell.executed = [] + mouseClick(cards[0], 20, 10) + settle() + compare(glance().showing, false) + compare(Quickshell.executed.filter(function(a) { return a[0] !== "busctl" }), []) + } + + function test_hide_text_toggle() { + harness.notificationsRaw = entry("Messages", 2 * minute, 1, "Sam", "Secret") + "\n" + writeFile(".local/state/omarchy/toggles/lock-hide-notification-text", "1\n") + show() + var card = byName("lockGlanceCard")[0] + compare(card.summary, "Messages") + compare(card.body, "Unlock to read") + compare(card.image, "", "no sender picture") + writeFile(".local/state/omarchy/toggles/lock-hide-notification-text", "") + settle() + compare(byName("lockGlanceCard")[0].summary, "Sam") + } + + function test_do_not_disturb_hides_cards() { + harness.notificationsRaw = entry("Messages", 2 * minute, 1, "Sam", "Hi") + "\n" + writeFile(".local/state/omarchy/notifications.json", '{"version": 3, "dnd": true}\n') + show() + compare(byName("lockGlanceCard").filter(function(c) { return c.visible }).length, 0) + writeFile(".local/state/omarchy/notifications.json", '{"version": 3, "dnd": false}\n') + settle() + compare(byName("lockGlanceCard").filter(function(c) { return c.visible }).length, 1) + } + + function test_no_notifications() { + show() + verify(one("lockGlanceQuiet").visible) + compare(one("lockGlanceMore").visible, false) + } + + function test_weather_line() { + var w = one("lockGlanceWeather") + compare(w.visible, false, "no reading, no line") + writeFile(".local/state/omamobile/weather.json", + JSON.stringify({ at: Date.now() - 10 * minute, temperature: 12.4, unit: "°C", text: "Partly cloudy" })) + settle() + verify(w.visible) + compare(w.text, "12°, partly cloudy") + writeFile(".local/state/omamobile/weather.json", + JSON.stringify({ at: Date.now() - 4 * 60 * minute, temperature: 12, unit: "°C", text: "Clear" })) + settle() + compare(w.visible, false, "a reading over 3 h old is not shown") + } + + function test_clock_follows_bar_format() { + writeFile(".config/omarchy/shell.json", JSON.stringify({ bar: { clockFormat: "h:mm AP" } })) + settle() + verify(/^\d{1,2}:\d\d$/.test(one("lockGlanceTime").text), one("lockGlanceTime").text) + verify(/^\d{1,2}:\d\d (AM|PM)$/i.test(one("lockPinClock").text), one("lockPinClock").text) + writeFile(".config/omarchy/shell.json", JSON.stringify({ bar: { clockFormat: "HH:mm" } })) + settle() + verify(/^\d\d:\d\d$/.test(one("lockGlanceTime").text), one("lockGlanceTime").text) + verify(/^\d\d:\d\d$/.test(one("lockPinClock").text), one("lockPinClock").text) + } + + function test_password_first_reveals_the_field() { + writeFile(".local/state/omarchy/toggles/credential-password", "1\n") + settle() + compare(harness.view.passwordFirst, true) + keyClick(Qt.Key_A) + settle() + compare(harness.password, "a", "a letter goes into a password") + compare(glance().showing, false) + verify(visiblePinParts().indexOf("123") < 0) + writeFile(".local/state/omarchy/toggles/credential-password", "") + } + + function test_computer_lock_unchanged() { + harness.view.keypad = false + settle() + compare(glance().visible, false) + compare(one("lockGlanceView").visible, false) + compare(harness.view.pinOpacity, 1) + compare(harness.view.pinVisible, true) + compare(one("lockPinClock").visible, false) + compare(one("lockEmergencyCall").visible, false) + verify(findAll(harness.view, function(i) { return i.visible && String(i.text) === "Enter Password" }).length > 0) + } + } +} diff --git a/packages/omamobile-omarchy/test/patches.py b/packages/omamobile-omarchy/test/patches.py index 32aad4f78..d31a41f4d 100755 --- a/packages/omamobile-omarchy/test/patches.py +++ b/packages/omamobile-omarchy/test/patches.py @@ -382,6 +382,7 @@ def make_root(name, mtree_from): "real omarchy: Backspace and Left still go back (0018)") ok("property bool cardSettled: false" in menu, "real omarchy: the menu-first-frame bridge applies after 0018") qml_parse(root) + lock_glance(root) for name in ("omarchy-channel-set", "omarchy-refresh-pacman"): text = read(root, "usr/bin/" + name) guard = text.find("if [[ -x /usr/bin/omamobile-update ]]") @@ -443,6 +444,40 @@ def qml_parse(root): ok(files and not bad, "real omarchy: the %d patched QML files parse (qmlformat)%s" % (len(files), " " + str(bad) if bad else "")) +def lock_glance(root): + """Patch 0023: the lock's glance view. Static checks on the patched + files, then test/lock-glance (qmltestrunner, offscreen) against them.""" + lock = "usr/share/omarchy/shell/plugins/lock/" + view = read(root, lock + "LockView.qml") + service = read(root, lock + "Service.qml") + card = read(root, "usr/share/omarchy/shell/plugins/notifications/components/NotificationCard.qml") + ok(os.path.isfile(os.path.join(root, lock + "LockGlance.qml")) and os.path.isfile(os.path.join(root, lock + "LockGlance.js")) + and "LockGlance {\n id: glance" in view, + "real omarchy: the lock has a glance view (0023)") + ok(view.count("opacity: root.pinOpacity") == 4 and view.count("&& root.pinVisible") == 3 and "visible: root.pinVisible" in view, + "real omarchy: every part of the PIN view hides under the glance (0023)") + wake = service.split("function wake(): string {", 1) + ok(len(wake) == 2 and "root.wakeSerial += 1" in wake[1].split("}", 1)[0] + and "wakeSerial: root.wakeSerial" in service, + "real omarchy: the wake call brings the glance back (0023)") + ok("maximumLineCount: root.summaryLines" in card and "maximumLineCount: root.bodyLines" in card + and "property int summaryLines: 2" in card and "property int bodyLines: 3" in card, + "real omarchy: notification toasts keep their line counts (0023)") + glance = read(root, lock + "LockGlance.qml") + read(root, lock + "LockGlance.js") + ok("XMLHttpRequest" not in glance and "curl" not in glance and "execDetached" not in glance, + "real omarchy: the glance asks no network and runs nothing (0023)") + p = subprocess.run(["bash", os.path.join(HERE, "lock-glance"), os.path.join(root, "usr/share/omarchy/shell")], + capture_output=True, text=True) + if p.returncode == 77: + print("ok - real omarchy: the glance under qmltestrunner # SKIP no qmltestrunner") + return + out = p.stdout + p.stderr + totals = [l for l in out.splitlines() if l.startswith("Totals:")] + ok(p.returncode == 0, "real omarchy: the glance under qmltestrunner (0023: %s)" % (totals[-1] if totals else "no result")) + if p.returncode != 0: + print("\n".join(l for l in out.splitlines() if l.startswith(("FAIL", " ", "QWARN")))[:4000]) + + def screensaver_launcher(t, launcher): """Patch 0006's launcher against fake commands: every way out of it puts the on-screen keyboard back unless a screensaver runs (TOUCH-PLAN 0.5).""" diff --git a/packages/omamobile-omarchy/test/qml-stubs/Quickshell/Io/FileView.qml b/packages/omamobile-omarchy/test/qml-stubs/Quickshell/Io/FileView.qml new file mode 100644 index 000000000..f0379519e --- /dev/null +++ b/packages/omamobile-omarchy/test/qml-stubs/Quickshell/Io/FileView.qml @@ -0,0 +1,50 @@ +// SPDX-License-Identifier: MIT +import QtQuick +import Quickshell + +// Stand-in for Quickshell's FileView: the test's Quickshell.files when it +// names the path (an empty text is no file), else the disk through +// XMLHttpRequest (QML_XHR_ALLOW_FILE_READ=1). Quickshell.diskChanged() +// stands in for a change on disk. +QtObject { + id: view + property string path: "" + property bool watchChanges: false + property bool printErrors: true + property bool blockLoading: false + property bool preload: true + property string content: "" + signal loaded() + signal loadFailed(int error) + signal fileChanged() + + function text() { return content } + function setText(value) { content = String(value) } + function reload() { + if (!path) return + if (Quickshell.files[path] !== undefined) { + content = String(Quickshell.files[path]) + if (content.length > 0) loaded() + else loadFailed(1) + return + } + var x = new XMLHttpRequest() + x.open("GET", "file://" + path, false) + try { x.send() } catch (e) { content = ""; loadFailed(1); return } + if (x.responseText.length > 0) { + content = x.responseText + loaded() + } else { + content = "" + loadFailed(1) + } + } + + onPathChanged: Qt.callLater(reload) + Component.onCompleted: Qt.callLater(reload) + + property Connections watcher: Connections { + target: Quickshell + function onDiskChanged() { if (view.watchChanges && view.path) view.fileChanged() } + } +} diff --git a/packages/omamobile-omarchy/test/qml-stubs/Quickshell/Io/Process.qml b/packages/omamobile-omarchy/test/qml-stubs/Quickshell/Io/Process.qml new file mode 100644 index 000000000..2592f407a --- /dev/null +++ b/packages/omamobile-omarchy/test/qml-stubs/Quickshell/Io/Process.qml @@ -0,0 +1,31 @@ +// SPDX-License-Identifier: MIT +import QtQuick +import Quickshell + +// Stand-in for Quickshell's Process: records what it would run, and when +// the test's responder answers the command, finishes with that output. +QtObject { + id: proc + property var command: [] + property bool running: false + property var stdout: null + property var stderr: null + property var environment: ({}) + signal exited(int exitCode, int exitStatus) + + onRunningChanged: { + if (!running) return + var argv = command + Quickshell.started = Quickshell.started.concat([argv]) + var out = typeof Quickshell.responder === "function" ? Quickshell.responder(argv) : null + if (out === null || out === undefined) return + Qt.callLater(function() { + if (proc.stdout) { + proc.stdout.text = String(out) + proc.stdout.streamFinished() + } + proc.running = false + proc.exited(0, 0) + }) + } +} diff --git a/packages/omamobile-omarchy/test/qml-stubs/Quickshell/Io/StdioCollector.qml b/packages/omamobile-omarchy/test/qml-stubs/Quickshell/Io/StdioCollector.qml new file mode 100644 index 000000000..a5ed25bcf --- /dev/null +++ b/packages/omamobile-omarchy/test/qml-stubs/Quickshell/Io/StdioCollector.qml @@ -0,0 +1,8 @@ +// SPDX-License-Identifier: MIT +import QtQuick + +QtObject { + property string text: "" + property bool waitForEnd: false + signal streamFinished() +} diff --git a/packages/omamobile-omarchy/test/qml-stubs/Quickshell/Io/qmldir b/packages/omamobile-omarchy/test/qml-stubs/Quickshell/Io/qmldir new file mode 100644 index 000000000..3a532e8e6 --- /dev/null +++ b/packages/omamobile-omarchy/test/qml-stubs/Quickshell/Io/qmldir @@ -0,0 +1,4 @@ +module Quickshell.Io +Process 1.0 Process.qml +StdioCollector 1.0 StdioCollector.qml +FileView 1.0 FileView.qml diff --git a/packages/omamobile-omarchy/test/qml-stubs/Quickshell/Quickshell.qml b/packages/omamobile-omarchy/test/qml-stubs/Quickshell/Quickshell.qml new file mode 100644 index 000000000..0904b5e4a --- /dev/null +++ b/packages/omamobile-omarchy/test/qml-stubs/Quickshell/Quickshell.qml @@ -0,0 +1,25 @@ +// SPDX-License-Identifier: MIT +pragma Singleton +import QtQuick + +// Stand-in for Quickshell's singleton, enough for Omarchy's Commons and the +// lock to load under qmltestrunner (test/lock-glance). The test sets the +// environment (vars), the files FileView finds (files: path -> text, which +// take the place of the disk), and answers the commands Process starts +// (responder); diskChanged() makes every watching FileView re-read. +QtObject { + property var vars: ({}) + property var files: ({}) + property var screens: [] + property string shellDir: "/stub/shell" + property var executed: [] + property var started: [] + // function(argv) -> stdout text, or null to leave the process running + property var responder: null + + signal diskChanged() + + function env(name) { return vars[name] !== undefined ? String(vars[name]) : "" } + function execDetached(argv) { executed = executed.concat([argv]) } + function iconPath(name, check) { return "" } +} diff --git a/packages/omamobile-omarchy/test/qml-stubs/Quickshell/SystemClock.qml b/packages/omamobile-omarchy/test/qml-stubs/Quickshell/SystemClock.qml new file mode 100644 index 000000000..021759f90 --- /dev/null +++ b/packages/omamobile-omarchy/test/qml-stubs/Quickshell/SystemClock.qml @@ -0,0 +1,10 @@ +// SPDX-License-Identifier: MIT +import QtQuick + +// Stand-in for Quickshell's SystemClock: the time when it was made, or what +// the test sets. +QtObject { + enum Precision { Hours, Minutes, Seconds } + property int precision: SystemClock.Seconds + property date date: new Date() +} diff --git a/packages/omamobile-omarchy/test/qml-stubs/Quickshell/qmldir b/packages/omamobile-omarchy/test/qml-stubs/Quickshell/qmldir new file mode 100644 index 000000000..a556b4ab6 --- /dev/null +++ b/packages/omamobile-omarchy/test/qml-stubs/Quickshell/qmldir @@ -0,0 +1,3 @@ +module Quickshell +singleton Quickshell 1.0 Quickshell.qml +SystemClock 1.0 SystemClock.qml diff --git a/packages/omamobile-omarchy/version b/packages/omamobile-omarchy/version index 0e24a92ff..e8e277f2f 100644 --- a/packages/omamobile-omarchy/version +++ b/packages/omamobile-omarchy/version @@ -1 +1 @@ -0.1.12 +0.1.16