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

# The system print dialog, matched by its exact title.
#
# This is the one place a title is used, and only to recognise a single
# known dialog. It is not classifying Chrome windows — creation order
# still does that. The dialog and the window that rendered the document
# for it are otherwise identical to sway, and if the render window ends
# up in front the teacher cannot print at all.
PRINT_TITLE = "Print"

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)


def is_print_dialog(window):
    return (window or {}).get("name") == PRINT_TITLE


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"])

    # The print dialog is configured last, because configuring a window
    # focuses it and whichever is done last ends up in front. Both can
    # arrive between two events, and the tree does not promise to list
    # them in the order they were created.
    arriving = sorted(
        changes["new_secondary"],
        key=lambda identifier: is_print_dialog(chrome.get(identifier)),
    )

    for identifier in arriving:
        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)

    keep_print_in_front(roles.secondary, chrome)

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


def keep_print_in_front(secondary, chrome):
    """The print dialog stays the obvious foreground window.

    The window that rendered the document is a secondary like any other
    and will raise itself over the dialog given the chance, which leaves
    the teacher looking at a document they cannot print.

    Focus is only ever taken back from another Chrome popup. Clicking
    the main browser, the dock or anything else is the teacher's
    business and is left alone.
    """
    dialogs = [
        identifier
        for identifier in secondary
        if identifier in chrome
        and is_print_dialog(chrome[identifier])
        and not chrome[identifier]["hidden"]
    ]

    if not dialogs:
        return

    dialog = dialogs[-1]

    if chrome[dialog]["focused"]:
        return

    intruder = next(
        (
            identifier
            for identifier in secondary
            if identifier in chrome
            and chrome[identifier]["focused"]
            and identifier != dialog
        ),
        None,
    )

    if intruder is None:
        return

    command(f"[con_id={dialog}] focus")


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())