From 7816633353a8e3c16a7be77f023e727db4f01d3a Mon Sep 17 00:00:00 2001 From: DeeJanuz <45082401+DeeJanuz@users.noreply.github.com> Date: Thu, 1 Oct 2026 21:13:19 -0600 Subject: [PATCH 1/5] README: link the Frametop Discord Co-Authored-By: Claude Opus 5.5 --- README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 335e228..6119c02 100644 --- a/README.md +++ b/README.md @@ -13,6 +13,8 @@ Two settings apps come with it: Frametop Display Settings for the screens, profi Frametop is an independent project, not made by or affiliated with Valve. +Join the [Frametop Discord](https://discord.gg/W3X9f7z3Bc) for questions, ideas, and help with your setup. + ## Install on the headset You need a Steam Frame with an internet connection, a keyboard (Bluetooth, or the on-screen one), and about 3 GB of free space. @@ -138,7 +140,7 @@ In a terminal on the headset, run: cd ~/frametop && scripts/report.sh ``` -This writes `frametop-report-.txt` with version numbers, service states, settings, and recent logs. Bluetooth addresses and the headset's serial number are masked. Then [open an issue](https://github.com/DeeJanuz/frametop/issues), describe what you did, what you expected, and what happened, and attach the file. +This writes `frametop-report-.txt` with version numbers, service states, settings, and recent logs. Bluetooth addresses and the headset's serial number are masked. Then [open an issue](https://github.com/DeeJanuz/frametop/issues), describe what you did, what you expected, and what happened, and attach the file. Quick questions can go to [Discord](https://discord.gg/W3X9f7z3Bc) instead. ## Update From 072a294941f2b0ef2b8f2fa0cfb23243d9fdcf2a Mon Sep 17 00:00:00 2001 From: DeeJanuz <45082401+DeeJanuz@users.noreply.github.com> Date: Fri, 2 Oct 2026 16:12:52 -0600 Subject: [PATCH 2/5] README: Frametop doesn't work on the SteamOS beta yet Co-Authored-By: Claude Opus 5.5 --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 6119c02..e094ed5 100644 --- a/README.md +++ b/README.md @@ -17,6 +17,8 @@ Join the [Frametop Discord](https://discord.gg/W3X9f7z3Bc) for questions, ideas, ## Install on the headset +> **Frametop doesn't work on the SteamOS beta right now.** On the beta (SteamOS 0.4.3), gaze mode can't read the eye tracker, and the desktop has started without its taskbar ([#15](https://github.com/DeeJanuz/frametop/issues/15)). Use the stable SteamOS release until this note is gone. + You need a Steam Frame with an internet connection, a keyboard (Bluetooth, or the on-screen one), and about 3 GB of free space. 1. In the launcher, choose Launch a program → Desktop. From 1ebf3692fbda7f34e413339e6ec86dc829b8a80a Mon Sep 17 00:00:00 2001 From: Patrick McDavid Date: Fri, 2 Oct 2026 21:12:49 -0600 Subject: [PATCH 3/5] ft-floatd: a launch for a missing app no longer kills the control socket (#16) Gio.DesktopAppInfo.new() returns NULL for a desktop file that doesn't exist, and PyGObject raises TypeError ("constructor returned NULL") rather than returning None, so launch()'s `if info is None` never ran. The exception escaped the control socket's GLib callback, GLib dropped the watch, and ft-floatd stopped answering everything: the float key, dock, Launch as Standalone, and profiles, until the desktop restarted. Found on the Frame (2026-10-02): a profile saved with RustDesk's Flatpak open records its window's app id, com.carriez.flutter_hbb, which has no desktop file (the Flatpak's is com.rustdesk.RustDesk). `ft-layout use` on that profile asked ft-floatd to launch it, and ft-floatd went silent. With this, that launch replies "error no app com.carriez.flutter_hbb" and the profile's other apps open. Co-authored-by: Claude Opus 5.5 --- float/ft_floatd.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/float/ft_floatd.py b/float/ft_floatd.py index bc66380..66a81e1 100644 --- a/float/ft_floatd.py +++ b/float/ft_floatd.py @@ -745,7 +745,10 @@ class Daemon: Returns (reply, pid or None).""" if app: app = app.removesuffix(".desktop") - info = Gio.DesktopAppInfo.new(app + ".desktop") + try: + info = Gio.DesktopAppInfo.new(app + ".desktop") + except TypeError: # PyGObject raises for the NULL a missing desktop file returns + info = None if info is None: return f"error no app {app}", None pids = [] From 6fb168a8b85bc3e35802e86eee7b4deebac6a215 Mon Sep 17 00:00:00 2001 From: Patrick McDavid Date: Sat, 3 Oct 2026 10:17:22 -0600 Subject: [PATCH 4/5] Lazy susan: Meta+Alt+Tab spins the panels around you - ft-screens "spin next|prev|": every unpinned screen and floating window turns together about a vertical axis through your head (0.3 s, eased), so the next panel on the right or left comes to straight ahead; the arrangement stays as it is. Taps during a spin add to it, from where the panels are headed; grabbing a panel or placing it (ft-layout, ft-floatd) takes it out of the spin - when a spin settles, the panel in front gets the pointer (recenter), typing (as after a click), and KWin's active window: its floating window, or the top window on a screen (ft-floatd "front N", the KWin script's activate-output). KWin's outputs follow the screens' new places (ft-layout scale), as after a move - the input relay: spin_next and spin_prev actions, Meta+Alt+Tab and Meta+Alt+Shift+Tab by default; Frametop Input Settings lists them. Not Meta+Tab: that's Cmd+Tab on a Mac reached through a remote desktop like RustDesk, and the relay would take the Mac's app switcher. Meta+Alt+Tab (Cmd+Option+Tab) is unused on macOS, Windows, and KDE Used on the Frame (SteamOS 0.3.0 build 20260922) with one screen and three or four floating windows, through RustDesk to a Mac. Co-Authored-By: Claude Opus 5.5 --- README.md | 1 + docs/reference.md | 2 +- float/frametop-float.js | 11 ++ float/ft_floatd.py | 9 ++ input-settings/ft_input_settings.py | 7 +- input/input-relay.py | 27 +++-- screens/compositor.c | 14 +++ screens/vr.cpp | 156 ++++++++++++++++++++++++++++ screens/vr.h | 3 +- 9 files changed, 220 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index e094ed5..21ff1ef 100644 --- a/README.md +++ b/README.md @@ -57,6 +57,7 @@ If you work in the desktop for long stretches, or leave the headset on a stand, | While carrying a screen, sweep its laser across your other controller's ring, then let go | Pins it to that wrist, at its size and distance, as you hold it when you let go; it shows while you see its front. Grab its bar to adjust it (it stays pinned); sweep across the ring again to take it off | | Set a screen to On your head (Frametop Display Settings, Visibility & pins) | Pins it to your head where it is, like a HUD. Grab its bar to move it; it stays on your head | | Meta+Shift+R in the desktop | Puts the screens back in their layout (also in the menu as Reset Screen Layout, and mappable to a mouse button) | +| Meta+Alt+Tab, or Meta+Alt+Shift+Tab | Spins every screen and floating window around you together, like a lazy susan, so the next one on your right (or left) glides to straight ahead, with the pointer and typing going to it. Their arrangement stays the same: the room turns instead of you. Tap again to keep going; Meta+Shift+R puts the screens back. Pinned screens stay where they are | | Meta+Shift+H in the desktop | Hides or shows all screens (also in the menu as Hide/Show Screens, and mappable). The Visibility & pins tab of Frametop Display Settings can instead show them only with the dashboard open, or while you look at your wrist | | Switch a screen to Hidden (Frametop Display Settings, Visibility & pins → Screens shown) | Hides just that screen until you switch it back, whatever the other visibility settings say; new windows that would open on it float instead | | Play a VR game | The screens hide and your controllers stay in the game. Open the SteamVR dashboard, or press Meta+Shift+H, to see and use them. To keep them visible over games, change During VR games on the Visibility & pins tab; the controllers still stay in the game, and you use the screens with the mouse or the dashboard | diff --git a/docs/reference.md b/docs/reference.md index 8b3fac2..6692cd5 100644 --- a/docs/reference.md +++ b/docs/reference.md @@ -117,7 +117,7 @@ A Kirigami app with a Python backend, in the Plasma menu under Settings. It runs - Devices lists every USB and Bluetooth mouse and keyboard, with a light that flashes when the device is used. Each device gets a role: 3D pointer (grabbed, drives the pointer; the default for anything with a mouse), Pass through (grabbed only while typing goes to the desktop; the default for keyboards, where a Meta tap toggles the dashboard if `META_DASHBOARD=1` is in `~/.config/frametop.conf`), or Ignore. A device is identified by its Bluetooth address, or its USB ids and name, so all of its input nodes share one role. Forget drops everything saved for a device. - Buttons maps a pointer device's buttons. Choose Capture a button, press the button or key, then pick an action: a click, back, scroll, toggle dashboard, recenter, pointer on or off, head follow on or off, gaze pointer on or off, gaze precision, gaze drag, gaze quick check, faster or slower, reset the screen layout, hide or show the screens, open or close the keyboard, float a window in VR or put it back, put all floating windows back, Open profile NAME (one per profile, [profiles.md](profiles.md)), pass the key through, or nothing. Devices with saved mappings are listed even while they're asleep. - Controllers maps the Frame controllers' buttons (every button but the system button) to the same actions, except passing a key through and the gaze actions: gaze mode is a mouse and keyboard feature ([gaze-controllers.md](gaze-controllers.md)). Capture a button and press it on a controller, or pick it from the list. The controllers aren't input devices on the host; only SteamVR sees them. So the pointer helper reads them with SteamVR input (`pointer/helper/vrbuttons.h`, `pointer/helper/actions/`) and sends presses to the relay (`vrbtn right/a 1`), which does the mapped action. The helper only takes the buttons that are mapped (the relay tells it with `vrbind`), at an overlay-global priority, and only while no game (scene application) runs, so games keep every button; with In games on (`controller_in_games`), a mapped button is taken from games too. That needs SteamVR's "Enable global input from overlays (Experimental)" setting (`steamvr/globalActionSetPriority`), which the page's Global input switch turns on and off. Mappings are saved as `controller_buttons` in `~/.config/frametop-input.json`. -- Keyboard sets when Frametop's keyboard opens: whenever a text field is selected; only while no pass-through keyboard is connected (the default; keyboards other programs make through uinput, like frame-voice's, don't count); only with a mouse or controller button mapped to Open/close keyboard; or never, which turns the button off too. Keep it open (on by default, `vr_keyboard_persist`) leaves it open after the text field loses focus. The mode is saved as `vr_keyboard` in `~/.config/frametop-input.json`, and the page lists the keyboards that count as connected. Its Key combinations section maps modifiers plus a key, on any keyboard, to any action but passing a key through or nothing. The gaze clicks (Gaze left click and Gaze right click) only go on key combinations. The defaults are Meta+J (gaze left click), Meta+K (gaze right click), and Meta+Shift+F (float window in VR or put it back); remove them or add others there. The combination's last key isn't typed, and the modifiers still reach the app. They're saved as `key_bindings` in the same file. +- Keyboard sets when Frametop's keyboard opens: whenever a text field is selected; only while no pass-through keyboard is connected (the default; keyboards other programs make through uinput, like frame-voice's, don't count); only with a mouse or controller button mapped to Open/close keyboard; or never, which turns the button off too. Keep it open (on by default, `vr_keyboard_persist`) leaves it open after the text field loses focus. The mode is saved as `vr_keyboard` in `~/.config/frametop-input.json`, and the page lists the keyboards that count as connected. Its Key combinations section maps modifiers plus a key, on any keyboard, to any action but passing a key through or nothing. The gaze clicks (Gaze left click and Gaze right click) only go on key combinations. The defaults are Meta+J (gaze left click), Meta+K (gaze right click), Meta+Shift+F (float window in VR or put it back), and Meta+Alt+Tab and Meta+Alt+Shift+Tab (spin the panels: every screen and floating window turns about your head, so the next one on the right or left comes to the front; ft-screens' `spin next|prev|`); remove them or add others there. The combination's last key isn't typed, and the modifiers still reach the app. They're saved as `key_bindings` in the same file. - Pointer has a Head follow switch and sliders for the pointer settings, which apply immediately, and a Recenter button. - Ignored panels lists the SteamVR overlays that are showing, grouped by app (the first two parts of the overlay key, such as `sasaken.frame-perf-overlay`), from the pointer helper (`overlays`). Tick a panel, or Ignore the whole app, and the pointer passes through it to what's behind. It's for panels you only look at, like a performance overlay that follows your view. The list is saved as `POINTER_IGNORE` in `~/.config/frametop.conf`: comma-separated overlay keys, where a shell pattern like `vendor.app*` covers a whole app, including panels it opens later. The helper reloads at once. Frametop's own screens aren't listed, and entries for apps that aren't open are listed below, to remove. - Gaze has the gaze pointer switch (on now and from now on; a mapped button toggles it until the helper restarts), what the mouse's left button and movement do, the gaze dot, the eye tracker and eye bias, the gaze mode sliders, the gaze service's state (headset, samples per second, how often the tracker is losing each eye, the calibration, the nudges learned), and Quick check, Calibrate, and Check headset fit (each in a panel in the headset), Reload calibration, and Forget nudges. The gaze probe, a development tool, is in the page's overflow menu. diff --git a/float/frametop-float.js b/float/frametop-float.js index 85c0f0a..5f52059 100644 --- a/float/frametop-float.js +++ b/float/frametop-float.js @@ -378,6 +378,17 @@ function run(c) { case "activate": if (w) workspace.activeWindow = w; break; + case "activate-output": { // the top window on that output (a spin brought it to the front) + const order = workspace.stackingOrder; + for (let i = order.length - 1; i >= 0; --i) { + const o = order[i]; + if (o.deleted || o.minimized || o.hidden || !o.managed || !o.output) continue; + if (o.output.name !== c.output || !o.normalWindow || o.popupWindow) continue; + workspace.activeWindow = o; + break; + } + break; + } case "minimize": if (w) w.minimized = c.on; break; diff --git a/float/ft_floatd.py b/float/ft_floatd.py index 66a81e1..59acc08 100644 --- a/float/ft_floatd.py +++ b/float/ft_floatd.py @@ -18,6 +18,8 @@ command-line side). Replies go to the sender: ("float pointer" is the float key: the window under the pointer, else the active one, floated or docked; the input relay sends it for float_toggle, and "dock all" for dock_all) dock N | close N | resize N W H | scale N STEPS (ft-screens, N = its screen) + front N (ft-screens: a spin brought panel N to the front: make its window, or the top one + on a screen, KWin's active window) Spare outputs are WL- .. WL-. A floating window's output is its frame plus a margin on each side (FLOAT_MARGIN pixels), so menus have room; the panel shows @@ -1043,6 +1045,13 @@ class Daemon: for f in list(self.floats.values()): self.dock(f) return "ok" + if cmd == "front" and len(rest) == 1 and rest[0].isdigit(): + f = self.by_panel(int(rest[0])) + if f: + self.command(cmd="activate", id=f.id) + else: # a screen: its output is WL- + self.command(cmd="activate-output", output=f"WL-{int(rest[0]) - 1}") + return "ok" if cmd in ("dock", "close", "resize", "scale") and rest and rest[0].isdigit(): f = self.by_panel(int(rest[0])) if not f: diff --git a/input-settings/ft_input_settings.py b/input-settings/ft_input_settings.py index d804f17..24145b2 100644 --- a/input-settings/ft_input_settings.py +++ b/input-settings/ft_input_settings.py @@ -71,6 +71,8 @@ ACTION_LABELS = { "sens_down": "Slower pointer", "layout_reset": "Reset desktop screen layout", "screens_toggle": "Hide/show desktop screens", "keyboard_toggle": "Open/close keyboard", "float_toggle": "Float window in VR / put it back", "dock_all": "Put all floating windows back", + "spin_next": "Spin the panels: next one on the right to the front", + "spin_prev": "Spin the panels: next one on the left to the front", "key": "Pass through as key", "none": "Do nothing", } @@ -142,8 +144,9 @@ GAZE_MOUSE = {"precision": "Gaze precision: hold to steer with the mouse, releas MODIFIER_CODES = {29: 29, 97: 29, 42: 42, 54: 42, 56: 56, 100: 56, 125: 125, 126: 125} MODIFIER_NAMES = {29: "Ctrl", 42: "Shift", 56: "Alt", 125: "Meta"} # What a rules file without "key_bindings" gets (the relay's DEFAULT_KEY_BINDINGS): Meta+J and -# Meta+K click at the gaze, Meta+Shift+F floats a window. -DEFAULT_KEY_BINDINGS = {"125+36": "gaze_left", "125+37": "gaze_right", "42+125+33": "float_toggle"} +# Meta+K click at the gaze, Meta+Shift+F floats a window, Meta+Alt+Tab and Meta+Alt+Shift+Tab spin the panels. +DEFAULT_KEY_BINDINGS = {"125+36": "gaze_left", "125+37": "gaze_right", "42+125+33": "float_toggle", + "56+125+15": "spin_next", "42+56+125+15": "spin_prev"} def key_bindings(rules): diff --git a/input/input-relay.py b/input/input-relay.py index e4fb462..e658b0b 100755 --- a/input/input-relay.py +++ b/input/input-relay.py @@ -31,7 +31,9 @@ gaze_quickcal = the gaze service's one-dot check ("quickcal" to @ft_gazed), sens layout_reset = put the desktop screens back in their saved layout, screens_toggle = hide or show the desktop screens, keyboard_toggle = open or close Frametop's keyboard, float_toggle = float the desktop window under the pointer (else the active one) in VR, or put it back if it floats, dock_all = put every floating -window back (both to ft-floatd, @frametop_float), profile:NAME = switch to that profile (ft-layout +window back (both to ft-floatd, @frametop_float), spin_next and spin_prev = turn every panel in the +room about your head so the next one to the right or left comes to the front (ft-screens' "spin", +Meta+Alt+Tab and Meta+Alt+Shift+Tab by default), profile:NAME = switch to that profile (ft-layout use NAME: its screens and apps; docs/profiles.md), key = pass through as a key, none). Frame controller buttons can be mapped too ("controller_buttons": {"right/a": action} in the @@ -189,12 +191,15 @@ RULES_PATH = os.path.expanduser("~/.config/frametop-input.json") ACTIONS = ("left", "right", "middle", "back", "scroll_up", "scroll_down", "dashboard", "recenter", "pointer_toggle", "follow_toggle", "gaze_toggle", "gaze_precision", "gaze_drag", "gaze_left", "gaze_right", "gaze_quickcal", "sens_up", "sens_down", "layout_reset", "screens_toggle", "keyboard_toggle", "float_toggle", - "dock_all", "key", "none") + "dock_all", "spin_next", "spin_prev", "key", "none") # Gaze mode is a mouse feature: these never come from a controller button (docs/gaze-controllers.md). GAZE_ACTIONS = ("gaze_toggle", "gaze_precision", "gaze_drag", "gaze_left", "gaze_right", "gaze_quickcal") # Key combinations a rules file without "key_bindings" gets: Meta+J and Meta+K click at the gaze -# (free on the Frametop desktop, and apps don't use Meta), Meta+Shift+F floats a window. -DEFAULT_KEY_BINDINGS = {"125+36": "gaze_left", "125+37": "gaze_right", "42+125+33": "float_toggle"} +# (free on the Frametop desktop, and apps don't use Meta), Meta+Shift+F floats a window, and +# Meta+Alt+Tab and Meta+Alt+Shift+Tab spin the panels around you (ft-screens' lazy susan); not +# Meta+Tab, which is Cmd+Tab on a Mac reached through a remote desktop like RustDesk. +DEFAULT_KEY_BINDINGS = {"125+36": "gaze_left", "125+37": "gaze_right", "42+125+33": "float_toggle", + "56+125+15": "spin_next", "42+56+125+15": "spin_prev"} KEY_F24 = 194 # sent to the desktop with a Meta combination (see the top) # Key combinations ("key_bindings"): modifiers, each side's code folded into the left one's. MODIFIERS = {29: 29, 97: 29, 42: 42, 54: 42, 56: 56, 100: 56, 125: 125, 126: 125} @@ -210,6 +215,9 @@ GAZED = "\0ft_gazed" FLOAT = "\0frametop_float" # ft-floatd, floating windows in the Frametop desktop # Actions for ft-floatd ("float_toggle", "dock_all"): they don't need pointer mode. FLOAT_ACTIONS = {"float_toggle": b"float pointer", "dock_all": b"dock all"} +# Actions for ft-screens: spin_next and spin_prev turn every panel in the room about your head, +# so the next one to the right or left comes to the front. They don't need pointer mode either. +SCREENS_ACTIONS = {"spin_next": b"spin next", "spin_prev": b"spin prev"} PROFILE = "profile:" # "profile:NAME": switch to that profile (doesn't need pointer mode either) @@ -218,7 +226,7 @@ def known_action(a): def needs_pointer(a): - return a not in FLOAT_ACTIONS and not a.startswith(PROFILE) + return a not in FLOAT_ACTIONS and a not in SCREENS_ACTIONS and not a.startswith(PROFILE) KEYS = "\0frametop_keys" # keys of keyboards grabbed for the desktop, for other readers FT_LAYOUT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "layout", "ft-layout") DEFAULT_BUTTONS = {BTN_LEFT: "left", BTN_RIGHT: "right", BTN_MIDDLE: "middle", @@ -748,7 +756,7 @@ def main(): def do_action(action, value, now, source="mouse"): """A mapped mouse or controller button, or key combination (pointer mode only, but - for FLOAT_ACTIONS and profiles).""" + for FLOAT_ACTIONS, SCREENS_ACTIONS, and profiles).""" if action == "keyboard_toggle": if value == 1 and vr_keyboard_mode() != "never": vr_keyboard("toggle") @@ -765,6 +773,13 @@ def main(): except OSError: pass # the Frametop desktop isn't running log(action) + elif action in SCREENS_ACTIONS: + if value == 1: + try: + screens_sock.sendto(SCREENS_ACTIONS[action], SCREENS) + except OSError: + pass # the Frametop desktop isn't running + log(action) elif state["pointer"]: state["pointer"].action(action, value, now, source) diff --git a/screens/compositor.c b/screens/compositor.c index f05732c..0aaa2bd 100644 --- a/screens/compositor.c +++ b/screens/compositor.c @@ -294,6 +294,20 @@ static void handle_vr_event(const struct ft_event *e, void *data) { if (e->screen < 0 || e->screen >= MAX_SCREENS || !s->screens[e->screen]) return; struct screen *sc = s->screens[e->screen]; struct wlr_surface *surface = sc->toplevel->base->surface; + if (e->type == FT_FRONT) { + // A spin brought this panel to the front: typing goes to it, as after a click there, + // and ft-floatd makes its window (or the top one on a screen) KWin's active window. + wlr_seat_keyboard_notify_enter(s->seat, surface, NULL, 0, NULL); + s->keys_clicked = true; + char msg[32]; + snprintf(msg, sizeof msg, "front %d", e->screen + 1); + struct sockaddr_un addr = {.sun_family = AF_UNIX}; + const char name[] = "frametop_float"; + memcpy(addr.sun_path + 1, name, sizeof name - 1); + sendto(s->relay_fd, msg, strlen(msg), MSG_DONTWAIT, (struct sockaddr *)&addr, + offsetof(struct sockaddr_un, sun_path) + 1 + sizeof name - 1); + return; + } const uint32_t t = now_ms(); const double x = e->x / s->scale[e->screen], y = e->y / s->scale[e->screen]; // KWin's units switch (e->type) { diff --git a/screens/vr.cpp b/screens/vr.cpp index 53ddc5f..2b0dce7 100644 --- a/screens/vr.cpp +++ b/screens/vr.cpp @@ -894,6 +894,17 @@ void SendFloat(const std::string &msg) { std::printf("to ft-floatd: %s\n", msg.c_str()); } +// To the pointer helper (@ft_pointer_helper), from an unbound socket. +void SendPointer(const std::string &msg) { + static const int fd = socket(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0); + sockaddr_un addr{}; + addr.sun_family = AF_UNIX; + const char name[] = "ft_pointer_helper"; + std::memcpy(addr.sun_path + 1, name, sizeof name - 1); + sendto(fd, msg.data(), msg.size(), MSG_DONTWAIT, reinterpret_cast(&addr), + socklen_t(offsetof(sockaddr_un, sun_path) + 1 + sizeof name - 1)); +} + // Where a device's ray meets the screen's plane, in the screen's x (right) and y (up), // metres from its centre. bool RayOnPlane(const Mat &p, const Mat &d, double *x, double *y) { @@ -1354,6 +1365,137 @@ Screen *Find(int one_based) { return it == g_screens.end() ? nullptr : &it->second; } +// ---------------------------------------------------------------- the lazy susan +// "spin next|prev|": the panels in the room (screens and floating windows, not +// pinned ones) turn together about a vertical axis through your head, so the next panel to +// your right (next) or left (prev) glides to straight ahead, or the ring turns by that many +// degrees (positive turns it left, like next). Their arrangement stays as it is: the room +// turns instead of you. A spin that arrives during one adds to it, from where the panels are +// headed, so quick taps carry on smoothly. Grabbing a panel, or a command that places it, +// takes it out of the spin where it is. The 3D mouse's pointer goes to straight ahead. +constexpr double kSpinSeconds = 0.3; // how long a spin takes +constexpr double kSpinAhead = 8; // degrees: a panel this near straight ahead is the current one +constexpr double kSpinFocus = 30; // degrees: when a spin settles, the panel this near ahead gets typing + +struct Spin { + bool on = false; + double cx = 0, cz = 0; // the axis + double from = 0, to = 0; // radians, turned from the poses in base (positive: to the left) + Clock::time_point start; + std::map base; // index -> its pose before the spin + int front = -1; // settled: this panel came to the front (ft_vr_poll reports it) +} g_spin; + +// p turned a radians about the vertical axis through (cx, cz); positive turns it to the left. +Mat Turned(const Mat &p, double a, double cx, double cz) { + const double c = std::cos(a), s = std::sin(a); + Mat r = Identity(); + r.m[0][0] = float(c), r.m[0][2] = float(s); + r.m[2][0] = float(-s), r.m[2][2] = float(c); + r.m[0][3] = float(cx - c * cx - s * cz); + r.m[2][3] = float(cz + s * cx - c * cz); + return Mul(r, p); +} + +bool Spinnable(const Screen &s) { return s.pinned == kNone && (!s.floating || s.floatOn) && s.drag == Drag::None; } + +double SpinNow() { + if (!g_spin.on) return g_spin.to; + const double t = std::min(1.0, std::chrono::duration(Clock::now() - g_spin.start).count() / kSpinSeconds); + return g_spin.from + (g_spin.to - g_spin.from) * t * t * (3 - 2 * t); +} + +void UpdateSpin() { + if (!g_spin.on) return; + const double a = SpinNow(); + const bool done = Clock::now() - g_spin.start >= std::chrono::duration(kSpinSeconds); + for (auto it = g_spin.base.begin(); it != g_spin.base.end();) { + auto s = g_screens.find(it->first); + if (s == g_screens.end() || !Spinnable(s->second)) { + it = g_spin.base.erase(it); // grabbed, pinned, or gone: it stays where it is now + continue; + } + SetAbsolute(s->second, Turned(it->second, a, g_spin.cx, g_spin.cz)); + ++it; + } + if (done) { + // The panel now nearest straight ahead (of where you face) gets typing and the active window. + Mat head; + double nearest = kSpinFocus; + if (DevicePose(vr::k_unTrackedDeviceIndex_Hmd, &head)) { + for (const auto &[i, p] : g_spin.base) { + const auto it = g_screens.find(i); + Mat q; + if (it == g_screens.end() || !it->second.visible || !ScreenPose(it->second, &q)) continue; + double f[3] = {-head.m[0][2], 0, -head.m[2][2]}; + double d[3] = {q.m[0][3] - head.m[0][3], 0, q.m[2][3] - head.m[2][3]}; + const double fl = std::sqrt(Dot3(f, f)), dl = std::sqrt(Dot3(d, d)); + if (fl < 1e-6 || dl < 1e-6) continue; + const double a = std::acos(std::clamp(Dot3(f, d) / (fl * dl), -1.0, 1.0)) * 180 / M_PI; + if (a < nearest) nearest = a, g_spin.front = i; + } + } + g_spin.on = false; + g_spin.base.clear(); + ArrangeDesktopSoon(); // KWin's outputs follow where the screens are now + } +} + +void SpinCommand(const char *arg, char *reply, int size) { + Mat head; + if (!DevicePose(vr::k_unTrackedDeviceIndex_Hmd, &head)) + return (void)std::snprintf(reply, size, "error no head pose (headset off?)"); + if (g_spin.on) { + g_spin.from = SpinNow(); // carry on from where the panels are now + } else { + g_spin.base.clear(); + for (auto &[i, s] : g_screens) { + Mat p; + if (Spinnable(s) && ScreenPose(s, &p)) g_spin.base[i] = p; + } + g_spin.cx = head.m[0][3], g_spin.cz = head.m[2][3]; + g_spin.from = g_spin.to = 0; + } + if (g_spin.base.empty()) return (void)std::snprintf(reply, size, "error nothing to spin"); + double turn; // degrees, positive to the left + const bool next = !std::strcmp(arg, "next"); + if (next || !std::strcmp(arg, "prev")) { + // Each visible panel's bearing from where you face, to the right positive, as it will + // be when the spin so far ends; the nearest one past straight ahead comes to the front. + double fx = -head.m[0][2], fz = -head.m[2][2]; + const double n = std::sqrt(fx * fx + fz * fz) + 1e-9; + fx /= n, fz /= n; + const double rx = -fz, rz = fx; + double best = 0; + bool found = false; + for (const auto &[i, p] : g_spin.base) { + const auto s = g_screens.find(i); + if (s == g_screens.end() || !s->second.visible) continue; + const Mat q = Turned(p, g_spin.to, g_spin.cx, g_spin.cz); + const double dx = q.m[0][3] - head.m[0][3], dz = q.m[2][3] - head.m[2][3]; + double a = std::atan2(dx * rx + dz * rz, dx * fx + dz * fz) * 180 / M_PI; + if (!next) a = -a; + if (a <= kSpinAhead) a += 360; + if (!found || a < best) best = a, found = true; + } + if (!found || best >= 360 - kSpinAhead) { + if (!g_spin.on) g_spin.base.clear(); + return (void)std::snprintf(reply, size, "ok 0 (no other panel)"); + } + if (best > 180) best -= 360; // the short way round + turn = next ? best : -best; + } else { + char *end; + turn = std::strtod(arg, &end); + if (end == arg || *end) return (void)std::snprintf(reply, size, "error spin next|prev|"); + } + g_spin.to += turn * M_PI / 180; + g_spin.start = Clock::now(); + g_spin.on = true; + SendPointer("recenter"); // the 3D mouse's pointer stays in front of you, on what comes there + std::snprintf(reply, size, "ok %.1f", turn); +} + uint32_t LinuxButton(uint32_t vrButton) { switch (vrButton) { case vr::VRMouseButton_Right: return BTN_RIGHT; @@ -1887,6 +2029,14 @@ void ft_vr_poll(void (*handle)(const struct ft_event *, void *), void *data) { handle(&e, data); } ++g_tick; + UpdateSpin(); + if (g_spin.front >= 0) { + ft_event e{}; + e.type = FT_FRONT; + e.screen = g_spin.front; + g_spin.front = -1; + handle(&e, data); + } UpdateGame(); UpdateArrange(); UpdateVisibility(); @@ -1959,6 +2109,8 @@ void ft_vr_keyboard_hide(void) { // ~100 ms (it landed on something else), KWin gets it anyway // state -> "ok // " +// spin next|prev| turn every panel in the room about your head (see the lazy +// susan) -> "ok " // cutouts on|off|state hand cutouts (see handcut.h) -> "ok // ms, predict lead ms" // cutouts predict on|off move the hands ahead along their velocity (on by default) @@ -1996,6 +2148,7 @@ void ft_vr_command(const char *cmd, char *reply, int size) { Screen *s = Find(n); if (!s) return (void)std::snprintf(reply, size, "error no screen %d", n); EndDrag(*s); + g_spin.base.erase(n - 1); SetAbsolute(*s, PanelPose(x, y, z, yaw, pitch, roll)); std::snprintf(reply, size, "ok"); } else if (std::sscanf(cmd, "width %d %lf", &n, &w) == 2) { @@ -2151,6 +2304,7 @@ void ft_vr_command(const char *cmd, char *reply, int size) { Mat m{}; for (int k = 0; k < 12; ++k) m.m[k / 4][k % 4] = r[k]; EndDrag(*s); + g_spin.base.erase(n - 1); SetAbsolute(*s, m); std::snprintf(reply, size, "ok"); } else if (int k0; std::sscanf(cmd, "sub %d %d %d %d %d %d", &n, &k0, &x0, &y0, &w0, &h0) == 6 || @@ -2178,6 +2332,8 @@ void ft_vr_command(const char *cmd, char *reply, int size) { if ((g_press.buttons & ButtonBit(BTN_LEFT)) && g_press.device != kNone && !IsHandController(g_press.device)) g_press.upAt = g_tick + 9; std::snprintf(reply, size, "ok"); + } else if (std::sscanf(cmd, "spin %15s", word) == 1) { + SpinCommand(word, reply, size); } else if (std::strncmp(cmd, "state", 5) == 0) { std::snprintf(reply, size, "ok %s %d %.0f %s %.0f %s %d %s", ModeName(), g_manual ? 1 : 0, g_wristAngle, g_gestureHand.c_str(), g_gestureAngle, LasersName(), g_gameRunning ? 1 : 0, diff --git a/screens/vr.h b/screens/vr.h index eb7abf8..d925f05 100644 --- a/screens/vr.h +++ b/screens/vr.h @@ -17,7 +17,8 @@ struct ft_dmabuf { int fd[4]; }; -enum ft_event_type { FT_MOTION, FT_BUTTON, FT_SCROLL, FT_LEAVE, FT_QUIT, FT_KEY, FT_KEYBOARD_CLOSED }; +// FT_FRONT: a spin (the lazy susan) brought panel `screen` to straight ahead: typing goes there. +enum ft_event_type { FT_MOTION, FT_BUTTON, FT_SCROLL, FT_LEAVE, FT_QUIT, FT_KEY, FT_KEYBOARD_CLOSED, FT_FRONT }; struct ft_event { enum ft_event_type type; From 9a4b66ff509e3b04f1573545bd84949f3a1d186e Mon Sep 17 00:00:00 2001 From: DeeJanuz <45082401+DeeJanuz@users.noreply.github.com> Date: Sun, 4 Oct 2026 08:36:33 -0600 Subject: [PATCH 5/5] keys-test: the spin bindings (Meta+Alt+Tab, Meta+Alt+Shift+Tab), not while paused Co-Authored-By: Claude Opus 5.5 --- input/test/keys-test.py | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/input/test/keys-test.py b/input/test/keys-test.py index 9fac4d1..f7b807f 100755 --- a/input/test/keys-test.py +++ b/input/test/keys-test.py @@ -206,7 +206,7 @@ def check(label, got, want): failures.append(label) -META, RMETA, SHIFT, CTRL, RCTRL, A, F, J, P = 125, 126, 42, 29, 97, 30, 33, 36, 25 +META, RMETA, SHIFT, CTRL, RCTRL, ALT, A, F, J, P, TAB = 125, 126, 42, 29, 97, 56, 30, 33, 36, 25, 15 F24 = ["key 194 1", "key 194 0"] @@ -265,6 +265,20 @@ def tests(): key(META, 1); key(J, 1); key(J, 0); key(META, 0) check("resumed: Meta+J is a combination again", typed(), ["key 125 1"] + F24 + ["key 125 0"]) + use(None) # the defaults: Meta+Alt+Tab and Meta+Alt+Shift+Tab spin the panels (ft-screens) + key(META, 1); key(ALT, 1); key(TAB, 1); key(TAB, 0); key(ALT, 0); key(META, 0) + got = typed() + check("Meta+Alt+Tab (default): spin next", [m for m in got if m.startswith("spin")], ["spin next"]) + check("Meta+Alt+Tab: Tab isn't typed", [m for m in got if m.startswith("key 15 ")], []) + key(META, 1); key(ALT, 1); key(SHIFT, 1); key(TAB, 1); key(TAB, 0); key(SHIFT, 0); key(ALT, 0); key(META, 0) + check("Meta+Alt+Shift+Tab (default): spin prev", [m for m in typed() if m.startswith("spin")], ["spin prev"]) + pause("on") + key(META, 1); key(ALT, 1); key(TAB, 1); key(TAB, 0); key(ALT, 0); key(META, 0) + check("paused: Meta+Alt+Tab doesn't spin", [m for m in typed() if m.startswith("spin")], []) + pause("off") + check("spinning works without pointer mode", (relay.needs_pointer("spin_next"), relay.needs_pointer("spin_prev")), + (False, False)) + check("an empty command isn't an action", relay.known_action("command: "), False) check("steam_menu, pause_toggle and commands work without pointer mode", (relay.needs_pointer("steam_menu"), relay.needs_pointer("pause_toggle"), relay.needs_pointer("command:ls")),