ekklesiaandClaude Opus 5
37f8166401
The readiness condition was playback state alone, and on a real disc VLC reports playing well before its window has taken the screen. The cover came off onto VLC's ordinary tiled startup window — black, sized to everything except the dock's reserved strip — and the disc menu only arrived afterwards. Exactly the state the cover exists to hide. Ask sway instead. VLC only takes the display when its window goes fullscreen, and the tree says when that happens. The cover now comes off when VLC reports playing or paused, its window is fullscreen, and 800ms have passed for the menu to draw its first frames. The playback check runs first because it is local and cheap; the tree is only walked once VLC claims to be playing something. The twenty second deadline is unchanged: a cover with nothing behind it is still the one outcome DVD mode must never produce. Co-Authored-By: Claude Opus 5 <[email protected]>
685 lines
20 KiB
Python
Executable File
685 lines
20 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
"""DVD mode: a full-screen playback surface owned by the classroom.
|
|
|
|
VLC decodes the disc and its menus, because nothing else on Debian does
|
|
that reliably. Everything a person can see or press belongs to the
|
|
classroom: VLC's own interface is switched off, every one of its
|
|
keyboard shortcuts is unbound, and the visible controls are the bar in
|
|
this program, styled from the same stylesheet as the dock.
|
|
|
|
Layout, bottom to top:
|
|
|
|
loading surface layer-shell OVERLAY, covers the whole display
|
|
including the dock while the disc loads, removed
|
|
once playback is actually on screen
|
|
VLC fullscreen, drawn above the top layer by sway
|
|
control bar layer-shell OVERLAY, drawn above fullscreen video
|
|
"""
|
|
|
|
import fcntl
|
|
import os
|
|
import re
|
|
import signal
|
|
import socket
|
|
import sys
|
|
from base64 import b64encode
|
|
from pathlib import Path
|
|
from urllib import error as urlerror
|
|
from urllib import parse as urlparse
|
|
from urllib import request as urlrequest
|
|
|
|
import gi
|
|
|
|
gi.require_version("Gtk", "3.0")
|
|
gi.require_version("Gdk", "3.0")
|
|
gi.require_version("GdkPixbuf", "2.0")
|
|
gi.require_version("GtkLayerShell", "0.1")
|
|
|
|
from gi.repository import Gdk, GdkPixbuf, GLib, Gtk, GtkLayerShell
|
|
|
|
sys.path.insert(0, "/usr/local/lib/ekklesia-classroom")
|
|
sys.path.insert(
|
|
0,
|
|
os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "lib"),
|
|
)
|
|
|
|
import classroom_optical as optical # noqa: E402
|
|
import classroom_style as style # noqa: E402
|
|
import classroom_sway as sway # noqa: E402
|
|
import classroom_vlc as vlc # noqa: E402
|
|
from classroom_config import SHELL_SCALE, read_device_config, scaled # noqa: E402
|
|
|
|
# Input shaping needs pycairo. Without it the bar still works, it just
|
|
# takes pointer events across its whole strip instead of only where it
|
|
# is actually showing something.
|
|
try:
|
|
import cairo
|
|
except ImportError:
|
|
cairo = None
|
|
|
|
ICON_DIR = Path("/etc/ekklesia-classroom/icons")
|
|
|
|
# The bar is the same height as the dock strip, so DVD mode feels like
|
|
# the same room rather than a different program.
|
|
BAR_HEIGHT = 76
|
|
ICON_SIZE = 28
|
|
|
|
# The dock floats clear of the bottom edge because its 44px buttons and
|
|
# 8px padding sit centred in a 76px strip. The bar matches that gap so it
|
|
# reads as the same surface rather than something stuck to the screen.
|
|
BAR_INSET = 7
|
|
|
|
# How far up from the bottom edge of the screen wakes the bar.
|
|
HOVER_STRIP = 14
|
|
|
|
# Hidden this long after the pointer stops moving, and this long after it
|
|
# leaves the bar.
|
|
IDLE_HIDE_SECONDS = 4
|
|
LEAVE_HIDE_SECONDS = 1
|
|
|
|
# How VLC is recognised in the sway tree. Qt5 puts it on XWayland, so
|
|
# the X11 class is what usually matches.
|
|
VLC_WINDOW = (r"vlc", r"vlc-.*")
|
|
|
|
# The loading surface goes away only once VLC has genuinely taken the
|
|
# screen. The deadline is a safety net: whatever happens, DVD mode must
|
|
# never leave a cover over a screen with nothing behind it. Generous,
|
|
# because an optical drive can take a while to spin a disc up.
|
|
READY_POLL_MS = 250
|
|
LOADING_DEADLINE_SECONDS = 20
|
|
|
|
# Held after VLC looks ready, so the disc menu has drawn its first frames
|
|
# before the cover comes off. Without this the handover lands on VLC's
|
|
# own black startup window instead of on the menu.
|
|
STABILISE_MS = 800
|
|
|
|
# Long enough for the cover to be on screen before VLC is even started,
|
|
# so no part of VLC's window is ever visible against the wallpaper.
|
|
LAUNCH_DELAY_MS = 120
|
|
|
|
STATUS_POLL_SECONDS = 1
|
|
|
|
def extra_css(scale):
|
|
"""Styling for the two surfaces this program owns.
|
|
|
|
The loading card reuses the dock's own .dock class, so it is the same
|
|
translucent surface, border and corner radius as everything else in
|
|
the room.
|
|
"""
|
|
return f"""
|
|
window#classroom-dvd-loading {{
|
|
background-color: #000000;
|
|
background-image: none;
|
|
}}
|
|
|
|
.dvd-loading {{
|
|
padding: {scaled(16, scale)}px {scaled(22, scale)}px;
|
|
}}
|
|
|
|
.dvd-loading label {{
|
|
color: #ffffff;
|
|
font-size: {scaled(17, scale)}px;
|
|
font-weight: 600;
|
|
}}
|
|
|
|
.dvd-loading spinner,
|
|
.dvd-loading spinner:checked {{
|
|
color: #ffffff;
|
|
opacity: 1;
|
|
min-width: {scaled(28, scale)}px;
|
|
min-height: {scaled(28, scale)}px;
|
|
}}
|
|
|
|
window#classroom-dvd-bar {{
|
|
background-color: transparent;
|
|
background-image: none;
|
|
border: none;
|
|
box-shadow: none;
|
|
}}
|
|
"""
|
|
|
|
|
|
def icon(filename, size):
|
|
path = ICON_DIR / filename
|
|
|
|
if not path.exists():
|
|
return None
|
|
|
|
return GdkPixbuf.Pixbuf.new_from_file_at_scale(str(path), size, size, True)
|
|
|
|
|
|
def free_port():
|
|
"""A loopback port for VLC's control interface."""
|
|
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as probe:
|
|
probe.bind(("127.0.0.1", 0))
|
|
return probe.getsockname()[1]
|
|
|
|
|
|
class VlcControl:
|
|
"""The classroom's line to VLC.
|
|
|
|
Commands go through VLC's HTTP interface as hotkey *actions* rather
|
|
than key presses, which is exactly why the control bar keeps working
|
|
after every key has been unbound.
|
|
"""
|
|
|
|
def __init__(self, port, password):
|
|
self.url = f"http://127.0.0.1:{port}/requests/status.xml"
|
|
self.authorization = "Basic " + b64encode(
|
|
f":{password}".encode("utf-8")
|
|
).decode("ascii")
|
|
|
|
def request(self, **parameters):
|
|
url = self.url
|
|
|
|
if parameters:
|
|
url += "?" + urlparse.urlencode(parameters)
|
|
|
|
try:
|
|
message = urlrequest.Request(
|
|
url,
|
|
headers={"Authorization": self.authorization},
|
|
)
|
|
|
|
with urlrequest.urlopen(message, timeout=1) as response:
|
|
return response.read().decode("utf-8", "replace")
|
|
except (urlerror.URLError, OSError, ValueError):
|
|
return None
|
|
|
|
def press(self, action):
|
|
return self.request(command="key", val=action)
|
|
|
|
def state(self):
|
|
"""playing, paused, stopped, or None while VLC is still coming up."""
|
|
body = self.request()
|
|
|
|
if not body:
|
|
return None
|
|
|
|
found = re.search(r"<state>(\w+)</state>", body)
|
|
|
|
return found.group(1) if found else None
|
|
|
|
|
|
class LoadingSurface(Gtk.Window):
|
|
"""The whole display, while the disc spins up.
|
|
|
|
Entering DVD mode has to look like entering DVD mode, not like an
|
|
application opening on the classroom desktop, so this goes up before
|
|
VLC is even started and covers everything until there is something
|
|
to show.
|
|
"""
|
|
|
|
def __init__(self, scale):
|
|
super().__init__()
|
|
|
|
self.set_name("classroom-dvd-loading")
|
|
self.set_decorated(False)
|
|
|
|
# Deliberately NOT app-paintable, and deliberately no RGBA visual.
|
|
# A GtkWindow only renders its own CSS background when the
|
|
# application is not painting the window itself, and this surface
|
|
# is nothing but background. Setting app_paintable here is what
|
|
# made an earlier version of this window invisible.
|
|
|
|
GtkLayerShell.init_for_window(self)
|
|
|
|
# OVERLAY rather than TOP. The dock is a TOP layer surface, and
|
|
# DVD mode has to cover it; OVERLAY is above it without depending
|
|
# on which surface sway happens to have created first. It is
|
|
# taken down the moment playback is on screen, so it never sits
|
|
# over the video.
|
|
GtkLayerShell.set_layer(self, GtkLayerShell.Layer.OVERLAY)
|
|
|
|
for edge in (
|
|
GtkLayerShell.Edge.TOP,
|
|
GtkLayerShell.Edge.BOTTOM,
|
|
GtkLayerShell.Edge.LEFT,
|
|
GtkLayerShell.Edge.RIGHT,
|
|
):
|
|
GtkLayerShell.set_anchor(self, edge, True)
|
|
|
|
# -1 means "do not move me out of anyone's way": the strip the
|
|
# dock reserves is part of the display like any other.
|
|
GtkLayerShell.set_exclusive_zone(self, -1)
|
|
GtkLayerShell.set_keyboard_interactivity(self, False)
|
|
|
|
card = Gtk.Box(
|
|
orientation=Gtk.Orientation.HORIZONTAL,
|
|
spacing=scaled(14, scale),
|
|
)
|
|
card.get_style_context().add_class("dock")
|
|
card.get_style_context().add_class("dvd-loading")
|
|
|
|
self.spinner = Gtk.Spinner()
|
|
self.spinner.set_size_request(scaled(28, scale), scaled(28, scale))
|
|
card.pack_start(self.spinner, False, False, 0)
|
|
|
|
label = Gtk.Label(label="Loading DVD\u2026")
|
|
card.pack_start(label, False, False, 0)
|
|
|
|
centred = Gtk.Alignment(xalign=0.5, yalign=0.5, xscale=0, yscale=0)
|
|
centred.add(card)
|
|
|
|
self.add(centred)
|
|
|
|
def show_all(self):
|
|
super().show_all()
|
|
self.spinner.start()
|
|
|
|
|
|
class ControlBar(Gtk.Window):
|
|
"""The classroom's DVD controls, above fullscreen video."""
|
|
|
|
def __init__(self, scale, buttons):
|
|
super().__init__()
|
|
|
|
self.scale = scale
|
|
self.height = scaled(BAR_HEIGHT, scale)
|
|
self.strip = scaled(HOVER_STRIP, scale)
|
|
self.idle_source = None
|
|
self.leave_source = None
|
|
self.revealed = False
|
|
|
|
screen = self.get_screen()
|
|
visual = screen.get_rgba_visual()
|
|
|
|
if visual is not None:
|
|
self.set_visual(visual)
|
|
|
|
self.set_app_paintable(True)
|
|
self.set_name("classroom-dvd-bar")
|
|
self.set_decorated(False)
|
|
|
|
GtkLayerShell.init_for_window(self)
|
|
|
|
# OVERLAY is the one layer sway draws above a fullscreen window.
|
|
GtkLayerShell.set_layer(self, GtkLayerShell.Layer.OVERLAY)
|
|
|
|
for edge in (
|
|
GtkLayerShell.Edge.BOTTOM,
|
|
GtkLayerShell.Edge.LEFT,
|
|
GtkLayerShell.Edge.RIGHT,
|
|
):
|
|
GtkLayerShell.set_anchor(self, edge, True)
|
|
|
|
GtkLayerShell.set_exclusive_zone(self, -1)
|
|
|
|
# Never take the keyboard: the disc menus need it.
|
|
GtkLayerShell.set_keyboard_interactivity(self, False)
|
|
|
|
self.set_size_request(-1, self.height)
|
|
|
|
bar = Gtk.Box(
|
|
orientation=Gtk.Orientation.HORIZONTAL,
|
|
spacing=scaled(10, scale),
|
|
)
|
|
bar.get_style_context().add_class("dock")
|
|
|
|
self.images = {}
|
|
|
|
for name, filename, callback in buttons:
|
|
button = Gtk.Button()
|
|
button.set_relief(Gtk.ReliefStyle.NONE)
|
|
button.get_style_context().add_class("dock-button")
|
|
|
|
pixbuf = icon(filename, scaled(ICON_SIZE, scale))
|
|
image = Gtk.Image.new_from_pixbuf(pixbuf) if pixbuf else Gtk.Image()
|
|
|
|
self.images[name] = image
|
|
button.add(image)
|
|
button.connect("clicked", callback)
|
|
|
|
bar.pack_start(button, False, False, 0)
|
|
|
|
centred = Gtk.Alignment(xalign=0.5, yalign=1.0, xscale=0, yscale=0)
|
|
centred.set_padding(0, scaled(BAR_INSET, scale), 0, 0)
|
|
centred.add(bar)
|
|
|
|
self.revealer = Gtk.Revealer()
|
|
self.revealer.set_transition_type(Gtk.RevealerTransitionType.SLIDE_UP)
|
|
self.revealer.set_transition_duration(220)
|
|
self.revealer.set_reveal_child(False)
|
|
self.revealer.set_valign(Gtk.Align.END)
|
|
self.revealer.add(centred)
|
|
|
|
self.add(self.revealer)
|
|
|
|
self.add_events(
|
|
Gdk.EventMask.ENTER_NOTIFY_MASK
|
|
| Gdk.EventMask.LEAVE_NOTIFY_MASK
|
|
| Gdk.EventMask.POINTER_MOTION_MASK
|
|
)
|
|
self.connect("enter-notify-event", self.on_enter)
|
|
self.connect("leave-notify-event", self.on_leave)
|
|
self.connect("motion-notify-event", self.on_motion)
|
|
# The shape has to be reapplied whenever the surface gets a
|
|
# size: at realize the allocation is still zero, which would
|
|
# leave a region nothing can ever enter.
|
|
self.connect("size-allocate", lambda *_: self.shape())
|
|
|
|
def shape(self):
|
|
"""Only take pointer events where the bar is actually reachable.
|
|
|
|
Concealed, that is a thin strip along the bottom edge, so a click
|
|
on a disc menu goes to VLC rather than to an invisible bar.
|
|
"""
|
|
if cairo is None:
|
|
return
|
|
|
|
window = self.get_window()
|
|
|
|
if window is None:
|
|
return
|
|
|
|
width = self.get_allocated_width()
|
|
height = self.get_allocated_height() or self.height
|
|
|
|
if width <= 0 or height <= 0:
|
|
return
|
|
|
|
if self.revealed:
|
|
area = cairo.RectangleInt(0, 0, width, height)
|
|
else:
|
|
area = cairo.RectangleInt(
|
|
0,
|
|
height - self.strip,
|
|
width,
|
|
self.strip,
|
|
)
|
|
|
|
window.input_shape_combine_region(cairo.Region(area), 0, 0)
|
|
|
|
def reveal(self):
|
|
if not self.revealed:
|
|
self.revealed = True
|
|
self.revealer.set_reveal_child(True)
|
|
self.shape()
|
|
|
|
self.arm_idle()
|
|
|
|
def conceal(self):
|
|
self.cancel(("idle_source", "leave_source"))
|
|
|
|
if self.revealed:
|
|
self.revealed = False
|
|
self.revealer.set_reveal_child(False)
|
|
self.shape()
|
|
|
|
return GLib.SOURCE_REMOVE
|
|
|
|
def cancel(self, names):
|
|
for name in names:
|
|
source = getattr(self, name)
|
|
|
|
if source is not None:
|
|
GLib.source_remove(source)
|
|
setattr(self, name, None)
|
|
|
|
def arm_idle(self):
|
|
self.cancel(("idle_source", "leave_source"))
|
|
self.idle_source = GLib.timeout_add_seconds(
|
|
IDLE_HIDE_SECONDS,
|
|
self.conceal,
|
|
)
|
|
|
|
def on_enter(self, *_):
|
|
self.reveal()
|
|
return False
|
|
|
|
def on_motion(self, *_):
|
|
self.reveal()
|
|
return False
|
|
|
|
def on_leave(self, *_):
|
|
self.cancel(("idle_source", "leave_source"))
|
|
self.leave_source = GLib.timeout_add_seconds(
|
|
LEAVE_HIDE_SECONDS,
|
|
self.conceal,
|
|
)
|
|
return False
|
|
|
|
def set_playing(self, playing):
|
|
image = self.images.get("play")
|
|
|
|
if image is None:
|
|
return
|
|
|
|
pixbuf = icon(
|
|
"media-pause.svg" if playing else "media-play.svg",
|
|
scaled(ICON_SIZE, self.scale),
|
|
)
|
|
|
|
if pixbuf is not None:
|
|
image.set_from_pixbuf(pixbuf)
|
|
|
|
|
|
class DvdSession:
|
|
def __init__(self):
|
|
self.config = read_device_config()
|
|
self.scale = SHELL_SCALE
|
|
|
|
self.device = optical.default_device()
|
|
self.port = free_port()
|
|
self.password = vlc.control_password()
|
|
self.control = VlcControl(self.port, self.password)
|
|
|
|
self.pid = None
|
|
self.closing = False
|
|
self.eject_on_exit = False
|
|
self.elapsed = 0
|
|
|
|
self.loading = LoadingSurface(self.scale)
|
|
self.bar = ControlBar(
|
|
self.scale,
|
|
[
|
|
("previous", "chapter-prev.svg", self.previous_chapter),
|
|
("play", "media-play.svg", self.play_pause),
|
|
("next", "chapter-next.svg", self.next_chapter),
|
|
("menu", "disc-menu.svg", self.disc_menu),
|
|
("eject", "eject.svg", self.eject),
|
|
("close", "close.svg", self.close),
|
|
],
|
|
)
|
|
|
|
# -- controls ---------------------------------------------------
|
|
|
|
def play_pause(self, *_):
|
|
self.control.press("play-pause")
|
|
|
|
def previous_chapter(self, *_):
|
|
self.control.press("chapter-prev")
|
|
|
|
def next_chapter(self, *_):
|
|
self.control.press("chapter-next")
|
|
|
|
def disc_menu(self, *_):
|
|
self.control.press("disc-menu")
|
|
|
|
def eject(self, *_):
|
|
self.eject_on_exit = True
|
|
self.close()
|
|
|
|
def close(self, *_):
|
|
if self.closing:
|
|
return
|
|
|
|
self.closing = True
|
|
|
|
# Ask, then insist.
|
|
self.control.press("quit")
|
|
GLib.timeout_add_seconds(2, self.insist)
|
|
|
|
def insist(self):
|
|
"""VLC did not take the hint. Ask the kernel."""
|
|
if self.pid is None:
|
|
Gtk.main_quit()
|
|
return GLib.SOURCE_REMOVE
|
|
|
|
try:
|
|
os.kill(self.pid, signal.SIGTERM)
|
|
except ProcessLookupError:
|
|
pass
|
|
|
|
GLib.timeout_add_seconds(2, self.finish)
|
|
|
|
return GLib.SOURCE_REMOVE
|
|
|
|
def finish(self):
|
|
if self.pid is not None:
|
|
try:
|
|
os.kill(self.pid, signal.SIGKILL)
|
|
except ProcessLookupError:
|
|
pass
|
|
|
|
Gtk.main_quit()
|
|
return GLib.SOURCE_REMOVE
|
|
|
|
# -- the player -------------------------------------------------
|
|
|
|
def start(self):
|
|
self.loading.show_all()
|
|
self.bar.show_all()
|
|
|
|
# The cover goes up first. VLC follows once it is actually on
|
|
# screen, so no part of its window is ever seen against the
|
|
# wallpaper.
|
|
GLib.timeout_add(LAUNCH_DELAY_MS, self.launch)
|
|
|
|
def launch(self):
|
|
command = vlc.player_command(self.device, self.port, self.password)
|
|
|
|
try:
|
|
self.pid, _, _, _ = GLib.spawn_async(
|
|
argv=command,
|
|
flags=GLib.SpawnFlags.SEARCH_PATH
|
|
| GLib.SpawnFlags.DO_NOT_REAP_CHILD,
|
|
)
|
|
except GLib.Error as error:
|
|
# A cover with nothing behind it is the one outcome DVD mode
|
|
# must never produce.
|
|
print(f"classroom-dvd-session: {error}", file=sys.stderr)
|
|
Gtk.main_quit()
|
|
return GLib.SOURCE_REMOVE
|
|
|
|
GLib.child_watch_add(GLib.PRIORITY_DEFAULT, self.pid, self.on_exit)
|
|
|
|
GLib.timeout_add(READY_POLL_MS, self.watch_startup)
|
|
GLib.timeout_add_seconds(STATUS_POLL_SECONDS, self.watch_state)
|
|
|
|
return GLib.SOURCE_REMOVE
|
|
|
|
def on_exit(self, pid, status, *_):
|
|
GLib.spawn_close_pid(pid)
|
|
self.pid = None
|
|
Gtk.main_quit()
|
|
|
|
def player_is_fullscreen(self):
|
|
"""True once VLC's window exists and has taken the whole output.
|
|
|
|
Playback state alone is not enough. VLC reports playing while its
|
|
window is still the ordinary tiled one sway gave it, which is the
|
|
black startup window the cover exists to hide. It only takes the
|
|
display when it goes fullscreen, and that is what the tree says.
|
|
"""
|
|
for window in sway.windows():
|
|
if sway.matches(window, VLC_WINDOW) and window["fullscreen"]:
|
|
return True
|
|
|
|
return False
|
|
|
|
def watch_startup(self):
|
|
"""Hold the cover until VLC is genuinely ready to replace it.
|
|
|
|
Three things have to line up: VLC says it is playing, its window
|
|
is fullscreen, and a moment has passed for the disc menu to draw.
|
|
The deadline is the safety net: DVD mode must never leave a cover
|
|
over a screen with nothing behind it, even if the disc never
|
|
opens.
|
|
"""
|
|
self.elapsed += READY_POLL_MS / 1000
|
|
|
|
# The cheap local check first; the tree is only worth walking
|
|
# once VLC claims to be playing something.
|
|
playing = self.control.state() in ("playing", "paused")
|
|
ready = playing and self.player_is_fullscreen()
|
|
|
|
if ready or self.elapsed >= LOADING_DEADLINE_SECONDS:
|
|
GLib.timeout_add(STABILISE_MS, self.drop_loading)
|
|
return GLib.SOURCE_REMOVE
|
|
|
|
return GLib.SOURCE_CONTINUE
|
|
|
|
def drop_loading(self):
|
|
self.loading.hide()
|
|
return GLib.SOURCE_REMOVE
|
|
|
|
def watch_state(self):
|
|
if self.closing:
|
|
return GLib.SOURCE_REMOVE
|
|
|
|
self.bar.set_playing(self.control.state() == "playing")
|
|
|
|
return GLib.SOURCE_CONTINUE
|
|
|
|
|
|
def load_css(scale):
|
|
try:
|
|
provider = Gtk.CssProvider()
|
|
provider.load_from_data(
|
|
(style.render(scale) + extra_css(scale)).encode("utf-8")
|
|
)
|
|
except (OSError, GLib.Error) as error:
|
|
print(f"classroom-dvd-session: {error}", file=sys.stderr)
|
|
return
|
|
|
|
Gtk.StyleContext.add_provider_for_screen(
|
|
Gdk.Screen.get_default(),
|
|
provider,
|
|
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION,
|
|
)
|
|
|
|
|
|
def take_lock():
|
|
"""One DVD session at a time, however fast the button is pressed."""
|
|
directory = Path(os.environ.get("XDG_RUNTIME_DIR") or "/tmp")
|
|
directory = directory / "ekklesia-classroom"
|
|
|
|
try:
|
|
directory.mkdir(parents=True, exist_ok=True)
|
|
handle = open(directory / "dvd.lock", "w", encoding="utf-8")
|
|
fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
|
except (OSError, BlockingIOError):
|
|
return None
|
|
|
|
return handle
|
|
|
|
|
|
def main():
|
|
lock = take_lock()
|
|
|
|
if lock is None:
|
|
print("classroom-dvd-session: already running", file=sys.stderr)
|
|
return 0
|
|
|
|
if optical.default_device() is None:
|
|
print("classroom-dvd-session: no optical drive", file=sys.stderr)
|
|
return 1
|
|
|
|
load_css(SHELL_SCALE)
|
|
|
|
session = DvdSession()
|
|
session.start()
|
|
|
|
Gtk.main()
|
|
|
|
if session.eject_on_exit:
|
|
optical.eject(session.device)
|
|
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|