Merge floating-windows into experimental

Floating windows join the keyboard and the hand cutouts. Floating panels
don't get cutouts yet: their panel and popups show crops of the client
buffer (texture bounds), which the side-by-side cutout buffer doesn't
match. KWin gets both the spare outputs and our input method, and the
pointer helper's frametop. prefix already covers the float panels.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

pointer/helper/ft-pointer.cpp

@@ -103,6 +103,13 @@
 // press and collision is frozen, so dragging past a panel's edge (resizing, moving)
 // doesn't jump the cursor to free space or swap in the laser-catching dot, which made
 // SteamVR's resize snap back.
+// A left release also goes to ft-screens ("up"), which releases a button held on its
+// screens in KWin if SteamVR gave the release to some other overlay.
+// Across Frametop's panels (a drag and drop, or a window moved from one screen or floating
+// window to another), the lock gives way: while the left button is held on one of ft-screens'
+// panels, the ray is still tested against ft-screens' panels, and the cursor goes onto
+// whichever it meets first. Not while that panel is being carried (its title bar or its bar):
+// then the ray would find what's behind it.
 //
 // Head follow (experimental, off by default; POINTER_FOLLOW=1, or the relay's "follow toggle"): the cursor
 // is carried by a reference direction, where the head faced when it last settled, and turns
@@ -283,6 +290,19 @@ std::string ExeDir() {
     return p.substr(0, p.rfind('/'));
 }
 
+// One of ft-screens' panels showing a desktop: a screen (frametop.screen.N), a floating
+// window (frametop.float.N), or a floating window's popup (frametop.float.N.sub.K), not a
+// control of theirs.
+bool FramePanel(const std::string &key) {
+    for (const char *prefix : {"frametop.screen.", "frametop.float."}) {
+        if (key.rfind(prefix, 0) != 0) continue;
+        const std::string rest = key.substr(std::strlen(prefix));
+        const size_t dot = rest.find('.');
+        return dot == std::string::npos || rest.compare(dot, 5, ".sub.") == 0;
+    }
+    return false;
+}
+
 void SendTo(int fd, const char *name, const std::string &msg) {
     sockaddr_un addr{};
     addr.sun_family = AF_UNIX;
@@ -369,6 +389,7 @@ private:
             if (rest.find("Thumbnail") != std::string::npos || rest.find("Subview") != std::string::npos) continue;
             if (key.rfind("system.pointer", 0) == 0 || key.rfind("system.cursor", 0) == 0 ||
                 key.rfind("frametop.pointer", 0) == 0 || key.rfind("frametop.guide", 0) == 0 ||
+                key == "frametop.catcher" ||  // ft-screens' release catcher: only on a laser mid-drag
                 key == "system.HeadsetView" || key == "system.toast")
                 continue;
             // The name can hold quotes; it ends at the last "', " (the size and state follow).
@@ -622,6 +643,9 @@ int main() {
     Clock::time_point dropHoldUntil{};  // after a left release: keep the drag pose this long
     bool debug = false;
     std::string lastHit;
+    // The ft-screens panel the left button was pressed on, and where it was then (see the top).
+    std::string pressKey;
+    vr::HmdMatrix34_t pressPose{};
     auto lastDebug = Clock::now();
     vr::VROverlayHandle_t systemPointer = vr::k_ulOverlayHandleInvalid;
     overlay->FindOverlay("system.pointer", &systemPointer);
@@ -684,6 +708,14 @@ int main() {
         nudging = false;
         leftHeld = true;
         dragDistance = lastDistance;
+        pressKey.clear();
+        if (FramePanel(lastHit)) {
+            vr::ETrackingUniverseOrigin uo;
+            auto it = handles.find(lastHit);
+            if (it != handles.end() &&
+                overlay->GetOverlayTransformAbsolute(it->second, &uo, &pressPose) == vr::VROverlayError_None)
+                pressKey = lastHit;
+        }
         tiltYaw = tiltPitch = 0;  // a new drag starts untilted
         dropHoldUntil = {};
         pulseAt = Clock::now();
@@ -695,6 +727,9 @@ int main() {
         // Hold the drag pose (tilt, frozen distance) while SteamVR finishes the drop.
         dropHoldUntil = Clock::now() + std::chrono::milliseconds(500);
         SendTo(out, "ft_pointer", "btn trigger 0");
+        // ft-screens releases a button held on its screens in KWin even when SteamVR hands
+        // the release to some other overlay (its catcher usually gets it; this is the backstop).
+        SendTo(out, "ft_screens", "up");
         if (gazeBack) gazeOwns = true, gazeBack = false;
     };
     // The left button, from the relay's "btn trigger", with gaze mode's held-back press (see
@@ -1254,8 +1289,9 @@ int main() {
                 overlay->GetOverlayTextureSize(h, &tw, &th);
                 vr::VROverlayTransformType tt = vr::VROverlayTransform_Invalid;
                 overlay->GetOverlayTransformType(h, &tt);
-                // ft-screens' panels (frametop.screen.N, the keyboard) are 0x0 and absolute too
-                // (a shared texture), but they're real panels of any size.
+                // ft-screens' panels (frametop.screen.N, floating windows with their popups,
+                // frametop.float.N..., the keyboard) are 0x0 and absolute too (a shared
+                // texture), but they're real panels of any size.
                 sceneGraph[key] = (tw == 0 || th == 0) && tt == vr::VROverlayTransform_Absolute &&
                                   key.rfind("frametop.", 0) != 0;
             }
@@ -1363,6 +1399,35 @@ int main() {
                     }
                 }
             }
+            // Held on one of ft-screens' panels that stays where it is: onto whichever of them
+            // the ray meets (see the top).
+            if (leftHeld && !pressKey.empty()) {
+                vr::ETrackingUniverseOrigin uo;
+                vr::HmdMatrix34_t now{};
+                auto it = handles.find(pressKey);
+                bool still = it != handles.end() &&
+                             overlay->GetOverlayTransformAbsolute(it->second, &uo, &now) == vr::VROverlayError_None;
+                for (int i = 0; still && i < 3; ++i)
+                    for (int j = 0; j < 4; ++j)
+                        if (std::fabs(now.m[i][j] - pressPose.m[i][j]) > 0.001f) still = false;
+                if (still) {
+                    Hit h;
+                    for (const auto &[key, handle] : handles) {
+                        if (!visible[key] || !FramePanel(key)) continue;
+                        vr::VROverlayIntersectionParams_t params{};
+                        params.vSource = {float(anchor.x), float(anchor.y), float(anchor.z)};
+                        params.vDirection = {float(dir.x), float(dir.y), float(dir.z)};
+                        params.eOrigin = vr::TrackingUniverseStanding;
+                        vr::VROverlayIntersectionResults_t r{};
+                        if (overlay->ComputeOverlayIntersection(handle, &params, &r) && r.fDistance > 0.05f &&
+                            r.fDistance < h.along)
+                            h.along = r.fDistance, h.key = key;
+                    }
+                    if (h.along < 1e8) dragDistance = h.along, lastHit = h.key;
+                } else {
+                    pressKey.clear();  // carried: the lock holds for the rest of this press
+                }
+            }
             // While dragging: keep the press-time distance and show the non-interactive marker.
             // On a scene-graph plane or a panel's edge: the laser-catching dot goes 5 cm behind it.
             double distance = dragging ? dragDistance : (best < 1e8 ? best : freeDistance);