Classroom_Desktop/scripts/classroom-chrome-windows

#!/usr/bin/env python3

"""Keep Chrome's first window tiled and make later windows usable popups.

Chrome gives the main browser and its secondary top-level windows the same
app_id, the same process and often nothing else to tell them apart. The only
stable fact is creation order, so this remembers the first Chrome container
and treats every later one as secondary. Page titles are deliberately ignored.

The close affordance for a secondary window lives in the dock. An earlier
attempt anchored a layer-shell button to the popup's own corner and moved it
whenever the window moved; on real hardware it chased the window and
flickered, because every position change meant tearing a surface down and
building another one. The dock is already on screen, already owns the
classroom's visual language, and does not move. This publishes which window
the dock's Close button should act on, and the dock does the rest.

Driven by Sway's own window events rather than a poll, so a window that is
being dragged costs nothing.
"""

import fcntl
import json
import os
import subprocess
import sys
import time
from pathlib import Path

sys.path.insert(0, "/usr/local/lib/ekklesia-classroom")
sys.path.insert(
    0,
    os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "lib"),
)

from classroom_chrome import ChromeRoles, chrome_windows  # noqa: E402
from classroom_sway import command, windows  # noqa: E402

SECONDARY_SIZE_PERCENT = 76

# Chrome renegotiates the size of a popup that was opened with explicit
# dimensions, and does it after the resize returns. Centring before that
# settles leaves the window visibly off to one side, so it is placed
# once more a moment later. Only ever at creation: after that the window
# is the teacher's to move, and nothing here touches it again.
SETTLE_SECONDS = 0.35

# Everything else a window event can report — a title change, an urgency
# hint, a mark — cannot change which window is which, and Chrome retitles
# constantly.
INTERESTING = frozenset(
    ("new", "close", "focus", "move", "floating", "fullscreen_mode")
)

RESUBSCRIBE_SECONDS = 2

STATE_NAME = "chrome-close-target"


def state_directory():
    runtime = Path(os.environ.get("XDG_RUNTIME_DIR") or "/tmp")
    directory = runtime / "ekklesia-classroom"
    directory.mkdir(parents=True, exist_ok=True)

    return directory


def criterion(identifier):
    return f"[con_id={identifier}]"


def configure_primary(identifier):
    """A promoted remaining window becomes the ordinary classroom browser."""
    command(f"{criterion(identifier)} floating disable")
    command(f"{criterion(identifier)} border none")
    command(f"{criterion(identifier)} focus")


def place(target):
    command(
        f"{target} resize set width {SECONDARY_SIZE_PERCENT} ppt "
        f"height {SECONDARY_SIZE_PERCENT} ppt"
    )
    command(f"{target} move position center")


def configure_secondary(identifier, arriving=True):
    """Float one exact container; never apply a broad Chrome float rule."""
    target = criterion(identifier)
    command(f"{target} floating enable")
    command(f"{target} border none")

    if not arriving:
        # Only restoring the floating role to a window that already
        # existed. Never move it: that would undo wherever the teacher
        # dragged it. Never focus it: that would raise the render window
        # over the print dialog sitting above it.
        return

    place(target)
    command(f"{target} focus")

    # Let Chrome have its say about the size, then place it again.
    time.sleep(SETTLE_SECONDS)
    place(target)


class ActiveSecondary:
    """The one secondary window the dock offers to close.

    Deliberately sticky. This used to be whichever secondary happened to
    be focused, which made the button impossible to click: moving the
    pointer down to the dock moves focus away from the popup, so the
    button disappeared on the way to it. Nobody could ever reach it.

    It is remembered instead. Losing focus changes nothing. It only
    changes when the window it names goes away, or when another
    secondary takes over by being focused.
    """

    def __init__(self):
        self.target = None

    def update(self, secondary, chrome):
        # A focused secondary takes over. Focus on the dock, the print
        # dialog, the main browser or any layer-shell surface is not a
        # secondary, so none of them disturb this.
        for identifier in secondary:
            window = chrome.get(identifier)

            if window and window["focused"] and not window["hidden"]:
                self.target = identifier
                break

        # Never anything that has closed, and never the main browser:
        # `secondary` cannot contain the primary.
        if self.target is not None and self.target not in secondary:
            self.target = None

        # If the remembered window closed, fall back to another one that
        # is still open, so cancelling a print dialog leaves the render
        # window still closeable from the dock.
        if self.target is None:
            live = [
                identifier
                for identifier in secondary
                if identifier in chrome and not chrome[identifier]["hidden"]
            ]
            self.target = live[-1] if live else None

        return self.target


def publish(target, path):
    """Tell the dock which window to offer to close, atomically."""
    temporary = path.with_suffix(".tmp")

    try:
        temporary.write_text("" if target is None else f"{target}\n")
        os.replace(temporary, path)
    except OSError as error:
        print(f"[classroom-chrome-windows] could not publish state: {error}",
              flush=True)


def reconcile(roles, active, path):
    current = windows()
    chrome = {window["id"]: window for window in chrome_windows(current)}
    changes = roles.update(current)

    if changes["promoted"] is not None:
        configure_primary(changes["promoted"])

    for identifier in changes["new_secondary"]:
        configure_secondary(identifier)

    # Reassert the role if something put a secondary back into the tiling
    # layout — a restore, or an application-initiated geometry change.
    # Hidden windows are left parked quietly.
    for identifier in roles.secondary:
        window = chrome.get(identifier)

        if window and not window["hidden"] and not window["floating"]:
            configure_secondary(identifier, arriving=False)

    publish(active.update(roles.secondary, chrome), path)


def subscribe():
    try:
        return subprocess.Popen(
            ["swaymsg", "-t", "subscribe", "-m", "-r", '["window"]'],
            stdout=subprocess.PIPE,
            stderr=subprocess.DEVNULL,
            text=True,
        )
    except (OSError, subprocess.SubprocessError):
        return None


def watch():
    directory = state_directory()
    path = directory / STATE_NAME

    with (directory / "chrome-windows.lock").open("w") as lock:
        try:
            fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
        except BlockingIOError:
            return 0

        roles = ChromeRoles()
        active = ActiveSecondary()

        try:
            while True:
                # Whatever happened while there was no subscription.
                reconcile(roles, active, path)

                stream = subscribe()

                if stream is None or stream.stdout is None:
                    time.sleep(RESUBSCRIBE_SECONDS)
                    continue

                for line in stream.stdout:
                    try:
                        event = json.loads(line)
                    except ValueError:
                        continue

                    if event.get("change") in INTERESTING:
                        reconcile(roles, active, path)

                # Sway went away or restarted; wait, then pick it back up.
                stream.wait()
                time.sleep(RESUBSCRIBE_SECONDS)
        finally:
            publish(None, path)


def main():
    return watch()


if __name__ == "__main__":
    sys.exit(main())