flea-qml 0.0.0-stage → 0.2.0

package/ui/boot/Ui/WidgetButton.qml

@@ -0,0 +1,172 @@
+import QtQuick
+import qs.Commons
+import qs.Commons as Commons
+
+Item {
+  id: root
+
+  property var bar: null
+  property string text: ""
+  property string fontFamily: bar ? bar.fontFamily : Style.font.family
+  property real fontSize: Style.font.body
+  property color foreground: bar ? bar.barForeground : Commons.Color.foreground
+  property color activeColor: bar ? bar.urgent : Commons.Color.urgent
+  property bool active: false
+  property real horizontalMargin: 8.5
+  property real verticalPadding: 6
+  property real fixedWidth: -1
+  property real fixedHeight: -1
+  property real textRotation: 0
+  property bool keepSpace: false
+  property bool dimmed: false
+  property bool concealed: false
+  property bool interactive: true
+  property bool pressable: true
+  property bool useActiveColor: true
+  property bool maintainIndicatorReveal: false
+  property bool labelVisible: true
+  // Off for icon-font labels, whose figure metrics say nothing about the glyph.
+  property bool centerFigures: true
+  property bool hasVisualContent: text !== ""
+  property var revealHost: bar
+  property string tooltipText: ""
+  property var registeredBar: null
+
+  signal pressed(int button)
+  signal wheelMoved(int delta)
+
+  function triggerPress(button) {
+    if (root.bar) root.bar.hideTooltip(root)
+    root.pressed(button)
+  }
+
+  function hideOwnTooltip() {
+    if (root.bar) root.bar.hideTooltip(root)
+  }
+
+  function syncClickRegistration() {
+    if (registeredBar && registeredBar.unregisterClickTarget) registeredBar.unregisterClickTarget(root)
+    registeredBar = root.bar
+    if (registeredBar && registeredBar.registerClickTarget) registeredBar.registerClickTarget(root)
+  }
+
+  onBarChanged: syncClickRegistration()
+  onVisibleChanged: if (!visible) hideOwnTooltip()
+  onInteractiveChanged: if (!interactive) hideOwnTooltip()
+  onConcealedChanged: if (concealed) hideOwnTooltip()
+  Component.onCompleted: syncClickRegistration()
+  Component.onDestruction: if (registeredBar && registeredBar.unregisterClickTarget) registeredBar.unregisterClickTarget(root)
+
+  readonly property bool vertical: bar ? bar.vertical : false
+  readonly property int barSize: bar ? bar.barSize : Style.bar.sizeHorizontal
+  readonly property real scaledHorizontalMargin: Style.spaceReal(horizontalMargin)
+  readonly property real scaledVerticalPadding: Style.spaceReal(verticalPadding)
+  readonly property bool tooltipHovered: visible && interactive && !concealed && mouseArea.containsMouse
+  // Width of the painted label, for bar chrome that wants to line up with the
+  // text rather than with the slot it sits in. Zero on icon-only buttons.
+  readonly property real labelWidth: label.visible ? label.implicitWidth : 0
+  readonly property bool iconLabel: labelVisible && isIconGlyph(text)
+  readonly property real iconPaintedWidth: iconLabel && iconLoader.item ? iconLoader.item.paintedWidth : 0
+  readonly property real iconPaintedHeight: iconLabel && iconLoader.item ? iconLoader.item.paintedHeight : 0
+  readonly property real iconCenterErrorX: iconLabel && iconLoader.item
+    ? iconLoader.x + iconLoader.item.paintedCenterX - width / 2 : 0
+  readonly property real iconCenterErrorY: iconLabel && iconLoader.item
+    ? iconLoader.y + iconLoader.item.paintedCenterY - height / 2 : 0
+
+  function isIconGlyph(value) {
+    var text = String(value || "")
+    if (!text) return false
+    var code = text.codePointAt(0)
+    if (text.length !== (code > 0xffff ? 2 : 1)) return false
+    return (code >= 0xe000 && code <= 0xf8ff)
+      || (code >= 0xf0000 && code <= 0xffffd)
+      || (code >= 0x100000 && code <= 0x10fffd)
+      || (code >= 0x2190 && code <= 0x2bff)
+  }
+
+  visible: hasVisualContent || keepSpace
+  opacity: !hasVisualContent || concealed ? 0 : (dimmed ? 0.45 : 1)
+  implicitWidth: fixedWidth > 0 ? fixedWidth
+    : (vertical ? barSize : (iconLabel ? Style.bar.iconSlot : Math.max(12, label.implicitWidth + scaledHorizontalMargin * 2)))
+  implicitHeight: fixedHeight > 0 ? fixedHeight
+    : (vertical ? (iconLabel ? Style.bar.iconSlot : Math.max(12, label.implicitHeight + scaledVerticalPadding * 2)) : barSize)
+
+  Behavior on opacity {
+    NumberAnimation { duration: Style.duration(140); easing.type: Easing.OutCubic }
+  }
+
+  Text {
+    id: label
+    textFormat: Text.PlainText
+    visible: root.labelVisible && !root.iconLabel
+    anchors.centerIn: parent
+    // Centering the line box puts the figures above the bar's middle, since
+    // the box keeps room for descenders. Center the figure height instead, so
+    // labels line up with the icons beside them.
+    anchors.verticalCenterOffset: !root.centerFigures || root.vertical || root.text.indexOf("\n") !== -1
+      ? 0
+      : (labelMetrics.descent - labelMetrics.ascent + labelMetrics.tightBoundingRect("0").height) / 2
+    text: root.text
+    color: root.active && root.useActiveColor ? root.activeColor : root.foreground
+    font.family: root.fontFamily
+    font.pixelSize: root.fontSize
+    renderType: Text.NativeRendering
+    rotation: root.textRotation
+    horizontalAlignment: Text.AlignHCenter
+    verticalAlignment: Text.AlignVCenter
+
+    Behavior on color {
+      enabled: !root.bar || root.bar.foregroundAnimationEnabled
+      ColorAnimation { duration: Style.duration(160) }
+    }
+  }
+
+  FontMetrics {
+    id: labelMetrics
+    font: label.font
+  }
+
+  Loader {
+    id: iconLoader
+    active: root.iconLabel
+    width: Style.bar.iconCanvas
+    height: Style.bar.iconCanvas
+    x: (root.width - width) / 2
+    y: (root.height - height) / 2
+    sourceComponent: Component {
+      OpticalGlyph {
+        text: root.text
+        fontFamily: root.fontFamily
+        fontSize: root.fontSize
+        paintedSize: Style.bar.iconSize
+        color: root.active && root.useActiveColor ? root.activeColor : root.foreground
+        rotation: root.textRotation
+      }
+    }
+  }
+
+  MouseArea {
+    id: mouseArea
+    anchors.fill: parent
+    acceptedButtons: Qt.LeftButton | Qt.RightButton | Qt.MiddleButton
+    enabled: root.interactive
+    hoverEnabled: true
+    cursorShape: root.pressable ? Qt.PointingHandCursor : Qt.ArrowCursor
+    onEntered: {
+      if (root.bar) {
+        root.bar.showTooltip(root, root.tooltipText)
+      }
+      if (root.maintainIndicatorReveal && root.revealHost && root.revealHost.setIndicatorItemHovered)
+        root.revealHost.setIndicatorItemHovered(true)
+    }
+    onExited: {
+      if (root.bar) {
+        root.bar.hideTooltip(root)
+      }
+      if (root.maintainIndicatorReveal && root.revealHost && root.revealHost.setIndicatorItemHovered)
+        root.revealHost.setIndicatorItemHovered(false)
+    }
+    onClicked: function(mouse) { if (root.pressable) root.triggerPress(mouse.button) }
+    onWheel: function(wheel) { root.wheelMoved(wheel.angleDelta.y) }
+  }
+}

package/ui/boot/Ui/qmldir

@@ -0,0 +1,41 @@
+module qs.Ui
+
+BarIndicator 1.0 BarIndicator.qml
+BarIconButton 1.0 BarIconButton.qml
+BarIconContent 1.0 BarIconContent.qml
+BarWidget 1.0 BarWidget.qml
+BackgroundMedia 1.0 BackgroundMedia.qml
+BorderOverlay 1.0 BorderOverlay.qml
+BorderSurface 1.0 BorderSurface.qml
+Button 1.0 Button.qml
+ButtonGroup 1.0 ButtonGroup.qml
+ConfirmDialog 1.0 ConfirmDialog.qml
+CursorSurface 1.0 CursorSurface.qml
+Dropdown 1.0 Dropdown.qml
+FilterInput 1.0 FilterInput.qml
+IconContentBounds 1.0 IconContentBounds.qml
+KeyboardPanel 1.0 KeyboardPanel.qml
+MultiSelect 1.0 MultiSelect.qml
+NumberField 1.0 NumberField.qml
+OpticalGlyph 1.0 OpticalGlyph.qml
+OverlayWindow 1.0 OverlayWindow.qml
+Panel 1.0 Panel.qml
+PanelActionButton 1.0 PanelActionButton.qml
+PanelController 1.0 PanelController.qml
+PanelKeyCatcher 1.0 PanelKeyCatcher.qml
+PanelHero 1.0 PanelHero.qml
+PanelSectionHeader 1.0 PanelSectionHeader.qml
+PanelSeparator 1.0 PanelSeparator.qml
+PanelSlider 1.0 PanelSlider.qml
+PanelToolTip 1.0 PanelToolTip.qml
+PluginBarApi 1.0 PluginBarApi.qml
+PointerMoveGate 1.0 PointerMoveGate.qml
+ScreenMoveRemap 1.0 ScreenMoveRemap.qml
+PopupCard 1.0 PopupCard.qml
+SearchableDropdown 1.0 SearchableDropdown.qml
+SizedImage 1.0 SizedImage.qml
+SpeedTestOverlay 1.0 SpeedTestOverlay.qml
+TextField 1.0 TextField.qml
+Toggle 1.0 Toggle.qml
+ToggleSwitch 1.0 ToggleSwitch.qml
+WidgetButton 1.0 WidgetButton.qml

package/ui/boot/fleatab.qml

@@ -0,0 +1,50 @@
+import QtQml
+import Quickshell
+import Quickshell.Io
+
+// Only a validated tab's matching lift acknowledgment closes its source.
+QtObject {
+    id: root
+
+    property var tabBar: null
+    property var view: null
+    property var panes: []
+    property var tabs: null
+    // Stage trace, on only with FLEA_TRACE_TABDRAG=1; read once, silent otherwise.
+    readonly property bool tabTrace: Quickshell.env("FLEA_TRACE_TABDRAG") === "1"
+    function traceTab(stage, detail) { if (root.tabTrace) console.log("TABDRAG " + stage + " pid=" + Quickshell.processId + " " + detail) }
+
+    property IpcHandler ack: IpcHandler {
+        target: "fleatab"
+        function taken(token: string): bool { return root.take(token) }
+    }
+
+    function take(token) {
+        root.traceTab("taken-call", "token=" + String(token) + " outToken=" + String(root.tabBar ? root.tabBar.outToken : "") + " outActive=" + String(root.tabBar ? root.tabBar.outActive : ""))
+        if (!root.tabBar || !root.tabs) return false
+        var lift = root.tabs.liftFor(root.tabBar.outstandingLifts, token)
+        if (!lift || !root.tabs.ackCloses(lift.token, token, lift.liftedAt, Date.now())) return false
+        if (root.tabs.resolveMovedTab(lift.pane, lift.identity) < 0) return false
+        lift.taken = true
+        root.tabBar.drainLifts()
+        root.traceTab("taken-recv", "token=" + String(token) + " result=accepted")
+        return true
+    }
+
+    property string launchPid: Quickshell.env("FLEA_TAB_SOURCE_PID") || ""
+    property string launchToken: Quickshell.env("FLEA_TAB_TOKEN") || ""
+    property string launchPath: Quickshell.env("FLEA_PATH") || ""
+    function openedLaunch(path) {
+        if (path !== root.launchPath || !/^[0-9]+$/.test(root.launchPid) || !root.launchToken || !root.tabBar) return
+        root.tabBar.sendTaken(root.launchPid, root.launchToken)
+        root.launchToken = ""
+    }
+    property Connections primaryAck: Connections {
+        target: root.panes.length > 0 ? root.panes[0] : null
+        function onOpened(path) { root.openedLaunch(path) }
+    }
+    property Connections secondaryAck: Connections {
+        target: root.panes.length > 1 ? root.panes[1] : null
+        function onOpened(path) { root.openedLaunch(path) }
+    }
+}

package/ui/boot/picker.qml

@@ -0,0 +1,39 @@
+// Its own app id, so one Hyprland rule can give the chooser the floating treatment Omarchy already
+// gives xdg-desktop-portal-gtk without touching the window; flea --picker writes that rule.
+//@ pragma AppId com.thisisgm.flea.picker
+//@ pragma ShellId fleapicker
+//@ pragma NativeTextRendering
+//@ pragma CacheDir $BASE/flea
+
+import Quickshell
+import QtQuick
+
+// A file: URL away for the reason ui/boot/shell.qml gives, but its window stays whole: the chooser
+// is not on the measured path and its size comes from the Theme. See AGENTS.md "The first window".
+ShellRoot {
+    id: root
+
+    LazyLoader {
+        id: chooser
+        active: true
+        // This directory cannot import ui/js/Format.js through qs:, so the one call is written out.
+        source: "file://" + encodeURI(Quickshell.shellDir + "/../PickerWindow.qml").replace(/#/g, "%23").replace(/\?/g, "%3F")
+    }
+
+    // Well past the 1.7 to 3.0 s the first launch after an update spends writing Qt's cache.
+    readonly property int windowBackstopMs: 6000
+
+    // LazyLoader carries neither a status nor a usable loading edge, so no window by this point is
+    // a load that failed, and silence would leave tools/flea-portal's caller waiting out its 600 s.
+    Timer {
+        interval: root.windowBackstopMs
+        repeat: false
+        running: true
+        onTriggered: {
+            if (!chooser.item) {
+                console.warn("flea: the chooser window did not load, so there is nothing to show")
+                Quickshell.execDetached(["kill", String(Quickshell.processId)])
+            }
+        }
+    }
+}

package/ui/boot/shell.qml

@@ -0,0 +1,131 @@
+//@ pragma AppId com.thisisgm.flea
+//@ pragma ShellId flea
+//@ pragma NativeTextRendering
+//@ pragma CacheDir $BASE/flea
+
+import Quickshell
+import QtQuick
+
+// The entry is the window and imports Quickshell and QtQuick only, because a Quickshell config is
+// served through qs: URLs, which Qt's disk cache refuses; see AGENTS.md "The first window".
+ShellRoot {
+    FloatingWindow {
+        id: fleaWindow
+        title: "Flea"
+        implicitWidth: 900
+        implicitHeight: 600
+        // Never seen: the body covers it on the first frame. ui/Theme.qml's own fallback, for the record.
+        color: "#101315"
+        property bool rendererFallbackStarted: false
+        // True when a glass launch cleared the colour before the window was shown, which tests/glass-boot.sh reads.
+        property bool clearedEarly: false
+
+        // Every *Centre reader on the IPC seam is this: an item's painted box, reduced to the point a test clicks.
+        function centreOf(item) {
+            if (!item)
+                return ""
+            var rect = fleaWindow.itemRect(item)
+            return Math.round(rect.x + rect.width / 2) + " " + Math.round(rect.y + rect.height / 2)
+        }
+        // "x y width height" in window pixels, for a test that asserts a card stays inside the window.
+        function rectOf(item) {
+            if (!item)
+                return ""
+            var rect = fleaWindow.itemRect(item)
+            var left = Math.round(rect.x), top = Math.round(rect.y)
+            return left + " " + top + " " + (Math.round(rect.x + rect.width) - left) + " " + (Math.round(rect.y + rect.height) - top)
+        }
+        // centreOf's sibling, "x width centre": the edges round because a click needs a whole pixel, the centre keeps three decimals because the misalignment it reads is half of one.
+        function boxOf(item) {
+            if (!item)
+                return ""
+            var rect = fleaWindow.itemRect(item)
+            return Math.round(rect.x) + " " + Math.round(rect.width) + " " + (rect.x + rect.width / 2).toFixed(3)
+        }
+
+        // This directory cannot reach ui/js/Format.js through qs:, so its one call is written out.
+        function fileUrl(path) {
+            path = String(path)
+            // Only Windows paths use backslashes as separators; POSIX filenames may contain them.
+            var drive = /^[A-Za-z]:[\\/]/.test(path)
+            var unc = /^\\\\[^\\]/.test(path)
+            if (drive || unc) path = path.replace(/\\/g, "/")
+            var parts = path.split("/")
+            for (var i = 0; i < parts.length; i++) {
+                if (!(drive && i === 0)) parts[i] = encodeURIComponent(parts[i])
+            }
+            return (drive ? "file:///" : path.indexOf("//") === 0 ? "file:" : "file://") + parts.join("/")
+        }
+
+        // Before the first frame, so the window maps holding its chrome; see AGENTS.md "The first window".
+        function loadBody() {
+            if (bodyLoader.status !== Loader.Null)
+                return
+            bodyLoader.setSource(fleaWindow.fileUrl(Quickshell.shellDir + "/../WindowBody.qml"), { host: fleaWindow })
+            // Only before the window exists does Quickshell still take a clear surface; see ui/Glass.qml.
+            if (bodyLoader.item && bodyLoader.item.clearSurface) {
+                fleaWindow.clearedEarly = !(bodyLoader.Window.window && bodyLoader.Window.window.visible)
+                if (fleaWindow.clearedEarly) fleaWindow.color = "transparent"
+            }
+        }
+
+        // Quickshell 0.3.1 has no exit API, and it is signalled from here because a window closed
+        // before the body loads still has to take the process with it.
+        Connections { target: Quickshell; function onLastWindowClosed() { fleaWindow.quit() } }
+
+        // Nothing has been told to drain before the body exists, so an early exit kills directly.
+        function quit() {
+            if (bodyLoader.item)
+                bodyLoader.item.quitBackends()
+            else
+                Quickshell.execDetached(["kill", String(Quickshell.processId)])
+        }
+
+        // sceneGraphError arrives on the first frame, and the entry always exists, so the retry is here.
+        function handleSceneGraphError(error, message) {
+            var backendName = Quickshell.env("QSG_RHI_BACKEND")
+            console.warn("graphics backend " + backendName + " failed (" + error + "): " + message)
+            var retry = retryCommand(backendName)
+            if (retry && !rendererFallbackStarted) {
+                rendererFallbackStarted = true
+                Quickshell.execDetached(retry)
+            }
+            quit()
+        }
+
+        // Loaded only once the error has arrived, which keeps ui/js/Renderer.js off the startup path.
+        function retryCommand(backendName) {
+            var helper = Qt.createComponent(fleaWindow.fileUrl(Quickshell.shellDir + "/../RendererRetry.qml"))
+            if (helper.status !== Component.Ready) {
+                console.warn("flea: the renderer retry helper did not load, so there is no fallback: " + helper.errorString())
+                return null
+            }
+            var object = helper.createObject(fleaWindow)
+            var retry = object.fallbackCommand(backendName)
+            object.destroy()
+            return retry
+        }
+
+        Loader {
+            id: bodyLoader
+            anchors.fill: parent
+            // A Loader is a focus scope, so without this every key press lands nowhere.
+            focus: true
+            // An empty window forever is what this catches; the engine prints the reason above it.
+            onStatusChanged: {
+                if (status === Loader.Error) {
+                    console.warn("flea: the window body did not load, so there is nothing to show")
+                    fleaWindow.quit()
+                }
+            }
+        }
+
+        // Null while this file loads and the QQuickWindow once it exists, which is before the scene graph starts.
+        Connections {
+            target: bodyLoader.Window.window
+            function onSceneGraphError(error, message) { fleaWindow.handleSceneGraphError(error, message) }
+        }
+
+        Component.onCompleted: fleaWindow.loadBody()
+    }
+}

package/ui/boot/tabtearoff.qml

@@ -0,0 +1,51 @@
+import QtQuick
+import Quickshell
+import Quickshell.Wayland
+
+// The tear-off catcher: one transparent Bottom-layer panel per screen, alive only while the source
+// tab drag is out; the Loader that owns it unloads it on every end path.
+Item {
+    id: root
+
+    // Loader assigns this after creation, so required can never hold here.
+    property var tabBar: null
+    // The boot directory cannot reach ui/js through qs:, so the strip hands the tab MIME in.
+    property string tabMime: ""
+
+    Variants {
+        model: Quickshell.screens
+        PanelWindow {
+            required property var modelData
+            screen: modelData
+            color: "transparent"
+            anchors {
+                top: true
+                bottom: true
+                left: true
+                right: true
+            }
+            WlrLayershell.namespace: "flea-tab-tearoff"
+            WlrLayershell.layer: WlrLayer.Bottom
+            // Ignore reserved bars so catcher-local origin is exactly the screen origin.
+            exclusionMode: ExclusionMode.Ignore
+            // Hyprland focuses an interactive layer on map and releases held buttons,
+            // stealing drag focus from the target window. Escape stays with Qt's source.
+            WlrLayershell.keyboardFocus: WlrKeyboardFocus.None
+            DropArea {
+                anchors.fill: parent
+                keys: [root.tabMime]
+                onEntered: function (drag) {
+                    if (root.tabBar !== null)
+                        root.tabBar.traceTab("catcher-enter", "global=" + (modelData.x + drag.x) + "," + (modelData.y + drag.y))
+                }
+                onDropped: function (drop) {
+                    // The full-screen catcher starts at the screen's compositor position.
+                    if (root.tabBar !== null && drop.getDataAsString(root.tabMime) !== "") {
+                        drop.accept(Qt.MoveAction)
+                        root.tabBar.catcherDrop(modelData.x + drop.x, modelData.y + drop.y)
+                    }
+                }
+            }
+        }
+    }
+}