#!/usr/bin/env python3 """Frametop Display Settings: the Frametop screens' count, resolution, size, scale, and layout. A Kirigami (QML) app with a Python backend, like Frametop Input Settings. It runs in the dev container: - Screens (ft-screens backend): each screen's resolution (any, portrait too), its width in VR in metres, its scale, and which one has the taskbar. Resolution and width apply at once (ft-screens' control socket, @ft_screens); adding or removing a screen when the desktop starts again. (gamescope backend: one shared resolution, at most 1920x1080 worth of pixels, rotation for portrait.) - Visibility (ft-screens): when the screens show (always, only with the SteamVR dashboard open, while you look at a controller, or only when toggled), the wrist angle within which a pinned screen shows, and pinning each screen to a wrist or your head. - Layout: a preset (curved or flat, rows, distance, gap, height) or a named layout saved from where the screens are, with a preview; arrange now; save the current arrangement under a name; rename and delete; arrange automatically when the desktop starts. - Power: how long the headset can go unused before ft-powerd turns its displays off (DISPLAY_OFF_MIN; the service's state comes from its control socket, @ft_powerd), and whether the Frame stays awake while plugged in, which is Steam's own setting (steam_settings.py; the value from before is kept as STEAM_SLEEP_AC_BEFORE). Settings go to ~/.config/frametop.conf and ~/.config/frametop-layout.json. Anything that touches SteamVR runs layout/ft-layout on the host. Launch with display-settings/ft-display-settings (host wrapper). """ import os import shutil import socket import sys import threading from PySide6.QtCore import Property, QObject, QProcess, Qt, QTimer, QUrl, Signal, Slot from PySide6.QtGui import QGuiApplication, QIcon from PySide6.QtQml import QQmlApplicationEngine from PySide6.QtQuickControls2 import QQuickStyle HERE = os.path.dirname(os.path.abspath(__file__)) LAYOUT_DIR = os.path.join(HERE, "..", "layout") sys.path.insert(0, LAYOUT_DIR) import ft_layout # noqa: E402 (pure Python: the same geometry ft-layout uses) import steam_settings # noqa: E402 FT_LAYOUT = os.path.join(LAYOUT_DIR, "ft-layout") DESKTOPS = os.path.join(HERE, "..", "desktops.sh") CONF_PATH = ft_layout.CONF_PATH # gamescope's VR backend uploads a texture the size of a screen at start, through a # 1920x1080x4-byte buffer: more pixels than 1920x1080 abort it (see the design notes). MAX_PIXELS = 1920 * 1080 RESOLUTIONS = [(1280, 720), (1600, 900), (1920, 1080), (1728, 1080), (1920, 800), (2224, 928), (2560, 800)] # ft-screens has no pixel limit; portrait screens are just tall. SCREEN_RESOLUTIONS = [(1920, 1080, ""), (2560, 1440, ""), (3840, 2160, "4K"), (2560, 1080, "ultrawide"), (3440, 1440, "ultrawide"), (5120, 1440, "super ultrawide"), (1920, 1200, "16:10"), (2560, 1600, "16:10"), (1080, 1920, "portrait"), (1440, 2560, "portrait"), (2160, 3840, "portrait 4K")] FT_SCREENS = "\0ft_screens" FT_POWERD = "\0ft_powerd" # Steam's default for "When Plugged In and Idle -> Sleep after", to go back to when # nothing was saved. STEAM_SLEEP_AC_DEFAULT = 3600 SCALES = [0.75, 1.0, 1.25, 4 / 3, 1.5, 1.75, 2.0] ROTATIONS = [("normal", "Landscape"), ("left", "Portrait"), ("right", "Portrait (flipped)")] def write_conf_value(key, value): """Set KEY=value in frametop.conf, keeping comments and the rest of the file.""" try: with open(CONF_PATH) as f: lines = f.read().splitlines() except OSError: lines = [] for i, line in enumerate(lines): if line.split("#", 1)[0].strip().startswith(f"{key}="): comment = line[line.index("#"):] if "#" in line else "" lines[i] = f"{key}={value}" + (f" {comment}" if comment else "") break else: lines.append(f"{key}={value}") with open(CONF_PATH, "w") as f: f.write("\n".join(lines) + "\n") def host_command(*cmd): """argv to run a command on the SteamOS host (we live in the dev container). distrobox-host-exec reaches the host through the user's real session bus; inside the desktop our DBUS_SESSION_BUS_ADDRESS is the nested session's private one, where it fails (exit 127, silently).""" if not shutil.which("distrobox-host-exec"): return list(cmd) bus = f"unix:path=/run/user/{os.getuid()}/bus" return ["env", f"DBUS_SESSION_BUS_ADDRESS={bus}", "distrobox-host-exec"] + list(cmd) class Backend(QObject): changed = Signal() busyChanged = Signal() powerChanged = Signal() message = Signal(str, bool) # text, is error _steamDone = Signal(object, object, str) # Steam's sleep settings or None, error or None, what was done def __init__(self): super().__init__() self._busy = "" self._proc = None self._running = False self._running_count = 0 self._sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM) self._sock.bind("") # an abstract address ft-screens can reply to self._sock.settimeout(1.0) self._started = {} # conf values the running desktop started with self._psock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM) self._psock.bind("") # for ft-powerd's replies self._psock.settimeout(0.5) self._powerd = None # ft-powerd's status: (state, seconds unused, timeout seconds); None: not running self._steam = None # Steam's sleep settings: {"ac": seconds, "battery": seconds} self._steam_error = "" self._steam_busy = False self._steamDone.connect(self._steam_done, Qt.QueuedConnection) self._pins = [] # each running screen's pin: none | left | right | head self.poll = QTimer(interval=3000, timeout=self._check_running) self.poll.start() self._check_running() # --- state --- def _conf(self): conf = ft_layout.read_conf() def num(key, default, cast=float): try: return cast(conf.get(key, default)) except ValueError: return default return {"screens": num("SCREENS", 2, int), "width": num("WIDTH", 1920, int), "height": num("HEIGHT", 1080, int), "physWidth": num("PHYS_WIDTH", 1.6)} def _check_running(self): # The session's own Wayland socket (host processes' environments aren't readable # from the container, so ft_layout.nested_env() doesn't work here). running = os.path.exists(f"/run/user/{os.getuid()}/frametop/wayland-0") count = self._screens_running() if running and ft_layout.backend() == "screens" else 0 pins = self._read_pins(count) if running != self._running or count != self._running_count or pins != self._pins: if running != self._running or count != self._running_count: self._started = self._conf() if running else {} self._running = running self._running_count = count self._pins = pins self.changed.emit() self._check_powerd() def _read_pins(self, count): pins = [] for i in range(count): reply = self._ask_screens(f"get {i + 1}") f = reply.split() if reply and reply.startswith("ok") else [] pins.append(f[16] if len(f) > 16 else "none") return pins def _ask_screens(self, text): """Request/reply to ft-screens; None if it isn't running.""" try: self._sock.sendto(text.encode(), FT_SCREENS) return self._sock.recv(4096).decode() except OSError: return None def _screens_running(self): reply = self._ask_screens("screens") return int(reply.split()[1]) if reply and reply.startswith("ok") else 0 @Property(bool, notify=changed) def desktopRunning(self): return self._running @Property(str, notify=changed) def backend(self): return ft_layout.backend() @Property(bool, notify=changed) def restartNeeded(self): """ft-screens: screens added or removed since the desktop started; gamescope: count, resolution, or width changed.""" if not self._running: return False if ft_layout.backend() == "screens": return self._running_count != ft_layout.screen_count(ft_layout.load_layout()) return bool(self._started) and self._started != self._conf() @Property("QVariantList", constant=True) def screenResolutions(self): return [{"text": f"{w} × {h}" + (f" ({t})" if t else ""), "width": w, "height": h} for w, h, t in SCREEN_RESOLUTIONS] @Property(int, notify=changed) def screens(self): return self._conf()["screens"] @Property(int, notify=changed) def width(self): return self._conf()["width"] @Property(int, notify=changed) def height(self): return self._conf()["height"] @Property(float, notify=changed) def physWidth(self): return self._conf()["physWidth"] @Property("QVariantList", constant=True) def resolutions(self): return [{"text": f"{w} × {h}", "width": w, "height": h} for w, h in RESOLUTIONS] @Property("QVariantList", constant=True) def scales(self): return [{"text": f"{round(s * 100)}%", "value": round(s, 4)} for s in SCALES] @Property("QVariantList", constant=True) def rotations(self): return [{"text": t, "value": v} for v, t in ROTATIONS] @Property("QVariantList", notify=changed) def screenList(self): c, layout = self._conf(), ft_layout.load_layout() out = [] if ft_layout.backend() == "screens": primary = ft_layout.primary_screen(layout) for i in range(ft_layout.screen_count(layout)): w, h = ft_layout.screen_pixels(layout, i) s = ft_layout.screen_scale(layout, i) out.append({"index": i, "width": w, "height": h, "metres": ft_layout.screen_metres(layout, i), "scale": round(s, 4), "primary": i == primary, "curved": float(ft_layout.screen_entry(layout, i).get("curve", 0)) > 0, "effective": f"{round(w / s)} × {round(h / s)}"}) return out for i in range(c["screens"]): s = ft_layout.screen_scale(layout, i) rot = ft_layout.screen_rotation(layout, i) w, h = (c["height"], c["width"]) if rot != "normal" else (c["width"], c["height"]) out.append({"index": i, "scale": round(s, 4), "rotation": rot, "effective": f"{round(w / s)} × {round(h / s)}"}) return out @Property("QVariantMap", notify=changed) def layout(self): return ft_layout.load_layout() @Property("QVariantList", notify=changed) def plan(self): """The arrangement in the head frame, for the preview.""" layout = ft_layout.load_layout() c = self._conf() # Before any panel was measured: the width SteamVR floats a panel at, and the aspect. if "panel_size" not in layout or layout["panel_size"] == list(ft_layout.DEFAULT_PANEL): layout["panel_size"] = [ft_layout.DEFAULT_PANEL[0], ft_layout.DEFAULT_PANEL[0] * c["height"] / c["width"]] out = [] for i, t in enumerate(ft_layout.plan(layout, c["screens"])): w, h = ft_layout.screen_size(layout, i) out.append({"index": i, "x": t["pos"][0], "y": t["pos"][1], "z": t["pos"][2], "faceYaw": t["face"][0], "facePitch": t["face"][1], "width": w, "height": h}) return out @Property(str, notify=busyChanged) def busy(self): return self._busy # --- screens --- @Slot(int) def setScreens(self, n): write_conf_value("SCREENS", str(max(1, min(6, n)))) self.changed.emit() @Slot(int, int) def setResolution(self, w, h): if w * h > MAX_PIXELS: self.message.emit(f"{w} × {h} is more than gamescope's VR mode can draw (1920 × 1080 worth of pixels, " f"about {MAX_PIXELS // 1000} thousand); try {round((MAX_PIXELS * w / h) ** 0.5) // 8 * 8} × " f"{round((MAX_PIXELS * h / w) ** 0.5) // 8 * 8}", True) return if w >= 640 and h >= 360: write_conf_value("WIDTH", str(w)) write_conf_value("HEIGHT", str(h)) self.changed.emit() @Slot(float) def setPhysWidth(self, w): write_conf_value("PHYS_WIDTH", f"{w:.2f}") self.changed.emit() @Slot(int, float) def setScale(self, i, s): layout = ft_layout.load_layout() screens = layout.setdefault("screens", []) while len(screens) <= i: screens.append({}) screens[i]["scale"] = s ft_layout.save_layout(layout) self.changed.emit() if self._running: self._run("Applying scale", "scale") @Slot(int, str) def setRotation(self, i, rotation): layout = ft_layout.load_layout() screens = layout.setdefault("screens", []) while len(screens) <= i: screens.append({}) screens[i]["rotation"] = rotation screens[i].pop("roll", None) # a saved arrangement follows the new rotation ft_layout.save_layout(layout) self.changed.emit() if self._running: self._run("Rotating", "scale") # --- ft-screens: per-screen resolution and size --- def _edit_screen(self, i, fn): layout = ft_layout.load_layout() screens = layout.setdefault("screens", []) while len(screens) <= i: screens.append({"size": [1920, 1080], "metres": 1920 / ft_layout.PIXELS_PER_METRE}) fn(screens[i]) ft_layout.save_layout(layout) self.changed.emit() @Slot(int, int, int) def setScreenSize(self, i, w, h): if not (320 <= w <= 16384 and 200 <= h <= 16384): self.message.emit("Width and height: 320 to 16384 pixels", True) return self._edit_screen(i, lambda s: s.__setitem__("size", [w, h])) if self._running and i < self._running_count: self._ask_screens(f"size {i + 1} {w} {h}") @Slot(int, float) def setScreenMetres(self, i, m): self._edit_screen(i, lambda s: s.__setitem__("metres", round(m, 3))) if self._running and i < self._running_count: self._ask_screens(f"width {i + 1} {m:.3f}") @Slot(int, bool) def setCurved(self, i, on): """Curve a screen into a cylinder around you (radius: your distance to it now, from ft-screens; the layout's distance if the desktop isn't running).""" radius = float(ft_layout.load_layout()["preset"].get("distance", 2.0)) if on else 0.0 if self._running and i < self._running_count: reply = self._ask_screens(f"curve {i + 1} {'on' if on else 'off'}") if reply and reply.startswith("ok"): radius = float(reply.split()[1]) self._edit_screen(i, lambda s: s.__setitem__("curve", round(radius, 3))) @Slot(int) def setPrimary(self, i): layout = ft_layout.load_layout() layout["primary"] = i + 1 ft_layout.save_layout(layout) self.changed.emit() if self._running: self._run("Moving the taskbar", "scale") @Slot() def addScreen(self): layout = ft_layout.load_layout() layout.setdefault("screens", []).append({"size": [1920, 1080], "metres": 1920 / ft_layout.PIXELS_PER_METRE}) ft_layout.save_layout(layout) self.changed.emit() @Slot(int) def removeScreen(self, i): layout = ft_layout.load_layout() screens = layout.get("screens", []) if len(screens) <= 1 or i >= len(screens): return screens.pop(i) if layout.get("primary") == i + 1: layout.pop("primary") ft_layout.save_layout(layout) self.changed.emit() @Slot() def toggleScreens(self): self._ask_screens("toggle") # --- ft-screens: visibility and pinning --- @Property("QVariantMap", notify=changed) def visibility(self): return ft_layout.visibility(ft_layout.load_layout()) @Slot(str, "QVariant") def setVisibility(self, key, value): layout = ft_layout.load_layout() v = ft_layout.visibility(layout) v[key] = value layout["visibility"] = v ft_layout.save_layout(layout) self.changed.emit() if self._running: if key == "mode": self._ask_screens(f"visibility {value}") elif key == "wrist_angle": self._ask_screens(f"wrist {float(value):.1f}") elif key == "controllers": self._ask_screens(f"controllers {value}") elif key == "in_games": self._ask_screens(f"ingames {value}") else: self._ask_screens(f"gesture {v['gesture_hand']} {float(v['gesture_angle']):.1f}") @Property("QVariantList", notify=changed) def pins(self): return self._pins @Property("QVariantList", notify=changed) def screensShown(self): """For each screen, whether it shows (False: hidden on its own, ft-layout hide N).""" layout = ft_layout.load_layout() return [not ft_layout.screen_entry(layout, i).get("hidden") for i in range(ft_layout.screen_count(layout))] @Slot(int, bool) def setScreenShown(self, index, shown): """Hide screen `index` (0-based) on its own, whatever the visibility mode, or show it.""" layout = ft_layout.load_layout() screens = layout.setdefault("screens", []) while len(screens) <= index: screens.append({}) if shown: screens[index].pop("hidden", None) else: screens[index]["hidden"] = True ft_layout.save_layout(layout) self.changed.emit() if self._running: reply = self._ask_screens(f"{'reveal' if shown else 'conceal'} {index + 1}") if not (reply and reply.startswith("ok")): self.message.emit("Saved; the desktop applies it when it next starts " "(its compositor is older than hiding screens one at a time)", False) @Slot(str, str) def pin(self, which, where): """Pin screen `which` (1-based, or "all") to "left", "right", or "head" as it is now, or take it off ("none").""" cmd = f"unpin {which}" if where == "none" else f"pin {which} {where}" reply = self._ask_screens(cmd) if self._running else None if not (reply and reply.startswith("ok")): self.message.emit(f"Couldn't {'unpin' if where == 'none' else 'pin'}: " f"{reply or 'the desktop is not running'}", True) elif which == "all" and where != "none": place = "on your head" if where == "head" else f"on your {where} wrist" self.message.emit(f"All screens ride {place} now. Save current arrangement (Layout) keeps it.", False) self._check_running() # --- power: ft-powerd and Steam's sleep setting --- def _check_powerd(self): try: self._psock.sendto(b"status", FT_POWERD) reply = self._psock.recv(256).decode().split() status = (reply[1], float(reply[2]), float(reply[3])) if reply[:1] == ["ok"] else None except (OSError, IndexError, ValueError): status = None if status != self._powerd: self._powerd = status self.powerChanged.emit() @Property("QVariantMap", notify=powerChanged) def power(self): try: off_min = float(ft_layout.read_conf().get("DISPLAY_OFF_MIN") or 0) except ValueError: off_min = 0.0 state, unused, _ = self._powerd or ("", 0, 0) return {"offMinutes": off_min, "service": self._powerd is not None, "state": state, "unused": unused, "steam": self._steam is not None, "steamBusy": self._steam_busy, "steamError": self._steam_error, "acSleep": self._steam["ac"] if self._steam else -1, "batterySleep": self._steam["battery"] if self._steam else -1} @Slot(float) def setDisplayOffMinutes(self, minutes): """ft-powerd re-reads frametop.conf within 2 s.""" write_conf_value("DISPLAY_OFF_MIN", f"{max(0.0, minutes):g}") self.powerChanged.emit() @Slot() def displaysOffNow(self): try: self._psock.sendto(b"off", FT_POWERD) reply = self._psock.recv(256).decode() except OSError: reply = "error the power service isn't running" if not reply.startswith("ok"): self.message.emit(f"Couldn't turn the displays off: {reply.split(' ', 1)[-1]}", True) self._check_powerd() def _steam_call(self, what, fn): """Runs fn, which talks to Steam (up to a few seconds), off the UI thread, then reads Steam's sleep settings; _steam_done gets them on the UI thread.""" if self._steam_busy: return self._steam_busy = True self.powerChanged.emit() def work(): try: fn() self._steamDone.emit(steam_settings.sleep_settings(), None, what) except (steam_settings.SteamUnreachable, OSError, ValueError) as e: self._steamDone.emit(None, str(e), what) threading.Thread(target=work, daemon=True).start() def _steam_done(self, settings, error, what): self._steam_busy = False if settings is not None: self._steam, self._steam_error = settings, "" else: self._steam, self._steam_error = None, error if what: self.message.emit(f"Couldn't change Steam's sleep setting: {error}", True) self.powerChanged.emit() @Slot() def refreshPower(self): self._check_powerd() self._steam_call("", lambda: None) @Slot(bool) def setStayAwake(self, on): """Steam's "When Plugged In and Idle -> Sleep after" is Never while this is on. The value from before is kept in frametop.conf and goes back when it's turned off.""" def change(): ac = steam_settings.sleep_settings()["ac"] if on: if ac > 0: write_conf_value("STEAM_SLEEP_AC_BEFORE", str(ac)) steam_settings.set_sleep_setting("system_idle_suspend_ac_sec", 0) elif ac == 0: try: before = int(ft_layout.read_conf().get("STEAM_SLEEP_AC_BEFORE") or STEAM_SLEEP_AC_DEFAULT) except ValueError: before = STEAM_SLEEP_AC_DEFAULT steam_settings.set_sleep_setting("system_idle_suspend_ac_sec", before if before > 0 else STEAM_SLEEP_AC_DEFAULT) self._steam_call("stay awake" if on else "sleep", change) @Slot() def restartDesktop(self): """Restart the Frametop desktop (this app closes with it) to apply count and resolution.""" argv = host_command("systemd-run", "--user", "--collect", "--quiet", os.path.abspath(DESKTOPS), "restart") QProcess.startDetached(argv[0], argv[1:]) self.message.emit("Restarting the desktop…", False) # --- layout --- def _edit_layout(self, fn): layout = ft_layout.load_layout() fn(layout) ft_layout.save_layout(layout) self.changed.emit() @Slot(str) def setMode(self, mode): def edit(layout): layout["mode"] = mode layout.pop("active", None) self._edit_layout(edit) @Property("QVariantList", notify=changed) def layoutNames(self): return ft_layout.layout_names(ft_layout.load_layout()) @Slot(str) def useLayout(self, name): """A named layout as the arrangement (Arrange now puts the screens there).""" try: self._edit_layout(lambda l: ft_layout.use_named(l, name)) except RuntimeError as e: self.message.emit(str(e), True) @Slot(str) def saveLayout(self, name): try: ft_layout.check_name(name) except RuntimeError as e: return self.message.emit(str(e), True) self._run(f"Saving the arrangement as {' '.join(name.split())}", "save", name) @Slot(str, str) def renameLayout(self, old, new): try: self._edit_layout(lambda l: ft_layout.rename_named(l, old, new)) ft_layout.write_launchers(ft_layout.load_layout()) except (RuntimeError, OSError) as e: self.message.emit(str(e), True) @Slot(str) def deleteLayout(self, name): try: self._edit_layout(lambda l: ft_layout.delete_named(l, name)) ft_layout.write_launchers(ft_layout.load_layout()) except (RuntimeError, OSError) as e: self.message.emit(str(e), True) # --- profiles (docs/profiles.md): a named layout's apps and hidden screens --- @Slot(str, result="QVariantList") def profileWindows(self, name): """A profile's windows, as "app" and "where" for the list.""" out = [] for e in ft_layout.load_layout().get("profiles", {}).get(name, {}).get("windows", []): app = e.get("app") or os.path.basename((e.get("cmd") or ["?"])[0]) app = app.rsplit(".", 1)[-1] if "." in app and not e.get("cmd") else app where = "floating" if "float" in e else f"screen {e.get('screen', 1)}" + (", maximized" if e.get("maximized") else "") out.append({"app": app, "where": where}) return out @Slot(str, result="QVariantList") def profileHidden(self, name): return ft_layout.load_layout().get("profiles", {}).get(name, {}).get("hidden", []) @Slot(str, int) def removeProfileWindow(self, name, index): def edit(layout): windows = layout.get("profiles", {}).get(name, {}).get("windows", []) if 0 <= index < len(windows): windows.pop(index) self._edit_layout(edit) @Property(str, notify=changed) def defaultProfile(self): return ft_layout.load_layout().get("default_profile", "") @Slot(str) def setDefaultProfile(self, name): def edit(layout): if name: layout["default_profile"] = name else: layout.pop("default_profile", None) self._edit_layout(edit) @Slot(str, "QVariant") def setPreset(self, key, value): def edit(layout): layout["mode"] = "preset" layout["preset"][key] = value self._edit_layout(edit) @Slot(bool) def setAuto(self, on): self._edit_layout(lambda l: l.__setitem__("auto", bool(on))) @Slot() def arrange(self): """Arrange the screens; in a profile, also open its apps (ft-layout use).""" layout = ft_layout.load_layout() name = layout.get("active") if layout.get("mode") == "custom" and name in layout.get("layouts", {}): self._run(f"Opening {name}", "use", name) else: self._run("Arranging the screens", "apply") @Slot() def capture(self): self._run("Saving the current arrangement", "capture") # --- ft-layout on the host --- def _run(self, label, *args): if self._proc is not None: self.message.emit(f"Still busy: {self._busy}", True) return self._busy = label self.busyChanged.emit() proc = QProcess(self) proc.setProcessChannelMode(QProcess.MergedChannels) argv = host_command(os.path.abspath(FT_LAYOUT), *args) proc.finished.connect(lambda code, _status: self._done(proc, label, code)) self._proc = proc proc.start(argv[0], argv[1:]) def _done(self, proc, label, code): out = bytes(proc.readAllStandardOutput()).decode(errors="replace").strip() self._proc = None self._busy = "" self.busyChanged.emit() self.changed.emit() last = out.splitlines()[-1] if out else "" if code == 0: self.message.emit(f"{label}: done" + (f" ({last})" if last and not last.startswith("ok") else ""), False) else: self.message.emit(f"{label} failed: {last or 'exit code ' + str(code)}", True) def main(): app = QGuiApplication(sys.argv) app.setApplicationName("ft-display-settings") app.setApplicationDisplayName("Frametop Display Settings") app.setDesktopFileName("ft-display-settings") if not QIcon.themeName(): QIcon.setThemeName("breeze") QQuickStyle.setStyle("org.kde.desktop") engine = QQmlApplicationEngine() backend = Backend() engine.rootContext().setContextProperty("backend", backend) engine.rootContext().setContextProperty("startPage", os.environ.get("FT_DISPLAY_PAGE", "screens")) engine.load(QUrl.fromLocalFile(os.path.join(HERE, "main.qml"))) if not engine.rootObjects(): sys.exit(1) sys.exit(app.exec()) if __name__ == "__main__": main()