107 lines
4.0 KiB
Python
Executable File
107 lines
4.0 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""Focus/move-window to the monitor spatially adjacent to the currently focused one,
|
|
in a literal screen direction (left/right/up/down) — unlike Hyprland's native
|
|
`focusmonitor -1/+1` / `movewindow mon:-1/+1`, which cycle through Hyprland's internal
|
|
monitor list *order* (roughly connection/config order), not actual position.
|
|
|
|
That distinction matters once a monitor is rotated: a 90°/270° `transform` swaps a
|
|
monitor's *logical* width/height (see monitor-manager's `logical_width`/`logical_height`,
|
|
the same math reused here), but doesn't reorder Hyprland's monitor list. On a 3-wide
|
|
desk (e.g. a portrait-rotated monitor sitting to the right of a large landscape main
|
|
one), that can make "-1/+1" jump correctly one way and land on the wrong monitor (or a
|
|
no-op) the other way, because the list order and the physical left-to-right order have
|
|
silently diverged. This instead sorts monitors by their actual logical bounding-box
|
|
center each time, so "next"/"prev" always means the next monitor to the right/left (or
|
|
below/above) on screen, regardless of transform or connection order.
|
|
|
|
Usage:
|
|
monitor-adjacent focus l|r|u|d
|
|
monitor-adjacent move l|r|u|d
|
|
|
|
Silently does nothing if there's only one monitor, no monitor is focused, or there's no
|
|
monitor further in that direction (no wrap-around at the ends — see the note in
|
|
_pick_target for why).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import subprocess
|
|
import sys
|
|
|
|
AXIS = {"l": ("x", -1), "r": ("x", 1), "u": ("y", -1), "d": ("y", 1)}
|
|
|
|
|
|
def hypr_json(*args):
|
|
try:
|
|
return json.loads(subprocess.check_output(["hyprctl", *args, "-j"]))
|
|
except (subprocess.CalledProcessError, json.JSONDecodeError, FileNotFoundError):
|
|
return None
|
|
|
|
|
|
def _logical_size(m: dict) -> tuple[float, float]:
|
|
scale = m.get("scale") or 1.0
|
|
w, h = m.get("width", 0), m.get("height", 0)
|
|
if (m.get("transform", 0) & 3) in (1, 3):
|
|
w, h = h, w
|
|
return w / scale, h / scale
|
|
|
|
|
|
def _center(m: dict) -> tuple[float, float]:
|
|
w, h = _logical_size(m)
|
|
return m.get("x", 0) + w / 2, m.get("y", 0) + h / 2
|
|
|
|
|
|
def _pick_target(monitors: list[dict], current: dict, axis: str, sign: int) -> dict | None:
|
|
cur_c = _center(current)
|
|
idx_c = 0 if axis == "x" else 1
|
|
# Candidates strictly on the requested side of the current monitor's center.
|
|
candidates = []
|
|
for m in monitors:
|
|
if m is current:
|
|
continue
|
|
c = _center(m)
|
|
delta = (c[idx_c] - cur_c[idx_c]) * sign
|
|
if delta > 1: # >1 logical px: ignore near-exact ties/float noise
|
|
candidates.append((delta, m))
|
|
if not candidates:
|
|
# No wrap-around: at the physical edge of the desk, hjkl-style directional
|
|
# movement should just stop, the same way it does within a single monitor's
|
|
# windows. (Unlike Hyprland's index-based -1/+1, which does wrap — if you want
|
|
# that cyclic behaviour, that's what the explicit Super+,/. binds are for.)
|
|
return None
|
|
candidates.sort(key=lambda t: t[0]) # closest first
|
|
return candidates[0][1]
|
|
|
|
|
|
def main() -> int:
|
|
if len(sys.argv) != 3 or sys.argv[1] not in ("focus", "move") or sys.argv[2] not in AXIS:
|
|
print(__doc__)
|
|
return 2
|
|
kind, key = sys.argv[1], sys.argv[2]
|
|
axis, sign = AXIS[key]
|
|
|
|
monitors = hypr_json("monitors")
|
|
if not monitors or len(monitors) < 2:
|
|
return 0
|
|
current = next((m for m in monitors if m.get("focused")), None)
|
|
if current is None:
|
|
return 0
|
|
|
|
target = _pick_target(monitors, current, axis, sign)
|
|
if target is None:
|
|
return 0
|
|
|
|
name = target["name"]
|
|
if kind == "focus":
|
|
subprocess.run(["hyprctl", "dispatch", "focusmonitor", name],
|
|
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
|
else:
|
|
subprocess.run(["hyprctl", "dispatch", "movewindow", f"mon:{name}"],
|
|
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|