wiimote-spotlight 0.1.0__tar.gz

wiimote_spotlight-0.1.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.3
+Name: wiimote-spotlight
+Version: 0.1.0
+Summary: Add your description here
+Author: Daniel Raniz Raneland
+Author-email: Daniel Raniz Raneland <raniz@factor10.com>
+Requires-Dist: evdev>=2.0.0
+Requires-Dist: pycairo>=1.29.2
+Requires-Dist: pygobject>=3.58.0
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# Wiimote spotlight
+
+I simple Python application that uses a Wiimote to control a spotlight overlay on KDE/Plasma on Wayland.
+
+# Installation
+Either install from a checked out copy of this repository, or point [`uv`](https://docs.astral.sh/uv/) to the git repository:
+
+```shell
+$ uv install tool .
+```
+
+```shell
+$ uv install tool https://codeberg.org/raniz/wiimote-spotlight
+```

wiimote_spotlight-0.1.0/README.md

@@ -0,0 +1,14 @@
+# Wiimote spotlight
+
+I simple Python application that uses a Wiimote to control a spotlight overlay on KDE/Plasma on Wayland.
+
+# Installation
+Either install from a checked out copy of this repository, or point [`uv`](https://docs.astral.sh/uv/) to the git repository:
+
+```shell
+$ uv install tool .
+```
+
+```shell
+$ uv install tool https://codeberg.org/raniz/wiimote-spotlight
+```

wiimote_spotlight-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "wiimote-spotlight"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "evdev>=2.0.0",
+    "pycairo>=1.29.2",
+    "pygobject>=3.58.0",
+]
+
+[[project.authors]]
+name = "Daniel Raniz Raneland"
+email = "raniz@factor10.com"
+
+[project.scripts]
+wiimote-spotlight = "wiimote_spotlight:main"
+
+[build-system]
+requires = ["uv_build>=0.12.23,<0.13.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = ["pytest>=9.1.1"]

wiimote_spotlight-0.1.0/pyproject.toml.orig

@@ -0,0 +1,26 @@
+[project]
+name = "wiimote-spotlight"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "Daniel Raniz Raneland", email = "raniz@factor10.com" }
+]
+requires-python = ">=3.13"
+dependencies = [
+    "evdev>=2.0.0",
+    "pycairo>=1.29.2",
+    "pygobject>=3.58.0",
+]
+
+[project.scripts]
+wiimote-spotlight = "wiimote_spotlight:main"
+
+[build-system]
+requires = ["uv_build>=0.12.23,<0.13.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+]

wiimote_spotlight-0.1.0/src/wiimote_spotlight/__init__.py

@@ -0,0 +1 @@
+from .main import main

wiimote_spotlight-0.1.0/src/wiimote_spotlight/args.py

@@ -0,0 +1,17 @@
+import argparse
+
+
+def parse_args(argv=None):
+    parser = argparse.ArgumentParser(prog="wiimote-spotlight")
+    parser.add_argument("-r", "--radius", type=int, default=180,
+                        help="spotlight radius in logical pixels")
+    parser.add_argument("-m", "--monitor",
+                        help="screen to show the spotlight on, by index or "
+                             "connector name (see --list-monitors); defaults "
+                             "to the external screen when exactly two are "
+                             "connected, otherwise eDP-1")
+    parser.add_argument("-s", "--sensitivity", type=float, default=2e-3,
+                        help="spotlight pixels per raw gyro unit per report")
+    parser.add_argument("-l", "--list-monitors", action="store_true",
+                        help="list the available screens and exit")
+    return parser.parse_args(argv)

wiimote_spotlight-0.1.0/src/wiimote_spotlight/main.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+
+def main():
+    """
+    wiimote-spotlight: a Logitech-Spotlight-style highlight driven directly by a
+    Wii Remote with MotionPlus, on KDE Plasma / Wayland. No mouse, no Projecteur.
+
+    It draws its own click-through overlay (wlr-layer-shell, overlay layer, which
+    KWin supports) and moves the spotlight with the gyro. The real mouse cursor is
+    never touched.
+
+      Hold B ......... show spotlight (starts at screen centre) and steer it
+      Release B ...... hide spotlight
+      A, +, d-pad R .. next slide (Right arrow)
+      -, d-pad L ..... previous slide (Left arrow)
+      2 .............. Escape
+      Home ........... recalibrate gyro (lay the remote still for ~2 s)
+
+    Keep the remote still for ~2 s after starting (gyro calibration).
+
+    Needs: gtk4-layer-shell + its GObject-introspection data, PyGObject, pycairo,
+    python-evdev, the uinput module, and access to the Wiimote's /dev/input nodes
+    and /dev/uinput WITHOUT sudo (a GUI app can't run as root on Wayland), so
+    install the udev rule from the notes.
+    """
+    from .args import parse_args
+    from .monitors import format_monitors, resolve_monitor
+    args = parse_args()
+
+    # gtk4-layer-shell must be loaded before GTK / libwayland-client.
+    from ctypes import CDLL
+    for _lib in ("libgtk4-layer-shell.so", "libgtk4-layer-shell.so.0"):
+        try:
+            CDLL(_lib)
+            break
+        except OSError:
+            pass
+    else:
+        raise SystemExit("gtk4-layer-shell not found; install it first.")
+
+    import math
+    import cairo
+    import evdev
+    from evdev import ecodes as e, UInput
+    import gi
+    gi.require_version("Gtk", "4.0")
+    gi.require_version("Gdk", "4.0")
+    gi.require_version("Gtk4LayerShell", "1.0")
+    from gi.repository import Gtk, Gdk, GLib, Gtk4LayerShell as LayerShell
+
+    # ---- tuning (copy your working values from wiimote-pointer.py) ----------
+    SENS = args.sensitivity  # spotlight pixels per raw gyro unit per report
+    DEADZONE = 60       # raw units ignored around zero
+    CALIB_SAMPLES = 300 # ~3 s
+    YAW, YAW_SIGN = e.ABS_RX, 1
+    PITCH, PITCH_SIGN = e.ABS_RZ, -1
+
+    # ---- look ---------------------------------------------------------------
+    RADIUS = args.radius        # spotlight radius in logical pixels
+    SHADE = 0.35                # darkness outside the spotlight (0..1)
+    RING = (27 / 255, 131 / 255, 35 / 255, 1.0) # border colour RGBA; set RING_WIDTH = 0 for none
+    RING_WIDTH = 3
+
+    # ---- buttons -> keys (sent via uinput) ----------------------------------
+    KEYMAP = {
+        e.BTN_A: [e.KEY_RIGHT],
+        e.KEY_NEXT: [e.KEY_RIGHT],      # "+"
+        e.KEY_PREVIOUS: [e.KEY_LEFT],   # "-"
+        e.KEY_RIGHT: [e.KEY_RIGHT],
+        e.KEY_LEFT: [e.KEY_LEFT],
+        e.KEY_UP: [e.KEY_UP],
+        e.KEY_DOWN: [e.KEY_DOWN],
+        e.BTN_2: [e.KEY_ESC],
+    }
+    # --------------------------------------------------------------------------
+
+
+    Gtk.init()
+    monitors = Gdk.Display.get_default().get_monitors()
+    monitors = [monitors.get_item(i) for i in range(monitors.get_n_items())]
+    if args.list_monitors:
+        print(format_monitors([(m.get_connector(), m.get_description())
+                               for m in monitors]))
+        return
+    monitor = monitors[resolve_monitor(args.monitor,
+                                       [m.get_connector() for m in monitors])]
+
+
+    def find(name):
+        for path in evdev.list_devices():
+            dev = evdev.InputDevice(path)
+            if dev.name == name:
+                return dev
+        raise SystemExit(f'"{name}" not found. Is the Wiimote connected, and do '
+                         "you have access to /dev/input (see udev rule)?")
+
+
+    btn = find("Nintendo Wii Remote")
+    mp = find("Nintendo Wii Remote Motion Plus")
+    btn.grab()
+    mp.grab()
+    ui = UInput({e.EV_KEY: sorted({k for ks in KEYMAP.values() for k in ks})},
+                name="wiimote-spotlight-keys")
+
+
+    class State:
+        visible = False
+        x = y = 0.0
+        w = h = 1
+        gyro = {}
+        bias = None
+        n = 0
+        sums = {YAW: 0, PITCH: 0}
+
+        def recalibrate(self):
+            self.bias, self.n, self.sums = None, 0, {YAW: 0, PITCH: 0}
+            self.visible = False
+            print("Calibrating gyro, keep the remote still...")
+
+
+    s = State()
+    area = None  # Gtk.DrawingArea, set on activate
+
+
+    def redraw():
+        if area is not None:
+            area.queue_draw()
+
+
+    # ---- input handling -----------------------------------------------------
+    def on_gyro(ev):
+        if ev.type == e.EV_ABS:
+            s.gyro[ev.code] = ev.value
+            return
+        if ev.type != e.EV_SYN or YAW not in s.gyro or PITCH not in s.gyro:
+            return
+        if s.bias is None:
+            s.sums[YAW] += s.gyro[YAW]
+            s.sums[PITCH] += s.gyro[PITCH]
+            s.n += 1
+            if s.n >= CALIB_SAMPLES:
+                s.bias = {k: v / s.n for k, v in s.sums.items()}
+                print("Calibrated. Hold B to show the spotlight.")
+            return
+        if not s.visible:
+            return
+        moved = False
+        for ax, sign, attr, limit in ((YAW, YAW_SIGN, "x", s.w),
+                                      (PITCH, PITCH_SIGN, "y", s.h)):
+            v = s.gyro[ax] - s.bias[ax]
+            if abs(v) >= DEADZONE:
+                new = min(max(getattr(s, attr) + sign * v * SENS, 0), limit)
+                setattr(s, attr, new)
+                moved = True
+        if moved:
+            redraw()
+
+
+    def on_button(ev):
+        if ev.type != e.EV_KEY or ev.value == 2:
+            return
+        if ev.code == e.BTN_B:
+            if ev.value and s.bias is not None:
+                s.visible, s.x, s.y = True, s.w / 2, s.h / 2
+            else:
+                s.visible = False
+            redraw()
+            return
+        if ev.code == e.BTN_MODE and ev.value:
+            s.recalibrate()
+            redraw()
+            return
+        keys = KEYMAP.get(ev.code)
+        if keys:
+            for k in (keys if ev.value else reversed(keys)):
+                ui.write(e.EV_KEY, k, ev.value)
+            ui.syn()
+
+
+    def watch(dev, handler, app):
+        def cb(_source, _cond):
+            try:
+                for ev in dev.read():
+                    handler(ev)
+            except BlockingIOError:
+                pass
+            except OSError:
+                print("Wiimote disconnected.")
+                app.quit()
+                return False
+            return True
+        GLib.io_add_watch(dev.fd, GLib.PRIORITY_DEFAULT, GLib.IO_IN, cb)
+
+
+    # ---- overlay ------------------------------------------------------------
+    def draw(_area, cr, w, h, _data=None):
+        s.w, s.h = w, h
+        cr.set_operator(cairo.OPERATOR_SOURCE)
+        cr.set_source_rgba(0, 0, 0, 0)
+        cr.paint()
+        if not s.visible:
+            return
+        cr.set_operator(cairo.OPERATOR_OVER)
+        cr.set_fill_rule(cairo.FILL_RULE_EVEN_ODD)
+        cr.rectangle(0, 0, w, h)
+        cr.new_sub_path()
+        cr.arc(s.x, s.y, RADIUS, 0, 2 * math.pi)
+        cr.set_source_rgba(0, 0, 0, SHADE)
+        cr.fill()
+        if RING_WIDTH:
+            cr.new_sub_path()
+            cr.arc(s.x, s.y, RADIUS, 0, 2 * math.pi)
+            cr.set_line_width(RING_WIDTH)
+            cr.set_source_rgba(*RING)
+            cr.stroke()
+
+
+    def on_activate(app):
+        nonlocal area
+        win = Gtk.ApplicationWindow(application=app)
+        LayerShell.init_for_window(win)
+        LayerShell.set_namespace(win, "wiimote-spotlight")
+        LayerShell.set_layer(win, LayerShell.Layer.OVERLAY)
+        for edge in (LayerShell.Edge.LEFT, LayerShell.Edge.RIGHT,
+                     LayerShell.Edge.TOP, LayerShell.Edge.BOTTOM):
+            LayerShell.set_anchor(win, edge, True)
+        LayerShell.set_exclusive_zone(win, -1)
+        LayerShell.set_keyboard_mode(win, LayerShell.KeyboardMode.NONE)
+        LayerShell.set_monitor(win, monitor)
+
+        css = Gtk.CssProvider()
+        css.load_from_data(b"window { background: transparent; }")
+        Gtk.StyleContext.add_provider_for_display(
+            Gdk.Display.get_default(), css, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
+
+        area = Gtk.DrawingArea()
+        area.set_draw_func(draw)
+        win.set_child(area)
+        # Empty input region = every click and scroll passes straight through.
+        win.connect("realize",
+                    lambda w: w.get_surface().set_input_region(cairo.Region()))
+        win.present()
+
+        watch(mp, on_gyro, app)
+        watch(btn, on_button, app)
+        s.recalibrate()
+
+
+    app = Gtk.Application(application_id="local.wiimote.spotlight")
+    app.connect("activate", on_activate)
+    try:
+        app.run(None)
+    finally:
+        ui.close()
+
+if __name__ == "__main__":
+    main()

wiimote_spotlight-0.1.0/src/wiimote_spotlight/monitors.py

@@ -0,0 +1,31 @@
+LAPTOP_SCREEN = "eDP-1"
+
+
+def default_monitor(connectors):
+    if LAPTOP_SCREEN not in connectors:
+        return 0
+    if len(connectors) == 2:
+        external = [name for name in connectors if name != LAPTOP_SCREEN][0]
+        return connectors.index(external)
+    return connectors.index(LAPTOP_SCREEN)
+
+
+def resolve_monitor(spec, connectors):
+    if spec is None:
+        return default_monitor(connectors)
+    if spec.isdigit() and int(spec) < len(connectors):
+        return int(spec)
+    if spec in connectors:
+        return connectors.index(spec)
+    available = ", ".join(f"{i}: {name}" for i, name in enumerate(connectors))
+    raise SystemExit(f'Monitor "{spec}" not found. Available: {available}')
+
+
+def format_monitors(monitors):
+    lines = []
+    for i, (connector, description) in enumerate(monitors):
+        line = f"{i}: {connector}"
+        if description:
+            line += f" ({description})"
+        lines.append(line)
+    return "\n".join(lines)