DankMaterialShell/quickshell/Common/ConnectedModeState.qml

pragma Singleton
pragma ComponentBehavior: Bound

import QtQuick
import Quickshell
import "ConnectedSurfaceDescriptor.js" as SurfaceDescriptor

Singleton {
    id: root

    property var surfaceDescriptors: ({})
    property var surfaceMotion: ({})
    property var surfaceRevisions: ({})
    property var dockRetractRequests: ({})
    property var popoutMotionHandoff: null

    // One notifying object per claimed slot keeps animation frames from invalidating every descriptor binding.
    Component {
        id: motionComponent

        QtObject {
            property real bodyX: 0
            property real bodyY: 0
            property real bodyW: 0
            property real bodyH: 0
            property real animX: 0
            property real animY: 0
        }
    }

    function surfaceSlot(kind, instanceId) {
        const slot = SurfaceDescriptor.slotForKind(kind);
        return instanceId ? slot + ":" + instanceId : slot;
    }

    function _motionKey(screenName, slot) {
        return screenName + "|" + slot;
    }

    function _stored(screenName, slot) {
        return screenName ? surfaceDescriptors[screenName]?.[slot] ?? null : null;
    }

    function surfaceDescriptor(screenName, slot) {
        const base = _stored(screenName, slot) ?? SurfaceDescriptor.empty(slot.split(":")[0], screenName);
        const motion = surfaceMotion[_motionKey(screenName, slot)];
        if (!motion)
            return base;
        return SurfaceDescriptor.normalize({
            "bodyX": motion.bodyX,
            "bodyY": motion.bodyY,
            "bodyW": motion.bodyW,
            "bodyH": motion.bodyH,
            "animX": motion.animX,
            "animY": motion.animY
        }, base);
    }

    function surfaceDescriptorsOfKind(screenName, kind) {
        const screen = screenName ? surfaceDescriptors[screenName] : null;
        if (!screen)
            return [];
        return Object.keys(screen).filter(slot => slot === kind || slot.startsWith(kind + ":")).map(slot => surfaceDescriptor(screenName, slot));
    }

    function surfaceOwnerId(screenName, slot) {
        return _stored(screenName, slot)?.ownerId ?? "";
    }

    function hasSurfaceOwner(screenName, slot, ownerId) {
        return !!ownerId && surfaceOwnerId(screenName, slot) === ownerId;
    }

    function hasSurfaceDescriptor(screenName, slot, ownerId) {
        const descriptor = _stored(screenName, slot);
        return !!descriptor && descriptor.phase !== "hidden" && (!ownerId || descriptor.ownerId === ownerId);
    }

    function claimSurface(screenName, slot, state, ownerId, exclusive) {
        if (!screenName || !slot || !state || !ownerId)
            return false;
        if (exclusive) {
            for (const name of Object.keys(surfaceDescriptors)) {
                if (name !== screenName)
                    releaseSurface(name, slot, "");
            }
        }
        return _writeSurface(screenName, slot, state, ownerId);
    }

    function updateSurface(screenName, slot, state, ownerId) {
        if (!state || !hasSurfaceOwner(screenName, slot, ownerId))
            return false;
        return _writeSurface(screenName, slot, state, ownerId);
    }

    function _bumpSurfaceRevision(screenName) {
        surfaceRevisions = Object.assign({}, surfaceRevisions, {
            [screenName]: (surfaceRevisions[screenName] ?? 0) + 1
        });
    }

    function _writeSurface(screenName, slot, state, ownerId) {
        const stored = _stored(screenName, slot);
        const previous = surfaceDescriptor(screenName, slot);
        let next = SurfaceDescriptor.normalize(Object.assign({}, state, {
            "ownerId": ownerId,
            "screenName": screenName,
            "revision": previous.revision
        }), previous);
        if (SurfaceDescriptor.same(previous, next))
            return true;
        next = SurfaceDescriptor.withRevision(next, previous.revision + 1);
        const screen = Object.assign({}, surfaceDescriptors[screenName]);
        screen[slot] = next;
        surfaceDescriptors = Object.assign({}, surfaceDescriptors, {
            [screenName]: screen
        });
        if (!stored || stored.ownerId !== next.ownerId || stored.visible !== next.visible)
            _bumpSurfaceRevision(screenName);
        const key = _motionKey(screenName, slot);
        const motion = surfaceMotion[key] ?? motionComponent.createObject(root);
        motion.bodyX = next.bodyRect.x;
        motion.bodyY = next.bodyRect.y;
        motion.bodyW = next.bodyRect.width;
        motion.bodyH = next.bodyRect.height;
        motion.animX = next.animationOffset.x;
        motion.animY = next.animationOffset.y;
        if (!surfaceMotion[key])
            surfaceMotion = Object.assign({}, surfaceMotion, {
                [key]: motion
            });
        return true;
    }

    function releaseSurface(screenName, slot, ownerId) {
        const current = _stored(screenName, slot);
        if (!current || (ownerId && current.ownerId !== ownerId))
            return false;
        const screen = Object.assign({}, surfaceDescriptors[screenName]);
        delete screen[slot];
        const next = Object.assign({}, surfaceDescriptors);
        if (Object.keys(screen).length)
            next[screenName] = screen;
        else
            delete next[screenName];
        surfaceDescriptors = next;
        _dropMotion([_motionKey(screenName, slot)]);
        _bumpSurfaceRevision(screenName);
        return true;
    }

    function setSurfaceMotion(screenName, slot, ownerId, patch) {
        if (!patch || !hasSurfaceOwner(screenName, slot, ownerId))
            return false;
        const motion = surfaceMotion[_motionKey(screenName, slot)];
        if (!motion)
            return false;
        for (const key in patch) {
            const value = Number(patch[key]);
            if (!isNaN(value) && motion[key] !== value)
                motion[key] = value;
        }
        return true;
    }

    function _dropMotion(keys) {
        const dropped = keys.filter(key => surfaceMotion[key]);
        if (!dropped.length)
            return;
        const next = Object.assign({}, surfaceMotion);
        for (const key of dropped) {
            next[key].destroy();
            delete next[key];
        }
        surfaceMotion = next;
    }

    function savePopoutMotion(ownerId, screenName, barSide, rect, velocity) {
        if (!hasSurfaceOwner(screenName, "popout", ownerId))
            return;
        popoutMotionHandoff = {
            "ownerId": ownerId,
            "screen": screenName,
            "barSide": barSide,
            "rect": Qt.rect(rect.x, rect.y, rect.width, rect.height),
            "velocity": Qt.vector4d(velocity.x, velocity.y, velocity.z, velocity.w)
        };
    }

    function takePopoutMotion(screenName, barSide) {
        const handoff = popoutMotionHandoff;
        popoutMotionHandoff = null;
        if (!handoff || handoff.screen !== screenName || handoff.barSide !== barSide || !hasSurfaceOwner(screenName, "popout", handoff.ownerId))
            return null;
        return handoff;
    }

    function requestDockRetract(requesterId, screenName, side) {
        if (!requesterId || !screenName || !side)
            return false;
        const existing = dockRetractRequests[requesterId];
        if (existing && existing.screenName === screenName && existing.side === side)
            return true;
        dockRetractRequests = Object.assign({}, dockRetractRequests, {
            [requesterId]: {
                "screenName": screenName,
                "side": side
            }
        });
        return true;
    }

    function releaseDockRetract(requesterId) {
        if (!requesterId || !dockRetractRequests[requesterId])
            return false;
        const next = Object.assign({}, dockRetractRequests);
        delete next[requesterId];
        dockRetractRequests = next;
        return true;
    }

    function dockRetractActiveForSide(screenName, side) {
        if (!screenName || !side)
            return false;
        return Object.values(dockRetractRequests).some(request => request.screenName === screenName && request.side === side);
    }

    function _pruneKeyed(dict, keep) {
        const next = {};
        let changed = false;
        for (const key in dict) {
            if (keep(key, dict[key]))
                next[key] = dict[key];
            else
                changed = true;
        }
        return changed ? next : null;
    }

    function _pruneToLiveScreens() {
        const live = new Set((Quickshell.screens || []).map(screen => screen?.name).filter(Boolean));
        const descriptors = _pruneKeyed(surfaceDescriptors, name => live.has(name));
        if (descriptors)
            surfaceDescriptors = descriptors;
        const revisions = _pruneKeyed(surfaceRevisions, name => live.has(name));
        if (revisions)
            surfaceRevisions = revisions;
        const retract = _pruneKeyed(dockRetractRequests, (_, request) => live.has(request.screenName));
        if (retract)
            dockRetractRequests = retract;
        _dropMotion(Object.keys(surfaceMotion).filter(key => !live.has(key.split("|")[0])));
    }

    Connections {
        target: Quickshell
        function onScreensChanged() {
            screenPruneAction.schedule();
        }
    }

    DeferredAction {
        id: screenPruneAction
        onTriggered: root._pruneToLiveScreens()
    }
}