refactor(framemode): connected surfaces

quickshell/Common/ConnectedModalChrome.qml

@@ -7,6 +7,7 @@ Item {
 
     required property var modalHandle
     required property string claimPrefix
+    property string surfaceKind: "modal"
     property string screenName: ""
     property bool enabled: false
     property bool active: false
@@ -14,112 +15,97 @@ Item {
     property bool dockBlocked: false
     property string dockSide: ""
 
-    property string claimId: ""
-    property string claimedScreenName: ""
+    property alias claimId: lease.claimId
+    property alias claimedScreenName: lease.claimedScreenName
 
     signal recoveryRequested
 
     visible: false
 
-    function _nextClaimId() {
-        return claimPrefix + ":" + (new Date()).getTime() + ":" + Math.floor(Math.random() * 1000);
-    }
-
     function _isCurrentModal(name) {
         return !!name && ModalManager.isCurrentModal(modalHandle, name);
     }
 
-    function _shouldRecover() {
-        return active && enabled && _isCurrentModal(screenName);
-    }
-
-    function _requestRecovery() {
-        if (_shouldRecover())
-            recoveryRequested();
+    ConnectedSurfaceLease {
+        id: lease
+        claimPrefix: root.claimPrefix
+        screenName: root.screenName
+        enabled: root.enabled
+        active: root.active
+        presented: root.presented
+        dockBlocked: root.dockBlocked
+        dockSide: root.dockSide
+        isCurrentOwner: function(name) {
+            return root._isCurrentModal(name);
+        }
+        hasOwner: function(name, ownerId) {
+            return ConnectedModeState.hasModalOwner(name, ownerId);
+        }
+        statePresent: function(name, ownerId) {
+            return ConnectedModeState.hasModalOwner(name, ownerId) && ConnectedModeState.hasSurfaceDescriptor(name, root.surfaceKind, ownerId);
+        }
+        claimState: function(name, state, ownerId) {
+            return ConnectedModeState.claimModalState(name, state, ownerId);
+        }
+        ensureState: function(name, state, ownerId) {
+            return ConnectedModeState.ensureModalState(name, state, ownerId);
+        }
+        releaseState: function(name, ownerId) {
+            return ConnectedModeState.clearModalState(name, ownerId);
+        }
+        updateAnimationState: function(name, ownerId, animX, animY) {
+            return ConnectedModeState.setModalAnim(name, animX, animY, ownerId);
+        }
+        updateBodyState: function(name, ownerId, bodyX, bodyY, bodyW, bodyH) {
+            return ConnectedModeState.setModalBody(name, bodyX, bodyY, bodyW, bodyH, ownerId);
+        }
+        requestDockRetract: function(ownerId, name, side) {
+            return ConnectedModeState.requestDockRetract(ownerId, name, side);
+        }
+        releaseDockRetract: function(ownerId) {
+            return ConnectedModeState.releaseDockRetract(ownerId);
+        }
+        onRecoveryRequested: root.recoveryRequested()
     }
 
     function publish(state) {
-        if (!enabled || !screenName || !state) {
-            release();
-            return false;
-        }
-        if (claimedScreenName && claimedScreenName !== screenName)
-            release();
-
-        const isCurrent = _isCurrentModal(screenName);
-        let isClaim = !claimId;
-        if (isClaim && !isCurrent)
-            return false;
-        if (isClaim)
-            claimId = _nextClaimId();
-
-        let published = isClaim ? ConnectedModeState.claimModalState(screenName, state, claimId) : ConnectedModeState.ensureModalState(screenName, state, claimId);
-        if (!published && !isClaim && isCurrent) {
-            ConnectedModeState.releaseDockRetract(claimId);
-            claimId = _nextClaimId();
-            published = ConnectedModeState.claimModalState(screenName, state, claimId);
-        }
-        if (!published)
-            return false;
-
-        claimedScreenName = screenName;
-        if (dockBlocked && presented)
-            ConnectedModeState.requestDockRetract(claimId, screenName, dockSide);
-        else
-            ConnectedModeState.releaseDockRetract(claimId);
-        return true;
+        return lease.publish(Object.assign({}, state, {
+            "kind": root.surfaceKind,
+            "screenName": root.screenName,
+            "presented": root.presented,
+            "dockRetractSide": root.dockBlocked ? root.dockSide : ""
+        }), false);
     }
 
     function updateAnim(animX, animY) {
-        if (!enabled || !claimId || !claimedScreenName)
-            return false;
-        if (!ConnectedModeState.hasModalOwner(claimedScreenName, claimId)) {
-            _requestRecovery();
-            return false;
-        }
-        return ConnectedModeState.setModalAnim(claimedScreenName, animX, animY, claimId);
+        return lease.updateAnim(animX, animY);
     }
 
     function updateBody(bodyX, bodyY, bodyW, bodyH) {
-        if (!enabled || !claimId || !claimedScreenName)
-            return false;
-        if (!ConnectedModeState.hasModalOwner(claimedScreenName, claimId)) {
-            _requestRecovery();
-            return false;
-        }
-        return ConnectedModeState.setModalBody(claimedScreenName, bodyX, bodyY, bodyW, bodyH, claimId);
+        return lease.updateBody(bodyX, bodyY, bodyW, bodyH);
     }
 
     function release() {
-        if (!claimId)
-            return;
-        ConnectedModeState.releaseDockRetract(claimId);
-        const releasedClaimId = claimId;
-        const releasedScreenName = claimedScreenName;
-        claimId = "";
-        claimedScreenName = "";
-        if (releasedScreenName)
-            ConnectedModeState.clearModalState(releasedScreenName, releasedClaimId);
+        return lease.release();
     }
 
-    Component.onDestruction: release()
-
     Connections {
         target: ModalManager
         function onModalChanged() {
-            root._requestRecovery();
+            lease.requestRecovery();
         }
     }
 
     Connections {
         target: ConnectedModeState
         function onModalOwnersChanged() {
-            if (!ConnectedModeState.hasModalOwner(root.screenName, root.claimId))
-                root._requestRecovery();
+            lease.checkOwnershipRecovery();
         }
         function onModalStatesChanged() {
-            if (!ConnectedModeState.modalStates[root.screenName])
-                root._requestRecovery();
+            lease.checkStateRecovery();
+        }
+        function onSurfaceDescriptorsChanged() {
+            lease.checkStateRecovery();
         }
     }
 }

quickshell/Common/ConnectedModeState.qml

@@ -3,10 +3,141 @@ pragma ComponentBehavior: Bound
 
 import QtQuick
 import Quickshell
+import "ConnectedSurfaceDescriptor.js" as SurfaceDescriptor
 
 Singleton {
     id: root
 
+    property var surfaceDescriptors: ({})
+
+    function _surfaceSlot(kind) {
+        return SurfaceDescriptor.slotForKind(kind);
+    }
+
+    function surfaceDescriptor(screenName, kind) {
+        const slot = _surfaceSlot(kind);
+        const screenDescriptors = screenName ? surfaceDescriptors[screenName] : null;
+        const descriptor = screenDescriptors && screenDescriptors[slot] ? screenDescriptors[slot] : SurfaceDescriptor.empty(kind, screenName);
+        let bodyRect = descriptor.bodyRect;
+        let animationOffset = descriptor.animationOffset;
+        if (slot === "popout" && popoutScreen === screenName) {
+            bodyRect = {
+                "x": popoutBodyX,
+                "y": popoutBodyY,
+                "width": popoutBodyW,
+                "height": popoutBodyH
+            };
+            animationOffset = {
+                "x": popoutAnimX,
+                "y": popoutAnimY
+            };
+        } else if (slot === "modal" && modalStates[screenName]) {
+            const modal = modalStates[screenName];
+            bodyRect = {
+                "x": modal.bodyX,
+                "y": modal.bodyY,
+                "width": modal.bodyW,
+                "height": modal.bodyH
+            };
+            animationOffset = {
+                "x": modal.animX,
+                "y": modal.animY
+            };
+        } else if (slot === "dock" && dockStates[screenName]) {
+            const dock = dockStates[screenName];
+            const slide = dockSlides[screenName] || {
+                "x": dock.slideX,
+                "y": dock.slideY
+            };
+            bodyRect = {
+                "x": dock.bodyX,
+                "y": dock.bodyY,
+                "width": dock.bodyW,
+                "height": dock.bodyH
+            };
+            animationOffset = {
+                "x": slide.x,
+                "y": slide.y
+            };
+        } else if (slot === "notification" && notificationStates[screenName]) {
+            const notification = notificationStates[screenName];
+            bodyRect = {
+                "x": notification.bodyX,
+                "y": notification.bodyY,
+                "width": notification.bodyW,
+                "height": notification.bodyH
+            };
+        }
+        return SurfaceDescriptor.normalize({
+            "bodyRect": bodyRect,
+            "animationOffset": animationOffset
+        }, descriptor);
+    }
+
+    function legacySurfaceState(screenName, kind) {
+        return SurfaceDescriptor.toLegacyState(surfaceDescriptor(screenName, kind));
+    }
+
+    function hasSurfaceDescriptor(screenName, kind, ownerId) {
+        const descriptor = surfaceDescriptor(screenName, kind);
+        return descriptor.phase !== "hidden" && (!ownerId || descriptor.ownerId === ownerId);
+    }
+
+    function _setSurfaceDescriptor(screenName, slotKind, state, ownerId) {
+        if (!screenName || !state)
+            return false;
+        const slot = _surfaceSlot(slotKind);
+        const currentScreen = surfaceDescriptors[screenName] || {};
+        const previous = currentScreen[slot] || SurfaceDescriptor.empty(state.kind || slotKind, screenName);
+        let normalized = SurfaceDescriptor.normalize(Object.assign({}, state, {
+            "ownerId": ownerId !== undefined ? ownerId : previous.ownerId,
+            "screenName": screenName,
+            "revision": previous.revision
+        }), previous);
+        if (SurfaceDescriptor.same(previous, normalized))
+            return true;
+        normalized = SurfaceDescriptor.withRevision(normalized, previous.revision + 1);
+        const nextScreen = _cloneDict(currentScreen);
+        nextScreen[slot] = normalized;
+        const next = _cloneDict(surfaceDescriptors);
+        next[screenName] = nextScreen;
+        surfaceDescriptors = next;
+        return true;
+    }
+
+    function _clearSurfaceDescriptor(screenName, kind, ownerId) {
+        if (!screenName)
+            return false;
+        const slot = _surfaceSlot(kind);
+        const currentScreen = surfaceDescriptors[screenName];
+        const current = currentScreen ? currentScreen[slot] : null;
+        if (!current || (ownerId && current.ownerId !== ownerId))
+            return false;
+        const nextScreen = _cloneDict(currentScreen);
+        delete nextScreen[slot];
+        const next = _cloneDict(surfaceDescriptors);
+        if (Object.keys(nextScreen).length > 0)
+            next[screenName] = nextScreen;
+        else
+            delete next[screenName];
+        surfaceDescriptors = next;
+        return true;
+    }
+
+    function _setSurfaceAnimation(screenName, kind, ownerId, x, y) {
+        const current = surfaceDescriptor(screenName, kind);
+        if (current.phase === "hidden" || (ownerId && current.ownerId !== ownerId))
+            return false;
+        return true;
+    }
+
+    function _setSurfaceBody(screenName, kind, ownerId, x, y, width, height) {
+        const current = surfaceDescriptor(screenName, kind);
+        if (current.phase === "hidden" || (ownerId && current.ownerId !== ownerId))
+            return false;
+        return true;
+    }
+
     readonly property var emptyDockState: ({
             "reveal": false,
             "barSide": "bottom",
@@ -69,8 +200,10 @@ Singleton {
         popoutOwnerId = claimId;
         const ok = updatePopout(claimId, state);
         if (ok) {
-            if (previousScreen && previousScreen !== popoutScreen)
+            if (previousScreen && previousScreen !== popoutScreen) {
+                _clearSurfaceDescriptor(previousScreen, "popout");
                 _bumpSurfaceRevision(previousScreen);
+            }
             _bumpSurfaceRevision(popoutScreen);
         }
         return ok;
@@ -103,6 +236,21 @@ Singleton {
         if (state.omitEndConnector !== undefined)
             popoutOmitEndConnector = !!state.omitEndConnector;
 
+        _setSurfaceDescriptor(popoutScreen, "popout", Object.assign({}, state, {
+            "kind": "popout",
+            "screenName": popoutScreen,
+            "visible": popoutVisible,
+            "presented": state.presented !== undefined ? !!state.presented : popoutVisible,
+            "barSide": popoutBarSide,
+            "bodyX": popoutBodyX,
+            "bodyY": popoutBodyY,
+            "bodyW": popoutBodyW,
+            "bodyH": popoutBodyH,
+            "animX": popoutAnimX,
+            "animY": popoutAnimY,
+            "omitStartConnector": popoutOmitStartConnector,
+            "omitEndConnector": popoutOmitEndConnector
+        }), claimId);
         return true;
     }
 
@@ -123,6 +271,7 @@ Singleton {
         popoutScreen = "";
         popoutOmitStartConnector = false;
         popoutOmitEndConnector = false;
+        _clearSurfaceDescriptor(releasedScreen, "popout", claimId);
         _bumpSurfaceRevision(releasedScreen);
         return true;
     }
@@ -140,6 +289,7 @@ Singleton {
             if (!isNaN(nextY) && popoutAnimY !== nextY)
                 popoutAnimY = nextY;
         }
+        _setSurfaceAnimation(popoutScreen, "popout", claimId, animX, animY);
         return true;
     }
 
@@ -166,6 +316,7 @@ Singleton {
             if (!isNaN(nextH) && popoutBodyH !== nextH)
                 popoutBodyH = nextH;
         }
+        _setSurfaceBody(popoutScreen, "popout", claimId, bodyX, bodyY, bodyW, bodyH);
         return true;
     }
 
@@ -193,13 +344,21 @@ Singleton {
             return false;
 
         const normalized = _normalizeDockState(state);
-        if (_sameDockState(dockStates[screenName], normalized))
-            return true;
+        const descriptorState = Object.assign({}, state, normalized, {
+            "kind": "dock",
+            "screenName": screenName,
+            "visible": normalized.reveal,
+            "presented": normalized.reveal,
+            "phase": normalized.reveal ? (state.phase || "open") : "hidden"
+        });
         const previous = dockStates[screenName] || emptyDockState;
-
-        const next = _cloneDict(dockStates);
-        next[screenName] = normalized;
-        dockStates = next;
+        const legacyChanged = !_sameDockState(dockStates[screenName], normalized);
+        if (legacyChanged) {
+            const next = _cloneDict(dockStates);
+            next[screenName] = normalized;
+            dockStates = next;
+        }
+        _setSurfaceDescriptor(screenName, "dock", descriptorState, "dock:" + screenName);
         if (!!previous.reveal !== !!normalized.reveal)
             _bumpSurfaceRevision(screenName);
         return true;
@@ -212,6 +371,7 @@ Singleton {
         const next = _cloneDict(dockStates);
         delete next[screenName];
         dockStates = next;
+        _clearSurfaceDescriptor(screenName, "dock");
 
         // Also clear corresponding slide
         if (dockSlides[screenName]) {
@@ -237,6 +397,7 @@ Singleton {
             "y": numY
         };
         dockSlides = next;
+        _setSurfaceAnimation(screenName, "dock", "dock:" + screenName, numX, numY);
         return true;
     }
 
@@ -283,13 +444,20 @@ Singleton {
             return false;
 
         const normalized = _normalizeNotificationState(state);
-        if (_sameNotificationState(notificationStates[screenName], normalized))
-            return true;
+        const descriptorState = Object.assign({}, state, normalized, {
+            "kind": "notification",
+            "screenName": screenName,
+            "presented": normalized.visible,
+            "phase": normalized.visible ? (state.phase || "open") : "hidden"
+        });
         const previous = notificationStates[screenName] || emptyNotificationState;
-
-        const next = _cloneDict(notificationStates);
-        next[screenName] = normalized;
-        notificationStates = next;
+        const legacyChanged = !_sameNotificationState(notificationStates[screenName], normalized);
+        if (legacyChanged) {
+            const next = _cloneDict(notificationStates);
+            next[screenName] = normalized;
+            notificationStates = next;
+        }
+        _setSurfaceDescriptor(screenName, "notification", descriptorState, "notification:" + screenName);
         if (!!previous.visible !== !!normalized.visible)
             _bumpSurfaceRevision(screenName);
         return true;
@@ -302,6 +470,7 @@ Singleton {
         const next = _cloneDict(notificationStates);
         delete next[screenName];
         notificationStates = next;
+        _clearSurfaceDescriptor(screenName, "notification");
         _bumpSurfaceRevision(screenName);
         return true;
     }
@@ -362,6 +531,10 @@ Singleton {
         const next = _cloneDict(modalStates);
         next[screenName] = normalized;
         modalStates = next;
+        _setSurfaceDescriptor(screenName, "modal", Object.assign({}, state, normalized, {
+            "kind": state.kind || "modal",
+            "screenName": screenName
+        }), ownerId || "");
         _bumpSurfaceRevision(screenName);
         return true;
     }
@@ -372,11 +545,16 @@ Singleton {
         if (ownerId && modalOwners[screenName] !== ownerId)
             return false;
         const normalized = _normalizeModalState(state);
-        if (_sameModalState(modalStates[screenName], normalized))
-            return true;
-        const next = _cloneDict(modalStates);
-        next[screenName] = normalized;
-        modalStates = next;
+        const descriptorState = Object.assign({}, state, normalized, {
+            "kind": state.kind || (surfaceDescriptor(screenName, "modal").kind || "modal"),
+            "screenName": screenName
+        });
+        if (!_sameModalState(modalStates[screenName], normalized)) {
+            const next = _cloneDict(modalStates);
+            next[screenName] = normalized;
+            modalStates = next;
+        }
+        _setSurfaceDescriptor(screenName, "modal", descriptorState, ownerId || modalOwners[screenName] || "");
         return true;
     }
 
@@ -418,6 +596,7 @@ Singleton {
             delete nextOwners[screenName];
             modalOwners = nextOwners;
         }
+        _clearSurfaceDescriptor(screenName, "modal", ownerId);
         _bumpSurfaceRevision(screenName);
         return true;
     }
@@ -438,6 +617,7 @@ Singleton {
             "animY": nay
         });
         modalStates = next;
+        _setSurfaceAnimation(screenName, "modal", ownerId, animX, animY);
         return true;
     }
 
@@ -461,6 +641,7 @@ Singleton {
             "bodyH": nh
         });
         modalStates = next;
+        _setSurfaceBody(screenName, "modal", ownerId, bodyX, bodyY, bodyW, bodyH);
         return true;
     }
 
@@ -543,6 +724,9 @@ Singleton {
         const nextSurfaceRevisions = pruneKeyed(surfaceRevisions);
         if (nextSurfaceRevisions !== null)
             surfaceRevisions = nextSurfaceRevisions;
+        const nextDescriptors = pruneKeyed(surfaceDescriptors);
+        if (nextDescriptors !== null)
+            surfaceDescriptors = nextDescriptors;
 
         let retractChanged = false;
         const nextRetract = {};

quickshell/Common/ConnectedSurfaceDescriptor.js

@@ -0,0 +1,179 @@
+.pragma library
+
+var VALID_KINDS = {
+    "popout": true,
+    "modal": true,
+    "launcher": true,
+    "dock": true,
+    "notification": true
+};
+
+var VALID_PHASES = {
+    "opening": true,
+    "open": true,
+    "closing": true,
+    "hidden": true,
+    "recovering": true
+};
+
+function _number(value, fallback) {
+    var n = Number(value);
+    return isNaN(n) ? fallback : n;
+}
+
+function _bool(value, fallback) {
+    return value === undefined ? fallback : !!value;
+}
+
+function _kind(value, fallback) {
+    if (VALID_KINDS[value])
+        return value;
+    return VALID_KINDS[fallback] ? fallback : "modal";
+}
+
+function _defaultBarSide(kind) {
+    return kind === "popout" || kind === "notification" ? "top" : "bottom";
+}
+
+function _barSide(value, fallback) {
+    if (value === "top" || value === "bottom" || value === "left" || value === "right")
+        return value;
+    return fallback;
+}
+
+function slotForKind(kind) {
+    return kind === "launcher" ? "modal" : _kind(kind, "modal");
+}
+
+function inferPhase(visible, presented, requestedPhase) {
+    if (VALID_PHASES[requestedPhase])
+        return requestedPhase;
+    if (!visible && !presented)
+        return "hidden";
+    if (!visible && presented)
+        return "closing";
+    return "open";
+}
+
+function normalize(input, defaults) {
+    var source = input || {};
+    var base = defaults || {};
+    var kind = _kind(source.kind, base.kind);
+    var defaultSide = _defaultBarSide(kind);
+    var sourceRect = source.bodyRect || {};
+    var baseRect = base.bodyRect || {};
+    var sourceOffset = source.animationOffset || {};
+    var baseOffset = base.animationOffset || {};
+    var visible = _bool(source.visible !== undefined ? source.visible : source.reveal, _bool(base.visible !== undefined ? base.visible : base.reveal, false));
+    var presented = _bool(source.presented, _bool(base.presented, visible));
+    var bodyRect = {
+        "x": _number(sourceRect.x !== undefined ? sourceRect.x : source.bodyX, _number(baseRect.x !== undefined ? baseRect.x : base.bodyX, 0)),
+        "y": _number(sourceRect.y !== undefined ? sourceRect.y : source.bodyY, _number(baseRect.y !== undefined ? baseRect.y : base.bodyY, 0)),
+        "width": Math.max(0, _number(sourceRect.width !== undefined ? sourceRect.width : source.bodyW, _number(baseRect.width !== undefined ? baseRect.width : base.bodyW, 0))),
+        "height": Math.max(0, _number(sourceRect.height !== undefined ? sourceRect.height : source.bodyH, _number(baseRect.height !== undefined ? baseRect.height : base.bodyH, 0)))
+    };
+    var animationOffset = {
+        "x": _number(sourceOffset.x !== undefined ? sourceOffset.x : (source.animX !== undefined ? source.animX : source.slideX), _number(baseOffset.x !== undefined ? baseOffset.x : (base.animX !== undefined ? base.animX : base.slideX), 0)),
+        "y": _number(sourceOffset.y !== undefined ? sourceOffset.y : (source.animY !== undefined ? source.animY : source.slideY), _number(baseOffset.y !== undefined ? baseOffset.y : (base.animY !== undefined ? base.animY : base.slideY), 0))
+    };
+    var screenName = source.screenName !== undefined ? source.screenName : (source.screen !== undefined ? source.screen : (base.screenName !== undefined ? base.screenName : base.screen));
+    var opacity = Math.max(0, Math.min(1, _number(source.opacity, _number(base.opacity, 1))));
+
+    return {
+        "ownerId": String(source.ownerId !== undefined ? source.ownerId : (base.ownerId || "")),
+        "kind": kind,
+        "screenName": String(screenName || ""),
+        "phase": inferPhase(visible, presented, source.phase !== undefined ? source.phase : base.phase),
+        "visible": visible,
+        "presented": presented,
+        "barSide": _barSide(source.barSide, _barSide(base.barSide, defaultSide)),
+        "bodyRect": bodyRect,
+        "animationOffset": animationOffset,
+        "scale": Math.max(0, _number(source.scale, _number(base.scale, 1))),
+        "opacity": opacity,
+        "omitStartConnector": _bool(source.omitStartConnector, _bool(base.omitStartConnector, false)),
+        "omitEndConnector": _bool(source.omitEndConnector, _bool(base.omitEndConnector, false)),
+        "dockRetractSide": String(source.dockRetractSide !== undefined ? source.dockRetractSide : (base.dockRetractSide || "")),
+        "revision": Math.max(0, Math.floor(_number(source.revision, _number(base.revision, 0))))
+    };
+}
+
+function empty(kind, screenName) {
+    return normalize({
+        "kind": kind,
+        "screenName": screenName || "",
+        "phase": "hidden",
+        "visible": false,
+        "presented": false
+    });
+}
+
+function withRevision(descriptor, revision) {
+    var next = normalize(descriptor);
+    next.revision = Math.max(0, Math.floor(_number(revision, next.revision)));
+    return next;
+}
+
+function withAnimationOffset(descriptor, x, y) {
+    var next = normalize(descriptor);
+    next.animationOffset = {
+        "x": x === undefined ? next.animationOffset.x : _number(x, next.animationOffset.x),
+        "y": y === undefined ? next.animationOffset.y : _number(y, next.animationOffset.y)
+    };
+    return next;
+}
+
+function withBodyRect(descriptor, x, y, width, height) {
+    var next = normalize(descriptor);
+    next.bodyRect = {
+        "x": x === undefined ? next.bodyRect.x : _number(x, next.bodyRect.x),
+        "y": y === undefined ? next.bodyRect.y : _number(y, next.bodyRect.y),
+        "width": width === undefined ? next.bodyRect.width : Math.max(0, _number(width, next.bodyRect.width)),
+        "height": height === undefined ? next.bodyRect.height : Math.max(0, _number(height, next.bodyRect.height))
+    };
+    return next;
+}
+
+function same(a, b, threshold) {
+    if (!a || !b)
+        return false;
+    var epsilon = threshold === undefined ? 0.5 : Math.max(0, Number(threshold));
+    return a.ownerId === b.ownerId
+        && a.kind === b.kind
+        && a.screenName === b.screenName
+        && a.phase === b.phase
+        && a.visible === b.visible
+        && a.presented === b.presented
+        && a.barSide === b.barSide
+        && Math.abs(a.bodyRect.x - b.bodyRect.x) < epsilon
+        && Math.abs(a.bodyRect.y - b.bodyRect.y) < epsilon
+        && Math.abs(a.bodyRect.width - b.bodyRect.width) < epsilon
+        && Math.abs(a.bodyRect.height - b.bodyRect.height) < epsilon
+        && Math.abs(a.animationOffset.x - b.animationOffset.x) < epsilon
+        && Math.abs(a.animationOffset.y - b.animationOffset.y) < epsilon
+        && Math.abs(a.scale - b.scale) < 0.0001
+        && Math.abs(a.opacity - b.opacity) < 0.0001
+        && a.omitStartConnector === b.omitStartConnector
+        && a.omitEndConnector === b.omitEndConnector
+        && a.dockRetractSide === b.dockRetractSide;
+}
+
+function toLegacyState(descriptor) {
+    var d = normalize(descriptor);
+    return {
+        "visible": d.visible,
+        "reveal": d.visible,
+        "barSide": d.barSide,
+        "bodyX": d.bodyRect.x,
+        "bodyY": d.bodyRect.y,
+        "bodyW": d.bodyRect.width,
+        "bodyH": d.bodyRect.height,
+        "animX": d.animationOffset.x,
+        "animY": d.animationOffset.y,
+        "slideX": d.animationOffset.x,
+        "slideY": d.animationOffset.y,
+        "screen": d.screenName,
+        "omitStartConnector": d.omitStartConnector,
+        "omitEndConnector": d.omitEndConnector
+    };
+}

quickshell/Common/ConnectedSurfaceGeometry.js

@@ -0,0 +1,232 @@
+.pragma library
+
+function _number(value, fallback) {
+    var n = Number(value);
+    return isNaN(n) ? fallback : n;
+}
+
+function snap(value, dpr) {
+    var scale = dpr || 1;
+    return Math.round(_number(value, 0) * scale) / scale;
+}
+
+function isHorizontal(side) {
+    return side === "top" || side === "bottom";
+}
+
+function isVertical(side) {
+    return side === "left" || side === "right";
+}
+
+function bodyRect(descriptor, dpr) {
+    var source = descriptor && descriptor.bodyRect ? descriptor.bodyRect : descriptor || {};
+    return {
+        "x": snap(source.x !== undefined ? source.x : source.bodyX, dpr),
+        "y": snap(source.y !== undefined ? source.y : source.bodyY, dpr),
+        "width": Math.max(0, snap(source.width !== undefined ? source.width : source.bodyW, dpr)),
+        "height": Math.max(0, snap(source.height !== undefined ? source.height : source.bodyH, dpr))
+    };
+}
+
+function animatedBodyRect(descriptor, dpr) {
+    var rect = bodyRect(descriptor, dpr);
+    var offset = descriptor && descriptor.animationOffset ? descriptor.animationOffset : descriptor || {};
+    var side = descriptor && descriptor.barSide ? descriptor.barSide : "bottom";
+    var dx = isVertical(side) ? Math.max(-rect.width, Math.min(_number(offset.x !== undefined ? offset.x : offset.animX, 0), rect.width)) : 0;
+    var dy = isHorizontal(side) ? Math.max(-rect.height, Math.min(_number(offset.y !== undefined ? offset.y : offset.animY, 0), rect.height)) : 0;
+
+    return {
+        "x": snap(rect.x + (side === "right" ? dx : 0), dpr),
+        "y": snap(rect.y + (side === "bottom" ? dy : 0), dpr),
+        "width": Math.max(0, snap(rect.width - Math.abs(dx), dpr)),
+        "height": Math.max(0, snap(rect.height - Math.abs(dy), dpr)),
+        "dx": snap(dx, dpr),
+        "dy": snap(dy, dpr)
+    };
+}
+
+function translatedBodyRect(descriptor, dpr) {
+    var rect = bodyRect(descriptor, dpr);
+    var offset = descriptor && descriptor.animationOffset ? descriptor.animationOffset : {};
+    return {
+        "x": snap(rect.x + _number(offset.x, 0), dpr),
+        "y": snap(rect.y + _number(offset.y, 0), dpr),
+        "width": rect.width,
+        "height": rect.height
+    };
+}
+
+function connectorRadii(descriptor, rect, connectedRadius, surfaceRadius, dpr, nearIncludesSurface) {
+    var side = descriptor && descriptor.barSide ? descriptor.barSide : "bottom";
+    var horizontal = isHorizontal(side);
+    var extent = horizontal ? rect.height : rect.width;
+    var crossSize = horizontal ? rect.width : rect.height;
+    var nearLimit = nearIncludesSurface ? Math.min(connectedRadius, surfaceRadius, extent, crossSize / 2) : Math.min(connectedRadius, extent, crossSize / 2);
+    var farLimit = Math.min(connectedRadius, surfaceRadius, crossSize / 2);
+    var near = snap(Math.max(0, nearLimit), dpr);
+    var far = snap(Math.max(0, farLimit), dpr);
+    var omitStart = !!(descriptor && descriptor.omitStartConnector);
+    var omitEnd = !!(descriptor && descriptor.omitEndConnector);
+    return {
+        "near": near,
+        "far": far,
+        "start": omitStart ? 0 : near,
+        "end": omitEnd ? 0 : near,
+        "farStart": omitStart ? far : 0,
+        "farEnd": omitEnd ? far : 0,
+        "farExtent": Math.max(omitStart ? far : 0, omitEnd ? far : 0)
+    };
+}
+
+function _connectorWidth(side, spacing, radius) {
+    return isVertical(side) ? spacing + radius : radius;
+}
+
+function _connectorHeight(side, spacing, radius) {
+    return isVertical(side) ? radius : spacing + radius;
+}
+
+function connectorRect(side, rect, placement, spacing, radius, dpr) {
+    var width = _connectorWidth(side, spacing, radius);
+    var height = _connectorHeight(side, spacing, radius);
+    var seamX = isVertical(side) ? (side === "left" ? rect.x : rect.x + rect.width) : (placement === "left" ? rect.x : rect.x + rect.width);
+    var seamY = side === "top" ? rect.y : (side === "bottom" ? rect.y + rect.height : (placement === "left" ? rect.y : rect.y + rect.height));
+    var x = isVertical(side) ? (side === "left" ? seamX : seamX - width) : (placement === "left" ? seamX - width : seamX);
+    var y = side === "top" ? seamY : (side === "bottom" ? seamY - height : (placement === "left" ? seamY - height : seamY));
+    return {
+        "x": snap(x, dpr),
+        "y": snap(y, dpr),
+        "width": Math.max(0, snap(width, dpr)),
+        "height": Math.max(0, snap(height, dpr))
+    };
+}
+
+function farConnectorRect(side, rect, placement, radius, dpr) {
+    var x;
+    var y;
+    if (isHorizontal(side)) {
+        x = placement === "left" ? rect.x : rect.x + rect.width - radius;
+        y = side === "top" ? rect.y + rect.height : rect.y - radius;
+    } else {
+        x = side === "left" ? rect.x + rect.width : rect.x - radius;
+        y = placement === "left" ? rect.y : rect.y + rect.height - radius;
+    }
+    return {
+        "x": snap(x, dpr),
+        "y": snap(y, dpr),
+        "width": Math.max(0, snap(radius, dpr)),
+        "height": Math.max(0, snap(radius, dpr))
+    };
+}
+
+function farBodyCapRect(side, rect, placement, radius, dpr) {
+    var x;
+    var y;
+    if (isHorizontal(side)) {
+        x = placement === "left" ? rect.x : rect.x + rect.width - radius;
+        y = side === "top" ? rect.y + rect.height - radius : rect.y;
+    } else {
+        x = side === "left" ? rect.x + rect.width - radius : rect.x;
+        y = placement === "left" ? rect.y : rect.y + rect.height - radius;
+    }
+    return {
+        "x": snap(x, dpr),
+        "y": snap(y, dpr),
+        "width": Math.max(0, snap(radius, dpr)),
+        "height": Math.max(0, snap(radius, dpr))
+    };
+}
+
+function chromeBounds(rect, side, startRadius, endRadius, farExtent, dpr) {
+    var horizontal = isHorizontal(side);
+    var bodyOffsetX = horizontal ? startRadius : (side === "right" ? farExtent : 0);
+    var bodyOffsetY = horizontal ? (side === "bottom" ? farExtent : 0) : startRadius;
+    return {
+        "x": snap(rect.x - bodyOffsetX, dpr),
+        "y": snap(rect.y - bodyOffsetY, dpr),
+        "width": Math.max(0, snap(horizontal ? rect.width + startRadius + endRadius : rect.width + farExtent, dpr)),
+        "height": Math.max(0, snap(horizontal ? rect.height + farExtent : rect.height + startRadius + endRadius, dpr)),
+        "bodyOffsetX": snap(bodyOffsetX, dpr),
+        "bodyOffsetY": snap(bodyOffsetY, dpr)
+    };
+}
+
+function fillBounds(rect, side, seamOverlap, dpr) {
+    var overlapX = isHorizontal(side) ? seamOverlap : 0;
+    var overlapY = isVertical(side) ? seamOverlap : 0;
+    return {
+        "x": snap(rect.x - overlapX, dpr),
+        "y": snap(rect.y - overlapY, dpr),
+        "width": Math.max(0, snap(rect.width + overlapX * 2, dpr)),
+        "height": Math.max(0, snap(rect.height + overlapY * 2, dpr))
+    };
+}
+
+function clipEnvelope(rect, side, radii, seamOverlap, dpr) {
+    var fill = fillBounds(rect, side, seamOverlap, dpr);
+    var chrome = chromeBounds(fill, side, radii.start, radii.end, radii.farExtent, dpr);
+    return {
+        "x": chrome.x,
+        "y": chrome.y,
+        "width": chrome.width,
+        "height": chrome.height,
+        "bodyX": snap(fill.x - chrome.x, dpr),
+        "bodyY": snap(fill.y - chrome.y, dpr),
+        "bodyWidth": fill.width,
+        "bodyHeight": fill.height
+    };
+}
+
+function blurRegions(descriptor, rect, radii, dpr) {
+    var side = descriptor.barSide;
+    var regions = [bodyRect(rect, dpr)];
+    if (radii.start > 0)
+        regions.push(connectorRect(side, rect, "left", 0, radii.start, dpr));
+    if (radii.end > 0)
+        regions.push(connectorRect(side, rect, "right", 0, radii.end, dpr));
+    if (radii.farStart > 0) {
+        regions.push(farConnectorRect(side, rect, "left", radii.farStart, dpr));
+        regions.push(farBodyCapRect(side, rect, "left", radii.farStart, dpr));
+    }
+    if (radii.farEnd > 0) {
+        regions.push(farConnectorRect(side, rect, "right", radii.farEnd, dpr));
+        regions.push(farBodyCapRect(side, rect, "right", radii.farEnd, dpr));
+    }
+    return regions;
+}
+
+function unionBounds(rects, padding, dpr) {
+    var minX = Infinity;
+    var minY = Infinity;
+    var maxX = -Infinity;
+    var maxY = -Infinity;
+    for (var i = 0; i < rects.length; i++) {
+        var rect = rects[i];
+        if (!rect || rect.width <= 0 || rect.height <= 0)
+            continue;
+        minX = Math.min(minX, rect.x);
+        minY = Math.min(minY, rect.y);
+        maxX = Math.max(maxX, rect.x + rect.width);
+        maxY = Math.max(maxY, rect.y + rect.height);
+    }
+    if (minX === Infinity)
+        return {"x": 0, "y": 0, "width": 0, "height": 0};
+    var pad = Math.max(0, _number(padding, 0));
+    return {
+        "x": snap(minX - pad, dpr),
+        "y": snap(minY - pad, dpr),
+        "width": Math.max(0, snap(maxX - minX + pad * 2, dpr)),
+        "height": Math.max(0, snap(maxY - minY + pad * 2, dpr))
+    };
+}
+
+function shadowSourceBounds(descriptor, rect, radii, padding, dpr) {
+    return unionBounds(blurRegions(descriptor, rect, radii, dpr), padding, dpr);
+}
+
+function stableEqual(a, b, dpr) {
+    if (!a || !b)
+        return false;
+    var threshold = 0.5 / (dpr || 1);
+    return Math.abs(a.x - b.x) < threshold && Math.abs(a.y - b.y) < threshold && Math.abs(a.width - b.width) < threshold && Math.abs(a.height - b.height) < threshold;
+}

quickshell/Common/ConnectedSurfaceLease.qml

@@ -0,0 +1,176 @@
+pragma ComponentBehavior: Bound
+
+import QtQuick
+
+Item {
+    id: root
+
+    required property string claimPrefix
+    required property var isCurrentOwner
+    required property var hasOwner
+    required property var claimState
+    required property var ensureState
+    required property var releaseState
+
+    property var statePresent: null
+    property var updateAnimationState: null
+    property var updateBodyState: null
+    property var requestDockRetract: null
+    property var releaseDockRetract: null
+
+    property string screenName: ""
+    property bool enabled: false
+    property bool active: false
+    property bool presented: false
+    property bool dockBlocked: false
+    property string dockSide: ""
+    property bool renewTokenOnRecovery: true
+
+    property string claimId: ""
+    property string claimedScreenName: ""
+    property int _claimSerial: 0
+
+    signal recoveryRequested
+
+    visible: false
+
+    function _nextClaimId() {
+        _claimSerial += 1;
+        return claimPrefix + ":" + (new Date()).getTime() + ":" + _claimSerial + ":" + Math.floor(Math.random() * 1000000);
+    }
+
+    function _isCurrent(name) {
+        return !!name && !!isCurrentOwner && !!isCurrentOwner(name);
+    }
+
+    function _hasOwner(name, ownerId) {
+        return !!name && !!ownerId && !!hasOwner && !!hasOwner(name, ownerId);
+    }
+
+    function _hasState(name, ownerId) {
+        return !statePresent || !!statePresent(name, ownerId);
+    }
+
+    function _shouldRecover() {
+        return active && enabled && _isCurrent(screenName);
+    }
+
+    function requestRecovery() {
+        if (!_shouldRecover())
+            return false;
+        recoveryRequested();
+        return true;
+    }
+
+    function checkOwnershipRecovery() {
+        if (!_shouldRecover())
+            return false;
+        if (claimedScreenName === screenName && _hasOwner(screenName, claimId))
+            return false;
+        recoveryRequested();
+        return true;
+    }
+
+    function checkStateRecovery() {
+        if (!_shouldRecover())
+            return false;
+        if (claimedScreenName === screenName && _hasOwner(screenName, claimId) && _hasState(screenName, claimId))
+            return false;
+        recoveryRequested();
+        return true;
+    }
+
+    function checkRecovery() {
+        return checkStateRecovery();
+    }
+
+    function beginClaim() {
+        if (claimId && releaseDockRetract)
+            releaseDockRetract(claimId);
+        claimId = _nextClaimId();
+        claimedScreenName = "";
+        return claimId;
+    }
+
+    function _syncDockRetract() {
+        if (!claimId)
+            return;
+        if (dockBlocked && presented && dockSide && requestDockRetract)
+            requestDockRetract(claimId, screenName, dockSide);
+        else if (releaseDockRetract)
+            releaseDockRetract(claimId);
+    }
+
+    function publish(state, forceClaim) {
+        if (!enabled || !screenName || !state) {
+            release();
+            return false;
+        }
+
+        if (claimedScreenName && claimedScreenName !== screenName)
+            release();
+
+        const current = _isCurrent(screenName);
+        let claiming = !!forceClaim || !claimId;
+        if (claiming && !current)
+            return false;
+        if (!claimId)
+            beginClaim();
+
+        let published = claiming ? claimState(screenName, state, claimId) : ensureState(screenName, state, claimId);
+        if (!published && !claiming && current) {
+            if (renewTokenOnRecovery) {
+                beginClaim();
+            } else if (releaseDockRetract) {
+                releaseDockRetract(claimId);
+            }
+            published = claimState(screenName, state, claimId);
+        }
+        if (!published)
+            return false;
+
+        claimedScreenName = screenName;
+        _syncDockRetract();
+        return true;
+    }
+
+    function updateAnim(animX, animY) {
+        if (!enabled || !claimId || !claimedScreenName || !updateAnimationState)
+            return false;
+        if (!_hasOwner(claimedScreenName, claimId)) {
+            requestRecovery();
+            return false;
+        }
+        return updateAnimationState(claimedScreenName, claimId, animX, animY);
+    }
+
+    function updateBody(bodyX, bodyY, bodyW, bodyH) {
+        if (!enabled || !claimId || !claimedScreenName || !updateBodyState)
+            return false;
+        if (!_hasOwner(claimedScreenName, claimId)) {
+            requestRecovery();
+            return false;
+        }
+        return updateBodyState(claimedScreenName, claimId, bodyX, bodyY, bodyW, bodyH);
+    }
+
+    function release() {
+        if (!claimId) {
+            claimedScreenName = "";
+            return false;
+        }
+
+        const releasedClaimId = claimId;
+        const releasedScreenName = claimedScreenName;
+        claimId = "";
+        claimedScreenName = "";
+
+        if (releaseDockRetract)
+            releaseDockRetract(releasedClaimId);
+        if (releasedScreenName)
+            return !!releaseState(releasedScreenName, releasedClaimId);
+        return false;
+    }
+
+    Component.onDestruction: release()
+}