850 lines
31 KiB
Python
Executable File
850 lines
31 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
Hyprland monitor manager — WYSIWYG curses TUI.
|
|
|
|
Keys (normal mode):
|
|
Tab / Shift+Tab cycle selected monitor
|
|
h j k l move monitor (50 px)
|
|
H J K L move monitor (10 px fine)
|
|
u / i rotate CCW / CW
|
|
t / g scale up / scale down (valid Hyprland steps)
|
|
m toggle mirror (pick target) / un-mirror
|
|
n / N cycle display mode forward / backward
|
|
s save to hypr/usr/monitors.lua
|
|
Enter save & quit
|
|
q / Esc quit (prompts if unsaved changes)
|
|
|
|
Mirror-pick mode:
|
|
Tab / Shift+Tab cycle target
|
|
Enter confirm
|
|
Esc cancel
|
|
"""
|
|
|
|
import curses
|
|
import json
|
|
import math
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
from dataclasses import dataclass, field
|
|
from pathlib import Path
|
|
from typing import List, Optional
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Constants
|
|
# ---------------------------------------------------------------------------
|
|
|
|
# The live config Hyprland actually loads (hyprland.lua does `require("usr.monitors")`,
|
|
# which resolves to ~/.config/hypr/usr/monitors.lua). Writing here means `hyprctl
|
|
# reload` applies the layout immediately. The Dotfiles repo copy is the deploy
|
|
# source and is intentionally NOT written by this tool.
|
|
MONITORS_LUA = Path.home() / ".config/hypr/usr/monitors.lua"
|
|
MOVE_STEP = 50
|
|
MOVE_STEP_FINE = 10
|
|
MIN_SCALE = 0.25
|
|
MAX_SCALE = 4.0
|
|
_SCALE_MAX_DENOM = 6 # max denominator when enumerating valid Hyprland scales
|
|
MIN_BOX_W = 14
|
|
MIN_BOX_H = 4
|
|
INFO_W = 32
|
|
STATUS_ROWS = 2 # status + help rows at the bottom
|
|
MAX_RESOLVE_ITERS = 8 # auto-resolve nudges before giving up
|
|
|
|
TRANSFORM_LABEL = {
|
|
0: "↕ 0°",
|
|
1: "↻ 90°",
|
|
2: "↕ 180°",
|
|
3: "↺ 90°",
|
|
4: "⇔ 0°",
|
|
5: "⇔↻ 90°",
|
|
6: "⇔ 180°",
|
|
7: "⇔↺ 90°",
|
|
}
|
|
|
|
_MODE_RE = re.compile(r"(\d+)x(\d+)@([\d.]+)Hz")
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Rotation helpers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def rotate_cw(t: int) -> int:
|
|
return (t & 4) | ((t + 1) & 3)
|
|
|
|
def rotate_ccw(t: int) -> int:
|
|
return (t & 4) | ((t - 1) & 3)
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Scale helpers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def valid_scales(width: int, height: int) -> List[float]:
|
|
"""Return sorted list of scales valid for (width, height).
|
|
|
|
A scale s = p/q (in lowest terms) is valid iff both width/s and height/s
|
|
are integers, i.e. p divides gcd(width, height). We limit q ≤
|
|
_SCALE_MAX_DENOM to keep the step count practical (~20 steps per monitor).
|
|
"""
|
|
g = math.gcd(width, height)
|
|
divisors = [k for k in range(1, g + 1) if g % k == 0]
|
|
result: set = set()
|
|
for p in divisors:
|
|
for q in range(1, _SCALE_MAX_DENOM + 1):
|
|
if math.gcd(p, q) != 1:
|
|
continue
|
|
s = p / q
|
|
if MIN_SCALE <= s <= MAX_SCALE:
|
|
result.add(round(s, 10))
|
|
return sorted(result)
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Data model
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@dataclass
|
|
class MonitorState:
|
|
name: str
|
|
x: int
|
|
y: int
|
|
width: int
|
|
height: int
|
|
refresh_rate: float
|
|
transform: int
|
|
scale: float
|
|
mirror_of: str
|
|
available_modes: List[str]
|
|
mode_index: int
|
|
dirty: bool = False
|
|
|
|
@property
|
|
def logical_width(self) -> int:
|
|
if (self.transform & 3) in (1, 3):
|
|
return round(self.height / self.scale)
|
|
return round(self.width / self.scale)
|
|
|
|
@property
|
|
def logical_height(self) -> int:
|
|
if (self.transform & 3) in (1, 3):
|
|
return round(self.width / self.scale)
|
|
return round(self.height / self.scale)
|
|
|
|
@property
|
|
def mode_str(self) -> str:
|
|
return f"{self.width}x{self.height}@{int(round(self.refresh_rate))}"
|
|
|
|
@classmethod
|
|
def from_json(cls, d: dict) -> "MonitorState":
|
|
modes = d.get("availableModes", [])
|
|
w = d.get("width", 1920)
|
|
h = d.get("height", 1080)
|
|
rr = d.get("refreshRate", 60.0)
|
|
# Find current mode index
|
|
mode_index = 0
|
|
for i, m in enumerate(modes):
|
|
mo = _MODE_RE.match(m)
|
|
if mo and int(mo.group(1)) == w and int(mo.group(2)) == h:
|
|
if abs(float(mo.group(3)) - rr) < 1.0:
|
|
mode_index = i
|
|
break
|
|
return cls(
|
|
name=d.get("name", ""),
|
|
x=d.get("x", 0),
|
|
y=d.get("y", 0),
|
|
width=w,
|
|
height=h,
|
|
refresh_rate=rr,
|
|
transform=d.get("transform", 0),
|
|
scale=d.get("scale", 1.0),
|
|
mirror_of="" if d.get("mirrorOf", "none") in ("none", "") else d["mirrorOf"],
|
|
available_modes=modes,
|
|
mode_index=mode_index,
|
|
)
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# hyprctl helpers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def fetch_monitors() -> List[MonitorState]:
|
|
r = subprocess.run(
|
|
["hyprctl", "monitors", "-j"],
|
|
capture_output=True, text=True, check=True,
|
|
)
|
|
return [MonitorState.from_json(d) for d in json.loads(r.stdout)]
|
|
|
|
|
|
def apply_monitor(m: MonitorState) -> Optional[str]:
|
|
if m.mirror_of:
|
|
lua = f"hl.monitor({{output='{m.name}', mirror='{m.mirror_of}'}})"
|
|
else:
|
|
lua = (
|
|
f"hl.monitor({{"
|
|
f"output='{m.name}', "
|
|
f"mode='{m.mode_str}', "
|
|
f"position='{m.x}x{m.y}', "
|
|
f"scale={m.scale}, "
|
|
f"transform={m.transform}"
|
|
f"}})"
|
|
)
|
|
r = subprocess.run(["hyprctl", "eval", lua], capture_output=True, text=True, check=False)
|
|
if r.returncode != 0:
|
|
return (r.stderr or r.stdout).strip()
|
|
return None
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Overlap geometry
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _logical_rect(m: "MonitorState"):
|
|
return (m.x, m.y, m.x + m.logical_width, m.y + m.logical_height)
|
|
|
|
|
|
def _overlap_px(a, b):
|
|
"""Return (ox, oy) — overlapping width/height of two (x0,y0,x1,y1) rects."""
|
|
ox = max(0, min(a[2], b[2]) - max(a[0], b[0]))
|
|
oy = max(0, min(a[3], b[3]) - max(a[1], b[1]))
|
|
return ox, oy
|
|
|
|
|
|
def find_overlaps(monitors: List["MonitorState"]):
|
|
"""Return list of (name_a, name_b, ox, oy) for every overlapping pair.
|
|
|
|
Mirrored outputs are excluded — they intentionally share their target's
|
|
region and don't occupy independent layout space.
|
|
"""
|
|
active = [m for m in monitors if not m.mirror_of]
|
|
out = []
|
|
for i in range(len(active)):
|
|
for j in range(i + 1, len(active)):
|
|
ox, oy = _overlap_px(_logical_rect(active[i]), _logical_rect(active[j]))
|
|
if ox > 0 and oy > 0:
|
|
out.append((active[i].name, active[j].name, ox, oy))
|
|
return out
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Save
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def save_monitors_lua(monitors: List[MonitorState], path: Path) -> None:
|
|
lines = ["-- generated by monitor-manager -- do not edit by hand\n"]
|
|
for m in monitors:
|
|
if m.mirror_of:
|
|
lines.append(
|
|
f'hl.monitor({{\n'
|
|
f' output = "{m.name}",\n'
|
|
f' mirror = "{m.mirror_of}",\n'
|
|
f'}})\n\n'
|
|
)
|
|
else:
|
|
lines.append(
|
|
f'hl.monitor({{\n'
|
|
f' output = "{m.name}",\n'
|
|
f' mode = "{m.mode_str}",\n'
|
|
f' position = "{m.x}x{m.y}",\n'
|
|
f' scale = {m.scale},\n'
|
|
f' transform = {m.transform},\n'
|
|
f'}})\n\n'
|
|
)
|
|
lines.append(
|
|
'hl.config({\n'
|
|
' xwayland = {\n'
|
|
' force_zero_scaling = true,\n'
|
|
' },\n'
|
|
'})\n'
|
|
)
|
|
tmp = path.with_suffix(".lua.tmp")
|
|
tmp.write_text("".join(lines))
|
|
os.replace(tmp, path)
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Canvas math
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def compute_scale(monitors: List[MonitorState], pane_cols: int, pane_rows: int) -> float:
|
|
if not monitors:
|
|
return 1.0
|
|
max_x = max(m.x + m.logical_width for m in monitors)
|
|
max_y = max(m.y + m.logical_height for m in monitors)
|
|
if max_x <= 0 or max_y <= 0:
|
|
return 1.0
|
|
sx = pane_cols / (max_x * 1.15)
|
|
sy = pane_rows / (max_y * 1.15)
|
|
return min(sx, sy)
|
|
|
|
|
|
def to_screen(cx: int, cy: int, scale: float, margin_col: int = 1, margin_row: int = 1):
|
|
col = margin_col + int(cx * scale)
|
|
row = margin_row + int(cy * scale * 0.5)
|
|
return row, col
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Safe addstr / addch wrappers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def safe_addstr(win, row, col, text, attr=0):
|
|
try:
|
|
max_row, max_col = win.getmaxyx()
|
|
if row < 0 or row >= max_row or col < 0 or col >= max_col:
|
|
return
|
|
avail = max_col - col - 1
|
|
if avail <= 0:
|
|
return
|
|
win.addstr(row, col, text[:avail], attr)
|
|
except curses.error:
|
|
pass
|
|
|
|
|
|
def safe_addch(win, row, col, ch, attr=0):
|
|
try:
|
|
max_row, max_col = win.getmaxyx()
|
|
if row < 0 or row >= max_row or col < 0 or col >= max_col:
|
|
return
|
|
win.addch(row, col, ch, attr)
|
|
except curses.error:
|
|
pass
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Box drawing
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def draw_box(win, row, col, h, w, attr=0):
|
|
if h < 2 or w < 2:
|
|
return
|
|
safe_addch(win, row, col, "┌", attr)
|
|
safe_addch(win, row, col + w-1, "┐", attr)
|
|
safe_addch(win, row + h-1, col, "└", attr)
|
|
safe_addch(win, row + h-1, col + w-1, "┘", attr)
|
|
for c in range(col + 1, col + w - 1):
|
|
safe_addch(win, row, c, "─", attr)
|
|
safe_addch(win, row + h-1, c, "─", attr)
|
|
for r in range(row + 1, row + h - 1):
|
|
safe_addch(win, r, col, "│", attr)
|
|
safe_addch(win, r, col + w-1, "│", attr)
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# App
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class App:
|
|
def __init__(self, stdscr):
|
|
self.stdscr = stdscr
|
|
self.monitors: List[MonitorState] = []
|
|
self.selected_idx: int = 0
|
|
self.mode: str = "normal" # "normal" | "mirror_pick"
|
|
self.mirror_source_idx: int = 0
|
|
self.mirror_target_idx: int = 1
|
|
self.dirty: bool = False
|
|
self.status_msg: str = ""
|
|
self._scale: float = 0.0 # cached canvas scale
|
|
self._scale_pane: tuple = (0, 0) # pane size used for cached scale
|
|
self._load_monitors()
|
|
self._init_colors()
|
|
|
|
def _load_monitors(self):
|
|
self.monitors = fetch_monitors()
|
|
if self.selected_idx >= len(self.monitors):
|
|
self.selected_idx = 0
|
|
|
|
def _init_colors(self):
|
|
curses.start_color()
|
|
curses.use_default_colors()
|
|
# 1 = selected (cyan bold)
|
|
curses.init_pair(1, curses.COLOR_CYAN, -1)
|
|
# 2 = normal (white)
|
|
curses.init_pair(2, curses.COLOR_WHITE, -1)
|
|
# 3 = mirror target (yellow)
|
|
curses.init_pair(3, curses.COLOR_YELLOW, -1)
|
|
# 4 = mirrored / dim
|
|
curses.init_pair(4, curses.COLOR_BLACK + 8 if curses.COLORS >= 16 else curses.COLOR_WHITE, -1)
|
|
# 5 = status bar (reversed)
|
|
curses.init_pair(5, -1, -1)
|
|
# 6 = help (green)
|
|
curses.init_pair(6, curses.COLOR_GREEN, -1)
|
|
|
|
def _get_scale(self, pane_cols: int, pane_rows: int) -> float:
|
|
"""Return cached scale; recompute only on resize or when a monitor escapes the viewport."""
|
|
pane = (pane_cols, pane_rows)
|
|
if self._scale > 0 and self._scale_pane == pane:
|
|
# Check every monitor still fits inside the current viewport
|
|
inner_cols = pane_cols - 2
|
|
inner_rows = pane_rows - 2
|
|
all_fit = True
|
|
for m in self.monitors:
|
|
brow, bcol = to_screen(m.x + m.logical_width, m.y + m.logical_height, self._scale)
|
|
if bcol > inner_cols or brow > inner_rows:
|
|
all_fit = False
|
|
break
|
|
if all_fit:
|
|
return self._scale
|
|
self._scale = compute_scale(self.monitors, pane_cols - 2, pane_rows - 2)
|
|
self._scale_pane = pane
|
|
return self._scale
|
|
|
|
# -----------------------------------------------------------------------
|
|
# Event loop
|
|
# -----------------------------------------------------------------------
|
|
|
|
def run(self):
|
|
curses.curs_set(0)
|
|
self.stdscr.timeout(100)
|
|
self.draw()
|
|
while True:
|
|
ch = self.stdscr.getch()
|
|
if ch == curses.KEY_RESIZE:
|
|
self._scale_pane = (0, 0) # force scale recompute on resize
|
|
self.draw()
|
|
continue
|
|
if ch == -1:
|
|
continue
|
|
if self.mode == "normal":
|
|
result = self.handle_key_normal(ch)
|
|
if result == "quit":
|
|
break
|
|
elif self.mode == "mirror_pick":
|
|
self.handle_key_mirror(ch)
|
|
self.draw()
|
|
|
|
# -----------------------------------------------------------------------
|
|
# Key handlers
|
|
# -----------------------------------------------------------------------
|
|
|
|
def handle_key_normal(self, ch) -> Optional[str]:
|
|
mon = self.monitors[self.selected_idx] if self.monitors else None
|
|
|
|
# Tab / Shift+Tab — cycle monitor
|
|
if ch == ord("\t"):
|
|
self.selected_idx = (self.selected_idx + 1) % max(1, len(self.monitors))
|
|
return
|
|
if ch == curses.KEY_BTAB:
|
|
self.selected_idx = (self.selected_idx - 1) % max(1, len(self.monitors))
|
|
return
|
|
|
|
if mon is None:
|
|
return
|
|
|
|
# Movement — coarse
|
|
if ch == ord("h"):
|
|
self.move_monitor(-MOVE_STEP, 0)
|
|
elif ch == ord("l"):
|
|
self.move_monitor(MOVE_STEP, 0)
|
|
elif ch == ord("k"):
|
|
self.move_monitor(0, -MOVE_STEP)
|
|
elif ch == ord("j"):
|
|
self.move_monitor(0, MOVE_STEP)
|
|
# Movement — fine
|
|
elif ch == ord("H"):
|
|
self.move_monitor(-MOVE_STEP_FINE, 0)
|
|
elif ch == ord("L"):
|
|
self.move_monitor(MOVE_STEP_FINE, 0)
|
|
elif ch == ord("K"):
|
|
self.move_monitor(0, -MOVE_STEP_FINE)
|
|
elif ch == ord("J"):
|
|
self.move_monitor(0, MOVE_STEP_FINE)
|
|
# Rotation
|
|
elif ch == ord("u"):
|
|
self.rotate_monitor(-1)
|
|
elif ch == ord("i"):
|
|
self.rotate_monitor(+1)
|
|
# Scale
|
|
elif ch == ord("t"):
|
|
self.scale_monitor(+1)
|
|
elif ch == ord("g"):
|
|
self.scale_monitor(-1)
|
|
# Mirror
|
|
elif ch == ord("m"):
|
|
if mon.mirror_of:
|
|
mon.mirror_of = ""
|
|
self._apply_and_status(mon, f"Un-mirrored {mon.name}")
|
|
elif len(self.monitors) < 2:
|
|
self.status_msg = "Need 2+ monitors to mirror"
|
|
else:
|
|
self.mirror_source_idx = self.selected_idx
|
|
self.mirror_target_idx = (self.selected_idx + 1) % len(self.monitors)
|
|
self.mode = "mirror_pick"
|
|
# Mode cycling
|
|
elif ch == ord("n"):
|
|
self.cycle_mode(+1)
|
|
elif ch == ord("N"):
|
|
self.cycle_mode(-1)
|
|
# Save
|
|
elif ch == ord("s"):
|
|
self._save()
|
|
# Save & quit
|
|
elif ch in (curses.KEY_ENTER, ord("\n"), ord("\r")):
|
|
self._save()
|
|
return "quit"
|
|
# Quit
|
|
elif ch in (ord("q"), 27): # q or Esc
|
|
if self.dirty:
|
|
action = self.prompt_save_quit()
|
|
if action == "cancel":
|
|
return None
|
|
if action == "save":
|
|
self._save()
|
|
return "quit"
|
|
|
|
def handle_key_mirror(self, ch):
|
|
n = len(self.monitors)
|
|
|
|
def next_target(delta: int):
|
|
t = (self.mirror_target_idx + delta) % n
|
|
# skip source
|
|
if t == self.mirror_source_idx:
|
|
t = (t + delta) % n
|
|
self.mirror_target_idx = t
|
|
|
|
if ch == ord("\t"):
|
|
next_target(+1)
|
|
elif ch == curses.KEY_BTAB:
|
|
next_target(-1)
|
|
elif ch in (curses.KEY_ENTER, ord("\n"), ord("\r")):
|
|
self.set_mirror(self.mirror_source_idx, self.mirror_target_idx)
|
|
self.mode = "normal"
|
|
elif ch == 27: # Esc
|
|
self.mode = "normal"
|
|
self.status_msg = "Mirror cancelled"
|
|
|
|
# -----------------------------------------------------------------------
|
|
# Actions
|
|
# -----------------------------------------------------------------------
|
|
|
|
def _live_overlap_warning(self) -> Optional[str]:
|
|
"""Re-fetch live monitor positions and report any actual overlap.
|
|
|
|
Hyprland re-snaps fractionally-scaled/rotated outputs at apply time, so
|
|
the positions it ends up with can differ from what this TUI set. Only a
|
|
check against the live state catches snap-induced collisions.
|
|
"""
|
|
try:
|
|
ov = find_overlaps(fetch_monitors())
|
|
except Exception:
|
|
return None
|
|
if not ov:
|
|
return None
|
|
a, b, ox, _ = ov[0]
|
|
extra = f" (+{len(ov) - 1} more)" if len(ov) > 1 else ""
|
|
return f"{a} overlaps {b} by {ox}px{extra}"
|
|
|
|
def _auto_resolve(self, mon: MonitorState) -> bool:
|
|
"""Nudge `mon` until its *live* rectangle no longer overlaps a neighbor.
|
|
|
|
Hyprland may snap a fractionally-scaled/rotated output to a position
|
|
that collides with its neighbor. We can't predict the snap, so we read
|
|
the live layout, push `mon` by the minimal grid-aligned translation that
|
|
would separate it from its worst overlapper, re-apply, and repeat. Only
|
|
`mon` moves; other monitors are left where the user put them. Returns
|
|
True if any adjustment was made.
|
|
"""
|
|
if mon.mirror_of:
|
|
return False
|
|
moved = False
|
|
for _ in range(MAX_RESOLVE_ITERS):
|
|
try:
|
|
live = fetch_monitors()
|
|
except Exception:
|
|
break
|
|
me = next((lm for lm in live if lm.name == mon.name), None)
|
|
if me is None or me.mirror_of:
|
|
break
|
|
a = _logical_rect(me)
|
|
worst = None # (overlap_area, neighbor_rect)
|
|
for o in live:
|
|
if o.name == mon.name or o.mirror_of:
|
|
continue
|
|
ox, oy = _overlap_px(a, _logical_rect(o))
|
|
if ox > 0 and oy > 0 and (worst is None or ox * oy > worst[0]):
|
|
worst = (ox * oy, _logical_rect(o))
|
|
if worst is None:
|
|
break # no overlap left — resolved
|
|
b = worst[1]
|
|
# Minimal separating translation of `mon` along either axis.
|
|
axis, delta = min(
|
|
(("x", b[2] - a[0]), ("x", b[0] - a[2]),
|
|
("y", b[3] - a[1]), ("y", b[1] - a[3])),
|
|
key=lambda c: abs(c[1]),
|
|
)
|
|
# Round magnitude up to the grid so the next snap keeps a margin.
|
|
step = MOVE_STEP_FINE
|
|
mag = ((abs(delta) + step - 1) // step) * step
|
|
delta = mag if delta > 0 else -mag
|
|
if axis == "x":
|
|
mon.x = max(0, mon.x + delta)
|
|
else:
|
|
mon.y = max(0, mon.y + delta)
|
|
if apply_monitor(mon):
|
|
break
|
|
moved = True
|
|
return moved
|
|
|
|
def _apply_and_status(self, mon: MonitorState, success_msg: str):
|
|
"""Apply a monitor, mark dirty, auto-resolve snap overlap, set status."""
|
|
err = apply_monitor(mon)
|
|
mon.dirty = True
|
|
self.dirty = True
|
|
if err:
|
|
self.status_msg = err
|
|
return
|
|
resolved = self._auto_resolve(mon)
|
|
warn = self._live_overlap_warning()
|
|
if warn:
|
|
self.status_msg = f"{success_msg} ⚠ {warn}"
|
|
elif resolved:
|
|
self.status_msg = f"{success_msg} (auto-resolved → {mon.x},{mon.y})"
|
|
else:
|
|
self.status_msg = success_msg
|
|
|
|
def _would_overlap(self, idx: int) -> Optional[str]:
|
|
"""Name of the first monitor that monitor `idx` overlaps (TUI coords)."""
|
|
mon = self.monitors[idx]
|
|
if mon.mirror_of:
|
|
return None
|
|
a = _logical_rect(mon)
|
|
for j, other in enumerate(self.monitors):
|
|
if j == idx or other.mirror_of:
|
|
continue
|
|
ox, oy = _overlap_px(a, _logical_rect(other))
|
|
if ox > 0 and oy > 0:
|
|
return other.name
|
|
return None
|
|
|
|
def move_monitor(self, dx: int, dy: int):
|
|
mon = self.monitors[self.selected_idx]
|
|
# Snap to a round grid so positions stay multiples of MOVE_STEP_FINE.
|
|
# The seed comes from hyprctl, which may report a snapped value (e.g.
|
|
# a fractionally-scaled/rotated monitor), so raw addition would freeze
|
|
# the last digit. Rounding normalizes any odd seed on the first move.
|
|
base = MOVE_STEP_FINE
|
|
old_x, old_y = mon.x, mon.y
|
|
mon.x = max(0, round((mon.x + dx) / base) * base)
|
|
mon.y = max(0, round((mon.y + dy) / base) * base)
|
|
# Block moves that would drive this monitor into another (TUI coords).
|
|
clash = self._would_overlap(self.selected_idx)
|
|
if clash:
|
|
mon.x, mon.y = old_x, old_y
|
|
self.status_msg = f"Blocked: {mon.name} would overlap {clash}"
|
|
return
|
|
self._apply_and_status(mon, f"Moved {mon.name} to {mon.x},{mon.y}")
|
|
|
|
def rotate_monitor(self, direction: int):
|
|
mon = self.monitors[self.selected_idx]
|
|
if direction > 0:
|
|
mon.transform = rotate_cw(mon.transform)
|
|
else:
|
|
mon.transform = rotate_ccw(mon.transform)
|
|
self._apply_and_status(mon, f"Rotated {mon.name} → {TRANSFORM_LABEL[mon.transform]}")
|
|
|
|
def scale_monitor(self, direction: int):
|
|
mon = self.monitors[self.selected_idx]
|
|
scales = valid_scales(mon.width, mon.height)
|
|
cur = round(mon.scale, 10)
|
|
if direction > 0:
|
|
candidates = [s for s in scales if s > cur + 1e-9]
|
|
if not candidates:
|
|
self.status_msg = f"Scale already at max ({mon.scale}x)"
|
|
return
|
|
new_scale = candidates[0]
|
|
else:
|
|
candidates = [s for s in scales if s < cur - 1e-9]
|
|
if not candidates:
|
|
self.status_msg = f"Scale already at min ({mon.scale}x)"
|
|
return
|
|
new_scale = candidates[-1]
|
|
mon.scale = new_scale
|
|
self._apply_and_status(mon, f"{mon.name} scale → {new_scale}x")
|
|
|
|
def cycle_mode(self, delta: int):
|
|
mon = self.monitors[self.selected_idx]
|
|
if not mon.available_modes:
|
|
self.status_msg = "No mode list available"
|
|
return
|
|
mon.mode_index = (mon.mode_index + delta) % len(mon.available_modes)
|
|
mo = _MODE_RE.match(mon.available_modes[mon.mode_index])
|
|
if mo:
|
|
mon.width = int(mo.group(1))
|
|
mon.height = int(mo.group(2))
|
|
mon.refresh_rate = float(mo.group(3))
|
|
self._apply_and_status(mon, f"{mon.name} → {mon.mode_str}")
|
|
|
|
def set_mirror(self, src_idx: int, tgt_idx: int):
|
|
src = self.monitors[src_idx]
|
|
tgt = self.monitors[tgt_idx]
|
|
src.mirror_of = tgt.name
|
|
self._apply_and_status(src, f"Mirroring {src.name} → {tgt.name}")
|
|
|
|
def _save(self):
|
|
try:
|
|
save_monitors_lua(self.monitors, MONITORS_LUA)
|
|
for m in self.monitors:
|
|
m.dirty = False
|
|
self.dirty = False
|
|
subprocess.run(["hyprctl", "reload"], capture_output=True, check=False)
|
|
# Reload re-applies the saved config; re-check the live layout so a
|
|
# snap-induced collision is surfaced rather than silently saved.
|
|
warn = self._live_overlap_warning()
|
|
self.status_msg = (
|
|
f"Saved — ⚠ {warn}" if warn else f"Saved to {MONITORS_LUA.name}"
|
|
)
|
|
except Exception as e:
|
|
self.status_msg = f"Save failed: {e}"
|
|
|
|
# -----------------------------------------------------------------------
|
|
# Prompt
|
|
# -----------------------------------------------------------------------
|
|
|
|
def prompt_save_quit(self) -> str:
|
|
rows, cols = self.stdscr.getmaxyx()
|
|
prompt = "Unsaved changes. [s]ave & quit [n]o save [c]ancel"
|
|
safe_addstr(self.stdscr, rows - 1, 0, " " * (cols - 1), curses.A_REVERSE)
|
|
safe_addstr(self.stdscr, rows - 1, 0, prompt[:cols - 1], curses.A_REVERSE)
|
|
self.stdscr.timeout(-1)
|
|
while True:
|
|
ch = self.stdscr.getch()
|
|
if ch in (ord("s"), ord("S")):
|
|
self.stdscr.timeout(100)
|
|
return "save"
|
|
if ch in (ord("n"), ord("N")):
|
|
self.stdscr.timeout(100)
|
|
return "nosave"
|
|
if ch in (ord("c"), ord("C"), 27):
|
|
self.stdscr.timeout(100)
|
|
return "cancel"
|
|
|
|
# -----------------------------------------------------------------------
|
|
# Drawing
|
|
# -----------------------------------------------------------------------
|
|
|
|
def draw(self):
|
|
self.stdscr.erase()
|
|
rows, cols = self.stdscr.getmaxyx()
|
|
|
|
use_info = cols >= 80
|
|
canvas_w = (cols - INFO_W - 1) if use_info else cols
|
|
canvas_h = max(4, rows - STATUS_ROWS)
|
|
|
|
self.draw_canvas(canvas_w, canvas_h)
|
|
if use_info:
|
|
self.draw_info(canvas_w, canvas_h)
|
|
# vertical separator
|
|
for r in range(canvas_h):
|
|
safe_addch(self.stdscr, r, canvas_w, "│", curses.color_pair(2))
|
|
|
|
self.draw_status(rows - 2, cols)
|
|
self.draw_help(rows - 1, cols)
|
|
self.stdscr.noutrefresh()
|
|
curses.doupdate()
|
|
|
|
def draw_canvas(self, pane_cols: int, pane_rows: int):
|
|
scale = self._get_scale(pane_cols, pane_rows)
|
|
|
|
for idx, mon in enumerate(self.monitors):
|
|
brow, bcol = to_screen(mon.x, mon.y, scale)
|
|
bw = max(MIN_BOX_W, int(mon.logical_width * scale))
|
|
bh = max(MIN_BOX_H, int(mon.logical_height * scale * 0.5))
|
|
|
|
# Clamp to pane
|
|
if brow >= pane_rows or bcol >= pane_cols:
|
|
continue
|
|
|
|
# Choose color
|
|
if self.mode == "mirror_pick" and idx == self.mirror_target_idx:
|
|
attr = curses.color_pair(3) | curses.A_BOLD
|
|
elif idx == self.selected_idx:
|
|
attr = curses.color_pair(1) | curses.A_BOLD
|
|
elif mon.mirror_of:
|
|
attr = curses.color_pair(4)
|
|
else:
|
|
attr = curses.color_pair(2)
|
|
|
|
draw_box(self.stdscr, brow, bcol, bh, bw, attr)
|
|
|
|
# Labels inside box
|
|
inner_w = bw - 2
|
|
if inner_w < 1:
|
|
continue
|
|
|
|
def label_line(row_offset: int, text: str):
|
|
r = brow + row_offset
|
|
c = bcol + 1
|
|
if r >= pane_rows or r <= brow or r >= brow + bh - 1:
|
|
return
|
|
safe_addstr(self.stdscr, r, c, text[:inner_w], attr)
|
|
|
|
# Line 1: name (+ dirty marker)
|
|
name_label = mon.name + (" *" if mon.dirty else "")
|
|
if mon.mirror_of:
|
|
name_label = f"{mon.name} →{mon.mirror_of}"
|
|
label_line(1, name_label)
|
|
|
|
# Line 2: mode
|
|
if bh > 3:
|
|
label_line(2, mon.mode_str)
|
|
|
|
# Line 3: rotation
|
|
if bh > 4:
|
|
label_line(3, TRANSFORM_LABEL.get(mon.transform, ""))
|
|
|
|
def draw_info(self, start_col: int, pane_rows: int):
|
|
col = start_col + 1
|
|
row = 0
|
|
safe_addstr(self.stdscr, row, col, "Monitors:", curses.color_pair(6) | curses.A_BOLD)
|
|
row += 1
|
|
for idx, mon in enumerate(self.monitors):
|
|
if row >= pane_rows:
|
|
break
|
|
prefix = "> " if idx == self.selected_idx else " "
|
|
attr = curses.color_pair(1) | curses.A_BOLD if idx == self.selected_idx else curses.color_pair(2)
|
|
safe_addstr(self.stdscr, row, col, f"{prefix}{mon.name}", attr)
|
|
row += 1
|
|
if row < pane_rows:
|
|
safe_addstr(self.stdscr, row, col + 2, mon.mode_str, curses.color_pair(2))
|
|
row += 1
|
|
if row < pane_rows:
|
|
safe_addstr(self.stdscr, row, col + 2, f"pos {mon.x},{mon.y}", curses.color_pair(2))
|
|
row += 1
|
|
if row < pane_rows:
|
|
safe_addstr(self.stdscr, row, col + 2, f"scale {mon.scale}", curses.color_pair(2))
|
|
row += 1
|
|
if row < pane_rows:
|
|
rot_str = TRANSFORM_LABEL.get(mon.transform, "")
|
|
mirror_str = f" →{mon.mirror_of}" if mon.mirror_of else ""
|
|
safe_addstr(self.stdscr, row, col + 2, rot_str + mirror_str, curses.color_pair(2))
|
|
row += 1
|
|
row += 1 # blank between monitors
|
|
|
|
def draw_status(self, row: int, cols: int):
|
|
if self.mode == "mirror_pick":
|
|
src = self.monitors[self.mirror_source_idx].name if self.monitors else "?"
|
|
tgt = self.monitors[self.mirror_target_idx].name if self.monitors else "?"
|
|
mode_tag = f"[MIRROR] {src} → {tgt}"
|
|
else:
|
|
mode_tag = "[NORMAL]"
|
|
if self.dirty:
|
|
mode_tag += " *"
|
|
|
|
msg = f"{mode_tag} {self.status_msg}"
|
|
safe_addstr(self.stdscr, row, 0, " " * (cols - 1), curses.A_REVERSE)
|
|
safe_addstr(self.stdscr, row, 0, msg[:cols - 1], curses.A_REVERSE)
|
|
|
|
def draw_help(self, row: int, cols: int):
|
|
if self.mode == "mirror_pick":
|
|
text = "Tab:cycle-target Enter:confirm Esc:cancel"
|
|
else:
|
|
text = "Tab:next hjkl:move HJKL:fine u/i:rot t/g:scale m:mirror n/N:mode s:save Enter:save+quit q:quit"
|
|
safe_addstr(self.stdscr, row, 0, text[:cols - 1], curses.color_pair(6))
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Entry point
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def main():
|
|
try:
|
|
curses.wrapper(lambda stdscr: App(stdscr).run())
|
|
except subprocess.CalledProcessError as e:
|
|
print(f"Error: hyprctl failed — is Hyprland running?\n{e}", file=sys.stderr)
|
|
sys.exit(1)
|
|
except KeyboardInterrupt:
|
|
pass
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|