chore: clean up test blockage

fix: missing shortcuts file

dzgui/api/shortcuts.py

@@ -11,7 +11,7 @@ from typing import Any
 
 from dzgui.api.steam import find_user_id_32
 from dzgui.const.constants import APP_NAME, APP_NAME_LOWER, IMAGES_PATH
-from dzgui.util.dirs import copy_dzgui_to_xdg_data
+from dzgui.util.dirs import copy_dzgui_to_xdg_data, make_parents
 from dzgui.util.strings import unknown
 
 logger = logging.getLogger(APP_NAME)
@@ -75,6 +75,8 @@ class Shortcuts:
                 shortcuts = vdf.binary_load(f)
             self.shortcuts = shortcuts
             logger.debug("Loaded shortcuts file")
+        except FileNotFoundError:
+            self.shortcuts = {"shortcuts": {}}
         except Exception as e:
             logger.critical(e)
             raise e
@@ -109,6 +111,7 @@ class Shortcuts:
         for img in ("_hero", "p", "_logo"):
             filename = str(self.bpid) + img
             dest = grid_path.joinpath(filename).with_suffix(".png")
+            make_parents(dest)
             b = images.joinpath(img).with_suffix(".png").read_bytes()
             dest.write_bytes(b)
 
@@ -156,6 +159,7 @@ class Shortcuts:
         NEW_ENTRY["DevkitOverrideAppID"] = 0
         NEW_ENTRY["LastPlayTime"] = 0
         NEW_ENTRY["FlatpakAppID"] = ""
+
         NEW_ENTRY["sortas"] = ""
         NEW_ENTRY["tags"] = {}
         return NEW_ENTRY
@@ -172,6 +176,9 @@ class Shortcuts:
         try:
             backup = self.shortcuts_path.with_suffix(".vdf.bak")
             shutil.copy(self.shortcuts_path, backup)
+        except Exception as e:
+            logger.critical(e)
+        try:
             with open(self.shortcuts_path, "wb") as f:
                 vdf.binary_dump(self.shortcuts, f)
         except Exception as e:

dzgui/api/steam.py

@@ -1,17 +1,19 @@
 import logging
 import os
 import psutil
+import re
 import requests
 import subprocess
 import vdf  # type: ignore
 
 from pathlib import Path
 from requests.exceptions import HTTPError
-from typing import Any, Union
+from typing import Any, Generator, Union
 from warnings import deprecated
 
 from dzgui.api.acf import ACF
-from dzgui.init.prereqs import has_steam_client
+from dzgui.init.prereqs import has_any_client
+from dzgui.init.proc import has_cmd
 from dzgui.const.constants import (
     APPID_DAYZ,
     APPID_DAYZ_EXP,
@@ -20,6 +22,8 @@ from dzgui.const.constants import (
     DAYZ_LAUNCHER,
     DEBIAN_STEAM_PATH,
     DEFAULT_STEAM_PATH,
+    DOWNLOADS_PATH,
+    FLATPAK_CMD,
     FLATPAK_STEAM_PATH,
     LIBRARYFOLDERS_PATH,
     UBUNTU_STEAM_PATH,
@@ -59,7 +63,7 @@ class VDFLoadError(Exception):
 
 def get_steam_paths() -> list[tuple[Path, str]]:
     paths = []
-    if has_steam_client():
+    if has_any_client():
         HOME = Path.home()
         env = os.environ.get("XDG_DATA_HOME")
         if env is not None:
@@ -80,6 +84,8 @@ def get_steam_paths() -> list[tuple[Path, str]]:
         }
 
         for path in DEFAULT_PATH, FLATPAK_PATH, UBUNTU_PATH, DEBIAN_PATH:
+            if path is FLATPAK_PATH and has_cmd(FLATPAK_CMD) is False:
+                continue
             if path.joinpath(VDF_PATH).is_file():
                 paths.append((path, human[path]))
     return paths
@@ -196,6 +202,7 @@ def load_to_menu(client: str, appid: int, name: str, mods: list[str]) -> int:
     """Loads to the menu screen with the selected mods; used for AFK/pre-joining"""
     concat = concat_mods(mods)
     client_args = concat_bash_args(client)
+    logger.debug(f"Setting client arguments to: {client_args}")
     params = [
         "-applaunch",
         str(appid),
@@ -245,9 +252,9 @@ def find_user_id(path: Path) -> str | None:
             last_user = str(next(iter(users)))
             if len(users) == 1:
                 return last_user
-            last_stamp = int(users[last_user]["Timestamp"])
+            last_stamp = int(users[last_user]["timestamp"])
             for user in users:
-                stamp = int(users[user]["Timestamp"])
+                stamp = int(users[user]["timestamp"])
                 if stamp > last_stamp:
                     last_stamp = stamp
                     last_user = user
@@ -265,12 +272,12 @@ def find_user_id_32(path: Path) -> int:
 
 
 class SteamAPIKeyError(Exception):
-    def __init__(self, msg: str | None = None):
+    def __init__(self, msg: str | None = None) -> None:
         super().__init__(msg or api_validation_error)
 
 
 class SteamWorkshopEndpointError(Exception):
-    def __init__(self, msg: str | None = None):
+    def __init__(self, msg: str | None = None) -> None:
         super().__init__(msg or workshop_endpoint_error)
 
 
@@ -439,6 +446,22 @@ def is_dayz_running() -> bool:
     return any(s in item for sublist in procs for item in sublist for s in substring)
 
 
+def get_pending_downloads(steam_path: Path, appid: int) -> Generator[Path, None, None]:
+    root_path = get_app_path(steam_path, appid)
+    downloads_dir = root_path / DOWNLOADS_PATH
+    files = downloads_dir.iterdir()
+    return files
+
+
+def is_dayz_downloading(steam_path: Path, appid: int) -> bool:
+    files = get_pending_downloads(steam_path, appid)
+    reg = re.compile(rf"^state_(?:{APPID_DAYZ_EXP}|{APPID_DAYZ})_.*\.patch$")
+    pending = [f for f in files if reg.match(f.name)]
+    if len(pending) > 0:
+        return True
+    return False
+
+
 def get_app_path(folders_path: Path, appid: int) -> Path:
     app_path = None
 

dzgui/app_init.py

@@ -1,10 +1,13 @@
 import logging
 import os
 import shutil
+
+from pathlib import Path
 from typing import TYPE_CHECKING
+from warnings import deprecated
 
 
-from dzgui.const.constants import APP_NAME
+from dzgui.const.constants import APP_NAME, STEAM_ICON, STEAM_ICONS_PATH
 from dzgui.const.enum import Preferences
 from dzgui.config.query import lookup
 from dzgui.config.userprefs import UserPrefs
@@ -15,7 +18,7 @@ from dzgui.init.migrate import (
     migrate_cols_file,
 )
 from dzgui.init.flock import lock_acquire
-from dzgui.init.prereqs import has_steam_client
+from dzgui.init.prereqs import has_any_client
 from dzgui.strings import boot
 
 from dzgui.util.deck import is_steam_deck, is_game_mode
@@ -23,7 +26,7 @@ from dzgui.util.dirs import make_parents
 from dzgui.util.localize import set_locale
 from dzgui.util.map_count import test_map_count
 from dzgui.util.redact import RedactionFilter, REDACTION_PATTERNS
-from dzgui.util.strings import init
+from dzgui.util.strings import init, steam_icon_missing
 
 from dzgui.views.base import App
 from dzgui.views.dialogs.boot import BootWindow
@@ -96,6 +99,28 @@ def copy_bare_configs(config: "Path", resolution: "Path") -> tuple[bool, bool]:
     return (config_changed, state_changed)
 
 
+@deprecated("Currently unused")
+def load_steam_icon(config: Path) -> None:
+    import gi
+
+    gi.require_version("Gtk", "3.0")
+    from gi.repository import Gtk  # noqa
+
+    default = lookup(config, Preferences.DEFAULT)
+    icon_path = Path(default).joinpath(STEAM_ICONS_PATH)
+    try:
+        theme = Gtk.IconTheme.get_default()
+        paths = theme.get_search_path()
+        theme.set_search_path(paths + [str(icon_path)])
+        paths = theme.get_search_path()
+        icons = theme.list_icons(None)
+        if STEAM_ICON not in icons:
+            logger.warning(steam_icon_missing)
+    except Exception as e:
+        print(e)
+        logger.warning(e)
+
+
 def load_gui(version: str, is_debug: bool) -> None:
     lock = lock_acquire()  # noqa
 
@@ -123,7 +148,7 @@ def load_gui(version: str, is_debug: bool) -> None:
         migrate_cols_file(XDG.columns)
         copy_state_files(xdg_paths["XDG_STATE_HOME"])
         # TODO: add logging inside wizard
-        wizard = SetupWizard(_is_steam_deck, XDG)
+        wizard = SetupWizard(_is_steam_deck, XDG, xdg_paths)
 
         if not wizard.is_setup_complete():
             return
@@ -136,13 +161,14 @@ def load_gui(version: str, is_debug: bool) -> None:
         # TODO: sudo escalation dialog
         # count = get_map_count()
         # TODO: move into module
-        if has_steam_client() is False:
+        if has_any_client() is False:
             EarlyAlertDialog(init.requires_steam)
 
     bootwin = BootWindow(XDG, version)
     local_coords, latest_release = bootwin.get_results()
 
     use_miles = lookup(XDG.config, Preferences.DIST)
+
     prefs = UserPrefs(
         is_steam_deck=_is_steam_deck,
         is_game_mode=_is_game_mode,

dzgui/config/query.py

@@ -4,8 +4,6 @@ from pathlib import Path
 from dzgui.util._json import read_json
 
 from dzgui.const.enum import Preferences
-from dzgui.const.constants import STEAM_CMD, FLATPAK_RUN_CMD, FLATPAK_SANDBOX
-
 
 class ConfigFileError(Exception):
     pass
@@ -40,23 +38,5 @@ def get_favorites(path: Path) -> list[str]:
     return list(conf["ip_list"])
 
 
-# def is_in_favs(record: str, path: Path) -> bool:
-#    favs = get_favorites(path)
-#    if record in favs:
-#        return True
-#    return False
-
-
 def enum_to_key(enum: Preferences) -> str:
     return str(enum.dict["key"])
-
-
-def get_client_index(client: str) -> int:
-    if client == STEAM_CMD:
-        return 0
-    elif client == FLATPAK_RUN_CMD:
-        return 1
-    elif client == FLATPAK_SANDBOX:
-        return 2
-    else:
-        return 0

dzgui/config/xdg.py

@@ -3,7 +3,13 @@ import os
 from pathlib import Path
 from dataclasses import dataclass
 
-from dzgui.const.constants import APP_NAME_LOWER, DEBUG_LOG, SYSTEM_LOG
+from dzgui.const.constants import (
+    APP_NAME_LOWER,
+    DEBUG_LOG,
+    FLATPAK_ROOT_PATH,
+    SYSTEM_LOG,
+)
+from dzgui.init.proc import is_sandboxed
 
 
 @dataclass
@@ -53,10 +59,12 @@ def get_xdg_paths() -> dict:
         "XDG_DATA_HOME": home / ".local" / "share",
         "XDG_CACHE_HOME": home / ".cache",
     }
-
     resolved_paths = {}
     for path in xdg_paths:
         real_path = os.environ.get(path)
+        if real_path is not None and is_sandboxed():
+            search_string = FLATPAK_ROOT_PATH + "/"
+            real_path = real_path.replace(search_string, "")
         if real_path is not None and is_writeable(real_path):
             new_path = Path(real_path)
         else:

dzgui/const/constants.py

@@ -15,6 +15,7 @@ DAYZ_BINARY = "DayZ_x64.exe"
 DAYZ_LAUNCHER = "DayZLauncher.exe"
 
 LIBRARYFOLDERS_PATH = "steamapps/libraryfolders.vdf"
+DOWNLOADS_PATH = "steamapps/downloading"
 WORKSHOP_PATH = "steamapps/workshop/content/" + str(APPID_DAYZ)
 
 STEAM_CMD = "steam"
@@ -84,9 +85,11 @@ HERO_PATH = "data/images/_hero.png"
 CSS_PATH = "data/app.css"
 VDF_PATH = "steamapps/libraryfolders.vdf"
 DEFAULT_STEAM_PATH = ".local/share/Steam"
-FLATPAK_STEAM_PATH = ".var/app/com.valvesoftware.Steam/data/Steam"
+FLATPAK_ROOT_PATH = ".var/app/com.valvesoftware.Steam"
+FLATPAK_STEAM_PATH = FLATPAK_ROOT_PATH + "/data/Steam"
 UBUNTU_STEAM_PATH = ".steam/steam"
 DEBIAN_STEAM_PATH = ".steam/debian-installation"
+STEAM_ICONS_PATH = "public"
 
 LOG_FILTERS = ("CRITICAL", "WARNING", "INFO", "DEBUG")
 

dzgui/controllers/mc.py

@@ -541,8 +541,10 @@ class Controller(GObject.GObject):
     def update_status(self) -> None:
         self.mediator.preconnect.mark_finished()
 
-    def get_steam_client_name(self, cmd: str) -> str:
+    def get_client_name(self) -> str:
-        return self.mediator.options.get_client_name(cmd)
+        # NOTE: only possible values are "Steam" and "Flatpak"
+        cmd = self.query_config(Preferences.CLIENT)
+        return str(cmd.split()[0].capitalize())
 
     def present_window(self) -> None:
         self.mediator.window.present_with_time(Gdk.CURRENT_TIME)

dzgui/init/prereqs.py

@@ -7,19 +7,32 @@ from dzgui.const.constants import APP_NAME, FLATPAK_APPID, FLATPAK_CMD, STEAM_CM
 logger = logging.getLogger(APP_NAME)
 
 
-def has_steam_client() -> bool:
+def has_flatpak_client() -> bool:
-    if shutil.which(STEAM_CMD):
-        return True
-    if not shutil.which(FLATPAK_CMD):
-        return False
     try:
         res = subprocess.run(
-            [FLATPAK_CMD, "list"], capture_output=True, text=True, check=True
+            [FLATPAK_CMD, "list", "--columns=application"],
+            capture_output=True,
+            text=True,
+            check=True,
         )
         if FLATPAK_APPID in res.stdout:
             return True
         else:
             return False
-    except subprocess.CalledProcessError as e:
+    except Exception as e:
         logger.critical(e)
         return False
+
+
+def has_steam_client() -> bool:
+    if shutil.which(STEAM_CMD):
+        return True
+    return False
+
+
+def has_any_client() -> bool:
+    if shutil.which(STEAM_CMD):
+        return True
+    if not shutil.which(FLATPAK_CMD):
+        return False
+    return has_flatpak_client()

dzgui/init/proc.py

@@ -1,7 +1,8 @@
-import psutil
-import subprocess
-import shutil
 import logging
+import os
+import psutil
+import shutil
+import subprocess
 
 from dzgui.const.constants import (
     APP_NAME,
@@ -10,28 +11,29 @@ from dzgui.const.constants import (
     FLATPAK_CMD,
     FLATPAK_RUN_CMD,
     FLATPAK_SANDBOX,
+    FLATPAK_ROOT_PATH,
+    FLATPAK_STEAM_PATH,
 )
 
 logger = logging.getLogger(APP_NAME)
 
 
 def is_steam_running(cmd: str) -> bool:
-    is_flatpak_running = is_flatpak_steam_running()
     if cmd in (FLATPAK_RUN_CMD, FLATPAK_SANDBOX):
-        return is_flatpak_running
+        return is_flatpak_steam_running()
     elif cmd == STEAM_CMD:
-        if is_flatpak_running:
+        return is_native_steam_running()
-            return False
-        if has_cmd(STEAM_CMD) is False:
-            return False
-        return is_running(STEAM_CMD)
     else:
         raise TypeError("Not a valid Steam client selection")
 
 
-# CHORE: test alternate clients
+def is_sandboxed() -> bool:
-# TODO: has_flatpak_steam
+    return bool(os.environ.get("FLATPAK_ID"))
+
+
 def is_flatpak_steam_running() -> bool:
+    if is_sandboxed():
+        return True
     if has_cmd(FLATPAK_CMD) is False:
         return False
     proc = subprocess.check_output(
@@ -43,14 +45,33 @@ def is_flatpak_steam_running() -> bool:
     return False
 
 
-def is_running(proc: str) -> bool:
+def get_steam_procs() -> list[list[str]]:
-    for process in psutil.process_iter(["pid", "name"]):
+    return [
-        if process.info["name"] == proc:
+        p.cmdline()
-            return True
+        for p in psutil.process_iter(["pid", "name"])
-    return False
+        if STEAM_CMD in p.info["name"]
+    ]
+
+
+def is_native_steam_running() -> bool:
+    if has_cmd(STEAM_CMD) is False:
+        return False
+    substrings = [FLATPAK_ROOT_PATH, "steam-runtime-launcher-service"]
+    steam_procs = get_steam_procs()
+    native_steam_procs = [
+        proc
+        for proc in steam_procs
+        if not any(sub in item for item in proc for sub in substrings)
+    ]
+    return bool(native_steam_procs)
 
 
 def has_cmd(cmd: str) -> bool:
     if shutil.which(cmd) is not None:
         return True
     return False
+
+
+def path_to_steam_cmd(path: str) -> str:
+    cmd = FLATPAK_RUN_CMD if FLATPAK_STEAM_PATH in path else STEAM_CMD
+    return cmd

dzgui/managers/config.py

@@ -6,9 +6,6 @@ from typing import Any, TYPE_CHECKING
 
 from dzgui.const.constants import (
     APP_NAME,
-    FLATPAK_RUN_CMD,
-    FLATPAK_SANDBOX,
-    STEAM_CMD,
     WINDOW_DEFAULT_X,
     WINDOW_DEFAULT_Y,
 )
@@ -129,15 +126,6 @@ class ConfigManager:
     def enum_to_key(self, enum: Preferences) -> str:
         return str(enum.dict["key"])
 
-    def get_client_index(self, client: str) -> int:
-        if client == STEAM_CMD:
-            return 0
-        if client == FLATPAK_RUN_CMD:
-            return 1
-        if client == FLATPAK_SANDBOX:
-            return 2
-        return 0
-
     def toggle_config(self, key: Preferences) -> None:
         try:
             real_key = self.enum_to_key(key)

dzgui/managers/connection.py

@@ -14,6 +14,7 @@ from dzgui.api.shortcuts import Shortcuts
 from dzgui.api.steam import (
     connect,
     connect_debug,
+    is_dayz_downloading,
     get_app_allows_downloads,
     get_app_name,
     get_needs_update,
@@ -84,6 +85,7 @@ class Prerequisites:
     available_space: float
     passworded: bool
     dayz_running: bool
+    download_paused: bool
     steam_proc: SteamProcess
     mods: list[list[str]]
     game_mode: bool
@@ -169,6 +171,7 @@ class ConnectionManager:
                     free_mib = format_mib(free)
 
         dayz_running = is_dayz_running()
+        download_paused = is_dayz_downloading(steam_path, self.appid)
 
         running_app = get_running_app()
         if running_app is not None:
@@ -185,7 +188,7 @@ class ConnectionManager:
             allows_downloads = (True, "")
 
         client = self.controller.query_config(Preferences.CLIENT)
-        client_name = self.controller.get_steam_client_name(client)
+        client_name = self.controller.get_client_name()
         running = is_steam_running(client)
         steam_proc = SteamProcess(client_name, running)
         self.client = client
@@ -210,6 +213,7 @@ class ConnectionManager:
             available_space=free_mib,
             passworded=info.password_protected,
             dayz_running=dayz_running,
+            download_paused=download_paused,
             steam_proc=steam_proc,
             mods=remote_mods,
             game_mode=game_mode,

dzgui/managers/filter.py

@@ -22,11 +22,12 @@ class FilterManager:
             strings.filter_night: True,
             strings.filter_full: show_full,
             strings.filter_official: True,
-            strings.filter_nonascii: False,
+            strings.filter_modded: True,
             strings.filter_lowpop: True,
             strings.filter_unofficial: True,
+            strings.filter_unmodded: True,
             strings.filter_duplicate: False,
-            strings.filter_modded: True,
+            strings.filter_nonascii: False,
         }
 
         # TODO: strings
@@ -43,6 +44,7 @@ class FilterManager:
             strings.filter_unofficial: "Third-party servers",
             strings.filter_duplicate: "Duplicates of existing servers (usually spoofed)",
             strings.filter_modded: "Servers with one or more mods",
+            strings.filter_unmodded: "Servers with no mods",
         }
 
         self.active_keyword = ""

dzgui/model/proxy_model.py

@@ -243,6 +243,8 @@ class ProxyModelManager:
                 rows = [row for row in rows if (row[4] / row[5] * 100) > 30]
             case strings.filter_modded:
                 rows = [row for row in rows if not row[11]]
+            case strings.filter_unmodded:
+                rows = [row for row in rows if row[11]]
         return rows
 
     def filter_toggle_on(self, filters: tuple[str]) -> list:

dzgui/strings/options.py

@@ -17,3 +17,10 @@ fullscreen_eventbox = "This option is not available on Steam Deck."
 save_button = "Save"
 
 api_failed = "API validation failed"
+
+flatpak_label = "Flatpak client"
+flatpak_standard = "Standard"
+flatpak_container = "Containerized (flatpak-spawn --host)"
+flatpak_info = (
+    "Containerized mode is used on certain distributions. May have side effects."
+)

dzgui/strings/preconnect.py

@@ -47,3 +47,7 @@ running_app = (
     "Either stop the game first, or update your global Steam settings or the game's local settings.\n"
     "Otherwise, mods may be queued for download but never update."
 )
+downloads_paused = (
+    "It looks like DayZ may have a pending update on Steam that was paused.\n"
+    "To enqueue mods for download, unpause any pending DayZ update and allow it to complete."
+)

dzgui/strings/wizard.py

@@ -3,6 +3,8 @@ title_intro = "Welcome"
 blurb_intro = """
 This wizard will help you set up some common config options before launching the application.
 """
+error_sandbox = "Setup cannot be run from inside Flatpak sandbox.\nPlease launch the application directly."
+welcome = "Welcome to {0}!"
 
 ### SteamPathPage
 heading_steam_path = "Steam path"
@@ -70,7 +72,8 @@ checkbox_steam_shortcut = (
     (
         "This creates a standalone copy of DZGUI and adds it to Steam. "
         "You <b>must restart Steam</b> for the shortcut to appear. This will not replace or update existing shortcuts. "
-        "If you update DZGUI when it is launched via Steam, updates will be applied to the Steam version."
+        "If you update DZGUI when it is launched via Steam, updates will be applied to the Steam version. "
+        "Not available if you selected the Flatpak client as your Steam default."
     ),
 )
 checkbox_start_menu = (
@@ -79,6 +82,17 @@ checkbox_start_menu = (
 )
 checkbox_desktop_shortcut = ("Add a desktop shortcut", "Depends on the option above.")
 
+### Flatpak page
+heading_flatpak = "Flatpak sandbox overrides"
+blurb_flatpak = (
+    "You chose to add a shortcut directly to Flatpak Steam. "
+    "To launch DZGUI from Flatpak's sandbox, you must grant "
+    "permission to read from and write to the following locations."
+)
+tree_column = "Paths"
+overrides_applied = "Overrides applied."
+button_flatpak = "Grant permissions"
+
 ### Completion page
 heading_completion = "Setup complete"
 blurb_completion = "Configuration completed successfully. Click 'Close' to close this dialog and launch DZGUI."

dzgui/util/bash.py

@@ -1,5 +1,12 @@
 import shlex
 
+from dzgui.const.constants import STEAM_CMD
+from dzgui.init.proc import is_sandboxed
+
 
 def concat_bash_args(command: str) -> list[str]:
+    # NOTE: NSGs spawned from sandbox cannot access host application commands,
+    # so fallback to Steam internal URIs
+    if is_sandboxed():
+        return [STEAM_CMD]
     return shlex.split(command)

dzgui/util/flatpak.py

@@ -0,0 +1,31 @@
+import logging
+import subprocess
+
+from dzgui.const.constants import APP_NAME, FLATPAK_APPID, GTK_APP_ID
+
+logger = logging.getLogger(APP_NAME)
+
+
+def apply_overrides(xdg: dict[str, str]) -> None:
+    try:
+        # NOTE: D-Bus registration required for sandbox
+        args = [
+            "flatpak",
+            "--user",
+            "override",
+            f"--own-name={GTK_APP_ID}",
+            FLATPAK_APPID,
+        ]
+        subprocess.run([*args], capture_output=True)
+
+        for path in xdg.values():
+            args = [
+                "flatpak",
+                "--user",
+                "override",
+                f"--filesystem={path}",
+                FLATPAK_APPID,
+            ]
+            subprocess.run([*args], capture_output=True)
+    except Exception as e:
+        logger.critical(e)

dzgui/util/strings.py

@@ -156,6 +156,7 @@ filter_duplicate = "Duplicate"
 filter_official = "Official"
 filter_unofficial = "Unofficial"
 filter_modded = "Modded"
+filter_unmodded = "Unmodded"
 
 # maps
 all_maps = "All maps"

dzgui/views/base.py

@@ -7,12 +7,11 @@ from dzgui.const.constants import (
     APP_NAME,
     APP_NAME_LOWER,
     GTK_APP_ID,
-    STEAM_ICON,
 )
 from dzgui.const.enum import NotebookPage
 from dzgui.controllers.emitter import Emitter
 from dzgui.controllers.mc import Controller
-from dzgui.util import css, strings
+from dzgui.util import css
 from dzgui.util.keys import is_ctrl_mask
 from dzgui.views.components.connect_panel import ConnectPanel
 from dzgui.views.components.crumbs import Breadcrumbs
@@ -332,13 +331,4 @@ class App(ColorAwareApp, Gtk.Application):  # type: ignore
     ) -> None:
         self.win.halt_proc_and_quit()
 
-
 MainController = Controller()
-
-try:
-    theme = Gtk.IconTheme.get_default()
-    icons = theme.list_icons(None)
-    if STEAM_ICON not in icons:
-        logger.warning(strings.steam_icon_missing)
-except Exception as e:
-    logger.warning(e)

dzgui/views/components/buttons.py

@@ -65,6 +65,7 @@ class IconButton(Gtk.Button):
         self.set_image(self.icon)
         self.set_image_position(position)
         self.set_focus_on_click(False)
+        self.set_always_show_image(True)
 
     def swap_icon(self, icon: str) -> None:
         start = self.icon.get_margin_start()

dzgui/views/components/misc.py

@@ -1,49 +1,72 @@
+from typing import Self
+from warnings import deprecated
+
 from dzgui.const.constants import ERROR, FLATPAK_RUN_CMD, FLATPAK_SANDBOX, STEAM_CMD
+from dzgui.init.prereqs import has_steam_client, has_flatpak_client
 from dzgui.strings import options
 from dzgui.views.components.box import HBox
 from dzgui.views.components.buttons import Icon
 
-
 import gi
 
 gi.require_version("Gtk", "3.0")
 from gi.repository import Gtk  # noqa
 
 
+@deprecated("Client choice is determined at setup time")
 class ClientCombo(Gtk.ComboBox):
     def __init__(self) -> None:
         super().__init__()
 
-        self.client_store = Gtk.ListStore(str, str)
+        has_steam = has_steam_client()
+        has_flatpak = has_flatpak_client()
+        self.client_store = Gtk.ListStore(str, str, bool)
         self.clients = (
             (
                 options.steam_combo,
                 STEAM_CMD,
+                has_steam,
             ),
             (
                 options.flatpak_combo,
                 FLATPAK_RUN_CMD,
+                has_flatpak,
             ),
             (
                 options.flatpak_container_combo,
                 FLATPAK_SANDBOX,
+                has_flatpak,
             ),
         )
         for client in self.clients:
             self.client_store.append(client)
+
         self.set_model(self.client_store)
         renderer_text = Gtk.CellRendererText()
         self.pack_start(renderer_text, True)
         self.add_attribute(renderer_text, "text", 0)
         self.set_active(0)
 
+        self.set_cell_data_func(self.get_cells()[0], self.data_func)
+
+    def data_func(
+        self,
+        combo: Self,
+        cell: Gtk.CellRendererText,
+        model: Gtk.ListStore,
+        _iter: Gtk.TreeIter,
+    ) -> None:
+        sens = model[_iter][2]
+        cell.set_property("sensitive", sens)
+
     def get_client_human_readable(self, cmd: str) -> str:
         for client in self.clients:
-            human, command = client
+            human, command, sens = client
             if command == cmd:
                 return human
         raise TypeError("Not a valid Steam client selection")
 
+
 class ErrorPopover(Gtk.Popover):
     def __init__(self, relative_to: Gtk.Widget, position: Gtk.PositionType) -> None:
         super().__init__(relative_to=relative_to, position=position)

dzgui/views/dialogs/wizard.py

@@ -12,21 +12,24 @@ from dzgui.const.constants import (
     APP_NAME,
     APP_NAME_LOWER,
     HERO_PATH,
+    FLATPAK_ROOT_PATH,
     LEGACY_CONFIG_PATH,
 )
 from dzgui.const.boilerplate import config_boilerplate
 from dzgui.const.endpoints import STEAM_API_SETUP
 from dzgui.config import freedesktop
+from dzgui.init.proc import is_sandboxed, path_to_steam_cmd
 from dzgui.init.migrate import migrate_legacy_conf
 from dzgui.managers.threading import call_on_thread, StoredFunc, ThreadingManager
 from dzgui.strings import wizard
 from dzgui.util._json import write_json
+from dzgui.util.flatpak import apply_overrides
 from dzgui.util.open_links import open_link_by_url
 from dzgui.util.css import add_class, load_css
 from dzgui.views.components.buttons import WebButton
 from dzgui.views.components.entry import APIEntry
-from dzgui.views.components.misc import ClientCombo
 from dzgui.views.mixins.colorscheme import ColorAwareApp
+from dzgui.views.trees.tree_simple import SimpleTree
 
 import gi
 
@@ -44,7 +47,8 @@ class PageNum(Enum):
     STEAM_API = 4
     USER_PREFS = 5
     SHORTCUTS = 6
-    FINAL = 7
+    FLATPAK = 7
+    FINAL = 8
 
 
 class OptionalPageMixin:
@@ -143,7 +147,7 @@ class NotificationFrame(Gtk.Frame):
             margin_start=50,
             margin_end=50,
         )
-        wrapped = textwrap.fill(label, width=80)
+        wrapped = textwrap.fill(label, width=60)
         self.label = Gtk.Label(
             label=wrapped,
             justify=Gtk.Justification.CENTER,
@@ -157,7 +161,7 @@ class NotificationFrame(Gtk.Frame):
             add_class(self, "error-frame")
 
     def set_text(self, text: str) -> None:
-        wrapped = textwrap.fill(text, width=80)
+        wrapped = textwrap.fill(text, width=60)
         self.label.set_markup(wrapped)
 
 
@@ -242,12 +246,23 @@ class IntroductionPage(EnumeratedWizardPage):
     def __init__(self) -> None:
         super().__init__(
             enum=PageNum.INTRO,
-            heading=f"Welcome to {APP_NAME}!",
+            heading=wizard.welcome.format(APP_NAME),
             description=wizard.blurb_intro,
         )
         self.page_type = Gtk.AssistantPageType.INTRO
         self.set_title(wizard.title_intro)
 
+        self.error_box = NotificationFrame(wizard.error_sandbox, error=True)
+        self.add_start(self.error_box)
+
+        self.connect("map", self._on_map)
+
+    def _on_map(self, page: "EnumeratedWizardPage") -> None:
+        self.error_box.hide()
+        if is_sandboxed():
+            self.error_box.show()
+            EMITTER.emit("step_pending")
+
 
 class Heading(Gtk.Label):
     def __init__(self, label: str):
@@ -384,26 +399,17 @@ class PreferencesPage(EnumeratedWizardPage):
         self.dist_box.add(self.radio_km)
         self.dist_box.add(self.radio_miles)
 
-        client_label = Gtk.Label(label=wizard.label_client, halign=Gtk.Align.START)
-        self.client_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
-        self.client_combo = ClientCombo()
-        self.client_box.add(client_label)
-        self.client_box.add(self.client_combo)
-
         outer_box = Gtk.Box(
             orientation=Gtk.Orientation.VERTICAL, halign=Gtk.Align.CENTER, spacing=10
         )
-        for el in self.name_box, self.client_box, self.dist_box:
+        for el in self.name_box, self.dist_box:
             outer_box.add(el)
         self.add_start(outer_box)
 
-    def get_prefs(self) -> tuple[str, bool, str]:
+    def get_prefs(self) -> tuple[str, bool]:
         name = self.name_entry.get_text().strip()
         use_miles = self.radio_miles.get_active()
-        model = self.client_combo.get_model()
+        return name, use_miles
-        ind = self.client_combo.get_active()
-        client = model[ind][1]
-        return name, use_miles, client
 
     def _on_entry_changed(self, entry: Gtk.Entry) -> None:
         text = entry.get_text()
@@ -413,6 +419,42 @@ class PreferencesPage(EnumeratedWizardPage):
         EMITTER.emit("step_complete")
 
 
+class FlatpakOverridePage(EnumeratedWizardPage):
+    def __init__(self, xdg_paths: dict[str, str]) -> None:
+        super().__init__(
+            enum=PageNum.FLATPAK,
+            heading=wizard.heading_flatpak,
+            description=wizard.blurb_flatpak,
+        )
+        self.xdg_paths = xdg_paths
+        self.page_type = Gtk.AssistantPageType.INTRO
+
+        store = Gtk.ListStore(str)
+        for path in xdg_paths.values():
+            store.append((str(path),))
+        tree = SimpleTree(store, wizard.tree_column)
+        tree.set_halign(Gtk.Align.CENTER)
+
+        self.authorize_button = Gtk.Button(
+            label=wizard.button_flatpak, halign=Gtk.Align.CENTER
+        )
+        self.authorize_button.connect("clicked", self._on_authorize)
+
+        self.notice = NotificationFrame(wizard.overrides_applied)
+        self.connect("map", self._on_map)
+
+        for el in tree, self.authorize_button, self.notice:
+            self.add_start(el)
+
+    def _on_map(self, page: "EnumeratedWizardPage") -> None:
+        self.notice.hide()
+
+    def _on_authorize(self, button: Gtk.Button) -> None:
+        apply_overrides(self.xdg_paths)
+        self.notice.show()
+        EMITTER.emit("step_complete")
+
+
 class CompletionPage(EnumeratedWizardPage):
     def __init__(self) -> None:
         super().__init__(
@@ -426,7 +468,7 @@ class CompletionPage(EnumeratedWizardPage):
 
 
 class Assistant(Gtk.Assistant):
-    def __init__(self, is_deck: bool, XDG: "Xdg"):
+    def __init__(self, is_deck: bool, XDG: "Xdg", xdg_paths: dict[str, str]):
         super().__init__()
         if is_deck:
             # NOTE: deemed to be "safe" dimensions that exclude taskbar size
@@ -445,6 +487,7 @@ class Assistant(Gtk.Assistant):
         self.page_api = SteamValidationPage()
         self.page_prefs = PreferencesPage()
         self.page_shortcuts = ShortcutCreationPage(XDG.shortcut)
+        self.page_flatpak = FlatpakOverridePage(xdg_paths)
         self.page_completion = CompletionPage()
 
         self.set_forward_page_func(self._advance_page)
@@ -464,6 +507,7 @@ class Assistant(Gtk.Assistant):
             self.page_api,
             self.page_prefs,
             self.page_shortcuts,
+            self.page_flatpak,
             self.page_completion,
         ):
             # NOTE: skip config migration page if no legacy config file
@@ -484,7 +528,10 @@ class Assistant(Gtk.Assistant):
     def write_config(self, config: dict[str, Any]) -> None:
         write_json(config, self.config_path)
 
-    def get_final_page(self) -> int:
+    def get_completion_page(self) -> int:
+        return self.pages[self.page_completion]
+
+    def get_shortcut_page(self) -> int:
         return self.pages[self.page_shortcuts]
 
     def _advance_page(self, index: int) -> int:
@@ -497,26 +544,39 @@ class Assistant(Gtk.Assistant):
                     sp = page.migrated_conf["default_steam_path"]
                     self.page_shortcuts.set_steam_path(sp)
                     self.config_values = self.page_migration.migrated_conf
-                    return self.get_final_page()
+                    return self.get_shortcut_page()
             case SteamPathPage():
-                self.config_values["default_steam_path"] = page.get_path_from_radio()
+                path = page.get_path_from_radio()
+                self.config_values["default_steam_path"] = path
+                self.config_values["client"] = path_to_steam_cmd(path)
             case SteamValidationPage():
                 self.config_values["steam_api"] = page.get_api_key()
             case PreferencesPage():
                 # NOTE: collects config values before advancing to last page
-                name, use_miles, client = self.page_prefs.get_prefs()
+                name, use_miles = self.page_prefs.get_prefs()
                 self.config_values["name"] = name
                 self.config_values["use_miles"] = use_miles
-                self.config_values["client"] = client
                 self.page_shortcuts.set_steam_path(
                     self.config_values["default_steam_path"]
                 )
             case ShortcutCreationPage():
                 page.create_shortcuts()
+                if not self.needs_flatpak_override():
+                    return self.get_completion_page()
+            case FlatpakOverridePage():
+                pass
             case _:
                 raise AttributeError("Trying to advance a non-canonical page")
         return index + 1
 
+    def needs_flatpak_override(self) -> bool:
+        if (
+            self.page_shortcuts.is_steam_checkbox_active()
+            and FLATPAK_ROOT_PATH in self.config_values["default_steam_path"]
+        ):
+            return True
+        return False
+
     def is_setup_complete(self) -> bool:
         return self.setup_complete
 
@@ -642,6 +702,9 @@ class ShortcutCreationPage(OptionalPageMixin, EnumeratedWizardPage):  # type: ig
     def set_steam_path(self, path: Path) -> None:
         self.steam_path = path
 
+    def is_steam_checkbox_active(self) -> bool:
+        return self.steam_checkbox.get_active()
+
     def create_shortcuts(self) -> None:
         # NOTE: best-effort, permissive even on failure (page is already marked as complete)
         if self.steam_checkbox.get_active():
@@ -710,10 +773,10 @@ class SteamPathPage(EnumeratedWizardPage):
 
 
 class SetupWizard(ColorAwareApp, Gtk.Application):  # type: ignore
-    def __init__(self, is_deck: bool, XDG: "Xdg") -> None:
+    def __init__(self, is_deck: bool, XDG: "Xdg", xdg_paths: dict[str, str]) -> None:
         super().__init__()
         GLib.set_prgname(APP_NAME)
-        self.win = Window(is_deck, XDG)
+        self.win = Window(is_deck, XDG, xdg_paths)
         Gtk.main()
 
     def is_setup_complete(self) -> int:
@@ -721,9 +784,9 @@ class SetupWizard(ColorAwareApp, Gtk.Application):  # type: ignore
 
 
 class Window(Gtk.Window):
-    def __init__(self, is_deck: bool, XDG: "Xdg") -> None:
+    def __init__(self, is_deck: bool, XDG: "Xdg", xdg_paths: dict[str, str]) -> None:
         super().__init__(title=APP_NAME, icon_name=APP_NAME)
-        self.assistant = Assistant(is_deck, XDG)
+        self.assistant = Assistant(is_deck, XDG, xdg_paths)
 
 
 class Emitter(GObject.GObject):

dzgui/views/pages/options.py

@@ -9,6 +9,9 @@ from dzgui.const.constants import (
     APPID_DAYZ_EXP,
     APPNAME_DAYZ,
     APPNAME_DAYZ_EXP_HUMAN,
+    FLATPAK_RUN_CMD,
+    FLATPAK_SANDBOX,
+    FLATPAK_STEAM_PATH,
     NO_EXPAND,
     NO_FILL,
     NO_PADDING,
@@ -25,7 +28,7 @@ from dzgui.views.components.eventbox import InfoEventBox
 from dzgui.views.components.labels import LeftLabel
 from dzgui.views.components.buttons import SpinnerButton, WebButton
 from dzgui.views.components.frame import HeadingFrame
-from dzgui.views.components.misc import ClientCombo, ErrorPopover
+from dzgui.views.components.misc import ErrorPopover
 from dzgui.views.dialogs.generic import ExceptionDialog
 from dzgui.views.mixins.scrollable_mixin import ScrollableMixin
 
@@ -246,6 +249,26 @@ class ToggleField(Gtk.Box):
             el.set_sensitive(state)
 
 
+class FlatpakToggleField(ToggleField):
+    def __init__(
+        self,
+        controller: "Controller",
+    ) -> None:
+        super().__init__(
+            controller,
+            first_option=options.flatpak_standard,
+            second_option=options.flatpak_container,
+            context=Preferences.CLIENT,
+        )
+        self.add(InfoEventBox(options.flatpak_info, self.controller))
+        self.controller = controller
+        self.radio1.connect("toggled", self._on_radio_toggled, Preferences.CLIENT)
+
+    def _on_radio_toggled(self, button: Gtk.RadioButton, context: Preferences) -> None:
+        cmd = FLATPAK_RUN_CMD if self.radio1.get_active() else FLATPAK_SANDBOX
+        self.controller.update_config(context, cmd)
+
+
 class Options(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
     def __init__(self, controller: "Controller"):
         super().__init__(
@@ -274,6 +297,7 @@ class Options(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
         self.player_box.set_halign(Gtk.Align.START)
         self.player_box.get_children()[0].set_width_chars(30)  # type: ignore
 
+        self.flatpak_toggle = FlatpakToggleField(self.controller)
         self.fullscreen_toggle = ToggleField(
             self.controller,
             strings.options.last_used,
@@ -281,11 +305,6 @@ class Options(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
             Preferences.WINDOW,
         )
 
-        self.client_combo = ClientCombo()
-        self.client_combo.connect("changed", self._on_client_changed)
-
-        client_hbox = ShortHBox(self.client_combo)
-
         self.distance_toggle = ToggleField(
             self.controller, strings.options.km, strings.options.mi, Preferences.DIST
         )
@@ -309,12 +328,17 @@ class Options(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
         self.start_tab_combo.connect("changed", self._on_start_tab_changed)
 
         pref_rows = [
-            [LeftLabel(strings.options.client), client_hbox],
             [LeftLabel(strings.options.window_size), self.fullscreen_toggle],
             [LeftLabel(strings.options.distance), self.distance_toggle],
             [LeftLabel(options.start_tab), start_tab_hbox],
             [LeftLabel(strings.options.name), self.player_box],
         ]
+        default = self.controller.query_config(Preferences.DEFAULT)
+        if FLATPAK_STEAM_PATH in default:
+            pref_rows.insert(
+                0,
+                [LeftLabel(options.flatpak_label), self.flatpak_toggle],
+            )
 
         self.dayz_version_label = Gtk.Label(label=strings.null)
         self.dayz_exp_version_label = Gtk.Label(label=strings.null)
@@ -367,17 +391,11 @@ class Options(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
 
         self.connect("key-press-event", self._on_keypress)
 
-    def get_client_name(self, cmd: str) -> str:
-        return self.client_combo.get_client_human_readable(cmd)
-
     def block_text_entry(self) -> None:
         self.steam_box.block_text_entry()
-        # self.steam_entry.set_position(-1)
-        # self.steam_entry.set_can_focus(False)
 
     def unblock_text_entry(self) -> None:
         self.steam_box.unblock_text_entry()
-        # self.steam_entry.set_can_focus(True)
 
     def _on_developers_clicked(self, button: Gtk.Button) -> None:
         self.controller.show_developers_page()
@@ -412,13 +430,6 @@ class Options(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
         index = enum.value
         self.controller.update_config(Preferences.START_TAB, index)
 
-    def _on_client_changed(self, combo: Gtk.ComboBoxText) -> None:
-        _iter = combo.get_active_iter()
-        if _iter is None:
-            raise ValueError(f"No active iterator set on {combo}")
-        real_cmd = combo.get_model()[_iter][1]
-        self.controller.update_config(Preferences.CLIENT, real_cmd)
-
     def populate_settings(self) -> None:
         prefs = self.controller.get_prefs()
         # NOTE: re-check in case file was removed by user between runs
@@ -464,10 +475,6 @@ class Options(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
         self.dayz_version_label.set_text(dayz_version)
         self.dayz_exp_version_label.set_text(dayz_exp_version)
 
-        # TODO: bicolumn list store with no cell renderer on index 1, use raw command names
-        active_combo = query.get_client_index(config["client"])
-        self.client_combo.set_active(active_combo)
-
         start_tab = self.controller.query_config(Preferences.START_TAB)
         self.start_tab_combo.set_active(start_tab)
 

dzgui/views/pages/preconnect.py

@@ -279,6 +279,8 @@ class PreConnectionAssistant(Gtk.Box):
             warnings.append(preconnect.protected_server)
         if prereqs.dayz_running is True:
             warnings.append(preconnect.dayz_running)
+        if len(prereqs.mods) > 0 and prereqs.download_paused:
+            warnings.append(preconnect.downloads_paused)
 
         allows_dl, running_app = prereqs.allows_downloads
         if len(prereqs.mods) > 0 and allows_dl is False:

dzgui/views/trees/tree_simple.py

@@ -0,0 +1,35 @@
+from typing import TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from dzgui.model.model_factory import FastInsertListStore
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk  # noqa
+
+
+class SimpleTree(Gtk.ScrolledWindow):
+    """Simple scrollable 1-column tree"""
+
+    def __init__(
+        self, model: Union[Gtk.ListStore, "FastInsertListStore"], title: str
+    ) -> None:
+        super().__init__(
+            overlay_scrolling=False,
+            propagate_natural_width=True,
+            propagate_natural_height=True,
+        )
+
+        self.tree = Gtk.TreeView(model=model, enable_search=False)
+        renderer = Gtk.CellRendererText()
+        column = Gtk.TreeViewColumn(title, renderer, text=0)
+        column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
+        column.set_resizable(False)
+        column.set_sort_column_id(0)
+        self.tree.append_column(column)
+
+        self.add(self.tree)
+
+    def get_tree(self) -> Gtk.TreeView:
+        return self.tree

pyproject.toml

@@ -110,10 +110,11 @@ config-settings-package = { pygobject-stubs = { config = "Gtk3,Gdk3,Soup2" } }
 markers = [
     "apitest: checks remote endpoints",
     "config: config file keys/values",
-    "realconfig: depends on actual generated local config file",
+    "flatpak: depends on local flatpak installation",
     "mods: tests mod metadata/link creation",
     "pefile: validate PE files",
     "post_install: requires a completed installation",
+    "realconfig: depends on actual generated local config file",
     "redact: log redaction mechanisms",
     "slow: long-running tests",
     "webtest: depends on remote endpoint",

tests/fixtures/api/loginusers_beta_client.vdf

@@ -8,6 +8,6 @@
 		"WantsOfflineMode"		"0"
 		"SkipOfflineModeWarning"		"0"
 		"AutoLogin"		"1"
-		"Timestamp"		"0"
+		"timestamp"		"0"
 	}
 }

tests/fixtures/api/loginusers_beta_client_multiple.vdf

@@ -8,7 +8,7 @@
 		"WantsOfflineMode"		"0"
 		"SkipOfflineModeWarning"		"0"
 		"AutoLogin"		"1"
-		"Timestamp"		"1787904411"
+		"timestamp"		"1787904411"
 	}
 	"1"
 	{
@@ -18,6 +18,6 @@
 		"WantsOfflineMode"		"0"
 		"SkipOfflineModeWarning"		"0"
 		"AutoLogin"		"1"
-		"Timestamp"		"1787904647"
+		"timestamp"		"1787904647"
 	}
 }

tests/fixtures/api/loginusers_beta_client_multiple_2.vdf

@@ -8,7 +8,7 @@
 		"WantsOfflineMode"		"0"
 		"SkipOfflineModeWarning"		"0"
 		"AutoLogin"		"1"
-		"Timestamp"		"1797904411"
+		"timestamp"		"1797904411"
 	}
 	"1"
 	{
@@ -18,6 +18,6 @@
 		"WantsOfflineMode"		"0"
 		"SkipOfflineModeWarning"		"0"
 		"AutoLogin"		"1"
-		"Timestamp"		"1787904647"
+		"timestamp"		"1787904647"
 	}
 }

tests/fixtures/api/loginusers_legacy_client.vdf

@@ -9,6 +9,6 @@
 		"SkipOfflineModeWarning"		"0"
 		"AllowAutoLogin"		"1"
 		"MostRecent"		"1"
-		"Timestamp"		"0"
+		"timestamp"		"0"
 	}
 }

tests/fixtures/api/loginusers_legacy_client_multiple.vdf

@@ -9,7 +9,7 @@
 		"SkipOfflineModeWarning"		"0"
 		"AllowAutoLogin"		"1"
 		"MostRecent"		"0"
-		"Timestamp"		"0"
+		"timestamp"		"0"
 	}
 	"1"
 	{
@@ -20,6 +20,6 @@
 		"SkipOfflineModeWarning"		"0"
 		"AllowAutoLogin"		"1"
 		"MostRecent"		"1"
-		"Timestamp"		"10"
+		"timestamp"		"10"
 	}
 }

tests/test_client_name.py

@@ -0,0 +1,19 @@
+import pytest
+
+from dzgui.const.constants import FLATPAK_RUN_CMD, STEAM_CMD
+from dzgui.controllers.mc import Controller
+
+
+@pytest.mark.parametrize(
+    "value, expected", [(FLATPAK_RUN_CMD, "Flatpak"), (STEAM_CMD, "Steam")]
+)
+def test_human_name(monkeypatch, value, expected) -> None:
+    def mock_query_config(*args) -> str:
+        return value
+
+    monkeypatch.setattr(
+        "dzgui.controllers.mc.Controller.query_config", mock_query_config
+    )
+    controller = Controller()
+    client = controller.get_client_name()
+    assert client == expected

tests/test_colorscheme.py

@@ -10,7 +10,7 @@ gi.require_version("Gtk", "3.0")
 from gi.repository import Gtk, Gio, GLib  # noqa
 
 
-class TestWidget(ColorAwareApp, Gtk.Button):
+class DummyWidget(ColorAwareApp, Gtk.Button):
     def __init__(self) -> None:
         super().__init__()
 
@@ -22,11 +22,10 @@ class TestWidget(ColorAwareApp, Gtk.Button):
 
 
 @pytest.fixture
-def widget() -> TestWidget:
+def widget() -> DummyWidget:
-    return TestWidget()
+    return DummyWidget()
 
 
-@pytest.mark.integration
 @pytest.mark.parametrize("key, expect", [("default", False), ("prefer-dark", True)])
 def test_light_mode(widget, key: str, expect: bool) -> None:
     local_pref = subprocess.run(

tests/test_flatpak_override.py

@@ -0,0 +1,43 @@
+import configparser
+import pytest
+
+from dzgui.const.constants import FLATPAK_APPID, GTK_APP_ID
+from dzgui.config.xdg import get_xdg_paths
+from dzgui.util.flatpak import apply_overrides
+
+PATHS_KEY = "Context"
+PATHS_SUBKEY = "filesystems"
+BUS_KEY = "Session Bus Policy"
+
+pytestmark = pytest.mark.flatpak
+
+
+@pytest.fixture
+def xdg_paths() -> dict[str, str]:
+    return get_xdg_paths()
+
+
+@pytest.fixture
+def override(xdg_paths) -> None:
+    apply_overrides(xdg_paths)
+
+
+@pytest.fixture
+def config(xdg_paths) -> configparser.ConfigParser:
+    conf_path = xdg_paths["XDG_DATA_HOME"].parent.joinpath(
+        f"flatpak/overrides/{FLATPAK_APPID}"
+    )
+    config = configparser.ConfigParser()
+    config.read(conf_path)
+    return config
+
+
+def test_session_bus(override, config) -> None:
+    bus = config[BUS_KEY][GTK_APP_ID]
+    assert bus == "own"
+
+
+def test_paths(override, xdg_paths, config) -> None:
+    expect = xdg_paths
+    paths = config[PATHS_KEY][PATHS_SUBKEY].split(";")
+    assert all(str(path) in paths for path in expect.values())

tests/test_flatpak_toggle.py

@@ -0,0 +1,30 @@
+import pytest
+
+from dzgui.const.constants import FLATPAK_RUN_CMD, FLATPAK_SANDBOX
+from dzgui.const.enum import Preferences
+from dzgui.views.pages.options import FlatpakToggleField
+
+
+class MockController:
+    def __init__(self) -> None:
+        self.command: str
+
+    def update_config(self, context: Preferences, cmd: str) -> None:
+        self.command = cmd
+
+    def get_command(self) -> str:
+        return self.command
+
+
+@pytest.mark.parametrize("index, expect", [(0, FLATPAK_RUN_CMD), (1, FLATPAK_SANDBOX)])
+def test_toggle(index: int, expect: str) -> None:
+    controller = MockController()
+    toggle = FlatpakToggleField(controller)
+    match index:
+        case 0:
+            toggle.radio2.set_active(True)
+            toggle.radio1.set_active(True)
+        case 1:
+            toggle.radio1.set_active(True)
+            toggle.radio2.set_active(True)
+    assert controller.get_command() == expect

tests/test_html_escaping.py

@@ -1,3 +1,5 @@
+import pytest
+
 from dzgui.api.servers import Details
 from dzgui.views.dialogs.servers import ServerDetailsDialog
 
@@ -21,6 +23,7 @@ class MockController:
         return None
 
 
+@pytest.mark.filterwarnings("ignore::DeprecationWarning")
 def test_html_escaping() -> None:
     name = "Test server"
     desc = "<Server description> Game & mods"
@@ -31,5 +34,7 @@ def test_html_escaping() -> None:
     controller = MockController()
     dialog = ServerDetailsDialog(controller, details)
     dialog.destroy()
+    while Gtk.events_pending():
+        Gtk.main_iteration()
 
     assert dialog.description.get_text() == desc

tests/test_loginusers.py

@@ -3,6 +3,7 @@ import pytest
 from pathlib import Path
 
 from dzgui.api.steam import find_user_id
+from dzgui.const.constants import DEFAULT_STEAM_PATH
 from tests.fixtures import fixture_path
 
 pytestmark = pytest.mark.apitest
@@ -25,3 +26,11 @@ def test_loginusers(monkeypatch, fixture: str, expect: int) -> None:
     monkeypatch.setattr("dzgui.api.steam.find_loginusers", mock_loginusers)
     uid = find_user_id(Path(""))
     assert int(uid) == expect
+
+
+@pytest.mark.realconfig
+def test_live_loginusers() -> None:
+    """Added on 2026-10-17 following changes to VDF keys"""
+    steam = Path.home().joinpath(DEFAULT_STEAM_PATH)
+    uid = find_user_id(steam)
+    assert uid is not None

tests/test_paused_downloads.py

@@ -0,0 +1,27 @@
+import pytest
+from pathlib import Path
+
+from dzgui.api.steam import is_dayz_downloading
+
+
+@pytest.mark.parametrize(
+    "file_list, expect",
+    [
+        (["state_221100_1111.patch"], True),
+        (["state_730_1111.patch"], False),
+        (["state_1024020_1111.patch"], True),
+        (["221100"], False),
+        (["221100", "state_221100_1111.patch"], True),
+        (["state_221100_1111.patch", "state_1024020_1111.patch"], True),
+        (["state_221100_1111"], False),
+    ],
+)
+def test_dayz_patch_pending(monkeypatch, file_list, expect) -> None:
+    def mock_get_pending_downloads(steam_path: Path, appid: int) -> None:
+        files = [Path(file) for file in file_list]
+        return files
+
+    monkeypatch.setattr(
+        "dzgui.api.steam.get_pending_downloads", mock_get_pending_downloads
+    )
+    assert is_dayz_downloading(Path("/tmp"), Path("/tmp")) == expect

tests/test_process_detection.py

@@ -1,14 +1,17 @@
+import pytest
 import unittest
 from unittest.mock import patch
 
 from dzgui.const.constants import (
     FLATPAK_APPID,
+    FLATPAK_ROOT_PATH,
     FLATPAK_RUN_CMD,
     FLATPAK_SANDBOX,
-    STEAM_CMD,
 )
 from dzgui.init import proc
 
+pytestmark = pytest.mark.flatpak
+
 
 class TestSteamDetection(unittest.TestCase):
     def test_flatpak_detection_with_multiple_running_apps(self):
@@ -45,16 +48,30 @@ class TestSteamDetection(unittest.TestCase):
 
     def test_native_steam(self):
         with patch.object(proc, "has_cmd", return_value=True):
-            for running in (True, False):
+            for output, expected in (
+                (
+                    [
+                        [FLATPAK_ROOT_PATH],
+                        "/home/user/.local/share/Steam/ubuntu12_64/steamwebhelper",
+                    ],
+                    True,
+                ),
+                ([[FLATPAK_ROOT_PATH]], False),
+                ([[FLATPAK_ROOT_PATH], ["steam-runtime-launcher-service"]], False),
+                ([["/home/user/.local/share/Steam/ubuntu12_64/steamwebhelper"]], True),
+                (
+                    [
+                        ["/home/user/.local/share/Steam/ubuntu12_64/steamwebhelper"],
+                        "steam-runtime-launcher-service",
+                    ],
+                    True,
+                ),
+            ):
                 with (
-                    self.subTest(running=running),
+                    self.subTest(running=output),
-                    patch.object(proc, "is_running", return_value=running),
+                    patch.object(proc, "get_steam_procs", return_value=output),
                 ):
-                    self.assertEqual(proc.is_steam_running(STEAM_CMD), running)
+                    self.assertEqual(proc.is_native_steam_running(), expected)
-
-    def test_native_steam_while_flatpak_is_running(self):
-        with patch.object(proc, "is_flatpak_steam_running", return_value=True):
-            self.assertEqual(proc.is_steam_running(STEAM_CMD), False)
 
     def test_invalid_client(self):
         with self.assertRaises(TypeError):