WinJitsu 0.2.0__py3-none-any.whl

winjitsu/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.2.0"
+
+from .cli import main
+
+__all__ = ["main"]

winjitsu/actions.py

@@ -0,0 +1,169 @@
+from .config import _CFG
+from .screen import get_screens, get_screen_for_window
+from .window import get_window_position, get_wm_class, move_window
+from .cache import load_state, save_state, clear_cache, _update_state
+
+
+VALID_ACTIONS = ["N", "S", "E", "W", "NE", "NW", "SE", "SW", "C", "F", "U", "TF", "TD", "CC"]
+DIRECTION_ACTIONS = {"N", "S", "E", "W", "NE", "NW", "SE", "SW", "C"}
+
+
+# --- Grid snapping ---
+def direction(direction_code):
+    window = get_window_position()
+    screen_width, screen_height, screen_origin_x, screen_origin_y = get_screen_for_window(window)
+    half_width = screen_width / 2
+    half_height = screen_height / 2
+
+    centered_x = screen_origin_x + (screen_width - window["WIDTH"]) / 2
+    centered_y = screen_origin_y + (screen_height - window["HEIGHT"]) / 2
+
+    targets_by_direction = {
+        "N":  {"width": screen_width, "height": half_height,  "x": screen_origin_x,              "y": screen_origin_y},
+        "S":  {"width": screen_width, "height": half_height,  "x": screen_origin_x,              "y": screen_origin_y + half_height},
+        "E":  {"width": half_width,   "height": screen_height,"x": screen_origin_x + half_width, "y": screen_origin_y},
+        "W":  {"width": half_width,   "height": screen_height,"x": screen_origin_x,              "y": screen_origin_y},
+        "NE": {"width": half_width,   "height": half_height,  "x": screen_origin_x + half_width, "y": screen_origin_y},
+        "NW": {"width": half_width,   "height": half_height,  "x": screen_origin_x,              "y": screen_origin_y},
+        "SE": {"width": half_width,   "height": half_height,  "x": screen_origin_x + half_width, "y": screen_origin_y + half_height},
+        "SW": {"width": half_width,   "height": half_height,  "x": screen_origin_x,              "y": screen_origin_y + half_height},
+        "C":  {"width": window["WIDTH"], "height": window["HEIGHT"], "x": centered_x, "y": centered_y},
+    }
+
+    target = targets_by_direction[direction_code]
+    target_width, target_height = target["width"], target["height"]
+    target_x, target_y = target["x"], target["y"]
+
+    _update_state(window, target_x, target_y, target_width, target_height)
+    move_window(
+        target_width, target_height,
+        window["WINDOW"],
+        window["WIDTH"], window["HEIGHT"],
+        window["X"], window["Y"],
+        target_x, target_y,
+    )
+
+
+# --- Fullscreen ---
+def fullscreen(window=None, screen_width=None, screen_height=None, screen_origin_x=None, screen_origin_y=None):
+    window = window or get_window_position()
+    if screen_width is None:
+        screen_width, screen_height, screen_origin_x, screen_origin_y = get_screen_for_window(window)
+
+    padding = _CFG.padding
+    target_x = screen_origin_x + padding
+    target_y = screen_origin_y + padding
+    target_width = screen_width - 2 * padding
+    target_height = screen_height - 2 * padding
+
+    _update_state(window, target_x, target_y, target_width, target_height)
+    move_window(
+        target_width, target_height,
+        window["WINDOW"],
+        window["WIDTH"], window["HEIGHT"],
+        window["X"], window["Y"],
+        target_x, target_y,
+    )
+
+
+def restore(window=None):
+    window = window or get_window_position()
+    window_id = window["WINDOW"]
+    saved_state = load_state(window_id, get_wm_class(window_id))
+    if saved_state is None:
+        return
+
+    move_window(
+        saved_state["WIDTH"], saved_state["HEIGHT"],
+        window_id,
+        window["WIDTH"], window["HEIGHT"],
+        window["X"], window["Y"],
+        saved_state["X"], saved_state["Y"],
+    )
+
+
+def toggle_fullscreen(window=None):
+    window = window or get_window_position()
+    screen_width, screen_height, screen_origin_x, screen_origin_y = get_screen_for_window(window)
+
+    padding = _CFG.padding
+    fullscreen_width = screen_width - 2 * padding
+    fullscreen_height = screen_height - 2 * padding
+
+    is_already_fullscreen = (
+        window["WIDTH"] == fullscreen_width
+        and window["HEIGHT"] == fullscreen_height
+    )
+
+    if is_already_fullscreen:
+        restore(window)
+    else:
+        fullscreen(window, screen_width, screen_height, screen_origin_x, screen_origin_y)
+
+
+# --- Display ---
+def toggle_display():
+    window = get_window_position()
+    primary_screen, other_screens = get_screens()
+    if not primary_screen or not other_screens:
+        return
+
+    all_screens = [primary_screen] + other_screens
+    window_center_x = window["X"] + window["WIDTH"] / 2
+    window_center_y = window["Y"] + window["HEIGHT"] / 2
+
+    def _distance_to_screen_center(screen):
+        screen_center_x = screen["x"] + screen["width"] / 2
+        screen_center_y = screen["y"] + screen["height"] / 2
+        return (window_center_x - screen_center_x) ** 2 + (window_center_y - screen_center_y) ** 2
+
+    def _contains_window_center(screen):
+        return (screen["x"] <= window_center_x < screen["x"] + screen["width"]
+                and screen["y"] <= window_center_y < screen["y"] + screen["height"])
+
+    current_screen = next(
+        (screen for screen in all_screens if _contains_window_center(screen)),
+        min(all_screens, key=_distance_to_screen_center),
+    )
+    current_screen_index = all_screens.index(current_screen)
+    target_screen_index = (current_screen_index + 1) % len(all_screens)
+    target_screen = all_screens[target_screen_index]
+
+    # Preserve the window's relative offset on the new screen
+    target_x = target_screen["x"] + (window["X"] - current_screen["x"])
+    target_y = target_screen["y"] + (window["Y"] - current_screen["y"])
+
+    window_id = window["WINDOW"]
+    wm_class = get_wm_class(window_id)
+    target_home_state = {
+        "WINDOW": window_id,
+        "X": target_x, "Y": target_y,
+        "WIDTH": window["WIDTH"], "HEIGHT": window["HEIGHT"],
+        "SCREEN": target_screen_index,
+    }
+    save_state(window_id, target_home_state, target_x, target_y, window["WIDTH"], window["HEIGHT"], wm_class)
+    move_window(
+        window["WIDTH"], window["HEIGHT"],
+        window_id,
+        window["WIDTH"], window["HEIGHT"],
+        window["X"], window["Y"],
+        target_x, target_y,
+    )
+
+
+# --- Dispatcher ---
+_ACTION_HANDLERS = {
+    "F":  fullscreen,
+    "U":  restore,
+    "TF": toggle_fullscreen,
+    "TD": toggle_display,
+    "CC": clear_cache,
+}
+
+def dispatch(action_code):
+    if action_code in DIRECTION_ACTIONS:
+        direction(action_code)
+    elif action_code in _ACTION_HANDLERS:
+        _ACTION_HANDLERS[action_code]()
+    else:
+        raise ValueError(f"Unknown action: {action_code!r}")

winjitsu/cache.py

@@ -0,0 +1,68 @@
+import json
+import shutil
+from pathlib import Path
+
+from .window import get_wm_class
+
+
+CACHE_DIR = Path.home() / ".cache" / "winjitsu"
+
+
+def load_state(window_id, wm_class):
+    cache_file_path = CACHE_DIR / f"{window_id}.json"
+    if not cache_file_path.exists():
+        return None
+    try:
+        with open(cache_file_path) as f:
+            cached_state = json.load(f)
+    except (json.JSONDecodeError, ValueError):
+        return None
+    # X11 window IDs are recycled across sessions — reject cache if the app changed
+    if cached_state.get("WM_CLASS") != wm_class:
+        return None
+    return cached_state
+
+
+def save_state(window_id, home_state, target_x, target_y, target_width, target_height, wm_class):
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    with open(CACHE_DIR / f"{window_id}.json", "w") as f:
+        json.dump({
+            "WINDOW": home_state["WINDOW"],
+            "X": home_state["X"], "Y": home_state["Y"],
+            "WIDTH": home_state["WIDTH"], "HEIGHT": home_state["HEIGHT"],
+            "SCREEN": home_state.get("SCREEN", 0),
+            "WM_CLASS": wm_class,
+            "_last_X": target_x, "_last_Y": target_y,
+            "_last_W": target_width, "_last_H": target_height,
+        }, f)
+
+
+def _resolve_home(window, cached_state):
+    # If the window is still at the last position we animated it to, the original
+    # home hasn't changed — reuse it. Otherwise the window moved elsewhere and its
+    # current position becomes the new home.
+    if cached_state is None:
+        return window
+    last_target_geometry = (
+        cached_state.get("_last_X"), cached_state.get("_last_Y"),
+        cached_state.get("_last_W"), cached_state.get("_last_H")
+    )
+    if None in last_target_geometry:
+        return window
+    current_geometry = (window["X"], window["Y"],
+                        window["WIDTH"], window["HEIGHT"])
+    if current_geometry == last_target_geometry:
+        return {k: cached_state[k] for k in ("WINDOW", "X", "Y", "WIDTH", "HEIGHT", "SCREEN")}
+    return window
+
+
+def _update_state(window, target_x, target_y, target_width, target_height):
+    wm_class = get_wm_class(window["WINDOW"])
+    cached_state = load_state(window["WINDOW"], wm_class)
+    home_state = _resolve_home(window, cached_state)
+    save_state(window["WINDOW"], home_state, target_x, target_y, target_width, target_height, wm_class)
+
+
+def clear_cache():
+    if CACHE_DIR.exists():
+        shutil.rmtree(CACHE_DIR)

winjitsu/cli.py

@@ -0,0 +1,127 @@
+import os
+import sys
+import argparse
+import signal
+import time
+from pathlib import Path
+
+from .config import _CFG, _load_config, _write_config
+from .actions import dispatch, VALID_ACTIONS
+from .daemon import _fork_daemon, send_command, PID_PATH
+
+
+_HELP_EPILOG = """
+actions:
+  grid snapping:
+    N / S           snap to top / bottom half of the screen
+    E / W           snap to right / left half of the screen
+    NE / NW         snap to top-right / top-left quarter
+    SE / SW         snap to bottom-right / bottom-left quarter
+    C               center window (keeps current size)
+
+  fullscreen:
+    F               fullscreen (covers the entire monitor)
+    U               restore window to its home position
+    TF              toggle fullscreen / restore home position
+
+  multi-monitor:
+    TD              move window to the next monitor
+
+  cache:
+    CC              clear the window state cache
+
+config file: ~/.config/winjitsu/config.ini  (XDG_CONFIG_HOME honoured)
+  --write-config    create config file with defaults (all options commented out)
+  --read-config     use a different config file path
+  --see-config      show active config file and current values
+"""
+
+
+def main():
+    import winjitsu.config as _config_module
+
+    # Pre-parse --read-config before the main parser so globals are updated
+    # before any action uses them.
+    pre_parser = argparse.ArgumentParser(add_help=False)
+    pre_parser.add_argument("--read-config", metavar="PATH")
+    pre_parsed_args, _ = pre_parser.parse_known_args()
+    if pre_parsed_args.read_config:
+        _config_module._CFG = _load_config(Path(pre_parsed_args.read_config))
+
+    parser = argparse.ArgumentParser(
+        description="Animated window management tool for Linux X11.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=_HELP_EPILOG,
+    )
+    parser.add_argument("action", nargs="?", choices=VALID_ACTIONS, metavar="ACTION",
+                        help="window management action (see below)")
+    parser.add_argument("--daemon",         action="store_true",    help="start background daemon")
+    parser.add_argument("--reload-daemon",  action="store_true",    help="restart the background daemon (preserves cache)")
+    parser.add_argument("--write-config",   action="store_true",    help="create config file with defaults and exit")
+    parser.add_argument("--read-config",    metavar="PATH",         help="use a custom config file path")
+    parser.add_argument("--see-config",     action="store_true",    help="print current config values and exit")
+    parser.add_argument("--steps",          type=int, metavar="N",  help="animation steps, overrides config (default: 25)")
+    parser.add_argument("--padding",        type=int, metavar="PX", help="fullscreen padding in pixels, overrides config (default: 0)")
+    parser.add_argument("--delay-ms",       type=int, metavar="MS", help="action delay in milliseconds, overrides config (default: 250)")
+    parsed_args = parser.parse_args()
+
+    config = _config_module._CFG
+
+    # CLI flags override config file and defaults
+    if parsed_args.steps    is not None: config.steps    = parsed_args.steps
+    if parsed_args.padding  is not None: config.padding  = parsed_args.padding
+    if parsed_args.delay_ms is not None: config.delay_ms = parsed_args.delay_ms
+
+    if parsed_args.write_config:
+        _write_config(config.path, config)
+        return
+
+    if parsed_args.see_config:
+        status = "exists" if config.path.exists() else "not found — using defaults"
+        print(f"config file : {config.path}  ({status})")
+        print(f"steps       : {config.steps}")
+        print(f"padding     : {config.padding}")
+        print(f"delay_ms    : {config.delay_ms}")
+        return
+
+    if parsed_args.daemon:
+        _fork_daemon()
+        return
+
+    if parsed_args.reload_daemon:
+        if not PID_PATH.exists():
+            print("No daemon running.", file=sys.stderr)
+            sys.exit(1)
+        try:
+            old_pid = int(PID_PATH.read_text().strip())
+            os.kill(old_pid, signal.SIGTERM)
+        except (ValueError, ProcessLookupError):
+            print("No daemon running (stale PID file).", file=sys.stderr)
+            PID_PATH.unlink(missing_ok=True)
+            sys.exit(1)
+        except PermissionError:
+            print("Permission denied sending SIGTERM.", file=sys.stderr)
+            sys.exit(1)
+        for _ in range(50):  # poll up to 5 s (50 × 0.1 s)
+            try:
+                os.kill(old_pid, 0)  # signal 0: liveness check, no signal sent
+                time.sleep(0.1)
+            except ProcessLookupError:
+                break
+        else:
+            # loop completed without break — daemon did not stop in time
+            print("Daemon did not stop within 5 seconds.", file=sys.stderr)
+            sys.exit(1)
+        _fork_daemon(clear_cache_on_stop=False)
+        return
+
+    if parsed_args.action is None:
+        parser.print_help()
+        sys.exit(1)
+
+    try:
+        if not send_command(parsed_args.action):
+            dispatch(parsed_args.action)
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)

winjitsu/config.py

@@ -0,0 +1,65 @@
+import os
+import configparser
+from dataclasses import dataclass
+from pathlib import Path
+
+
+_CONFIG_PATH = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "winjitsu" / "config.ini"
+
+
+
+@dataclass
+class _Config:
+    steps: int
+    padding: int
+    delay_ms: int
+    path: Path
+
+
+def _load_config(path=None):
+    ini_parser = configparser.ConfigParser()
+    ini_parser.read_dict({
+        "animation": {"steps": "25"},
+        "display":   {"padding": "0"},
+        "daemon":    {"delay_ms": "250"},
+    })
+    config_path = path or _CONFIG_PATH
+    ini_parser.read(config_path)
+    return _Config(
+        steps=ini_parser.getint("animation", "steps"),
+        padding=ini_parser.getint("display", "padding"),
+        delay_ms=ini_parser.getint("daemon", "delay_ms"),
+        path=config_path,
+    )
+
+
+def _write_config(config_path, active_config):
+    if config_path.exists():
+        overwrite_response = input(f"Config already exists: {config_path}\nOverwrite? [y/N] ").strip().lower()
+        if overwrite_response not in ("y", "yes"):
+            print("Aborted.")
+            return
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    content = f"""\
+# WinJitsu configuration
+
+[animation]
+# Steps in the window movement animation.
+# Higher = smoother but slower. Default: 25
+steps = {active_config.steps}
+
+[display]
+# Gap in pixels around the window when using F (fullscreen).
+# 0 = true fullscreen, 5 = small gap on all sides. Default: 0
+padding = {active_config.padding}
+
+[daemon]
+# Delay in milliseconds. Rapid actions within this window are
+# collapsed into one — only the last one fires. Default: 250
+delay_ms = {active_config.delay_ms}
+"""
+    config_path.write_text(content)
+    print(f"Config written to: {config_path}")
+
+
+_CFG = _load_config()

winjitsu/daemon.py

@@ -0,0 +1,129 @@
+import os
+import sys
+import socket
+import socketserver
+import signal
+import threading
+
+from .config import _CFG
+from .actions import dispatch, VALID_ACTIONS
+from .cache import clear_cache
+
+
+_XDG_DATA_HOME = os.environ.get("XDG_DATA_HOME", str(os.path.join(os.path.expanduser("~"), ".local", "share")))
+
+from pathlib import Path
+_RUNTIME_DIR = Path(_XDG_DATA_HOME) / "winjitsu"
+SOCKET_PATH  = _RUNTIME_DIR / "winjitsu.sock"
+PID_PATH     = _RUNTIME_DIR / "winjitsu.pid"
+
+
+_pending_timer = None
+_pending_lock  = threading.Lock()
+
+
+def _schedule_action(action):
+    # Delay: cancel any pending action and restart the timer. Only the last
+    # action in a rapid burst fires, preventing duplicate moves from key repeat.
+    global _pending_timer
+    with _pending_lock:
+        if _pending_timer is not None:
+            _pending_timer.cancel()
+        _pending_timer = threading.Timer(_CFG.delay_ms / 1000, _run_action, args=(action,))
+        _pending_timer.start()
+
+
+def _run_action(action):
+    global _pending_timer
+    with _pending_lock:
+        _pending_timer = None
+    dispatch(action)
+
+
+class _CommandHandler(socketserver.StreamRequestHandler):
+    timeout = 5
+
+    def handle(self):
+        received_action = self.rfile.readline(256).decode().strip()
+        if not received_action or received_action not in VALID_ACTIONS:
+            self.wfile.write(b"ERROR: invalid action\n")
+            return
+        self.wfile.write(b"OK\n")
+        self.wfile.flush()
+        _schedule_action(received_action)
+
+
+def _cleanup_stale_runtime():
+    if PID_PATH.exists():
+        try:
+            stored_pid = int(PID_PATH.read_text().strip())
+            os.kill(stored_pid, 0)
+            print(f"winjitsu daemon already running (PID {stored_pid})", file=sys.stderr)
+            sys.exit(1)
+        except (ValueError, ProcessLookupError):
+            PID_PATH.unlink(missing_ok=True)
+        except PermissionError:
+            print("winjitsu daemon already running", file=sys.stderr)
+            sys.exit(1)
+    SOCKET_PATH.unlink(missing_ok=True)
+
+
+def _cleanup_runtime_files():
+    SOCKET_PATH.unlink(missing_ok=True)
+    PID_PATH.unlink(missing_ok=True)
+
+
+def run_daemon(clear_cache_on_stop=True):
+    _RUNTIME_DIR.mkdir(parents=True, exist_ok=True)
+    _cleanup_stale_runtime()
+    PID_PATH.write_text(str(os.getpid()))
+
+    socket_server = socketserver.ThreadingUnixStreamServer(str(SOCKET_PATH), _CommandHandler)
+    stop_event    = threading.Event()
+
+    def _on_signal(signum, frame):
+        stop_event.set()
+
+    signal.signal(signal.SIGTERM, _on_signal)
+    signal.signal(signal.SIGINT,  _on_signal)
+
+    threading.Thread(target=socket_server.serve_forever, daemon=True).start()
+    stop_event.wait()
+
+    try:
+        if clear_cache_on_stop:
+            clear_cache()
+    finally:
+        socket_server.shutdown()
+        socket_server.server_close()
+        _cleanup_runtime_files()
+
+
+def _fork_daemon(clear_cache_on_stop=True):
+    _cleanup_stale_runtime()
+    child_pid = os.fork()
+    if child_pid > 0:
+        print(f"winjitsu daemon starting (PID {child_pid})")
+        sys.exit(0)
+    os.setsid()  # detach from the controlling terminal; become session leader
+    # Redirect stdin/stdout/stderr to /dev/null — daemon must not touch the terminal
+    devnull_file = open(os.devnull, "r+")
+    for fd in (0, 1, 2):
+        os.dup2(devnull_file.fileno(), fd)
+    devnull_file.close()
+    run_daemon(clear_cache_on_stop)
+
+
+def send_command(action):
+    if not SOCKET_PATH.exists():
+        return False
+    try:
+        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as unix_socket:
+            unix_socket.settimeout(2.0)
+            unix_socket.connect(str(SOCKET_PATH))
+            unix_socket.sendall(f"{action}\n".encode())
+            with unix_socket.makefile("r") as response_reader:
+                response = response_reader.readline().strip()
+        return response == "OK"
+    except (FileNotFoundError, ConnectionRefusedError, TimeoutError, OSError):
+        return False

winjitsu/screen.py

@@ -0,0 +1,73 @@
+import threading
+
+from Xlib import display as Xdisplay
+from Xlib.ext import randr
+
+
+_display: "Xdisplay.Display | None" = None
+_display_lock = threading.Lock()
+
+
+def _get_display() -> Xdisplay.Display:
+    global _display
+    if _display is None:
+        with _display_lock:
+            if _display is None:
+                _display = Xdisplay.Display()
+    return _display
+
+
+def get_screens():
+    display = _get_display()
+    if not display.has_extension('RANDR'):
+        raise RuntimeError("RandR extension not available.")
+    root             = display.screen().root
+    resources        = root.xrandr_get_screen_resources()
+    config_timestamp = resources.config_timestamp  # config_timestamp, NOT timestamp — timestamp causes BadMatch on some drivers
+    primary_id       = root.xrandr_get_output_primary().output
+
+    primary = None
+    others  = []
+
+    for output_id in resources.outputs:
+        output_info = display.xrandr_get_output_info(output_id, config_timestamp)
+        if output_info.connection != randr.Connected or not output_info.crtc:
+            continue
+        crtc_info       = display.xrandr_get_crtc_info(output_info.crtc, config_timestamp)
+        screen_geometry = {"width": crtc_info.width, "height": crtc_info.height,
+                           "x": crtc_info.x, "y": crtc_info.y}
+        if output_id == primary_id:
+            primary = screen_geometry
+        else:
+            others.append(screen_geometry)
+
+    return primary, others
+
+
+def get_screen_for_window(window):
+    primary, others = get_screens()
+    if not primary:
+        default_screen = _get_display().screen()
+        return default_screen.width_in_pixels, default_screen.height_in_pixels, 0, 0
+
+    all_screens     = [primary] + others
+    window_center_x = window["X"] + window["WIDTH"] / 2
+    window_center_y = window["Y"] + window["HEIGHT"] / 2
+
+    def _dist(screen_candidate):
+        screen_center_x = screen_candidate["x"] + screen_candidate["width"] / 2
+        screen_center_y = screen_candidate["y"] + screen_candidate["height"] / 2
+        x_distance = window_center_x - screen_center_x
+        y_distance = window_center_y - screen_center_y
+        return x_distance ** 2 + y_distance ** 2
+
+    # Use the screen whose bounds contain the window center. If the center falls
+    # outside all screens (e.g. window is mostly off-screen), fall back to the
+    # nearest screen by distance from its center.
+    screen = next(
+        (screen_candidate for screen_candidate in all_screens
+         if screen_candidate["x"] <= window_center_x < screen_candidate["x"] + screen_candidate["width"]
+         and screen_candidate["y"] <= window_center_y < screen_candidate["y"] + screen_candidate["height"]),
+        min(all_screens, key=_dist),
+    )
+    return screen["width"], screen["height"], screen["x"], screen["y"]