flea-qml 0.0.0-stage → 0.2.0

package/ui/boot/Ui/PanelSlider.qml

@@ -0,0 +1,156 @@
+import QtQuick
+import qs.Commons
+import qs.Commons as Commons
+
+Item {
+  id: root
+
+  property QtObject bar: null
+  property real value: 0
+  property real minimum: 0
+  property real maximum: 1
+  property real step: 0.05
+  property bool integer: false
+  property color trackColor: bar ? Style.selectedFillFor(bar.foreground, Commons.Color.accent) : "#333"
+  property color fillColor: bar ? bar.foreground : Commons.Color.foreground
+  property color knobColor: bar ? bar.foreground : Commons.Color.foreground
+  property bool dragging: false
+  property real trackHeight: Math.max(4, Math.round(Style.spacing.controlHeight * 0.11))
+  property real knobSize: Math.max(14, Math.round(Style.spacing.controlHeight * 0.38))
+  property real liveValue: value
+
+  // macOS-style notches. When > 1, that many evenly-spaced tick marks are cut
+  // into the track (drawn in the panel background color, so only the part
+  // crossing the track shows). Purely visual — snapping is the caller's job via
+  // `integer`/`step` or an index-based value. Default 0 leaves the track plain.
+  property int tickCount: 0
+  property color tickColor: bar ? bar.background : Commons.Color.background
+
+  onValueChanged: if (!dragging) liveValue = value
+
+  signal moved(real value)
+  signal released(real value)
+
+  // Right-click is a secondary action on the whole track — audio uses it to
+  // mute the channel the slider belongs to. Dragging stays left-button only.
+  signal rightClicked()
+
+  implicitWidth: Style.space(200)
+  implicitHeight: Math.max(Style.space(22), knobSize + Style.spacing.md)
+
+  readonly property real range: Math.max(0.0001, maximum - minimum)
+  readonly property real progress: Math.max(0, Math.min(1, (liveValue - minimum) / range))
+  readonly property bool _hot: mouseArea.containsMouse || root.dragging
+  // In a mirrored (right-to-left) layout the anchored fill already starts at
+  // the right; the knob, ticks, and pointer are placed by x, so they flip here.
+  readonly property bool mirrored: LayoutMirroring.enabled
+  function trackX(fraction) {
+    return track.width * (root.mirrored ? 1 - fraction : fraction)
+  }
+
+  Rectangle {
+    id: track
+    anchors.verticalCenter: parent.verticalCenter
+    anchors.left: parent.left
+    anchors.right: parent.right
+    height: root.trackHeight
+    radius: height / 2
+    color: root.trackColor
+  }
+
+  Rectangle {
+    id: fill
+    anchors.verticalCenter: track.verticalCenter
+    anchors.left: track.left
+    height: track.height
+    radius: track.radius
+    color: root.fillColor
+    width: track.width * root.progress
+
+    Behavior on width {
+      enabled: !root.dragging
+      NumberAnimation { duration: Style.duration(140); easing.type: Easing.OutCubic }
+    }
+  }
+
+  Repeater {
+    model: root.tickCount > 1 ? root.tickCount : 0
+    Rectangle {
+      required property int index
+      width: Math.max(1, Style.space(2))
+      height: root.trackHeight + Style.space(4)
+      radius: 1
+      color: root.tickColor
+      anchors.verticalCenter: track.verticalCenter
+      x: Math.max(0, Math.min(track.width - width,
+                              root.trackX(index / (root.tickCount - 1)) - width / 2))
+    }
+  }
+
+  BorderSurface {
+    id: knob
+    width: root.knobSize
+    height: root.knobSize
+    radius: root.knobSize / 2
+    color: root.knobColor
+    borderSpec: Border.flat(root.bar ? root.bar.background : "#101315", Math.max(1, Style.space(2)))
+    anchors.verticalCenter: track.verticalCenter
+    x: Math.max(0, Math.min(track.width - width, root.trackX(root.progress) - width / 2))
+    scale: root._hot ? 1.15 : 1.0
+
+    Behavior on x {
+      enabled: !root.dragging
+      NumberAnimation { duration: Style.duration(140); easing.type: Easing.OutCubic }
+    }
+
+    Behavior on scale {
+      NumberAnimation { duration: Style.duration(110); easing.type: Easing.OutCubic }
+    }
+  }
+
+  MouseArea {
+    id: mouseArea
+    anchors.fill: parent
+    hoverEnabled: true
+    cursorShape: Qt.PointingHandCursor
+    acceptedButtons: Qt.LeftButton | Qt.RightButton
+
+    function valueFromX(x) {
+      var clamped = Math.max(0, Math.min(track.width, root.mirrored ? track.width - x : x))
+      var raw = root.minimum + (clamped / track.width) * root.range
+      if (root.integer) raw = Math.round(raw)
+      return Math.max(root.minimum, Math.min(root.maximum, raw))
+    }
+
+    onPressed: function(mouse) {
+      if (mouse.button !== Qt.LeftButton) return
+      root.dragging = true
+      var next = valueFromX(mouse.x)
+      root.liveValue = next
+      root.moved(next)
+    }
+    onClicked: function(mouse) {
+      if (mouse.button === Qt.RightButton) root.rightClicked()
+    }
+    onPositionChanged: function(mouse) {
+      if (!root.dragging) return
+      var next = valueFromX(mouse.x)
+      root.liveValue = next
+      root.moved(next)
+    }
+    onReleased: function(mouse) {
+      if (mouse.button !== Qt.LeftButton) return
+      root.dragging = false
+      root.released(root.liveValue)
+      root.liveValue = root.value
+    }
+    onWheel: function(wheel) {
+      var delta = wheel.angleDelta.y > 0 ? root.step : -root.step
+      var next = Math.max(root.minimum, Math.min(root.maximum, root.liveValue + delta))
+      if (root.integer) next = Math.round(next)
+      root.liveValue = next
+      root.moved(next)
+      root.released(next)
+    }
+  }
+}

package/ui/boot/Ui/PanelToolTip.qml

@@ -0,0 +1,50 @@
+import QtQuick
+import QtQuick.Controls
+import qs.Commons
+import qs.Commons as Commons
+
+// Styled wrapper around Qt Quick Controls ToolTip. Drop-in: declare inside
+// the hovered item and bind `visible` to the hover state, e.g.
+//   PanelToolTip {
+//     visible: mouse.containsMouse
+//     text: "Forget network"
+//   }
+//
+// Defaults pull from [tooltip] in shell.toml via Commons.Color.tooltip.*. Override
+// the panel* properties per-instance only when you need a tooltip that
+// intentionally diverges from the theme.
+//
+// Property names are prefixed `panel*` to avoid clashing with ToolTip's
+// built-in `background`/`font` properties.
+ToolTip {
+  id: root
+
+  property color panelForeground: Commons.Color.tooltip.text
+  property color panelBackground: Commons.Color.tooltip.background
+  property color panelBorder: Commons.Color.tooltip.border
+  property string fontFamily: Style.font.family
+  property real fontSize: Style.font.bodySmall
+
+  readonly property var panelBorderSpec: Border.localOrSurfaceSpec("tooltip", "border", panelBorder, Commons.Color.tooltip.border, Style.normalBorderWidth)
+
+  delay: 400
+  padding: 0
+
+  background: BorderSurface {
+    color: root.panelBackground
+    borderSpec: root.panelBorderSpec
+    radius: Style.cornerRadius
+  }
+
+  contentItem: Text {
+    textFormat: Text.PlainText
+    text: root.text
+    color: root.panelForeground
+    font.family: root.fontFamily
+    font.pixelSize: root.fontSize
+    leftPadding: Border.left(root.panelBorderSpec) + Style.spacing.controlPaddingX
+    rightPadding: Border.right(root.panelBorderSpec) + Style.spacing.controlPaddingX
+    topPadding: Border.top(root.panelBorderSpec) + Style.spacing.controlPaddingY
+    bottomPadding: Border.bottom(root.panelBorderSpec) + Style.spacing.controlPaddingY
+  }
+}

package/ui/boot/Ui/PluginBarApi.qml

@@ -0,0 +1,89 @@
+import QtQuick
+
+// Bar surface exposed to an installed third-party widget. Scalar presentation
+// state is mirrored by Bar.qml and operations are delegated through scoped
+// callbacks. The facade avoids direct host-Bar injection; it cannot isolate a
+// visual child from the parent hierarchy of the QML scene that renders it.
+QtObject {
+  id: api
+
+  required property string pluginId
+  required property string moduleName
+  property var shell: null
+
+  property color foreground: "transparent"
+  property color barForeground: "transparent"
+  property color background: "transparent"
+  property color urgent: "transparent"
+  property string fontFamily: ""
+  property string position: "top"
+  property bool vertical: false
+  property int barSize: 0
+  property bool transparent: false
+  property bool foregroundAnimationEnabled: true
+  property bool centerSectionRevealHeld: false
+  property bool traySectionDragActive: false
+  property bool traySectionPopoutOpen: false
+  property bool _centerHoverRevealSuppressed: false
+  readonly property bool centerHoverRevealSuppressed: _centerHoverRevealSuppressed
+  property var activePopout: null
+  property var clickTargets: []
+  property var layoutConfig: ({})
+  readonly property var foreignPopoutMarker: ({ foreign: true })
+
+  property var _showTooltip: null
+  property var _hideTooltip: null
+  property var _registerClickTarget: null
+  property var _unregisterClickTarget: null
+  property var _requestPopout: null
+  property var _releasePopout: null
+  property var _switchPanelFrom: null
+  property var _targetBelongsToWindow: null
+  property var _moduleWidgets: null
+  property var _run: null
+  property var _setCenterHoverRevealSuppressed: null
+
+  function setCenterHoverRevealSuppressed(value) {
+    if (_setCenterHoverRevealSuppressed) _setCenterHoverRevealSuppressed(!!value)
+  }
+
+  function showTooltip(target, text) {
+    if (_showTooltip) _showTooltip(target, String(text || ""))
+  }
+
+  function hideTooltip(target) {
+    if (_hideTooltip) _hideTooltip(target)
+  }
+
+  function registerClickTarget(target) {
+    if (_registerClickTarget) _registerClickTarget(target)
+  }
+
+  function unregisterClickTarget(target) {
+    if (_unregisterClickTarget) _unregisterClickTarget(target)
+  }
+
+  function requestPopout(owner) {
+    if (_requestPopout) _requestPopout(owner)
+  }
+
+  function releasePopout(owner) {
+    if (_releasePopout) _releasePopout(owner)
+  }
+
+  function switchPanelFrom(owner, direction) {
+    return _switchPanelFrom ? _switchPanelFrom(owner, direction) : false
+  }
+
+  function targetBelongsToWindow(target, window) {
+    return _targetBelongsToWindow ? _targetBelongsToWindow(target, window) : false
+  }
+
+  function moduleWidgets(id) {
+    return _moduleWidgets ? _moduleWidgets(String(id || "")) : []
+  }
+
+  function run(command) {
+    if (_run) _run(String(command || ""))
+  }
+}

package/ui/boot/Ui/PointerMoveGate.qml

@@ -0,0 +1,54 @@
+import QtQuick
+
+// Filters synthetic hover churn from moving delegates under a stationary
+// pointer. Call reset() after keyboard/list mutations, then moved() from a
+// row MouseArea's onPositionChanged before changing cursor selection. A
+// transition known to originate from the pointer can call allowInitialSample()
+// so the item under the stationary pointer remains selected.
+QtObject {
+  id: root
+
+  property Item referenceItem: null
+  property real threshold: 1
+  property bool primed: false
+  property bool initialSampleAllowed: false
+  property real lastX: 0
+  property real lastY: 0
+
+  function reset() {
+    root.primed = false
+    root.initialSampleAllowed = false
+    root.lastX = 0
+    root.lastY = 0
+  }
+
+  function allowInitialSample() {
+    root.reset()
+    root.initialSampleAllowed = true
+  }
+
+  function moved(item, mouse) {
+    if (!item || !mouse) {
+      root.reset()
+      return false
+    }
+
+    var target = root.referenceItem || item
+    var point = item.mapToItem(target, mouse.x, mouse.y)
+    var firstSample = !root.primed
+    var didMove = !firstSample
+      ? Math.abs(point.x - root.lastX) > root.threshold || Math.abs(point.y - root.lastY) > root.threshold
+      : root.initialSampleAllowed
+
+    // Keep the previous accepted position while filtering jitter so slow,
+    // sub-threshold steps accumulate into deliberate pointer movement.
+    if (firstSample || didMove) {
+      root.lastX = point.x
+      root.lastY = point.y
+    }
+    root.primed = true
+    root.initialSampleAllowed = false
+
+    return didMove
+  }
+}

package/ui/boot/Ui/PopupCard.qml

@@ -0,0 +1,181 @@
+import QtQuick
+import Quickshell
+import Quickshell.Hyprland
+import qs.Commons
+import qs.Commons as Commons
+
+PopupWindow {
+  id: root
+
+  required property Item anchorItem
+  required property QtObject bar
+  property var owner: null
+  property int margin: Style.gapsOut
+  property int padding: Style.spacing.popupPadding
+  property int contentWidth: Style.space(280)
+  property int contentHeight: Style.space(200)
+  property color borderColor: Commons.Color.popups.border
+  property var borderSpec: Border.localOrSurfaceSpec("popups", "border", borderColor, Commons.Color.popups.border, Math.max(1, Style.space(2)))
+  property bool open: false
+  property bool centerOnBar: false
+  // "click" — uses HyprlandFocusGrab so clicking outside dismisses the popup.
+  // "hover" — passive overlay; the owning widget controls open via hover.
+  property string triggerMode: "click"
+
+  readonly property var coordinatorKey: owner || root
+  readonly property var anchorWindow: anchorItem ? anchorItem.QsWindow.window : null
+  readonly property var popupScreen: anchorWindow ? anchorWindow.screen : null
+  readonly property bool containsMouse: cardHover.hovered
+  readonly property real screenW: popupScreen ? popupScreen.width : 0
+  readonly property real screenH: popupScreen ? popupScreen.height : 0
+  readonly property real barW: anchorWindow ? anchorWindow.width : 0
+  readonly property real barH: anchorWindow ? anchorWindow.height : 0
+  readonly property real availableCardWidth: screenW > 0
+    ? Math.max(120, screenW - ((bar && (bar.position === "left" || bar.position === "right")) ? barW : 0) - root.margin * 2)
+    : 0
+  readonly property real availableCardHeight: screenH > 0
+    ? Math.max(120, screenH - ((bar && (bar.position === "top" || bar.position === "bottom")) ? barH : 0) - root.margin * 2)
+    : 0
+  readonly property real verticalContentInset: padding * 2 + Border.top(borderSpec) + Border.bottom(borderSpec)
+
+  function fittedContentWidth(width, cap) {
+    var desired = Math.max(1, Number(width) || 1)
+    var maxWidth = root.availableCardWidth > 0 ? root.availableCardWidth : desired
+    if (cap !== undefined && Number(cap) > 0) maxWidth = Math.min(maxWidth, Number(cap))
+    return Math.round(Math.min(desired, maxWidth))
+  }
+
+  function fittedContentHeight(implicitHeight, cap) {
+    var desired = Math.max(root.verticalContentInset, (Number(implicitHeight) || 0) + root.verticalContentInset)
+    var maxHeight = root.availableCardHeight > 0 ? root.availableCardHeight : desired
+    if (cap !== undefined && Number(cap) > 0) maxHeight = Math.min(maxHeight, Number(cap))
+    return Math.round(Math.min(desired, maxHeight))
+  }
+
+  function cappedContentHeight(height) {
+    var desired = Math.max(root.padding * 2, Number(height) || root.padding * 2)
+    var maxHeight = root.availableCardHeight > 0 ? root.availableCardHeight : desired
+    return Math.round(Math.min(desired, maxHeight))
+  }
+
+  function close() {
+    if (owner && "close" in owner) owner.close()
+    else root.open = false
+  }
+
+  default property alias contentItem: contentHolder.children
+
+  visible: open || card.opacity > 0
+  color: "transparent"
+  implicitWidth: contentWidth
+  implicitHeight: contentHeight
+
+  onOpenChanged: {
+    if (!bar) return
+    if (open) bar.requestPopout(coordinatorKey)
+    else if (bar.activePopout === coordinatorKey) bar.releasePopout(coordinatorKey)
+  }
+
+  // Outside-click dismissal via Hyprland's focus grab. While `active`, input
+  // is routed only to the listed windows; clicking anywhere else clears the
+  // grab and we close the popup. Skipped for hover-mode popups so the cursor
+  // can move freely between the trigger and the popup.
+  HyprlandFocusGrab {
+    active: root.open && root.triggerMode === "click"
+    windows: root.anchorWindow ? [root, root.anchorWindow] : [root]
+    onCleared: root.close()
+  }
+
+  anchor {
+    id: popupAnchor
+    window: anchorItem ? anchorItem.QsWindow.window : null
+    adjustment: PopupAdjustment.Slide
+    edges: Edges.Top | Edges.Left
+    gravity: Edges.Bottom | Edges.Right
+    rect.width: 1
+    rect.height: 1
+
+    onAnchoring: {
+      if (!root.anchorItem || !root.bar) return
+
+      var target = root.anchorItem
+      var popupWidth = root.implicitWidth
+      var popupHeight = root.implicitHeight
+      var localX = target.width / 2 - popupWidth / 2
+      var localY = target.height + root.margin
+
+      if (root.bar.position === "bottom") {
+        localY = -popupHeight - root.margin
+      } else if (root.bar.position === "left") {
+        localX = target.width + root.margin
+        localY = target.height / 2 - popupHeight / 2
+      } else if (root.bar.position === "right") {
+        localX = -popupWidth - root.margin
+        localY = target.height / 2 - popupHeight / 2
+      }
+
+      var window = target.QsWindow.window
+      if (!window) return
+
+      if (root.centerOnBar) {
+        var cx = 0;
+        var cy = 0;
+        if (root.bar.position === "top" || root.bar.position === "bottom") {
+          cx = window.width / 2 - popupWidth / 2
+          cy = root.bar.position === "bottom" ? -popupHeight - root.margin : window.height + root.margin
+          cx = Math.max(root.margin, Math.min(cx, window.width - popupWidth - root.margin))
+        } else {
+          cx = root.bar.position === "left" ? window.width + root.margin : -popupWidth - root.margin
+          cy = window.height / 2 - popupHeight / 2
+          cy = Math.max(root.margin, Math.min(cy, window.height - popupHeight - root.margin))
+        }
+
+        popupAnchor.rect.x = Math.round(cx)
+        popupAnchor.rect.y = Math.round(cy)
+        return
+      }
+
+      var point = window.contentItem.mapFromItem(target, localX, localY)
+
+      if (root.bar.position === "top" || root.bar.position === "bottom") {
+        point.x = Math.max(root.margin, Math.min(point.x, window.width - popupWidth - root.margin))
+      } else {
+        point.y = Math.max(root.margin, Math.min(point.y, window.height - popupHeight - root.margin))
+      }
+
+      popupAnchor.rect.x = Math.round(point.x)
+      popupAnchor.rect.y = Math.round(point.y)
+    }
+  }
+
+  BorderSurface {
+    id: card
+    anchors.fill: parent
+    color: Commons.Color.popups.background
+    borderSpec: root.borderSpec
+    padding: root.padding
+    radius: Style.cornerRadius
+    opacity: root.open ? 1.0 : 0
+
+    Behavior on opacity {
+      NumberAnimation { duration: Style.duration(140); easing.type: Easing.OutCubic }
+    }
+
+    Item {
+      id: contentHolder
+      anchors.fill: parent
+      // Right-to-left languages read the card mirrored; the card itself
+      // stays where the bar puts it.
+      LayoutMirroring.enabled: Commons.I18n.rightToLeft
+      LayoutMirroring.childrenInherit: true
+      anchors.topMargin: card.contentTopInset
+      anchors.rightMargin: card.contentRightInset
+      anchors.bottomMargin: card.contentBottomInset
+      anchors.leftMargin: card.contentLeftInset
+    }
+
+    HoverHandler {
+      id: cardHover
+    }
+  }
+}

package/ui/boot/Ui/ScreenMoveRemap.qml

@@ -0,0 +1,43 @@
+import QtQuick
+
+// Hyprland leaves an already-mapped layer surface at its old global position
+// when its monitor moves within the layout: undocking disables the internal
+// panel, the external monitor shifts to x=0, and long-lived surfaces such as
+// the bar and background keep rendering at the old offset — or entirely
+// off-screen — until they are unmapped and remapped. Watch the screen's
+// origin and pulse `remapping` when it moves; the owning window folds that
+// into its `visible` binding so the compositor re-places the surface at the
+// monitor's new origin.
+Item {
+  id: root
+
+  required property var window
+  readonly property var screen: window ? window.screen : null
+
+  // Fold into the window's binding: visible: <shown> && !guard.remapping
+  property bool remapping: false
+
+  visible: false
+
+  // A layout reshuffle can move the monitor more than once before it lands.
+  // Let the positions settle before the single remap pulse.
+  Timer {
+    id: settleTimer
+    interval: 200
+    onTriggered: root.remapping = true
+  }
+
+  // Hold the surface unmapped for a beat so the compositor processes the
+  // unmap before the remap instead of coalescing them into a no-op.
+  Timer {
+    interval: 50
+    running: root.remapping
+    onTriggered: root.remapping = false
+  }
+
+  Connections {
+    target: root.screen
+    function onXChanged() { settleTimer.restart() }
+    function onYChanged() { settleTimer.restart() }
+  }
+}