buninu-browser 0.3.0 → 0.5.0

package/test/fixtures/qml/flea-theme/ui/Glass.qml

@@ -0,0 +1,114 @@
+pragma Singleton
+import QtQuick
+import Quickshell
+import Quickshell.Io
+import qs.Commons
+import qs.Commons as Commons
+import "js/Material.js" as Material
+
+// shell.toml's [flea] background-alpha through Omarchy's reader, and Omarchy's Window Transparency mode: one plane per pixel, content opaque; AGENTS.md "Theme roles and sources".
+QtObject {
+    id: root
+
+    readonly property string key: "flea.background-alpha"
+    // Pick candidate A: match Nautilus's 0.75 ground, lifting text rather than fading it like window opacity does.
+    property real glassAlpha: root.mode === "glassy" && root.usesDefault ? Material.floor(Theme.color.opaquePalette, Theme.textContrast) / 255 : 1
+    property bool focused: Qt.application.active
+    readonly property bool split: true
+    readonly property bool usesDefault: root.valueIn(Commons.Color.userShellValues) < 0 && root.valueIn(Commons.Color.themeShellValues) < 0
+    // "opaque", "glassy" or "transparent" (Omarchy's default), read from its toggle files by reread().
+    property string mode: "transparent"
+    property bool hasOpaque: false
+    property bool hasGlassy: false
+    // Set once by launch(), before the window exists, because a Wayland surface's format is fixed at creation.
+    property bool clear: false
+    // In whole 8-bit steps, so a value that rounds to 1 is 1; a launch a [flea] value pins opaque holds 1 until the next launch.
+    readonly property real alpha: root.clear ? root.stepped(root.wanted()) : 1
+    // False keeps every plane on its own opaque role, so a stock theme draws exactly what it drew before.
+    readonly property bool on: root.alpha < 1
+    readonly property color background: root.on ? Util.alpha(Theme.color.background, root.alpha) : Theme.color.background
+    readonly property color surface: root.on ? Util.alpha(Theme.color.surface, root.alpha) : Theme.color.surface
+    readonly property real listAlpha: root.on && root.usesDefault && root.mode === "glassy" && root.split ? Math.max(root.alpha, Material.listFloor(Theme.color.opaquePalette, Theme.textContrast) / 255) : root.alpha
+    readonly property color listBackground: root.on ? Util.alpha(Theme.color.background, root.listAlpha) : Theme.color.background
+
+    readonly property string toggleDir: (Quickshell.env("XDG_STATE_HOME") || Quickshell.env("HOME") + "/.local/state") + "/omarchy/toggles/hypr"
+    // A file test and not omarchy-hyprland-window-transparency, which needs OMARCHY_PATH that ssh and some launchers lack.
+    property FileView opaqueFile: FileView {
+        path: root.toggleDir + "/window-opaque.lua"
+        printErrors: false
+        onLoaded: root.hasOpaque = true
+        onLoadFailed: root.hasOpaque = false
+    }
+    property FileView glassyFile: FileView {
+        path: root.toggleDir + "/window-glassy.lua"
+        printErrors: false
+        onLoaded: root.hasGlassy = true
+        onLoadFailed: root.hasGlassy = false
+    }
+    // Hyprland reloads its config for a Window Transparency change, with no theme switch.
+    property Connections reloads: Connections {
+        target: Theme
+        function onConfigReloaded() { root.reread(); root.retag() }
+        function onFleaWindowOpened() { root.startTagger() }
+    }
+    // Only inside Hyprland, as ui/Theme.qml's event hookup: a headless run has no compositor to ask.
+    readonly property bool inHyprland: Quickshell.env("HYPRLAND_INSTANCE_SIGNATURE") !== null
+    // ui/GlassTagger.qml, made when Hyprland opens the first Flea window, so it costs nothing before the first rows.
+    property QtObject tagger: null
+    onModeChanged: root.retag()
+    onUsesDefaultChanged: root.retag()
+
+    // Sample input: 0.34 answers 87/255, 0.999 answers 1.
+    function stepped(value) { return Math.round(value * 255) / 255 }
+
+    // One shell.toml's value: -1 when it sets none, the clamped number, or 1 for what is not a number.
+    function valueIn(values) {
+        var v = values ? values[root.key] : undefined
+        if (typeof v !== "string" || v.length === 0) return -1
+        var n = Number(v)
+        return isFinite(n) ? Util.clampAlpha(n) : 1
+    }
+    // User and theme values keep their precedence; bare Transparent is opaque: no shipped theme sets an opacity of its own, and no toggle file means transparency was never chosen.
+    function wanted() {
+        var user = root.valueIn(Commons.Color.userShellValues)
+        if (user >= 0) return user
+        if (root.mode === "opaque") return 1
+        var theme = root.valueIn(Commons.Color.themeShellValues)
+        if (theme >= 0) return theme
+        return root.mode === "glassy" ? root.glassAlpha : 1
+    }
+
+    function reread() {
+        root.opaqueFile.reload()
+        root.glassyFile.reload()
+        root.opaqueFile.waitForJob()
+        root.glassyFile.waitForJob()
+        root.mode = root.hasGlassy ? "glassy" : root.hasOpaque ? "opaque" : "transparent"
+    }
+
+    // A [flea] value that pins 1 keeps an opaque surface; every other launch is made clear, so each Window Transparency switch shows live.
+    function pinsOpaque() {
+        var user = root.valueIn(Commons.Color.userShellValues)
+        if (user >= 0) return root.stepped(user) >= 1
+        var theme = root.valueIn(Commons.Color.themeShellValues)
+        return theme >= 0 && root.stepped(theme) >= 1
+    }
+
+    // Color's two shell readers load asynchronously; waiting here lands both before the decision.
+    function launch() {
+        Commons.Color.shellFile.waitForJob()
+        Commons.Color.userShellFile.waitForJob()
+        root.reread()
+        root.clear = !root.pinsOpaque()
+    }
+
+    function startTagger() {
+        if (!root.inHyprland) return
+        if (!root.tagger) root.tagger = Qt.createComponent("GlassTagger.qml").createObject(root, {
+            mode: Qt.binding(function () { return root.mode }),
+            usesDefault: Qt.binding(function () { return root.usesDefault })
+        })
+        root.retag()
+    }
+    function retag() { if (root.tagger) root.tagger.retag() }
+}

package/test/fixtures/qml/flea-theme/ui/Glyph.qml

@@ -0,0 +1,54 @@
+import QtQuick
+import QtQuick.Shapes
+import qs.Commons
+import "js/Icons.js" as Icons
+
+// One row or sidebar mark, chosen by name. Lucide's grid is 24 units at stroke 2, scaled to the slot.
+Item {
+    id: root
+
+    property string name: "file"
+    property color color: "transparent"
+    // Lucide draws on a 24 unit grid, so every path in Icons.js is in those units.
+    readonly property real grid: 24
+    // The mark's ceiling. Default is the row and menu mark; a surface drawing a mark alone passes its own.
+    property real maxSize: Theme.markSize
+    // The min() against the slot is the icon spec's own rule, so a smaller caller slot still wins
+    // (the Network "+" at the caption token needs it) and no container can ever enlarge a mark.
+    readonly property real markSize: Math.min(root.maxSize, root.width, root.height)
+    // Its own name: "scale" would shadow Item.scale, which qmllint flagged.
+    readonly property real gridScale: root.markSize / root.grid
+    property real strokeWidth: Theme.strokeWidth
+    // The solid part of the mark (Icons.js FILLED), empty for every mark but the few that have one.
+    readonly property string filledPath: Icons.filledPathFor(root.name)
+    // Built the first time a mark names a solid part: a plain glyph owns no object for it, which tests/rowcost.qml counts.
+    property Item solid: null
+    function syncSolid() {
+        if (root.solid === null && root.filledPath.length > 0)
+            root.solid = Qt.createComponent("GlyphSolid.qml").createObject(root, { glyph: root })
+    }
+    // filledPath starts empty, so its first non-empty value, on a build or a reuse, lands here.
+    onFilledPathChanged: root.syncSolid()
+
+    // The Shape is sized in grid units pre-transform; Scale's origin defaults to (0,0), so this
+    // offset is what re-centers the scaled-down box in root's slot instead of pinning it top-left.
+    Shape {
+        width: root.grid
+        height: root.grid
+        x: (root.width - root.markSize) / 2
+        y: (root.height - root.markSize) / 2
+        preferredRendererType: Shape.CurveRenderer
+        transform: Scale { xScale: root.gridScale; yScale: root.gridScale }
+
+        ShapePath {
+            strokeColor: root.color
+            fillColor: "transparent"
+            strokeWidth: root.strokeWidth
+            // The Omarchy cut: square caps and mitered joins, the edge of the brand spiral; Icons.js paths are redrawn sharp to match.
+            capStyle: ViewState.hyprlandIcons && Style.cornerRadius > 0 ? ShapePath.RoundCap : ShapePath.SquareCap
+            joinStyle: ViewState.hyprlandIcons && Style.cornerRadius > 0 ? ShapePath.RoundJoin : ShapePath.MiterJoin
+            // A mark with more than one stroke is one multi-subpath SVG string; see Icons.js "Lucide path data".
+            PathSvg { path: Icons.pathFor(root.name) }
+        }
+    }
+}

package/test/fixtures/qml/flea-theme/ui/GlyphSolid.qml

@@ -0,0 +1,22 @@
+import QtQuick
+import QtQuick.Shapes
+
+// The solid part of a mark, drawn over its stroke in the same ink; ui/Glyph.qml builds it only for a mark that names one.
+Shape {
+    id: root
+
+    required property Glyph glyph
+
+    width: root.glyph.grid
+    height: root.glyph.grid
+    x: (root.glyph.width - root.glyph.markSize) / 2
+    y: (root.glyph.height - root.glyph.markSize) / 2
+    preferredRendererType: Shape.CurveRenderer
+    transform: Scale { xScale: root.glyph.gridScale; yScale: root.glyph.gridScale }
+
+    ShapePath {
+        strokeColor: "transparent"
+        fillColor: root.glyph.color
+        PathSvg { path: root.glyph.filledPath }
+    }
+}

package/test/fixtures/qml/flea-theme/ui/Reveal.qml

@@ -0,0 +1,54 @@
+import QtQuick
+import "js/Motion.js" as Motion
+
+// The one fade every dialog and menu shares: OutCubic, Motion.durMs.open in and .close out, snapped under reduced motion.
+QtObject {
+    id: root
+
+    // The item that fades; it declares a plain `opacity: 0` and never binds it.
+    property Item target: null
+    property bool shown: false
+    // A dialog's card: it rises Motion.translateUpPx into place on a fresh open only, and never moves while it fades out.
+    property Item lift: null
+
+    // Drives target.opacity from where it stands, so a reopen during a close fades up from there and never replays the old frame.
+    function drive() {
+        if (root.target === null) return
+        fade.stop()
+        risen.stop()
+        if (Theme.reducedMotion) {
+            root.target.opacity = root.shown ? 1 : 0
+            rise.y = 0
+            return
+        }
+        if (root.shown && root.lift !== null) {
+            if (root.target.opacity === 0) rise.y = Motion.translateUpPx
+            if (rise.y !== 0) risen.start()
+        }
+        fade.to = root.shown ? 1 : 0
+        fade.duration = root.shown ? Motion.durMs.open : Motion.durMs.close
+        fade.start()
+    }
+
+    onShownChanged: root.drive()
+    Component.onCompleted: {
+        if (root.lift !== null) root.lift.transform = rise
+        if (root.shown) root.drive()
+    }
+
+    property Translate rise: Translate {}
+    property NumberAnimation fade: NumberAnimation {
+        target: root.target
+        property: "opacity"
+        easing.type: Easing.OutCubic
+        // A close cut inside the rise leaves the card where it stood until it is gone, then rests it.
+        onFinished: if (!root.shown) root.rise.y = 0
+    }
+    property NumberAnimation risen: NumberAnimation {
+        target: root.rise
+        property: "y"
+        to: 0
+        duration: Motion.durMs.open
+        easing.type: Easing.OutCubic
+    }
+}

package/test/fixtures/qml/flea-theme/ui/SettingsRuler.qml

@@ -0,0 +1,85 @@
+import QtQuick
+
+// The Display board's seven-stop ruler: one tick per size Omarchy offers, each carrying its own
+// number, with the stop in force marked by a taller tick under a foreground number rather than by a
+// fill nobody could read (SettingsRest rule 2). The marked tick takes the accent once an override
+// makes the ruler the control, which is the Blueprint's own rule for an active control against a
+// quiet one, and stays muted while Omarchy owns the size and the ruler is only reporting it.
+Item {
+    id: root
+
+    property var stops: []
+    // The last filled tick. Omarchy can be on a size that is not a stop, so the caller fills to the
+    // nearest one rather than leaving the ruler blank.
+    property int index: -1
+    property bool active: false
+
+    signal picked(int stop)
+
+    readonly property int tickGap: Theme.spacing.hairline * 2
+    readonly property int tickHeight: Theme.spacing.hairline * 3
+    // The board's own 7 against 11: the stop in force stands taller, so the mark is never a colour alone.
+    readonly property int markedHeight: Theme.spacing.hairline * 5
+    // And the board's own 2 against 3 across; the tap target is the slot behind the ink, so a mark this narrow still answers a click anywhere on its stop.
+    readonly property int tickInk: Theme.spacing.hairline * 2
+    readonly property int markedInk: Theme.spacing.hairline * 3
+    // The hairline treatment the panel already uses for a quiet edge, so an unmarked stop reads as one.
+    readonly property real restOpacity: 0.4
+    readonly property real tickWidth: root.stops.length > 0
+        ? (root.width - root.tickGap * (root.stops.length - 1)) / root.stops.length : 0
+    readonly property real numberHeight: Theme.font.caption * 1.5
+    // WCAG 2.5.8's floor under the tap target, whatever height the numbers and ticks come to.
+    readonly property int hitHeight: Math.max(Theme.hitMin, Math.round(root.numberHeight + root.markedHeight))
+
+    implicitHeight: root.hitHeight
+
+    Repeater {
+        model: root.stops
+
+        delegate: Item {
+            id: tick
+            required property var modelData
+            required property int index
+            readonly property bool marked: tick.index === root.index
+
+            // The hit box is taller than the drawn tick and centred on the ruler, so it moves nothing.
+            x: tick.index * (root.tickWidth + root.tickGap)
+            y: Math.round((root.height - tick.height) / 2)
+            width: root.tickWidth
+            height: root.hitHeight
+
+            Text {
+                id: number
+                anchors.horizontalCenter: parent.horizontalCenter
+                y: Math.round((root.numberHeight - implicitHeight) / 2)
+                text: tick.modelData
+                color: tick.marked ? Theme.color.foreground : Theme.color.muted
+                opacity: tick.marked ? 1 : root.restOpacity
+                font.family: Theme.font.family
+                font.pixelSize: Theme.font.caption
+                textFormat: Text.PlainText
+            }
+
+            Rectangle {
+                anchors.horizontalCenter: parent.horizontalCenter
+                y: Math.round(root.numberHeight)
+                width: tick.marked ? root.markedInk : root.tickInk
+                height: tick.marked ? root.markedHeight : root.tickHeight
+                color: root.active && tick.marked ? Theme.color.accent : Theme.color.mutedFrame
+                opacity: tick.marked ? 1 : root.restOpacity
+            }
+
+            HoverHandler {
+                enabled: root.active
+                cursorShape: Qt.PointingHandCursor
+            }
+
+            TapHandler {
+                enabled: root.active
+                acceptedButtons: Qt.LeftButton
+                gesturePolicy: TapHandler.ReleaseWithinBounds
+                onTapped: root.picked(tick.modelData)
+            }
+        }
+    }
+}

package/test/fixtures/qml/flea-theme/ui/SettingsSegment.qml

@@ -0,0 +1,85 @@
+import QtQuick
+import "." as Flea
+import "js/Buttons.js" as Buttons
+
+// The Display board's two-value control: both names side by side, the current one bright, rather than
+// the chevron walk a longer list needs. ui/SettingsRow.qml draws it for any row whose model names its
+// options, and the row above owns the writer, so nothing here holds state.
+Row {
+    id: root
+
+    property var options: []
+    property string value: ""
+    property var glyphs: []
+    // A host that puts the row in its Tab order (a dialog's Format) sets this; Settings never focuses it.
+    property bool tabStop: false
+    // The hit minimum in Settings; a chrome strip hosts the same cells at its control height.
+    property int cellHeight: Theme.hitMin
+
+    // The option a pointer chose, which is never the one already showing.
+    signal picked(int index)
+
+    spacing: Theme.spacing.hairline * Buttons.SEGMENT_GAP
+
+    Repeater {
+        model: root.options
+
+        delegate: Rectangle {
+            id: segment
+            required property var modelData
+            required property int index
+
+            readonly property bool current: segment.modelData === root.value
+            readonly property string glyph: root.glyphs[segment.index] || ""
+            // A segment that takes the keyboard (a dialog's Tab stop) marks its current cell as DialogButton marks a focused set member.
+            readonly property bool focusedHere: root.tabStop && segment.current && root.activeFocus && segment.glyph.length === 0
+            // Accent where it has hue, else RING wide in the foreground, both inside the cell like DialogButton's set member.
+            readonly property string focusFrame: Buttons.focusFrame(Theme.color.accentHasHue, true, false)
+
+            // The WCAG floor the Blueprint sets for a compact control, which this row has room for.
+            width: segment.glyph ? Math.max(Theme.hitMin, Theme.railIconSize + 2 * (Theme.spacing.gap - Theme.spacing.hairline))
+                                 : name.implicitWidth + 2 * Theme.spacing.gap
+            height: root.cellHeight
+            // Containers rule 4: a segmented cell is never filled, so the choice reads as brightness.
+            color: "transparent"
+            // Rule 3: words in a set are Tier B and every member wears the box; glyphs in a strip are
+            // Tier A, where a box around four marks would be furniture.
+            border.width: segment.glyph ? 0 : segment.focusedHere && segment.focusFrame === "thick" ? Buttons.RING : Theme.spacing.hairline
+            border.color: segment.focusedHere && segment.focusFrame === "accent" ? Theme.color.accent
+                : segment.current ? Theme.color.foreground : Theme.color.mutedFrame
+            Accessible.role: Accessible.Button
+            Accessible.name: String(segment.modelData)
+            Accessible.onPressAction: root.picked(segment.index)
+
+            Flea.Glyph {
+                anchors.centerIn: parent
+                visible: segment.glyph.length > 0
+                width: Theme.railIconSize
+                height: width
+                name: segment.glyph || "file"
+                color: segment.current ? Theme.color.foreground : Theme.color.mutedFrame
+            }
+
+            Text {
+                id: name
+                visible: segment.glyph.length === 0
+                anchors.centerIn: parent
+                text: segment.modelData
+                color: segment.current ? Theme.color.foreground : Theme.color.muted
+                font.family: Theme.font.family
+                font.pixelSize: Theme.font.caption
+                textFormat: Text.PlainText
+            }
+
+            HoverHandler {
+                cursorShape: Qt.PointingHandCursor
+            }
+
+            TapHandler {
+                acceptedButtons: Qt.LeftButton
+                gesturePolicy: TapHandler.ReleaseWithinBounds
+                onTapped: if (!segment.current) root.picked(segment.index)
+            }
+        }
+    }
+}

package/test/fixtures/qml/flea-theme/ui/StableModel.qml

@@ -0,0 +1,89 @@
+import QtQuick
+import QtQml.Models
+
+// A view's row count as a model that never changes identity, so a new count keeps the delegates that stay drawn.
+DelegateModel {
+    id: root
+
+    required property Item view
+    property int total: 0
+    // The compositor is filled in componentComplete, so a group change before onCompleted is silently dropped.
+    property bool ready: false
+
+    // A move asked for inside the change's own layout is dropped, so a view that places itself does it here.
+    signal resized()
+
+    // Qt refuses an integer model larger than 100,000,000 rows.
+    readonly property int cap: 100000000
+    model: root.cap
+    groups: DelegateModelGroup { id: shown; name: "shown"; includeByDefault: false }
+    filterOnGroup: "shown"
+
+    // While true a view short of a viewport keeps a full layout's delegates in its reuse pool, so a count that grows takes them instead of building.
+    property bool warm: false
+    // The rows a full layout from the top builds, its cache buffer's included: the fill lays out no more, so none is left incubating.
+    property int warmRows: 0
+
+    // While true a count change leaves the current delegate current: Qt focuses each new current delegate, which takes the keys from an editor inside the old one.
+    property bool holdCurrent: false
+
+    onTotalChanged: root.resize()
+    onWarmChanged: if (root.warm) root.fill()
+    Component.onCompleted: { root.ready = true; root.resize() }
+
+    // Grows the count and shrinks it back in one turn, so no frame sees the rows and what they laid out waits pooled; a geometry change drains it.
+    function fill() {
+        var from = shown.count
+        var to = Math.min(root.warmRows, root.cap)
+        if (!root.ready || !root.view.reuseItems || to <= from)
+            return
+        // The buffer's rows lay out with the viewport's for this pass, built at once where a buffer pass would incubate them later.
+        var margin = root.view.displayMarginEnd
+        root.view.displayMarginEnd = margin + root.view.cacheBuffer + root.view.height
+        root.items.addGroups(from, to - from, "shown")
+        root.view.forceLayout()
+        shown.removeGroups(from, to - from, "shown")
+        root.view.forceLayout()
+        root.view.displayMarginEnd = margin
+    }
+
+    // Moves to the top and, unless holdCurrent, row 0 as a reset does, before the change, so only top rows lay out and a view placing itself after keeps its place.
+    function resize() {
+        var to = Math.min(Math.max(root.total, 0), root.cap)
+        var from = shown.count
+        if (!root.ready || to === from)
+            return
+        root.view.contentY = root.view.originY - root.view.topMargin
+        if (from > 0 && to > 0 && !root.holdCurrent)
+            root.view.currentIndex = 0
+        if (to > from)
+            root.items.addGroups(from, to - from, "shown")
+        else
+            shown.removeGroups(to, from - to, "shown")
+        // Lays out now: Qt pools a layout's removed rows only after building its inserted ones, so the next count reuses them.
+        root.view.forceLayout()
+        if (to > 0 && root.view.currentIndex < 0)
+            root.view.currentIndex = 0
+        root.resized()
+        if (to === 0)
+            root.drainHidden()
+    }
+
+    // True where a hidden count is rows kept for the return rather than an edit in flight, so the hide drains the pool beside them.
+    property bool keptRows: false
+    // A hidden view holds no delegates, pooled ones included; a shown one keeps its pool, parked, for the next listing.
+    function drainHidden() {
+        if (root.view.visible || shown.count > 0 && !root.keptRows || !root.view.reuseItems)
+            return
+        // Unpersist first so the pool toggle below frees the parked tiles too.
+        if (persistedItems.count > 0)
+            persistedItems.removeGroups(0, persistedItems.count, "persistedItems")
+        root.view.reuseItems = false
+        root.view.reuseItems = true
+    }
+    // A view hidden after it emptied drains here, since its count does not change again.
+    property Connections hiding: Connections {
+        target: root.view
+        function onVisibleChanged() { root.drainHidden() }
+    }
+}