chore: update placeholder appid

fix: dword parse

CHANGELOG.md

@@ -51,6 +51,8 @@
 - Update map count (-u flag)
 - Filter button tooltips
 - Expand/collapse changelog versions
+- Support local light/dark mode changes on system theme
+- Server time calculator
 
 ### Changed
 - Conform to PEP 440 versioning for beta versions
@@ -89,6 +91,7 @@
 - Rare segfaults when changing maps (threading)
 - Moved dialogs out of threads
 - History table not being in lock-step with state file
+- Current keyword filter not being applied when refreshing table
 
 ### Unreleased
 - Load offline mods

README.md

@@ -1,15 +1,23 @@
 ## What this is
-DZGUI is a turnkey browser and mod manager for DayZ on Linux. It allows you to connect to both official and modded/community DayZ servers on Linux via a graphical user interface (GUI).
+DZGUI is a turnkey server browser and mod manager for DayZ on Linux. It allows you to connect to both official and modded/community DayZ servers on Linux via a graphical user interface (GUI).
 
 This overcomes certain limitations in the Linux client and helps prepare the game to launch by providing features like:
 
 - Search for and display global and LAN servers via an interactive table
 - Supports official, third-party, and modded DayZ servers
 - Automatically find and prepare mods being requested by servers
-- Add/delete/manage favorite servers by IP or ID
 - Quick-connect to favorite/recent servers
-- Manage local mods and symlinks
-- Prepare launch options to pass to Steam
+- Manage and delete local mods
+- And more
+
+## Design philosophy
+
+DZGUI follows a specific set of guidelines, enumerated below:
+
+- Provide a free and open-source tool under GPL
+- Do not use undocumented, third-party servers to aggregate data; no central "DZGUI" server
+- All connections go to Steam and DayZ servers directly; the tool should function in perpetuity without intermediary endpoints
+- Target Linux desktop and Steam deck specifically; not a cross-platform tool
 
 ## Setup and usage
 
@@ -18,7 +26,7 @@ Please refer to the documentation for installation and setup instructions:
 - [GitHub](https://aclist.github.io/dzgui/index.html)
 - [Codeberg (Mirror)](https://aclist.codeberg.page)
 
-![A screenshot of DZGUI](/images/example.png)
+![A screenshot of DZGUI](/dzgui/data/images/example.png)
 
 ## Attribution
 

dzgui/api/pefile.py

@@ -255,16 +255,28 @@ class PeFileError(Exception):
 
     pass
 
+
 def parse_version_number(data: BinaryIO) -> FileVersion:
     # https://learn.microsoft.com/en-us/windows/win32/api/verrsrc/ns-verrsrc-vs_fixedfileinfo
-    minor = struct.unpack("<L", data.read(4))[0] >> 16 & 0xFFFF
-    major = struct.unpack("<L", data.read(4))[0] >> 0 & 0xFFFF
-    build = struct.unpack("<L", data.read(4))[0] >> 0 & 0xFFFF
-    # NOTE: 0-pad revision number
-    revision = str(struct.unpack("<L", data.read(4))[0] >> 16 & 0xFFFF)
-    offset = 3 - len(revision)
-    padded = "0" * offset + revision
-    return FileVersion(major, minor, build, padded)
+    """
+    Note: structure differs from standard VS_FIXEDFILEINFO
+    Major: lower 16 bits of first DWORD
+    Minor: upper 16 bits of first DWORD
+    Build: lower 16 bits of third DWORD
+    Revision: upper 16 bits of second DWORD, zero-padded
+    Lower 16 bits of revision DWORD appear unused.
+    """
+    major_minor = struct.unpack("<I", data.read(4))[0]
+    revision_pair = struct.unpack("<I", data.read(4))[0]
+    build_dword = struct.unpack("<I", data.read(4))[0]
+
+    major = major_minor & 0xFFFF
+    minor = (major_minor >> 16) & 0xFFFF
+    build = build_dword & 0xFFFF
+    revision = (revision_pair >> 16) & 0xFFFF
+    revision = f"{revision:03d}"
+
+    return FileVersion(major, minor, build, revision)
 
 
 def seek_to_hex(address: str, data: BinaryIO) -> None:

dzgui/api/servers.py

@@ -54,19 +54,16 @@ class Res:
 
 @dataclass(slots=True, frozen=True)
 class Details:
-    data: Union[list, None]
+    data: list[list[str]]
+    name: str
     description: str
-    success: bool
+    gametime: str
+    day_accel: float
+    night_accel: float
 
 
-@dataclass(slots=True)
+@dataclass(slots=True, frozen=True)
 class Record:
-    # TODO: investigate whether this enum is still being used;
-    # can this be frozen?
-    """
-    The gameport field is manipulated by the RowType.CONN_BY_IP method
-    """
-
     ip: str
     gameport: int
     qport: int
@@ -283,43 +280,41 @@ def query_direct(ip: str, qport: int, timeout: float = 3.0) -> dict[str, Any] |
         info = a2s.info((ip, qport), timeout)
         return source_info_to_dict(ip, qport, info)
     except Exception as e:
-        logger.warning(e)
+        logger.debug(e)
         return None
 
 
-def get_details(record: Record) -> Details:
-    # TODO: consolidate try/except statements
+def get_details(record: Record) -> Details | None:
     ip = record.ip
     qport = record.qport
     default_str = strings.none_provided
 
     try:
         info = a2s.info((ip, qport))
-    except (TimeoutError, a2s.exceptions.BrokenMessageError):
-        return Details(None, default_str, False)
-    try:
         rules = dayzquery.dayz_rules((ip, qport))
-    except Exception:
-        return Details(None, default_str, False)
-
-    try:
         keywords = info.keywords.split(",")
-    except AttributeError:
-        return Details(None, default_str, False)
+    except Exception as e:
+        logger.critical(e)
+        return None
 
     battleye = strings.disabled
     if "battleye" in keywords:
         battleye = strings.enabled
 
-    day_accel = 0.0
-    night_accel = 0.0
+    name = info.server_name
+    day_accel = 1.0
+    night_accel = 1.0
+    gametime = "00:00"
     for keyword in keywords:
         if "etm" in keyword:
             day_accel = float(keyword.lstrip("etm"))
             day_accel = float(f"{day_accel:g}")
-        if "entm" in keywords:
+        if "entm" in keyword:
             night_accel = float(keyword.lstrip("entm"))
             night_accel = float(f"{night_accel:g}")
+        time_reg = r"^(0[0-9]|1[0-9]|2[0-3]):([0-5][0-9]$)"
+        if re.match(time_reg, keyword):
+            gametime = keyword
 
     try:
         password = info.password_protected
@@ -346,10 +341,15 @@ def get_details(record: Record) -> Details:
 
     try:
         dlc = rules.dlc_flags
-        if dlc == 0:
-            dlc = strings.none
-        if dlc == 2:
-            dlc = strings.dlc_frostline
+        match dlc:
+            case 0:
+                dlc = strings.dlc_none
+            case 2:
+                dlc = strings.dlc_frostline
+            case 4:
+                dlc = strings.dlc_badlands
+            case _:
+                dlc = strings.unspecified
     except AttributeError:
         dlc = strings.unspecified
 
@@ -380,7 +380,7 @@ def get_details(record: Record) -> Details:
         ["Version", version],
     ]
 
-    return Details(rows, description, True)
+    return Details(rows, name, description, gametime, day_accel, night_accel)
 
 
 def ping(ip: str, qport: int) -> int:

dzgui/api/steam.py

@@ -1,12 +1,14 @@
 import logging
 import os
 import psutil
+import re
 import requests
 import subprocess
 import vdf  # type: ignore
 
 from pathlib import Path
-from typing import Any, Union
+from requests.exceptions import HTTPError
+from typing import Any, Generator, Union
 from warnings import deprecated
 
 from dzgui.api.acf import ACF
@@ -19,6 +21,7 @@ from dzgui.const.constants import (
     DAYZ_LAUNCHER,
     DEBIAN_STEAM_PATH,
     DEFAULT_STEAM_PATH,
+    DOWNLOADS_PATH,
     FLATPAK_STEAM_PATH,
     LIBRARYFOLDERS_PATH,
     UBUNTU_STEAM_PATH,
@@ -32,6 +35,7 @@ from dzgui.const.endpoints import (
     UNSUB_ENDPOINT,
 )
 from dzgui.strings import wizard
+from dzgui.strings.errors import api_validation_error, workshop_endpoint_error
 from dzgui.util.bash import concat_bash_args
 
 logger = logging.getLogger(APP_NAME)
@@ -151,7 +155,9 @@ def get_remote_signatures(mods: list[str]) -> list[tuple[str, str, int, int]]:
     return hashes
 
 
-def connect_debug(client: str, addr: str, appid: int, name: str, mods: list[str]) -> str:
+def connect_debug(
+    client: str, addr: str, appid: int, name: str, mods: list[str]
+) -> str:
     concat = concat_mods(mods)
     client_args = concat_bash_args(client)
     params = [
@@ -167,6 +173,7 @@ def connect_debug(client: str, addr: str, appid: int, name: str, mods: list[str]
     client_args.extend(params)
     return " ".join(client_args)
 
+
 # TODO: set config to name=user, use official server and no mods,
 # ensure that formatted string is identical to fixture with same hash
 def connect(client: str, addr: str, appid: int, name: str, mods: list[str]) -> int:
@@ -235,14 +242,18 @@ def find_user_id(path: Path) -> str | None:
     try:
         with open(resolved_path, "r") as f:
             v = vdf.load(f)
-            # NOTE: beta client
-            # /package/beta
-            if len(v["users"]) == 1:
-                return str(list(v["users"].keys())[0])
-            for user in v["users"]:
-                if v["users"][user]["MostRecent"] == "1":
-                    return str(user)
-            return None
+            users = v["users"]
+            # NOTE: beta client: /package/beta
+            last_user = str(next(iter(users)))
+            if len(users) == 1:
+                return last_user
+            last_stamp = int(users[last_user]["Timestamp"])
+            for user in users:
+                stamp = int(users[user]["Timestamp"])
+                if stamp > last_stamp:
+                    last_stamp = stamp
+                    last_user = user
+            return last_user
     except Exception as e:
         logger.debug(e)
         return None
@@ -255,6 +266,16 @@ def find_user_id_32(path: Path) -> int:
     return int(uid) & 0xFFFFFFFF
 
 
+class SteamAPIKeyError(Exception):
+    def __init__(self, msg: str | None = None):
+        super().__init__(msg or api_validation_error)
+
+
+class SteamWorkshopEndpointError(Exception):
+    def __init__(self, msg: str | None = None):
+        super().__init__(msg or workshop_endpoint_error)
+
+
 def update_workshop(key: str, mod: int, endpoint: str) -> None:
     payload: dict[str, Union[int, str]] = {
         "publishedfileid": mod,
@@ -266,8 +287,19 @@ def update_workshop(key: str, mod: int, endpoint: str) -> None:
     try:
         res = requests.post(endpoint, params=payload, timeout=REQUEST_TIMEOUT)
         res.raise_for_status()
+    except HTTPError as e:
+        logger.critical(e)
+        match res.status_code:
+            case 403:
+                raise SteamAPIKeyError()
+            case 404:
+                raise SteamWorkshopEndpointError()
+            case _:
+                # TODO: apply redaction filter
+                raise e
     except Exception as e:
         logger.critical(e)
+        raise e
 
 
 def subscribe(key: str, mod: int) -> None:
@@ -409,6 +441,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

@@ -154,4 +154,5 @@ def load_gui(version: str, is_debug: bool) -> None:
         use_miles=use_miles,
     )
     print(boot.all_ok)
-    App(prefs)
+    app = App(prefs)
+    app.run(None)

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"
@@ -30,12 +31,14 @@ BETA_REPO = "testing"
 APP_NAME = "DZGUI"
 APP_NAME_LOWER = "dzgui"
 APP_NAME_ABBR = "dzg"
+GTK_APP_ID = "io.github.aclist.dzgui"
 
 HEX_GREEN = "#32CD32"
 HEX_RED = "#FF0000"
 HEX_ORANGE = "#FFAC1C"
 
-# FIXME: normalize icon names
+# TODO: normalize icon names
+CALCULATOR = "accessories-calculator-symbolic"
 CARET_DOWN = "go-down-symbolic"
 CARET_UP = "go-up-symbolic"
 CLIPBOARD = "edit-copy-symbolic"
@@ -53,6 +56,8 @@ VIEW_CONCEAL = "view-conceal-symbolic"
 VIEW_REVEAL = "view-reveal-symbolic"
 WARNING = "dialog-warning-symbolic"
 WEB_BROWSER = "web-browser-symbolic"
+DAY_ICON = "weather-clear-symbolic"
+NIGHT_ICON = "weather-clear-night-symbolic"
 
 SEPARATOR = "SEPARATOR"
 
@@ -91,3 +96,8 @@ TMP_TARBALL = "/tmp/dzgui.tar.gz"
 TMP_EXE = "/tmp/dzgui/dzgui"
 
 DAYZ_COMMUNITY_ROOT = "Missions"
+
+GIO_SETTINGS_INTERFACE = "org.gnome.desktop.interface"
+GIO_SETTINGS_PROP = "color-scheme"
+GIO_SETTINGS_KEY = "gtk-application-prefer-dark-theme"
+GIO_SETTINGS_VAL = "prefer-dark"

dzgui/controllers/mc.py

@@ -7,11 +7,12 @@ import dzgui.util._json as JSON  # noqa
 
 
 from dzgui.const.enum import (
-    FilterMode,
-    Preferences,
-    NotebookPage,
     ButtonType,
     ContextMenu,
+    FilterMode,
+    NotebookPage,
+    Preferences,
+    ServerTab,
 )
 
 from dzgui.config.userprefs import UserPrefs
@@ -37,7 +38,6 @@ logger = logging.getLogger(APP_NAME)
 
 if TYPE_CHECKING:
     from dzgui.api.servers import Record
-    from dzgui.const.enum import ServerTab
     from dzgui.managers.connection import Prerequisites
     from dzgui.managers.filter import FilterManager
     from dzgui.util.dist import Haversine
@@ -498,6 +498,9 @@ class Controller(GObject.GObject):
 
     def set_active_keyword(self, keyword: str) -> None:
         self.get_filter_man().set_active_keyword(keyword)
+        ServerModelManager(self, self.get_active_treeview()).refilter(
+            FilterMode.TOGGLE_ON
+        )
 
     def get_modtreeview(self) -> "ModTreeView":
         return self.mediator.modtreeview
@@ -523,6 +526,7 @@ class Controller(GObject.GObject):
 
     def set_start_tab(self) -> None:
         ind = self.config_man.get_start_tab()
+        logger.info(f"Setting start tab to index {ind}")
         self.get_servers().notebook.set_current_page(ind)
 
     def get_debug_args(self) -> str:
@@ -537,8 +541,8 @@ class Controller(GObject.GObject):
     def update_status(self) -> None:
         self.mediator.preconnect.mark_finished()
 
-    def get_steam_client_name(self) -> str:
-        return self.mediator.options.get_client_name()
+    def get_steam_client_name(self, cmd: str) -> str:
+        return self.mediator.options.get_client_name(cmd)
 
     def present_window(self) -> None:
         self.mediator.window.present_with_time(Gdk.CURRENT_TIME)

dzgui/data/CHANGELOG.md

@@ -51,6 +51,8 @@
 - Update map count (-u flag)
 - Filter button tooltips
 - Expand/collapse changelog versions
+- Support local light/dark mode changes on system theme
+- Server time calculator
 
 ### Changed
 - Conform to PEP 440 versioning for beta versions
@@ -89,6 +91,7 @@
 - Rare segfaults when changing maps (threading)
 - Moved dialogs out of threads
 - History table not being in lock-step with state file
+- Current keyword filter not being applied when refreshing table
 
 ### Unreleased
 - Load offline mods

dzgui/data/app.css

@@ -24,6 +24,10 @@
 .left-label {
     font-size: 1.3rem;
 }
+.server-subheading {
+    font-size: 1.1rem;
+    font-weight: 700;
+}
 .details-heading {
     font-size: 1.2rem
 }

dzgui/init/dayz.py

@@ -4,17 +4,24 @@ from pathlib import Path
 
 from dzgui.api.steam import get_app_path
 from dzgui.config.query import lookup
-from dzgui.const.constants import APPID_DAYZ, APP_NAME
+from dzgui.const.constants import APPID_DAYZ, APP_NAME, APPNAME_DAYZ
 from dzgui.const.enum import Preferences
 
+from dzgui.strings.preconnect import resync
+
 
 logger = logging.getLogger(APP_NAME)
 
 
+class VDFSyncError(Exception):
+    pass
+
+
 def is_dayz_installed(config: Path) -> None:
     try:
         path = lookup(config, Preferences.DEFAULT)
         get_app_path(Path(path), APPID_DAYZ)
     except Exception as e:
         logger.critical(e)
-        raise e
+        msg = resync.format(APPNAME_DAYZ)
+        raise VDFSyncError(msg)

dzgui/init/migrate.py

@@ -1,3 +1,4 @@
+import json
 import shutil
 
 from pathlib import Path
@@ -7,11 +8,10 @@ from dzgui.config.convert import rc2json
 from dzgui.util._json import read_json, write_json
 
 
-def migrate_legacy_conf(config: Path) -> None:
+def migrate_legacy_conf(config: Path) -> Any:
     old_conf = Path.home() / LEGACY_CONFIG_PATH
     j = rc2json(old_conf)
-    config.parent.mkdir(parents=True, exist_ok=True)
-    config.write_text(j)
+    return json.loads(j)
 
 
 def has_new_config(config: Path) -> bool:

dzgui/init/proc.py

@@ -16,12 +16,15 @@ logger = logging.getLogger(APP_NAME)
 
 
 def is_steam_running(cmd: str) -> bool:
-    if cmd == STEAM_CMD:
+    is_flatpak_running = is_flatpak_steam_running()
+    if cmd in (FLATPAK_RUN_CMD, FLATPAK_SANDBOX):
+        return is_flatpak_running
+    elif cmd == STEAM_CMD:
+        if is_flatpak_running:
+            return False
         if has_cmd(STEAM_CMD) is False:
             return False
         return is_running(STEAM_CMD)
-    elif cmd == FLATPAK_RUN_CMD or FLATPAK_SANDBOX:
-        return is_flatpak_steam_running()
     else:
         raise TypeError("Not a valid Steam client selection")
 
@@ -31,7 +34,9 @@ def is_steam_running(cmd: str) -> bool:
 def is_flatpak_steam_running() -> bool:
     if has_cmd(FLATPAK_CMD) is False:
         return False
-    proc = subprocess.check_output([FLATPAK_CMD, "ps"], text=True)
+    proc = subprocess.check_output(
+        [FLATPAK_CMD, "ps", "--columns=application"], text=True
+    )
     lines = proc.splitlines()
     if FLATPAK_APPID in lines:
         return True

dzgui/managers/config.py

@@ -19,11 +19,6 @@ from dzgui.views.dialogs.generic import ExceptionDialog
 from dzgui.strings import dialogs
 from dzgui.util._json import read_json, write_json
 
-import gi
-
-gi.require_version("Gtk", "3.0")
-from gi.repository.Gtk import main_quit  # noqa E402
-
 if TYPE_CHECKING:
     from dzgui.config.userprefs import UserPrefs
     from dzgui.controllers.mc import Controller
@@ -206,7 +201,10 @@ class ConfigManager:
 
         logger.info("Normal user exit")
         if window.props.is_maximized:
-            main_quit()
+            app = window.get_application()
+            if app is None:
+                return
+            app.quit()
             return
 
         w, h = window.get_size()
@@ -218,7 +216,10 @@ class ConfigManager:
         except Exception as e:
             logger.critical(e)
 
-        main_quit()
+        app = window.get_application()
+        if app is None:
+            return
+        app.quit()
 
     def set_resolution(self, window: "OuterWindow") -> None:
         if self.prefs.is_game_mode:

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,
@@ -48,7 +49,7 @@ from dzgui.strings.dialogs import (
 )
 from dzgui.strings import kb
 from dzgui.strings.server_mods import checkmark, resync
-from dzgui.util.format import format_mib
+from dzgui.util.format import format_exception, format_mib
 from dzgui.util.strings import dialog, server_timeout
 from dzgui.util.symlink import rebuild_symlinks
 from dzgui.views.dialogs.generic import ExceptionDialog
@@ -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:
@@ -184,8 +187,8 @@ class ConnectionManager:
         else:
             allows_downloads = (True, "")
 
-        client_name = self.controller.get_steam_client_name()
         client = self.controller.query_config(Preferences.CLIENT)
+        client_name = self.controller.get_steam_client_name(client)
         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,
@@ -235,7 +239,7 @@ class ConnectionManager:
     @call_on_thread(dialog.querying)
     def query_details(self, record: Servers.Record) -> None:
         details = Servers.get_details(record)
-        if details.success is False:
+        if details is None:
             self.thread_man.set_cleanup_func(
                 StoredFunc(self._server_timeout), destroy_first=True
             )
@@ -300,6 +304,11 @@ class ConnectionManager:
         dialog = ServerDetailsDialog(self.controller, details)
         dialog.run()
 
+    def _workshop_timeout(self, msg: str) -> None:
+        dialog = ExceptionDialog(self.controller, msg)
+        dialog.show_all()
+        dialog.run()
+
     def _server_timeout(self) -> None:
         dialog = ExceptionDialog(self.controller, server_timeout)
         dialog.set_details_buffer(kb.DZG_006)
@@ -351,8 +360,14 @@ class ConnectionManager:
         for title, mod, stamp, size in self.missing_mods:
             if self.controller.is_cancel_pending():
                 return
-            subscribe(key, int(mod))
-            time.sleep(API_RATE_LIMIT)
+            try:
+                subscribe(key, int(mod))
+                time.sleep(API_RATE_LIMIT)
+            except Exception as e:
+                msg = format_exception(e)
+                func = StoredFunc(self._workshop_timeout, msg)
+                self.thread_man.set_cleanup_func(func, destroy_first=True)
+                return
 
         self.thread_man.update_dialog(waiting_for_directories)
         for title, mod, stamp, size in self.missing_mods:

dzgui/managers/contextmenu.py

@@ -1,4 +1,3 @@
-import gi
 import logging
 from typing import TYPE_CHECKING
 
@@ -14,10 +13,6 @@ from dzgui.views.trees.tree_servers import ServerTreeView
 from dzgui.views.trees.tree_server_mods import ServerModTreeView
 
 
-gi.require_version("Gtk", "3.0")
-from gi.repository import Gtk, Gdk, GLib, GObject  # noqa E402
-
-
 logger = logging.getLogger(APP_NAME)
 
 if TYPE_CHECKING:

dzgui/managers/filter.py

@@ -32,10 +32,10 @@ class FilterManager:
         # TODO: strings
         self.tooltips = {
             strings.filter_1pp: "First-person perspective",
-            strings.filter_day: "In-game time between 0700 and 1659",
+            strings.filter_day: "In-game time between 0600 and 1759",
             strings.filter_empty: "Servers with no players",
             strings.filter_3pp: "Third-person perspective",
-            strings.filter_night: "In-game time between 1700 and 0659",
+            strings.filter_night: "In-game time between 1800 and 0559",
             strings.filter_full: "Servers with no open slots",
             strings.filter_official: "Bohemia official servers",
             strings.filter_nonascii: "Server names using non-standard, complex glyphs",

dzgui/managers/mods.py

@@ -122,7 +122,11 @@ class ModManager:
     def unsub_atomic_mod(self, mod: str) -> None:
         config_man = self.controller.get_config_man()
         key = config_man.lookup(Preferences.STEAM)
-        unsubscribe(key, int(mod))
+        try:
+            unsubscribe(key, int(mod))
+        except Exception as e:
+            logger.critical(e)
+            return
 
         steam_path = Path(self.path)
         app_path = PeFile.get_nested_app_path(steam_path, APPID_DAYZ)

dzgui/model/proxy_model.py

@@ -12,8 +12,8 @@ if TYPE_CHECKING:
     from dzgui.api.servers import Record
     from dzgui.model.servers import NewPlayerCount
 
-DAY_REG = r"([0][7-9]|[1][0-6])"
-NIGHT_REG = r"([0][0-6]|[1][7-9]|[2][0-3])"
+DAY_REG = r"([0][6-9]|[1][0-7])"
+NIGHT_REG = r"([0][0-5]|[1][8-9]|[2][0-3])"
 
 
 class ProxyModelManager:
@@ -259,10 +259,6 @@ class ProxyModelManager:
     def set_cache(self, filters: tuple[str], filtered_rows: list[tuple]) -> None:
         self.filter_cache[filters] = filtered_rows
 
-    # @deprecated("Currently unused")
-    # def convert_model_to_list(self, model: "FastInsertListStore") -> list:
-    #    return [[el for el in row] for row in model]
-
     def set_filtered(self, rows: list | None) -> None:
         if rows is None:
             self.filtered = []
@@ -298,4 +294,6 @@ class ProxyModelManager:
     def push(self, data: list[Any]) -> None:
         self.wipe_cache()
         self.set_control(data)
-        self.filter(FilterMode.INITIAL)
+        cur_keyword = self.filter_man.get_active_keyword()
+        mode = FilterMode.TOGGLE_ON if len(cur_keyword) > 0 else FilterMode.INITIAL
+        self.filter(mode)

dzgui/model/servers.py

@@ -21,7 +21,7 @@ from dzgui.views.dialogs.generic import ExceptionDialog
 import gi
 
 gi.require_version("Gtk", "3.0")
-from gi.repository import Gtk  # noqa E402
+from gi.repository import Gtk, GLib  # noqa E402
 
 if TYPE_CHECKING:
     from dzgui.api.servers import A2SInfo, Record
@@ -390,6 +390,8 @@ class ServerModelManager:
     def _cleanup_on_success(self) -> None:
         proxy = self.proxy_man.get_proxy_model()
         self.tv.set_model(proxy)
+        if self.tv.enum == ServerTab.BROWSER:
+            GLib.idle_add(self.tv.wipe_cache)
         if self.preserve_on_fail is True:
             self.proxy_man.wipe_cache()
 

dzgui/strings/calc.py

@@ -0,0 +1,7 @@
+heading_local_time = "Local time"
+heading_server_time = "In-game time"
+heading_target_time = "Target time"
+heading_remainder_time = "Remainder until target"
+heading_adjusted_time = "Adjusted local time"
+calculate = "Calculate"
+disclaimer = "Times shown are approximations.\nServer time may differ based on time of year in game."

dzgui/strings/connect_panel.py

@@ -1,20 +1,22 @@
-add_button="Add"
-add_con_heading="Add/connect"
+from dzgui.const.constants import UDP_PORT
+
+add_button = "Add"
+add_con_heading = "Add/connect"
 add_popover = "This address is already in your Saved Servers"
-add_tooltip="Add to Saved Servers"
-connect_button="Connect"
-connect_tooltip="Connect to this server"
-connect_entry_placeholder="Enter IP:Query port (e.g., 192.168.1.1:27016)"
+add_tooltip = "Add to Saved Servers"
+connect_button = "Connect"
+connect_tooltip = "Connect to this server"
+connect_entry_placeholder = f"Enter IP:Query port (e.g., 192.168.1.1:{UDP_PORT})"
 
-fav_heading="Favorite server"
-favs_empty="None set. Right click a server and select 'Set favorite' to set."
+fav_heading = "Favorite server"
+favs_empty = "None set. Right click a server and select 'Set favorite' to set."
 
-lan_heading="LAN query port"
-lan_default_button="Default port (27016)"
-lan_custom_button="Custom port"
-lan_scan_button="Scan"
+lan_heading = "LAN query port"
+lan_default_button = f"Default port ({UDP_PORT})"
+lan_custom_button = "Custom port"
+lan_scan_button = "Scan"
 lan_abort_tooltip = "Unless you have multiple DayZ servers on your LAN,\nleave this checked to get results faster"
 lan_checkbox = "Stop scanning on first hit"
-lan_entry_placeholder="Enter the query port (1-65535)"
-lan_entry_tooltip="Specify the port to search for DayZ servers on the local network"
-lan_scan_tooltip="Scan for servers"
+lan_entry_placeholder = "Enter the query port (1-65535)"
+lan_entry_tooltip = "Specify the port to search for DayZ servers on the local network"
+lan_scan_tooltip = "Scan for servers"

dzgui/strings/dialogs.py

@@ -23,3 +23,8 @@ custom_mod_dialog = "Set location to a custom mods folder"
 
 debug_heading = "Debug"
 debug_secondary = "Launch arguments"
+
+toggle_calc = "Toggle calculator"
+
+server_details = "Server details"
+server_message = "Server message"

dzgui/strings/errors.py

@@ -4,3 +4,4 @@ api_validation_error = (
 
 api_popover = "API key validation failed."
 dayz_not_found = "Could not find a valid DayZ installation."
+workshop_endpoint_error = "Steam Workshop service unavailable, try again later."

dzgui/strings/preconnect.py

@@ -11,8 +11,6 @@ mods = "Mods"
 total_mods = "Total mods: "
 up_to_date = "All mods are up to date."
 all_updated = "All mods updated."
-"If you recently installed {build} or moved it to a different drive, "
-"restart Steam to allow these changes to synchronize, then try again."
 required_space = " Need to download {0} MiB of mod updates."
 
 placeholder_no_mods = "This server has no mods."
@@ -36,6 +34,7 @@ steam_not_running = "'{0}' is set as the default Steam client, but it is either
 use_desktop_mode = "Use Desktop Mode to download mods on Steam Deck."
 version_mismatch = "Local client version '{0}' does not match remote version '{1}'."
 version_missing = "Remote server is running the build '{0}', but it is not installed."
+no_errors = "No errors."
 
 
 # Warnings
@@ -48,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/uninstall.py

@@ -30,7 +30,8 @@ path_remove_prefix = "The following path will be removed:"
 not_installed = "It looks like DZGUI was not previously set up; nothing to uninstall."
 standalone_uninstall = (
     "It looks like you are running the standalone version of DZGUI.\n"
-    "To finalize the uninstall process, you can remove the 'dzgui' file."
+    "To finalize the uninstall process, invoke './dzgui self remove',\n"
+    "then remove the 'dzgui' file."
 )
 system_uninstall = (
     "It looks like DZGUI was installed via your system package manager or directly from source code.\n"

dzgui/util/dist.py

@@ -84,6 +84,5 @@ class CalcDist:
         except Exception:
             return None
 
-        # TODO: handle failed remote dist
         haversine = Haversine(local.lat, local.lon, remote.lat, remote.lon)
         return haversine

dzgui/util/ip.py

@@ -2,14 +2,13 @@ import a2s
 import requests
 import shutil
 import subprocess
-from warnings import deprecated
 
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from dzgui.api.servers import Record
 from dzgui.const.constants import REQUEST_TIMEOUT
-from dzgui.const.endpoints import COORDS_API, IP_ECHO
+from dzgui.const.endpoints import IP_ECHO
 
 
 if TYPE_CHECKING:
@@ -127,10 +126,3 @@ def is_valid_port(port: str) -> bool:
     if not port.isdigit() or int(port) == 0 or int(port[0]) == 0 or int(port) > 65535:
         return True
     return False
-
-
-@deprecated("use ips.csv")
-def get_local_coords(ip: str) -> str:
-    url = COORDS_API + "/" + ip
-    # local res=$(curl -Ls "$url" | jq -r '"\(.lat)\n\(.lon)"')
-    return url

dzgui/util/strings.py

@@ -11,7 +11,6 @@ delimiter = "␞"
 # GenericDialog
 main_menu = "Return to main menu"
 exit_app = "Exit"
-server_details = "Server details"
 modlist = "Modlist"
 input_required = "User input required"
 confirm = "Confirmation"
@@ -59,7 +58,6 @@ browser_cols = [
 ]
 
 # DetailsDialog
-server_message = "Server message"
 workshop = "Enter/double click a row to open in Steam Workshop."
 
 # LanDialog
@@ -168,11 +166,12 @@ none_provided = "None provided"
 disabled = "Disabled"
 enabled = "Enabled"
 null = "-"
-none = "None"
 unspecified = "not specified"
 
 # DLC
 dlc_frostline = "Frostline"
+dlc_badlands = "Badlands"
+dlc_none = "None"
 
 # platform
 windows = "Windows"

dzgui/util/symlink.py

@@ -2,7 +2,12 @@ import logging
 from pathlib import Path
 
 from dzgui.api.mods import get_local_mod_path, get_local_mod_ids, _hash
-from dzgui.const.constants import APPID_DAYZ, APPID_DAYZ_EXP, APP_NAME, DAYZ_COMMUNITY_ROOT
+from dzgui.const.constants import (
+    APPID_DAYZ,
+    APPID_DAYZ_EXP,
+    APP_NAME,
+    DAYZ_COMMUNITY_ROOT,
+)
 from dzgui.const.enum import Preferences
 from dzgui.config.query import lookup
 
@@ -20,6 +25,7 @@ def expunge_link(file: Path) -> None:
     if str(file.stem)[:2] == "@C":
         file.unlink()
 
+
 def rebuild_symlinks(config: Path) -> None:
     # TODO: pass direct path as argument
     path = lookup(config, Preferences.DEFAULT)
@@ -63,10 +69,9 @@ def symlink_mission(steam_path: Path, target: str) -> str:
     stem = path.name
     parent = path.parent
     source = dayz_path.joinpath(DAYZ_COMMUNITY_ROOT)
-    try:
-        source.symlink_to(parent)
-    except Exception:
-        return ""
+    if source.exists():
+        source.unlink()
+    source.symlink_to(parent)
     return f"{DAYZ_COMMUNITY_ROOT}/{stem}"
 
 

dzgui/views/base.py

@@ -1,10 +1,14 @@
 import logging
 import signal
-import warnings
 
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Literal, Self
 
-from dzgui.const.constants import APP_NAME, APP_NAME_LOWER, STEAM_ICON
+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
@@ -14,6 +18,7 @@ from dzgui.views.components.connect_panel import ConnectPanel
 from dzgui.views.components.crumbs import Breadcrumbs
 from dzgui.views.components.right_panel import RightPanel
 from dzgui.views.components.statusbar import Statusbar
+from dzgui.views.mixins.colorscheme import ColorAwareApp
 from dzgui.views.mixins.scrollable_mixin import ScrollableMixin
 
 # TODO: import notebook only and add components there?
@@ -41,14 +46,12 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(APP_NAME)
 
-# TODO: drop
-# https://bugzilla.gnome.org/show_bug.cgi?id=708676
-warnings.filterwarnings("ignore", ".*g_value_get_int", Warning)
 
-
-class OuterWindow(Gtk.Window):
-    def __init__(self) -> None:
-        super().__init__(title=APP_NAME, border_width=10, icon_name=APP_NAME_LOWER)
+class OuterWindow(Gtk.ApplicationWindow):
+    def __init__(self, app: Gtk.Application) -> None:
+        super().__init__(
+            application=app, title=APP_NAME, border_width=10, icon_name=APP_NAME_LOWER
+        )
 
         self.hb = AppHeaderBar()
         MainController.register_widget("window", self)
@@ -279,13 +282,18 @@ class Grid(Gtk.Grid):
         self.right_panel.refresh_button.set_visible(state)
 
 
-class App(Gtk.Application):
+class App(ColorAwareApp, Gtk.Application):  # type: ignore
     def __init__(self, prefs: "UserPrefs") -> None:
+        super().__init__(application_id=GTK_APP_ID)
 
         GLib.set_prgname(APP_NAME)
         MainController.set_prefs(prefs)
 
-        self.win = OuterWindow()
+        self._setup_signals()
+        self.connect("activate", self._on_activate)
+
+    def _on_activate(self, app: Self) -> None:
+        self.win = OuterWindow(app)
 
         accel = Gtk.AccelGroup()
         accel.connect(
@@ -296,9 +304,6 @@ class App(Gtk.Application):
         )
         self.win.add_accel_group(accel)
 
-        self._setup_signals()
-        Gtk.main()
-
     def _setup_signals(self) -> None:
         SIGNAL_ADD = "signal_add"
         SIGNAL_ADD_FULL = "signal_add_full"
@@ -334,8 +339,6 @@ try:
     theme = Gtk.IconTheme.get_default()
     icons = theme.list_icons(None)
     if STEAM_ICON not in icons:
-        logger.warn(strings.steam_icon_missing)
-        warnings.warn(strings.steam_icon_missing, stacklevel=2)
+        logger.warning(strings.steam_icon_missing)
 except Exception as e:
     logger.warning(e)
-    warnings.warn(strings.gtk_theme_missing, stacklevel=2)

dzgui/views/components/box.py

@@ -24,6 +24,7 @@ class VBox(GenericBox):
     def __init__(self, spacing: int = 0) -> None:
         super().__init__(orientation=Gtk.Orientation.VERTICAL, spacing=spacing)
 
+
 class ShortHBox(HBox):
     def __init__(self, widget: Gtk.Widget) -> None:
         super().__init__(spacing=5)

dzgui/views/components/filter_panel.py

@@ -9,8 +9,6 @@ from dzgui.const.constants import (
     NO_PADDING,
     SEARCH_ICON,
 )
-from dzgui.const.enum import FilterMode
-from dzgui.model.servers import ServerModelManager
 from dzgui.util.format import format_exception
 from dzgui.util.strings import all_maps
 from dzgui.views.components.maps_combo import MapsCombo
@@ -148,10 +146,6 @@ class KeywordEntry(Gtk.Entry):
         self.controller.set_active_keyword(keyword)
         logger.info(f"User filtered by keyword '{keyword}'")
 
-        ServerModelManager(
-            self.controller, self.controller.get_active_treeview()
-        ).refilter(FilterMode.TOGGLE_ON)
-
 
 class FilterPanel(Gtk.Box):
     def __init__(self, controller: "Controller") -> None:

dzgui/views/components/icon.py

@@ -9,3 +9,6 @@ class Icon(Gtk.Image):
         super().__init__(
             icon_name=name, icon_size=Gtk.IconSize.BUTTON, margin_start=l_margin
         )
+
+    def set_icon_name(self, name: str) -> None:
+        super().set_from_icon_name(name, Gtk.IconSize.BUTTON)

dzgui/views/components/misc.py

@@ -15,7 +15,7 @@ class ClientCombo(Gtk.ComboBox):
         super().__init__()
 
         self.client_store = Gtk.ListStore(str, str)
-        clients = (
+        self.clients = (
             (
                 options.steam_combo,
                 STEAM_CMD,
@@ -29,7 +29,7 @@ class ClientCombo(Gtk.ComboBox):
                 FLATPAK_SANDBOX,
             ),
         )
-        for client in clients:
+        for client in self.clients:
             self.client_store.append(client)
         self.set_model(self.client_store)
         renderer_text = Gtk.CellRendererText()
@@ -37,6 +37,13 @@ class ClientCombo(Gtk.ComboBox):
         self.add_attribute(renderer_text, "text", 0)
         self.set_active(0)
 
+    def get_client_human_readable(self, cmd: str) -> str:
+        for client in self.clients:
+            human, command = 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/boot.py

@@ -4,6 +4,9 @@ from typing import Any, Literal, Self, TYPE_CHECKING
 # import time
 from enum import Enum
 
+
+from dzgui.views.mixins.colorscheme import ColorAwareApp
+
 # TODO: import dialog titles
 from dzgui.api.mods import remove_stale_signatures as remove_stale
 from dzgui.config.ipdb import get_ipdb
@@ -37,7 +40,7 @@ class Success(Enum):
 
 # TODO: strings for "Running", "Failed", etc.
 # TODO: add margins to tree
-class BootDialog(Gtk.Dialog):
+class BootDialog(ColorAwareApp, Gtk.Dialog):  # type: ignore
     def __init__(self, parent: "BootWindow", xdg: "Xdg", version: str) -> None:
         super().__init__(
             title=dialog_header,
@@ -99,7 +102,7 @@ class BootDialog(Gtk.Dialog):
             margin_top=30,
             margin_bottom=30,
         )
-        self.error_label = Gtk.Label()
+        self.error_label = Gtk.Label(margin_start=15, margin_end=15)
 
         # TODO: abstract class
         self.copy_button = ClipboardButton(None, lambda: self.error_label.get_text())

dzgui/views/dialogs/calc.py

@@ -0,0 +1,457 @@
+import gi
+from dataclasses import dataclass
+from datetime import datetime, time, timedelta
+from typing import Literal
+
+from dzgui.const.constants import DAY_ICON, NIGHT_ICON
+from dzgui.strings import calc
+from dzgui.views.components.icon import Icon
+from dzgui.views.components.labels import BoldLabel
+from dzgui.views.components.box import VBox, HBox
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, GLib, GObject  # type: ignore  # noqa E402
+
+DAY_START_TIME = time(hour=6, minute=0, second=0)
+DAY_END_TIME = time(hour=18, minute=0, second=0)
+NIGHT_START_TIME = time(hour=18, minute=0, second=0)
+NIGHT_END_TIME = time(hour=6, minute=0, second=0)
+EXTENDED_TIME_FORMAT = "%H:%M:%S"
+
+
+@dataclass(slots=True, frozen=True)
+class Time:
+    time: str
+    day_accel: float
+    night_accel: float
+
+
+class Emitter(GObject.GObject):
+    def __init__(self) -> None:
+        super().__init__()
+
+    @GObject.Signal(flags=GObject.SignalFlags.RUN_LAST, arg_types=(object, object))
+    def local_time_incremented(self, time_now: datetime, elapsed: timedelta) -> None:
+        pass
+
+    @GObject.Signal(flags=GObject.SignalFlags.RUN_LAST, arg_types=(object,))
+    def server_time_incremented(self, server_time: datetime) -> None:
+        pass
+
+    @GObject.Signal(flags=GObject.SignalFlags.RUN_LAST, arg_types=())
+    def calculate_button_clicked(self) -> None:
+        pass
+
+    @GObject.Signal(flags=GObject.SignalFlags.RUN_LAST, arg_types=(object,))
+    def target_time_changed(self, time: timedelta) -> None:
+        pass
+
+    @GObject.Signal(flags=GObject.SignalFlags.RUN_LAST, arg_types=(object,))
+    def target_time_reset(self, time: timedelta) -> None:
+        pass
+
+    @GObject.Signal(flags=GObject.SignalFlags.RUN_LAST, arg_types=(object,))
+    def remaining_time_changed(self, time: datetime) -> None:
+        pass
+
+    @GObject.Signal(flags=GObject.SignalFlags.RUN_LAST, arg_types=(object,))
+    def adjusted_local_time_changed(self, time: datetime) -> None:
+        pass
+
+
+class LocalClock:
+    def __init__(self, emitter: Emitter) -> None:
+        self.emitter = emitter
+        self.start_time = datetime.now()
+        # NOTE: highest theoretical accel interval is 24 * 64
+        GLib.timeout_add(500, self.check_time)
+
+    def get_time(self) -> str:
+        return datetime.now().time().strftime(EXTENDED_TIME_FORMAT)
+
+    def get_elapsed_time(self) -> timedelta:
+        return datetime.now() - self.start_time
+
+    def check_time(self) -> Literal[True]:
+        time_now = datetime.now()
+        elapsed = datetime.now() - self.start_time
+        self.emitter.emit("local_time_incremented", time_now, elapsed)
+        return True
+
+
+class ServerClock:
+    def __init__(
+        self, server_time: Time, emitter: Emitter, local_clock: LocalClock
+    ) -> None:
+
+        self.local_clock = local_clock
+        self.emitter = emitter
+
+        hour, minute = self.split_time(server_time)
+        self.day_accel = server_time.day_accel
+        self.night_accel = server_time.night_accel
+
+        self.start_time = datetime.combine(datetime.today(), time(hour, minute))
+        self.cur_time = datetime.combine(datetime.today(), time(hour, minute))
+
+        self._last_elapsed = self.local_clock.get_elapsed_time()
+        self.emitter.connect("local_time_incremented", self._on_local_time_incremented)
+
+    @staticmethod
+    def split_time(server_time: Time) -> tuple[int, int]:
+        split = server_time.time.split(":")
+        return int(split[0]), int(split[1])
+
+    def is_day(self) -> bool:
+        if DAY_START_TIME <= self.cur_time.time() <= DAY_END_TIME:
+            return True
+        return False
+
+    def _on_local_time_incremented(
+        self,
+        emitter: Emitter,
+        time: datetime,
+        elapsed: timedelta,
+    ) -> Literal[True]:
+        delta = elapsed - self._last_elapsed
+        self._last_elapsed = elapsed
+        factor = self.get_accel_factor(self.cur_time)
+        self.cur_time += delta * factor
+        self.emitter.emit("server_time_incremented", self.cur_time)
+        return True
+
+    def get_accel_factor(self, dt: datetime) -> float:
+        return (
+            self.day_accel
+            if DAY_START_TIME <= dt.time() < DAY_END_TIME
+            else (self.night_accel * self.day_accel)
+        )
+
+    def get_values(self) -> tuple[int, int]:
+        return self.cur_time.hour, self.cur_time.minute
+
+    def get_datetime(self) -> datetime:
+        return self.cur_time
+
+    def get_time(self) -> time:
+        return self.cur_time.time()
+
+    def calc_delta(self, end_time: datetime) -> timedelta:
+        total = 0.0
+        current_time = self.cur_time
+
+        if current_time > end_time:
+            end_time += timedelta(days=1)
+
+        while current_time < end_time:
+            factor = self.get_accel_factor(current_time)
+            day_start = datetime.combine(current_time.date(), DAY_START_TIME)
+            day_end = datetime.combine(current_time.date(), DAY_END_TIME)
+
+            if current_time.time() < DAY_START_TIME:
+                edge = day_start
+            elif current_time.time() < DAY_END_TIME:
+                edge = day_end
+            else:
+                edge = datetime.combine(
+                    current_time.date() + timedelta(days=1), DAY_START_TIME
+                )
+
+            chunk_end = min(end_time, edge)
+            total += (chunk_end - current_time).total_seconds() / factor
+            current_time = chunk_end
+        return timedelta(seconds=total)
+
+
+class RemainderClock:
+    def __init__(self, emitter: Emitter) -> None:
+        self.emitter = emitter
+        self.emitter.connect("target_time_changed", self._on_target_time_changed)
+        self.emitter.connect("target_time_reset", self._on_target_time_reset)
+        self.emitter.connect("local_time_incremented", self._on_local_time_incremented)
+        self.reset_time(True)
+
+        self.previous = timedelta(0)
+
+    def reset_time(self, zero_out: bool = False) -> None:
+        now = datetime.now()
+        second, ms = (0, 0) if zero_out else (now.second, now.microsecond)
+        self.time = datetime.combine(
+            now, time(hour=0, minute=0, second=second, microsecond=ms)
+        )
+
+    def _on_local_time_incremented(
+        self, emitter: Emitter, time: datetime, elapsed: timedelta
+    ) -> None:
+        if self.time == datetime.min.time():
+            return
+
+        delta = elapsed - self.previous
+        # NOTE: clamp to midnight
+        self.time = max(
+            self.time - delta, self.time.replace(hour=0, minute=0, second=0)
+        )
+        self.previous = elapsed
+        self.emitter.emit("remaining_time_changed", self.time)
+
+    def _on_target_time_reset(self, emitter: Emitter, time: timedelta) -> None:
+        self.reset_time(True)
+        self.emitter.emit("remaining_time_changed", self.time)
+        # NOTE: restore adjusted time to current time
+        self.emitter.emit("adjusted_local_time_changed", datetime.now())
+
+    def _on_target_time_changed(self, emitter: Emitter, time: timedelta) -> None:
+        self.reset_time(True)
+        self.time += time
+        self.emitter.emit("remaining_time_changed", self.time)
+
+    def get_time(self) -> str:
+        return self.time.strftime(EXTENDED_TIME_FORMAT)
+
+
+class AdjustedClock:
+    def __init__(self, emitter: Emitter) -> None:
+        self.emitter = emitter
+        self.emitter.connect("target_time_changed", self._on_target_time_changed)
+        self.start_time = datetime.now()
+
+    def _on_target_time_changed(self, emitter: Emitter, time: timedelta) -> None:
+        self.start_time = datetime.now()
+        adjusted = self.start_time + time
+        self.emitter.emit("adjusted_local_time_changed", adjusted)
+
+    def get_time(self) -> str:
+        return self.start_time.strftime(EXTENDED_TIME_FORMAT)
+
+
+class VerticalSpinBox(Gtk.SpinButton):
+    def __init__(self, value: int, upper: int) -> None:
+        super().__init__(
+            adjustment=Gtk.Adjustment(
+                value=value,
+                lower=0,
+                upper=upper,
+                step_increment=1,
+                page_increment=1,
+                page_size=0,
+            ),
+            orientation=Gtk.Orientation.VERTICAL,
+        )
+
+
+class HourSpinBox(VerticalSpinBox):
+    def __init__(self, hour: int) -> None:
+        super().__init__(value=hour, upper=23)
+
+
+class MinuteSpinBox(VerticalSpinBox):
+    def __init__(self, minute: int) -> None:
+        super().__init__(value=minute, upper=59)
+
+        self.get_adjustment().set_page_increment(10)
+
+
+class TimePicker(Gtk.Box):
+    def __init__(self, hour: int, minute: int) -> None:
+        super().__init__(
+            orientation=Gtk.Orientation.HORIZONTAL,
+            halign=Gtk.Align.CENTER,
+            valign=Gtk.Align.CENTER,
+        )
+        self.hour_spin = HourSpinBox(hour)
+        self.minute_spin = MinuteSpinBox(minute)
+        self.add(self.hour_spin)
+        self.add(self.minute_spin)
+
+        self.hour_spin.connect("output", self._on_output)
+        self.minute_spin.connect("output", self._on_output)
+
+    def _on_output(self, spin_button: VerticalSpinBox) -> Literal[True]:
+        val = spin_button.get_value()
+        spin_button.set_text(f"{int(val):02d}")
+        # NOTE: indicates that rendering completed
+        return True
+
+    def get_values(self) -> tuple[int, int]:
+        hour = self.get_hour()
+        minute = self.get_minute()
+        return hour, minute
+
+    def get_hour(self) -> int:
+        return int(self.hour_spin.get_adjustment().get_value())
+
+    def get_minute(self) -> int:
+        return int(self.minute_spin.get_adjustment().get_value())
+
+    def get_time(self) -> datetime:
+        """
+        NOTE: interpolating seconds/microseconds from the current time
+        may prevent abrupt visual changes when setting a new TimePicker time
+        while a clock tick is updating the local remainder label.
+        However, this can introduce false negatives when running tests due to microsecond drift.
+        Ideally, tests should be decoupled from this logic.
+        """
+        d = datetime.now()
+        return datetime.combine(
+            d,
+            time(
+                hour=self.get_hour(),
+                minute=self.get_minute(),
+                second=0,
+                microsecond=0,
+            ),
+        )
+
+    def set_time(self, hour: int, minute: int) -> None:
+        self.hour_spin.get_adjustment().set_value(hour)
+        self.minute_spin.get_adjustment().set_value(minute)
+
+
+class AdjustedTimeFrame(Gtk.Frame):
+    def __init__(self, emitter: Emitter) -> None:
+        super().__init__(margin_start=50, margin_end=50)
+
+        self.emitter = emitter
+        self.emitter.connect(
+            "adjusted_local_time_changed", self._on_adjusted_time_changed
+        )
+        self.emitter.connect("remaining_time_changed", self._on_remainder_changed)
+
+        self.remainder_clock = RemainderClock(emitter)
+        self.remainder_heading = BoldLabel(calc.heading_remainder_time)
+        self.remaining_time = Gtk.Label(label=self.remainder_clock.get_time())
+
+        self.adjusted_clock = AdjustedClock(emitter)
+        self.adjusted_heading = BoldLabel(calc.heading_adjusted_time)
+        self.adjusted_local_time = Gtk.Label(label=self.adjusted_clock.get_time())
+
+        flowbox = Gtk.FlowBox(
+            row_spacing=20,
+            column_spacing=50,
+            min_children_per_line=2,
+            max_children_per_line=2,
+            margin=15,
+            halign=Gtk.Align.CENTER,
+            selection_mode=Gtk.SelectionMode.NONE,
+        )
+        flowbox.add(self.remainder_heading)
+        flowbox.add(self.adjusted_heading)
+        flowbox.add(self.remaining_time)
+        flowbox.add(self.adjusted_local_time)
+
+        recalc = Gtk.Button(
+            label=calc.calculate, halign=Gtk.Align.CENTER, margin_bottom=20
+        )
+        recalc.connect("clicked", self._on_recalc_clicked)
+
+        vbox = VBox()
+        vbox.extend([flowbox, recalc])
+        self.add(vbox)
+
+    def _on_remainder_changed(self, emitter: Emitter, time: datetime) -> None:
+        strtime = str(time.strftime(EXTENDED_TIME_FORMAT))
+        self.remaining_time.set_text(strtime)
+
+    def _on_adjusted_time_changed(self, emitter: Emitter, time: datetime) -> None:
+        strtime = str(time.strftime(EXTENDED_TIME_FORMAT))
+        self.adjusted_local_time.set_text(strtime)
+
+    def _on_recalc_clicked(self, button: Gtk.Button) -> None:
+        self.emitter.emit("calculate_button_clicked")
+
+
+class TimePickerFrame(Gtk.Frame):
+    def __init__(self, emitter: Emitter, stime: Time) -> None:
+        super().__init__(margin_start=50, margin_end=50)
+
+        self.emitter = emitter
+        self.emitter.connect("local_time_incremented", self._on_local_clock_increment)
+        self.emitter.connect("server_time_incremented", self._on_server_clock_increment)
+        self.emitter.connect(
+            "calculate_button_clicked", self._on_calculate_button_clicked
+        )
+
+        self.local_clock = LocalClock(self.emitter)
+        local_clock_time = self.local_clock.get_time()
+
+        self.server_time = ServerClock(stime, self.emitter, self.local_clock)
+        hour, minute = self.server_time.get_values()
+        self.picker = TimePicker(hour, minute)
+
+        self.local_timelabel = Gtk.Label(label=local_clock_time)
+        self.server_timelabel = Gtk.Label(label=stime.time, halign=Gtk.Align.CENTER)
+
+        h0 = BoldLabel(calc.heading_local_time)
+        h1 = BoldLabel(calc.heading_server_time)
+        h2 = BoldLabel(calc.heading_target_time)
+
+        self.icon_indicator = Icon(DAY_ICON)
+        self.update_server_icon()
+
+        server_time_box = HBox(10)
+        server_time_box.set_halign(Gtk.Align.CENTER)
+        server_time_box.extend([self.server_timelabel, self.icon_indicator])
+
+        flowbox = Gtk.FlowBox(
+            row_spacing=10,
+            column_spacing=50,
+            min_children_per_line=3,
+            max_children_per_line=3,
+            margin=15,
+            halign=Gtk.Align.CENTER,
+            selection_mode=Gtk.SelectionMode.NONE,
+        )
+        flowbox.add(h0)
+        flowbox.add(h1)
+        flowbox.add(h2)
+        flowbox.add(self.local_timelabel)
+        flowbox.add(server_time_box)
+        flowbox.add(self.picker)
+
+        self.add(flowbox)
+
+    def update_server_icon(self) -> None:
+        icon = DAY_ICON if self.server_time.is_day() else NIGHT_ICON
+        self.icon_indicator.set_icon_name(icon)
+
+    def _on_server_clock_increment(self, emitter: Emitter, time_now: datetime) -> None:
+        t = time_now.time().strftime("%H:%M")
+        self.server_timelabel.set_text(t)
+        self.update_server_icon()
+
+    def _on_local_clock_increment(
+        self, emitter: Emitter, time_now: datetime, elapsed: timedelta
+    ) -> None:
+        t = time_now.time().strftime(EXTENDED_TIME_FORMAT)
+        self.local_timelabel.set_text(t)
+
+    def _on_calculate_button_clicked(self, button: Gtk.Button) -> None:
+        if (self.picker.get_values()) == (self.server_time.get_values()):
+            total_time = timedelta(seconds=0)
+            self.emitter.emit("target_time_reset", total_time)
+        else:
+            picker_time = self.picker.get_time()
+            total_time = self.server_time.calc_delta(picker_time)
+            self.emitter.emit("target_time_changed", total_time)
+
+
+class ServerTimeCalculator(Gtk.ScrolledWindow):
+    def __init__(self, stime: Time) -> None:
+        super().__init__(propagate_natural_width=True)
+
+        self.emitter = Emitter()
+        outerbox = Gtk.Box(
+            halign=Gtk.Align.CENTER,
+            valign=Gtk.Align.START,
+            spacing=20,
+            orientation=Gtk.Orientation.VERTICAL,
+        )
+        time_picker_frame = TimePickerFrame(self.emitter, stime)
+        adjusted_time_frame = AdjustedTimeFrame(self.emitter)
+        disclaimer = Gtk.Label(
+            label=calc.disclaimer,
+            justify=Gtk.Justification.CENTER,
+        )
+        for el in time_picker_frame, adjusted_time_frame, disclaimer:
+            outerbox.add(el)
+        self.add(outerbox)

dzgui/views/dialogs/early_alert.py

@@ -3,6 +3,7 @@ import sys
 
 from typing import Self
 from dzgui.util.strings import dialog_error, dialog_header
+from dzgui.views.mixins.colorscheme import ColorAwareApp
 
 import gi
 
@@ -10,7 +11,7 @@ gi.require_version("Gtk", "3.0")
 from gi.repository import Gtk  # noqa E402
 
 
-class AbortDialog(Gtk.MessageDialog):
+class AbortDialog(ColorAwareApp, Gtk.MessageDialog):  # type: ignore
     def __init__(self, string: str, buttons: Gtk.ButtonsType) -> None:
         super().__init__(
             title=dialog_header,

dzgui/views/dialogs/generic.py

@@ -309,6 +309,14 @@ class ExceptionDialog(TextBufferDialog):
         content.set_spacing(0)
         content.add(scrollable)
 
+        self.connect("map", self._on_map)
+
+    def _on_map(self, dialog: Self) -> None:
+        button = self.get_widget_for_response(Gtk.ResponseType.OK)
+        if button is None:
+            return
+        button.grab_focus()
+
     def _on_page_changed(
         self, notebook: Gtk.Notebook, child: Gtk.Box | Gtk.ScrolledWindow, index: int
     ) -> None:

dzgui/views/dialogs/servers.py

@@ -1,20 +1,21 @@
+import gi
 import html
 from typing import Self, TYPE_CHECKING
 
-from dzgui.const.constants import EXPAND, FILL
+from dzgui.const.constants import CALCULATOR
 from dzgui.const.enum import ContextMenuGroup
 from dzgui.model.model_factory import ModelFactory
 from dzgui.util import css
-from dzgui.util import strings
 from dzgui.util.format import format_hyperlinks, format_server_mods
-from dzgui.strings import server_mods
+from dzgui.strings import server_mods, dialogs
+from dzgui.views.components.buttons import IconTextButton
+from dzgui.views.components.box import VBox
+from dzgui.views.dialogs.calc import Time, ServerTimeCalculator
 from dzgui.views.dialogs.generic import GenericDialog
 from dzgui.views.trees.tree_base import TreeView
 
-import gi
-
 gi.require_version("Gtk", "3.0")
-from gi.repository import Gtk, GLib, Gdk, GObject, Pango  # noqa
+from gi.repository import Gtk, Gdk, Pango  # noqa
 
 if TYPE_CHECKING:
     from dzgui.api.servers import Details
@@ -46,12 +47,19 @@ class ServerDialog(GenericDialog):
         self.connect("response", self._on_response)
         self.view.connect("key-press-event", self._on_keypress)
 
-        self.scrollable_tree = Gtk.ScrolledWindow()
+        self.scrollable_tree = Gtk.ScrolledWindow(vexpand=True)
         self.scrollable_tree.add(self.view)
-        self.scrollable_tree.set_size_request(700, 400)
+        self.scrollable_tree.set_size_request(700, 500)
+
+        self.stack = Gtk.Stack()
+        self.content_box = VBox(10)
+        self.content_box.set_valign(Gtk.Align.FILL)
+        self.content_box.add(self.scrollable_tree)
+
+        self.stack.add_named(self.content_box, "METADATA")
 
         self.content = self.get_content_area()
-        self.content.pack_start(self.scrollable_tree, EXPAND, FILL, 0)
+        self.content.pack_start(self.stack, expand=True, fill=True, padding=0)
 
     def _on_keypress(self, view: Gtk.TreeView, event: Gdk.EventKey) -> bool:
         # NOTE: ESC normally unfocuses treeview instead of destroying dialog
@@ -66,9 +74,7 @@ class ServerDialog(GenericDialog):
 
 class ServerDetailsDialog(ServerDialog):
     def __init__(self, controller: "Controller", details: "Details"):
-        # TODO: server name should also be packed in details struct
-        name = controller.get_server_name()
-        super().__init__(controller, strings.server_details, name, menu=None)
+        super().__init__(controller, dialogs.server_details, details.name, menu=None)
 
         self.store = Gtk.ListStore(str, str, Pango.Weight)
         self.view.connect("row-activated", self._on_row_activated)
@@ -85,14 +91,9 @@ class ServerDetailsDialog(ServerDialog):
             column.set_sort_column_id(i)
             column.set_expand(True)
 
-        # NOTE: constrain tree area to logical height of metadata
-        # leaving room for server message
-        self.scrollable_tree.set_size_request(700, 150)
-
-        # TODO: make "Server message" text boldface
-        scrollable_message = Gtk.ScrolledWindow()
-        desc = Gtk.Label(label=strings.server_message, valign=Gtk.Align.START)
-        css.add_class(desc, "details-heading")
+        scrollable_message = Gtk.ScrolledWindow(vexpand=True)
+        desc = Gtk.Label(label=dialogs.server_message, valign=Gtk.Align.START)
+        css.add_class(desc, "server-subheading")
         box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, halign=Gtk.Align.CENTER)
         self.description = Gtk.Label(justify=Gtk.Justification.CENTER, wrap=True)
         sep = Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL)
@@ -100,11 +101,7 @@ class ServerDetailsDialog(ServerDialog):
         for el in desc, sep, self.description:
             box.add(el)
         scrollable_message.add(box)
-
-        self.pack(scrollable_message)
-
-        if details.data is None:
-            return
+        self.content_box.add(scrollable_message)
 
         for row in details.data:
             self.store.append(row + [Pango.Weight.BOLD])
@@ -113,8 +110,32 @@ class ServerDetailsDialog(ServerDialog):
         text = format_hyperlinks(text)
         self.description.set_markup(html.escape(text))
 
+        calc_button = IconTextButton(CALCULATOR, dialogs.toggle_calc)
+        calc_button.connect("clicked", self._on_calc_pressed)
+        calc_button.set_halign(Gtk.Align.END)
+        calc_button.set_valign(Gtk.Align.START)
+        self.content.pack_start(calc_button, False, False, 0)
+        self.content.reorder_child(calc_button, 2)
+
+        self.scrollable_tree.set_size_request(700, 250)
+        self.calc = ServerTimeCalculator(
+            Time(details.gametime, details.day_accel, details.night_accel)
+        )
+        self.stack.add_named(self.calc, "CALCULATOR")
+
+        self.connect("map", self._on_map)
         self.show_all()
 
+    def _on_map(self, dialog: Self) -> None:
+        if widget := self.get_widget_for_response(Gtk.ResponseType.OK):
+            widget.grab_focus()
+
+    def _on_calc_pressed(self, button: Gtk.Button) -> None:
+        if self.stack.get_visible_child_name() == "METADATA":
+            self.stack.set_visible_child_name("CALCULATOR")
+        else:
+            self.stack.set_visible_child_name("METADATA")
+
     def _on_row_activated(
         self,
         treeview: Gtk.TreeView,

dzgui/views/dialogs/uninstall.py

@@ -13,6 +13,7 @@ from dzgui.util.css import load_css
 from dzgui.util.format import format_exception
 from dzgui.views.components.box import HBox
 from dzgui.views.dialogs.wizard import ScrolledWizardPage, CheckboxWithLabel
+from dzgui.views.mixins.colorscheme import ColorAwareApp
 
 import gi
 
@@ -217,7 +218,7 @@ class UninstallPage(ScrolledWizardPage):
         pass
 
 
-class UninstallWizard(Gtk.Application):
+class UninstallWizard(ColorAwareApp, Gtk.Application):  # type: ignore
     def __init__(self, is_deck: bool, paths: dict[str, str]) -> None:
         super().__init__()
         config = Path(paths["XDG_CONFIG_HOME"])

dzgui/views/dialogs/wizard.py

@@ -1,4 +1,3 @@
-import os
 import textwrap
 
 from enum import Enum
@@ -17,9 +16,7 @@ from dzgui.const.constants import (
 )
 from dzgui.const.boilerplate import config_boilerplate
 from dzgui.const.endpoints import STEAM_API_SETUP
-from dzgui.const.enum import Preferences
 from dzgui.config import freedesktop
-from dzgui.config.query import lookup
 from dzgui.init.migrate import migrate_legacy_conf
 from dzgui.managers.threading import call_on_thread, StoredFunc, ThreadingManager
 from dzgui.strings import wizard
@@ -29,6 +26,7 @@ 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
 
 import gi
 
@@ -304,6 +302,7 @@ class ConfigMigrationPage(EnumeratedWizardPage):
         )
 
         self.migrated = False
+        self.migrated_conf: dict[str, Any] = {}
         self.config = config
         self.page_type = Gtk.AssistantPageType.INTRO
 
@@ -343,8 +342,7 @@ class ConfigMigrationPage(EnumeratedWizardPage):
     def _on_import_clicked(self, button: Gtk.Button) -> None:
         self.grid.set_sensitive(False)
         try:
-            # TODO: this could be deferred to the final page (prevents accidental destruction of dialog via ESC)
-            migrate_legacy_conf(self.config)
+            self.migrated_conf = migrate_legacy_conf(self.config)
             self.migrated = True
             self.success_box.set_visible(True)
         except Exception:
@@ -436,20 +434,18 @@ class Assistant(Gtk.Assistant):
         else:
             self.set_default_size(1500, 900)
 
-        self.is_binary = False if os.getenv("PYAPP") is None else True
         self.config_path = XDG.config
-
         self.config_values: dict[str, Any] = config_boilerplate
 
         self.setup_complete = False
 
-        self.page1 = IntroductionPage()
-        self.page2 = ConfigMigrationPage(XDG.config)
-        self.page3 = SteamPathPage()
-        self.page4 = SteamValidationPage()
-        self.page5 = PreferencesPage()
-        self.page6 = ShortcutCreationPage(XDG.shortcut)
-        self.page7 = CompletionPage()
+        self.page_intro = IntroductionPage()
+        self.page_migration = ConfigMigrationPage(XDG.config)
+        self.page_paths = SteamPathPage()
+        self.page_api = SteamValidationPage()
+        self.page_prefs = PreferencesPage()
+        self.page_shortcuts = ShortcutCreationPage(XDG.shortcut)
+        self.page_completion = CompletionPage()
 
         self.set_forward_page_func(self._advance_page)
 
@@ -457,16 +453,18 @@ class Assistant(Gtk.Assistant):
         EMITTER.connect("step_pending", self._mark_page_incomplete)
         EMITTER.connect("config", self._set_config_state)
 
+        self.pages: dict[EnumeratedWizardPage, int] = {}
+
         legacy_path = Path.home().joinpath(LEGACY_CONFIG_PATH)
         self.has_legacy_config = legacy_path.is_file()
         for page in (
-            self.page1,
-            self.page2,
-            self.page3,
-            self.page4,
-            self.page5,
-            self.page6,
-            self.page7,
+            self.page_intro,
+            self.page_migration,
+            self.page_paths,
+            self.page_api,
+            self.page_prefs,
+            self.page_shortcuts,
+            self.page_completion,
         ):
             # NOTE: skip config migration page if no legacy config file
             if (
@@ -474,10 +472,8 @@ class Assistant(Gtk.Assistant):
                 and self.has_legacy_config is False
             ):
                 continue
-            # NOTE: disabled for now on system-provided packages
-            if isinstance(page, ShortcutCreationPage) and not self.is_binary:
-                continue
-            self._add_page(page, page.get_page_type())
+            ind = self._add_page(page, page.get_page_type())
+            self.pages[page] = ind
 
         self.connect("prepare", self._on_page_prepare)
         self.connect("cancel", self.destroy_and_quit)
@@ -485,8 +481,11 @@ class Assistant(Gtk.Assistant):
         self.show_all()
         load_css()
 
-    def write_config(self) -> None:
-        write_json(self.config_values, self.config_path)
+    def write_config(self, config: dict[str, Any]) -> None:
+        write_json(config, self.config_path)
+
+    def get_final_page(self) -> int:
+        return self.pages[self.page_shortcuts]
 
     def _advance_page(self, index: int) -> int:
         page = self.get_nth_page(index)
@@ -495,24 +494,23 @@ class Assistant(Gtk.Assistant):
                 pass
             case ConfigMigrationPage():
                 if page.is_migrated():
-                    steam_path = lookup(self.config_path, Preferences.DEFAULT)
-                    self.page6.set_steam_path(steam_path)
-                    offset = 1 if not self.is_binary else 2
-                    self.setup_complete = True
-                    return self.get_n_pages() - offset
+                    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()
             case SteamPathPage():
                 self.config_values["default_steam_path"] = page.get_path_from_radio()
             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.page5.get_prefs()
+                name, use_miles, client = self.page_prefs.get_prefs()
                 self.config_values["name"] = name
                 self.config_values["use_miles"] = use_miles
                 self.config_values["client"] = client
-                self.write_config()
-                self.page6.set_steam_path(self.config_values["default_steam_path"])
-                self.setup_complete = True
+                self.page_shortcuts.set_steam_path(
+                    self.config_values["default_steam_path"]
+                )
             case ShortcutCreationPage():
                 page.create_shortcuts()
             case _:
@@ -542,11 +540,12 @@ class Assistant(Gtk.Assistant):
 
     def _add_page(
         self, page: EnumeratedWizardPage, ptype: Gtk.AssistantPageType
-    ) -> None:
-        self.append_page(page)
+    ) -> int:
+        ind = self.append_page(page)
         self.set_page_type(page, ptype)
         self.set_page_title(page, page.get_title())
         self.set_page_complete(page, True)
+        return ind
 
     def _set_config_state(self, emitter: "Emitter", state: bool) -> None:
         self.config = state
@@ -563,6 +562,10 @@ class Assistant(Gtk.Assistant):
         if not isinstance(page, IntroductionPage):
             EMITTER.emit("step_pending")
 
+        if page == self.page_completion:
+            self.write_config(self.config_values)
+            self.setup_complete = True
+
 
 class CheckboxWithLabel(Gtk.Box):
     def __init__(self, text: str, blurb_text: str) -> None:
@@ -706,7 +709,7 @@ class SteamPathPage(EnumeratedWizardPage):
         self.err_box.set_visible(False)
 
 
-class SetupWizard(Gtk.Application):
+class SetupWizard(ColorAwareApp, Gtk.Application):  # type: ignore
     def __init__(self, is_deck: bool, XDG: "Xdg") -> None:
         super().__init__()
         GLib.set_prgname(APP_NAME)

dzgui/views/mixins/colorscheme.py

@@ -0,0 +1,37 @@
+from typing import Any
+
+from dzgui.const.constants import (
+    GIO_SETTINGS_KEY,
+    GIO_SETTINGS_INTERFACE,
+    GIO_SETTINGS_PROP,
+    GIO_SETTINGS_VAL,
+)
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, Gio  # noqa
+
+
+class ColorAwareApp:
+    """
+    Polls the local theme's color scheme settings.
+    Intended to be consumed by Gtk.Applications (or ephemeral widgets like EarlyAlertDialogs)
+    on initialization, prior to being realized. Applying scheme changes too late in the chain
+    may cause a blinking effect.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.interface_settings = Gio.Settings.new(GIO_SETTINGS_INTERFACE)
+        self.interface_settings.connect(
+            "changed::color-scheme", self._on_color_scheme_changed
+        )
+        self.default_settings = Gtk.Settings.get_default()
+        self._on_color_scheme_changed(self.interface_settings, GIO_SETTINGS_PROP)
+
+    def _on_color_scheme_changed(self, settings: Gio.Settings, prop: str) -> None:
+        state = self.interface_settings.get_string(prop) == GIO_SETTINGS_VAL
+        if self.default_settings is None:
+            return
+        self.default_settings.set_property(GIO_SETTINGS_KEY, state)

dzgui/views/pages/options.py

@@ -76,7 +76,7 @@ class SubmitField(Gtk.Box):
             self.button = Gtk.Button(label=options.save_button)
 
         self.button.connect("clicked", self._on_save_clicked)
-        self.entry.connect("insert-text", self._on_text_typed)
+        self.entry.connect("changed", self._on_text_typed)
         self.entry.connect("activate", self._on_field_activated)
         self.entry.get_property("buffer").connect("deleted-text", self._on_text_deleted)
 
@@ -113,13 +113,9 @@ class SubmitField(Gtk.Box):
     def _on_text_typed(
         self,
         entry: Gtk.Entry,
-        text: str,
-        length: int,
-        pos: int,
     ) -> None:
 
-        buffer = entry.get_property("buffer")
-        text = buffer.get_text() + text
+        text = entry.get_text()
         state = self._is_valid_text(text)
         self.button.set_sensitive(state)
 
@@ -371,10 +367,8 @@ class Options(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
 
         self.connect("key-press-event", self._on_keypress)
 
-    def get_client_name(self) -> str:
-        model = self.client_combo.get_model()
-        ind = self.client_combo.get_active()
-        return str(model[ind][0])
+    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()

dzgui/views/pages/preconnect.py

@@ -176,8 +176,7 @@ class PreConnectionAssistant(Gtk.Box):
 
         self.error_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
         self.error_tree = MaskedTree(ERROR)
-        # TODO: strings
-        self.error_placeholder = Placeholder("No errors.")
+        self.error_placeholder = Placeholder(preconnect.no_errors)
         self.error_box.add(self.error_tree)
         self.error_box.add(self.error_placeholder)
         self.error_frame = HeadingFrame.new_with_widget_and_label(
@@ -280,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_servers.py

@@ -66,7 +66,7 @@ class ServerTreeView(ContextMixin, TreeView):  # type: ignore
         self.handler_id: int
         self.queue: Queue = Queue()
 
-        self.seen_cache: list[str] = []
+        self.seen_cache: list[Record] = []
 
         prefs = self.controller.get_prefs()
         columns = prefs.paths.columns
@@ -252,7 +252,6 @@ class ServerTreeView(ContextMixin, TreeView):  # type: ignore
                 case Gdk.KEY_c:
                     self.controller.menu_action(ContextMenu.COPY_SERVER_IP, self)
                 case Gdk.KEY_r:
-                    # TODO: unimplemented, needs threading
                     self.controller.menu_action(ContextMenu.REFRESH_PLAYERS, self)
         else:
             match event.keyval:
@@ -341,16 +340,24 @@ class ServerTreeView(ContextMixin, TreeView):  # type: ignore
         control = self.proxy_man.get_control()
         return model, control
 
-    @staticmethod
     def ping_server(
+        self,
         model: "FastInsertListStore",
         _iter: Gtk.TreeIter,
-        ip: str,
-        qport: int,
-        ping_column: int,
+        record: Record,
     ) -> None:
-        _ping = ping(ip, qport)
-        GLib.idle_add(lambda: model.set(_iter, ping_column, _ping))
+        _ping = ping(record.ip, record.qport)
+        GLib.idle_add(self._redraw, model, _iter, _ping)
+
+    def _redraw(
+        self, model: "FastInsertListStore", _iter: Gtk.TreeIter, _ping: int
+    ) -> None:
+        ping_column = 9
+        model.set(_iter, ping_column, _ping)
+        self.queue_draw()
+
+    def wipe_cache(self) -> None:
+        self.seen_cache = []
 
     def _get_ping(
         self,
@@ -363,13 +370,12 @@ class ServerTreeView(ContextMixin, TreeView):  # type: ignore
 
         addr_column = 7
         qport_column = 8
-        ping_column = 9
 
         addr = model.get_value(_iter, addr_column).split(":")
         ip = addr[0]
-        gameport = addr[1]
+        gameport = int(addr[1])
         qport = model.get_value(_iter, qport_column)
-        record = f"{addr}:{gameport}:{qport}"
+        record = Record(ip, gameport, qport)
 
         if record in self.seen_cache:
             return
@@ -378,7 +384,7 @@ class ServerTreeView(ContextMixin, TreeView):  # type: ignore
         thread = threading.Thread(
             daemon=True,
             target=self.ping_server,
-            args=(model, _iter, ip, qport, ping_column),
+            args=(model, _iter, record),
         )
         thread.start()
 

pyproject.toml

@@ -4,7 +4,7 @@ description = "DayZ server browser and mod manager for Linux"
 authors = [
     {name = "aclist"}
 ]
-version = "7.0.0b22"
+version = "7.0.0b28"
 license = "GPL-3.0-or-later"
 license-files = ["LICENSE"]
 readme = "README.md"
@@ -47,6 +47,7 @@ docs = [
 ]
 test = [
     "black==25.1.0",
+    "hypothesis==6.167.1",
     "pre-commit==4.4.0",
     "pytest==8.4.2",
     "pytest-cov==7.0.0",

scripts/prebuild.py

@@ -27,7 +27,7 @@ def fetch(url: str, destination: str) -> None:
 
 def get_cpython() -> None:
     source = f"https://github.com/astral-sh/python-build-standalone/releases/download/{DATE}/"
-    build = f"{CPYTHON_BUILD}%2B{DATE}-x86_64_v3-unknown-linux-gnu-install_only_stripped.tar.gz"
+    build = f"{CPYTHON_BUILD}%2B{DATE}-x86_64-unknown-linux-gnu-install_only_stripped.tar.gz"
     url = f"{source}{build}"
     outfile = unquote(build)
     fetch(url, outfile)

scripts/unused_imports.py

@@ -1,12 +1,23 @@
 from pathlib import Path
 
+
 def iterate(search_str: str) -> None:
     # TODO: exclude files from .gitignore
     print()
     print(f"Searching for '{search_str}'")
     print()
     files = Path(".").rglob("*")
-    ignore = [".git", ".mypy", "build/", "test.py"]
+    ignore = [
+        "scripts/",
+        ".git",
+        "egg",
+        "CHANGELOG",
+        ".mypy",
+        "build/",
+        "test.py",
+        "bugs",
+        "pyproject.toml",
+    ]
     for file in files:
         if file.is_dir():
             continue

tests/fixtures/api/loginusers_beta_client_multiple.vdf

@@ -0,0 +1,23 @@
+"users"
+{
+	"0"
+	{
+		"AccountName"		"STEAMUSER"
+		"PersonaName"		"STEAMUSER"
+		"RememberPassword"		"0"
+		"WantsOfflineMode"		"0"
+		"SkipOfflineModeWarning"		"0"
+		"AutoLogin"		"1"
+		"Timestamp"		"1787904411"
+	}
+	"1"
+	{
+		"AccountName"		"STEAMUSER2"
+		"PersonaName"		"STEAMUSER2"
+		"RememberPassword"		"0"
+		"WantsOfflineMode"		"0"
+		"SkipOfflineModeWarning"		"0"
+		"AutoLogin"		"1"
+		"Timestamp"		"1787904647"
+	}
+}

tests/fixtures/api/loginusers_beta_client_multiple_2.vdf

@@ -0,0 +1,23 @@
+"users"
+{
+	"0"
+	{
+		"AccountName"		"STEAMUSER"
+		"PersonaName"		"STEAMUSER"
+		"RememberPassword"		"0"
+		"WantsOfflineMode"		"0"
+		"SkipOfflineModeWarning"		"0"
+		"AutoLogin"		"1"
+		"Timestamp"		"1797904411"
+	}
+	"1"
+	{
+		"AccountName"		"STEAMUSER2"
+		"PersonaName"		"STEAMUSER2"
+		"RememberPassword"		"0"
+		"WantsOfflineMode"		"0"
+		"SkipOfflineModeWarning"		"0"
+		"AutoLogin"		"1"
+		"Timestamp"		"1787904647"
+	}
+}

tests/fixtures/api/loginusers_legacy_client_multiple.vdf

@@ -20,6 +20,6 @@
 		"SkipOfflineModeWarning"		"0"
 		"AllowAutoLogin"		"1"
 		"MostRecent"		"1"
-		"Timestamp"		"0"
+		"Timestamp"		"10"
 	}
 }

tests/test_colorscheme.py

@@ -0,0 +1,59 @@
+import pytest
+import subprocess
+
+from dzgui.const.constants import GIO_SETTINGS_KEY
+from dzgui.views.mixins.colorscheme import ColorAwareApp
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, Gio, GLib  # noqa
+
+
+class TestWidget(ColorAwareApp, Gtk.Button):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.state: bool
+
+    def check_theme(self) -> None:
+        self.state = self.get_settings().get_property(GIO_SETTINGS_KEY)
+        Gtk.main_quit()
+
+
+@pytest.fixture
+def widget() -> TestWidget:
+    return TestWidget()
+
+
+@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(
+        ["gsettings", "get", "org.gnome.desktop.interface", "color-scheme"],
+        capture_output=True,
+        text=True,
+    ).stdout
+    subprocess.run(
+        [
+            "gsettings",
+            "set",
+            "org.gnome.desktop.interface",
+            "color-scheme",
+            key,
+        ],
+    )
+
+    # NOTE: allow changes to propagate
+    GLib.idle_add(widget.check_theme)
+    Gtk.main()
+    subprocess.run(
+        [
+            "gsettings",
+            "set",
+            "org.gnome.desktop.interface",
+            "color-scheme",
+            local_pref,
+        ]
+    )
+    assert widget.state is expect

tests/test_html_escaping.py

@@ -22,9 +22,14 @@ class MockController:
 
 
 def test_html_escaping() -> None:
-    text = "<Server description> Game & mods"
-    details = Details([["0", "1"]], text, True)
+    name = "Test server"
+    desc = "<Server description> Game & mods"
+    gametime = "05:30"
+    day_accel = 5.0
+    night_accel = 1.0
+    details = Details([["0", "1"]], name, desc, gametime, day_accel, night_accel)
     controller = MockController()
     dialog = ServerDetailsDialog(controller, details)
+    dialog.destroy()
 
-    assert dialog.description.get_text() == text
+    assert dialog.description.get_text() == desc

tests/test_loginusers.py

@@ -14,6 +14,8 @@ pytestmark = pytest.mark.apitest
         ("api/loginusers_legacy_client.vdf", 0),
         ("api/loginusers_legacy_client_multiple.vdf", 1),
         ("api/loginusers_beta_client.vdf", 0),
+        ("api/loginusers_beta_client_multiple.vdf", 1),
+        ("api/loginusers_beta_client_multiple_2.vdf", 0),
     ],
 )
 def test_loginusers(monkeypatch, fixture: str, expect: int) -> None:

tests/test_path_conversion.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+from dzgui.config.xdg import get_xdg_paths
+
+
+def test_path_fallback(monkeypatch) -> None:
+    envs = ["XDG_DATA_HOME", "XDG_STATE_HOME", "XDG_CONFIG_HOME", "XDG_CACHE_HOME"]
+    for env in envs:
+        monkeypatch.setenv(env, "/etc/dzgui")
+    paths = get_xdg_paths()
+    assert paths["XDG_CONFIG_HOME"] == Path.home().joinpath(".config/dzgui")
+    assert paths["XDG_STATE_HOME"] == Path.home().joinpath(".local/state/dzgui")
+    assert paths["XDG_DATA_HOME"] == Path.home().joinpath(".local/share/dzgui")
+    assert paths["XDG_CACHE_HOME"] == Path.home().joinpath(".cache/dzgui")

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

@@ -0,0 +1,61 @@
+import unittest
+from unittest.mock import patch
+
+from dzgui.const.constants import (
+    FLATPAK_APPID,
+    FLATPAK_RUN_CMD,
+    FLATPAK_SANDBOX,
+    STEAM_CMD,
+)
+from dzgui.init import proc
+
+
+class TestSteamDetection(unittest.TestCase):
+    def test_flatpak_detection_with_multiple_running_apps(self):
+        def flatpak_output(args, *, text):
+            # Default `flatpak ps` includes instance, PID, app and runtime columns.
+            if args == ["flatpak", "ps", "--columns=application"]:
+                return f"com.spotify.Client\n{FLATPAK_APPID}\n{FLATPAK_APPID}\n"
+            return f"3904921611\t1257689\t{FLATPAK_APPID}\torg.freedesktop.Platform\n"
+
+        with (
+            patch.object(proc, "has_cmd", return_value=True),
+            patch.object(proc.subprocess, "check_output", side_effect=flatpak_output),
+        ):
+            for client in (FLATPAK_RUN_CMD, FLATPAK_SANDBOX):
+                with self.subTest(client=client):
+                    self.assertTrue(proc.is_steam_running(client))
+
+    def test_flatpak_not_running(self):
+        with patch.object(proc, "has_cmd", return_value=True):
+            for output in ("", "com.spotify.Client\n", f"{FLATPAK_APPID}Helper\n"):
+                with (
+                    self.subTest(output=output),
+                    patch.object(proc.subprocess, "check_output", return_value=output),
+                ):
+                    self.assertFalse(proc.is_flatpak_steam_running())
+
+    def test_flatpak_not_installed(self):
+        with (
+            patch.object(proc, "has_cmd", return_value=False),
+            patch.object(proc.subprocess, "check_output") as check_output,
+        ):
+            self.assertFalse(proc.is_flatpak_steam_running())
+            check_output.assert_not_called()
+
+    def test_native_steam(self):
+        with patch.object(proc, "has_cmd", return_value=True):
+            for running in (True, False):
+                with (
+                    self.subTest(running=running),
+                    patch.object(proc, "is_running", return_value=running),
+                ):
+                    self.assertEqual(proc.is_steam_running(STEAM_CMD), running)
+
+    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):
+            proc.is_steam_running("invalid-client")

tests/test_server_metadata.py

@@ -0,0 +1,45 @@
+import pytest
+import re
+
+from dzgui.api.servers import Details, Record, get_details
+
+
+@pytest.fixture
+def details() -> Details:
+    """
+    Static official server, metadata is expected to be invariate
+    """
+    r = Record("85.190.157.111", 10400, 10401)
+    return get_details(r)
+
+
+def test_invalid_server() -> None:
+    r = Record("127.0.0.1", 10400, 10401)
+    assert get_details(r) is None
+
+
+@pytest.mark.parametrize("key, expect", [("day_accel", 2.3), ("night_accel", 6.8)])
+def test_time_accel(details, key, expect) -> None:
+    assert getattr(details, key) == expect
+
+
+def test_gametime(details) -> None:
+    time_reg = r"^(0[0-9]|1[0-9]|2[0-3]):([0-5][0-9]$)"
+    match = re.match(time_reg, details.gametime)
+    assert match is not None
+
+
+def test_metadata(details) -> None:
+    for row in details.data:
+        label, value = row
+        match label:
+            case "Password":
+                assert value == "Disabled"
+            case "Platform":
+                assert value == "Windows"
+            case "Battleye":
+                assert value == "Enabled"
+            case "Valve Anti-Cheat":
+                assert value == "Enabled"
+            case _:
+                pass

tests/test_server_time.py

@@ -0,0 +1,112 @@
+import pytest
+
+from hypothesis import given, strategies as st
+from datetime import datetime, timedelta
+
+from dzgui.views.dialogs.calc import (
+    LocalClock,
+    ServerClock,
+    Time,
+    TimePicker,
+    DAY_START_TIME,
+    DAY_END_TIME,
+)
+
+
+class DummyEmitter:
+    def __init__(self) -> None:
+        pass
+
+    def connect(self, _, __) -> None:
+        pass
+
+
+@pytest.fixture(params=[("05:00", 10.0), ("15:30", 5.0)])
+def accel_server_clock(request) -> None:
+    clock_time, expect = request.param
+    cur_time = Time(clock_time, 5.0, 2.0)
+    emitter = DummyEmitter()
+    local_clock = LocalClock(emitter)
+    server_clock = ServerClock(cur_time, emitter, local_clock)
+    return expect, server_clock
+
+
+def test_accel_factor(accel_server_clock) -> None:
+    """Static test checking times at known boundaries"""
+    expect, clock = accel_server_clock
+    assert clock.get_accel_factor(clock.cur_time) == expect
+
+
+def reference_calc(start, end, day_factor, night_factor):
+    """
+    Reference implementation to test validity of UI-side calculator
+    Aggregates total seconds and applies accel factors after
+    """
+    day_start = datetime.combine(start.date(), DAY_START_TIME)
+    day_end = datetime.combine(start.date(), DAY_END_TIME)
+    night_factor = day_factor * night_factor
+
+    if end < start:
+        end += timedelta(days=1)
+
+    day_max = max(start, day_start)
+    day_min = min(end, day_end)
+
+    next_day_start = datetime.combine(end.date(), DAY_START_TIME)
+    next_day_end = datetime.combine(end.date(), DAY_END_TIME)
+
+    range1 = (day_end - day_max).total_seconds()
+    range2 = (min(end, next_day_end) - next_day_start).total_seconds()
+
+    if end.date() > start.date():
+        day_seconds = max(0, range1) + max(0, range2)
+    else:
+        day_seconds = max(0, (day_min - day_max).total_seconds())
+
+    total_seconds = (end - start).total_seconds()
+    night_seconds = (total_seconds - day_seconds) / night_factor
+    day_seconds = day_seconds / day_factor
+    total = night_seconds + day_seconds
+
+    return timedelta(seconds=total)
+
+
+day_accel = st.floats(
+    min_value=1.0, max_value=24.0, allow_nan=False, allow_infinity=False
+)
+night_accel = st.floats(
+    min_value=1.0, max_value=64.0, allow_nan=False, allow_infinity=False
+)
+
+
+@st.composite
+def time_ranges(draw):
+    start_time = draw(st.times())
+    deltas = st.timedeltas(min_value=timedelta(0), max_value=timedelta(days=1))
+    duration = draw(deltas)
+
+    start = datetime.combine(datetime.now(), start_time)
+    end = start + duration
+    return start, end
+
+
+@given(span=time_ranges(), day_factor=day_accel, night_factor=night_accel)
+def test_time_aggregation(span, day_factor, night_factor) -> None:
+    start, end = span
+
+    strtime = start.strftime("%H:%M")
+    t = Time(strtime, day_factor, night_factor)
+    emitter = DummyEmitter()
+    local_clock = LocalClock(emitter)
+    server_clock = ServerClock(t, emitter, local_clock)
+    h = end.time().hour
+    m = end.time().minute
+    picker = TimePicker(h, m)
+
+    # NOTE: truncates microseconds to mimic widget HH:MM selection behavior
+    start = server_clock.get_datetime()
+    end = picker.get_time()
+    actual = server_clock.calc_delta(end)
+    expect = reference_calc(start, end, day_factor, night_factor)
+
+    assert actual == expect

tests/test_time.py

@@ -2,7 +2,6 @@ import re
 
 from dzgui.model.proxy_model import DAY_REG, NIGHT_REG
 
-
 def iterate(h: str, r: str) -> None:
     for m in range(60):
         time = f"{h:02}:{m:02}"
@@ -18,6 +17,6 @@ def test_day() -> None:
 
 def test_night() -> None:
     for h in range(24):
-        if 6 < h < 17:
+        if 5 < h < 18:
             continue
         iterate(h, NIGHT_REG)