fix: allow using refresh button after timeout events (#484)

dzgui/api/shortcuts.py

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

dzgui/api/steam.py

@@ -13,7 +13,6 @@ from warnings import deprecated
 
 from dzgui.api.acf import ACF
 from dzgui.init.prereqs import has_any_client
-from dzgui.init.proc import has_cmd
 from dzgui.const.constants import (
     APPID_DAYZ,
     APPID_DAYZ_EXP,
@@ -23,7 +22,6 @@ from dzgui.const.constants import (
     DEBIAN_STEAM_PATH,
     DEFAULT_STEAM_PATH,
     DOWNLOADS_PATH,
-    FLATPAK_CMD,
     FLATPAK_STEAM_PATH,
     LIBRARYFOLDERS_PATH,
     UBUNTU_STEAM_PATH,
@@ -84,8 +82,6 @@ def get_steam_paths() -> list[tuple[Path, str]]:
         }
 
         for path in DEFAULT_PATH, FLATPAK_PATH, UBUNTU_PATH, DEBIAN_PATH:
-            if path is FLATPAK_PATH and has_cmd(FLATPAK_CMD) is False:
-                continue
             if path.joinpath(VDF_PATH).is_file():
                 paths.append((path, human[path]))
     return paths
@@ -202,7 +198,6 @@ def load_to_menu(client: str, appid: int, name: str, mods: list[str]) -> int:
     """Loads to the menu screen with the selected mods; used for AFK/pre-joining"""
     concat = concat_mods(mods)
     client_args = concat_bash_args(client)
-    logger.debug(f"Setting client arguments to: {client_args}")
     params = [
         "-applaunch",
         str(appid),

dzgui/app_init.py

@@ -148,7 +148,7 @@ def load_gui(version: str, is_debug: bool) -> None:
         migrate_cols_file(XDG.columns)
         copy_state_files(xdg_paths["XDG_STATE_HOME"])
         # TODO: add logging inside wizard
-        wizard = SetupWizard(_is_steam_deck, XDG, xdg_paths)
+        wizard = SetupWizard(_is_steam_deck, XDG)
 
         if not wizard.is_setup_complete():
             return

dzgui/config/xdg.py

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

dzgui/controllers/emitter.py

@@ -111,6 +111,10 @@ class Emitter(GObject.GObject):
     def check_toggled(self, label: str, state: bool) -> None:
         pass
 
+    @GObject.Signal(flags=GObject.SignalFlags.RUN_LAST, arg_types=())
+    def servers_timed_out(self) -> None:
+        pass
+
     @GObject.Signal(flags=GObject.SignalFlags.RUN_LAST, arg_types=(object,))
     def servers_loaded(self, tag: "ServerTab") -> None:
         pass

dzgui/init/proc.py

@@ -1,8 +1,7 @@
-import logging
-import os
 import psutil
-import shutil
 import subprocess
+import shutil
+import logging
 
 from dzgui.const.constants import (
     APP_NAME,
@@ -27,13 +26,7 @@ def is_steam_running(cmd: str) -> bool:
         raise TypeError("Not a valid Steam client selection")
 
 
-def is_sandboxed() -> bool:
-    return bool(os.environ.get("FLATPAK_ID"))
-
-
 def is_flatpak_steam_running() -> bool:
-    if is_sandboxed():
-        return True
     if has_cmd(FLATPAK_CMD) is False:
         return False
     proc = subprocess.check_output(

dzgui/model/servers.py

@@ -92,6 +92,7 @@ class ServerModelManager:
         job = Servers.query_api
         params = Servers.params
         servers = []
+
         with ThreadPoolExecutor() as executor:
             futures = [executor.submit(job, key, APPID_DAYZ, param) for param in params]
             for future in as_completed(futures):
@@ -414,6 +415,8 @@ class ServerModelManager:
         # TODO: disable map, keyword, and filter widgets if model is None
         # signal driven (servers_empty, servers_failed_to_load)
 
+        self.emitter.emit("servers_timed_out")
+
         if self.preserve_on_fail is False:
             self.tv.set_model(None)
             filter_man = self.tv.get_filter_man()

dzgui/strings/wizard.py

@@ -3,8 +3,6 @@ title_intro = "Welcome"
 blurb_intro = """
 This wizard will help you set up some common config options before launching the application.
 """
-error_sandbox = "Setup cannot be run from inside Flatpak sandbox.\nPlease launch the application directly."
-welcome = "Welcome to {0}!"
 
 ### SteamPathPage
 heading_steam_path = "Steam path"
@@ -82,17 +80,6 @@ checkbox_start_menu = (
 )
 checkbox_desktop_shortcut = ("Add a desktop shortcut", "Depends on the option above.")
 
-### Flatpak page
-heading_flatpak = "Flatpak sandbox overrides"
-blurb_flatpak = (
-    "You chose to add a shortcut directly to Flatpak Steam. "
-    "To launch DZGUI from Flatpak's sandbox, you must grant "
-    "permission to read from and write to the following locations."
-)
-tree_column = "Paths"
-overrides_applied = "Overrides applied."
-button_flatpak = "Grant permissions"
-
 ### Completion page
 heading_completion = "Setup complete"
 blurb_completion = "Configuration completed successfully. Click 'Close' to close this dialog and launch DZGUI."

dzgui/util/bash.py

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

dzgui/util/flatpak.py

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

dzgui/views/components/buttons.py

@@ -163,18 +163,24 @@ class RefreshButton(IconTextButton):
         self.set_tooltip_text(atomic_buttons.refresh_tooltip)
 
         self.connect("clicked", self._on_refresh_clicked)
-        emitter.connect("servers_loaded", self.start_decrement)
+        emitter.connect("servers_loaded", self._on_load)
+        emitter.connect("servers_timed_out", self._on_timeout)
+
+    def _on_timeout(self, emitter: "Emitter") -> None:
+        self.is_clicked = True
+        self.start_decrement()
+
+    def _on_load(self, emitter: "Emitter", tab: "ServerTab") -> None:
+        self.start_decrement()
 
     def _on_refresh_clicked(self, button: Self) -> None:
         """Spawned in a thread"""
-        if self.controller.get_active_treeview().is_loaded() is False:
-            return
         self.is_clicked = True
         self.controller.refresh_tree()
         # TODO: get server tab enum
         # if LAN tab, reload existing entries in place
 
-    def start_decrement(self, emitter: "Emitter", tab: "ServerTab") -> None:
+    def start_decrement(self) -> None:
         if self.is_clicked is False:
             return
         if self.loading:

dzgui/views/dialogs/wizard.py

@@ -12,24 +12,22 @@ from dzgui.const.constants import (
     APP_NAME,
     APP_NAME_LOWER,
     HERO_PATH,
-    FLATPAK_ROOT_PATH,
+    FLATPAK_STEAM_PATH,
     LEGACY_CONFIG_PATH,
 )
 from dzgui.const.boilerplate import config_boilerplate
 from dzgui.const.endpoints import STEAM_API_SETUP
 from dzgui.config import freedesktop
-from dzgui.init.proc import is_sandboxed, path_to_steam_cmd
+from dzgui.init.proc import path_to_steam_cmd
 from dzgui.init.migrate import migrate_legacy_conf
 from dzgui.managers.threading import call_on_thread, StoredFunc, ThreadingManager
 from dzgui.strings import wizard
 from dzgui.util._json import write_json
-from dzgui.util.flatpak import apply_overrides
 from dzgui.util.open_links import open_link_by_url
 from dzgui.util.css import add_class, load_css
 from dzgui.views.components.buttons import WebButton
 from dzgui.views.components.entry import APIEntry
 from dzgui.views.mixins.colorscheme import ColorAwareApp
-from dzgui.views.trees.tree_simple import SimpleTree
 
 import gi
 
@@ -47,8 +45,7 @@ class PageNum(Enum):
     STEAM_API = 4
     USER_PREFS = 5
     SHORTCUTS = 6
-    FLATPAK = 7
-    FINAL = 8
+    FINAL = 7
 
 
 class OptionalPageMixin:
@@ -147,7 +144,7 @@ class NotificationFrame(Gtk.Frame):
             margin_start=50,
             margin_end=50,
         )
-        wrapped = textwrap.fill(label, width=60)
+        wrapped = textwrap.fill(label, width=80)
         self.label = Gtk.Label(
             label=wrapped,
             justify=Gtk.Justification.CENTER,
@@ -161,7 +158,7 @@ class NotificationFrame(Gtk.Frame):
             add_class(self, "error-frame")
 
     def set_text(self, text: str) -> None:
-        wrapped = textwrap.fill(text, width=60)
+        wrapped = textwrap.fill(text, width=80)
         self.label.set_markup(wrapped)
 
 
@@ -246,23 +243,12 @@ class IntroductionPage(EnumeratedWizardPage):
     def __init__(self) -> None:
         super().__init__(
             enum=PageNum.INTRO,
-            heading=wizard.welcome.format(APP_NAME),
+            heading=f"Welcome to {APP_NAME}!",
             description=wizard.blurb_intro,
         )
         self.page_type = Gtk.AssistantPageType.INTRO
         self.set_title(wizard.title_intro)
 
-        self.error_box = NotificationFrame(wizard.error_sandbox, error=True)
-        self.add_start(self.error_box)
-
-        self.connect("map", self._on_map)
-
-    def _on_map(self, page: "EnumeratedWizardPage") -> None:
-        self.error_box.hide()
-        if is_sandboxed():
-            self.error_box.show()
-            EMITTER.emit("step_pending")
-
 
 class Heading(Gtk.Label):
     def __init__(self, label: str):
@@ -419,42 +405,6 @@ class PreferencesPage(EnumeratedWizardPage):
         EMITTER.emit("step_complete")
 
 
-class FlatpakOverridePage(EnumeratedWizardPage):
-    def __init__(self, xdg_paths: dict[str, str]) -> None:
-        super().__init__(
-            enum=PageNum.FLATPAK,
-            heading=wizard.heading_flatpak,
-            description=wizard.blurb_flatpak,
-        )
-        self.xdg_paths = xdg_paths
-        self.page_type = Gtk.AssistantPageType.INTRO
-
-        store = Gtk.ListStore(str)
-        for path in xdg_paths.values():
-            store.append((str(path),))
-        tree = SimpleTree(store, wizard.tree_column)
-        tree.set_halign(Gtk.Align.CENTER)
-
-        self.authorize_button = Gtk.Button(
-            label=wizard.button_flatpak, halign=Gtk.Align.CENTER
-        )
-        self.authorize_button.connect("clicked", self._on_authorize)
-
-        self.notice = NotificationFrame(wizard.overrides_applied)
-        self.connect("map", self._on_map)
-
-        for el in tree, self.authorize_button, self.notice:
-            self.add_start(el)
-
-    def _on_map(self, page: "EnumeratedWizardPage") -> None:
-        self.notice.hide()
-
-    def _on_authorize(self, button: Gtk.Button) -> None:
-        apply_overrides(self.xdg_paths)
-        self.notice.show()
-        EMITTER.emit("step_complete")
-
-
 class CompletionPage(EnumeratedWizardPage):
     def __init__(self) -> None:
         super().__init__(
@@ -468,7 +418,7 @@ class CompletionPage(EnumeratedWizardPage):
 
 
 class Assistant(Gtk.Assistant):
-    def __init__(self, is_deck: bool, XDG: "Xdg", xdg_paths: dict[str, str]):
+    def __init__(self, is_deck: bool, XDG: "Xdg"):
         super().__init__()
         if is_deck:
             # NOTE: deemed to be "safe" dimensions that exclude taskbar size
@@ -487,7 +437,6 @@ class Assistant(Gtk.Assistant):
         self.page_api = SteamValidationPage()
         self.page_prefs = PreferencesPage()
         self.page_shortcuts = ShortcutCreationPage(XDG.shortcut)
-        self.page_flatpak = FlatpakOverridePage(xdg_paths)
         self.page_completion = CompletionPage()
 
         self.set_forward_page_func(self._advance_page)
@@ -507,7 +456,6 @@ class Assistant(Gtk.Assistant):
             self.page_api,
             self.page_prefs,
             self.page_shortcuts,
-            self.page_flatpak,
             self.page_completion,
         ):
             # NOTE: skip config migration page if no legacy config file
@@ -528,10 +476,7 @@ class Assistant(Gtk.Assistant):
     def write_config(self, config: dict[str, Any]) -> None:
         write_json(config, self.config_path)
 
-    def get_completion_page(self) -> int:
-        return self.pages[self.page_completion]
-
-    def get_shortcut_page(self) -> int:
+    def get_final_page(self) -> int:
         return self.pages[self.page_shortcuts]
 
     def _advance_page(self, index: int) -> int:
@@ -544,7 +489,7 @@ class Assistant(Gtk.Assistant):
                     sp = page.migrated_conf["default_steam_path"]
                     self.page_shortcuts.set_steam_path(sp)
                     self.config_values = self.page_migration.migrated_conf
-                    return self.get_shortcut_page()
+                    return self.get_final_page()
             case SteamPathPage():
                 path = page.get_path_from_radio()
                 self.config_values["default_steam_path"] = path
@@ -561,22 +506,10 @@ class Assistant(Gtk.Assistant):
                 )
             case ShortcutCreationPage():
                 page.create_shortcuts()
-                if not self.needs_flatpak_override():
-                    return self.get_completion_page()
-            case FlatpakOverridePage():
-                pass
             case _:
                 raise AttributeError("Trying to advance a non-canonical page")
         return index + 1
 
-    def needs_flatpak_override(self) -> bool:
-        if (
-            self.page_shortcuts.is_steam_checkbox_active()
-            and FLATPAK_ROOT_PATH in self.config_values["default_steam_path"]
-        ):
-            return True
-        return False
-
     def is_setup_complete(self) -> bool:
         return self.setup_complete
 
@@ -692,6 +625,12 @@ class ShortcutCreationPage(OptionalPageMixin, EnumeratedWizardPage):  # type: ig
         self.add_start(self.checks_area)
         self.show_all()
         self.connect("map", self._on_map)
+        self.connect("map", self._toggle_checkbox)
+
+    def _toggle_checkbox(self, page: "EnumeratedWizardPage") -> None:
+        if FLATPAK_STEAM_PATH in str(self.steam_path):
+            self.steam_checkbox.set_active(False)
+            self.steam_checkbox.set_sensitive(False)
 
     def _on_start_menu_toggled(self, button: Gtk.CheckButton) -> None:
         state = button.get_active()
@@ -702,9 +641,6 @@ class ShortcutCreationPage(OptionalPageMixin, EnumeratedWizardPage):  # type: ig
     def set_steam_path(self, path: Path) -> None:
         self.steam_path = path
 
-    def is_steam_checkbox_active(self) -> bool:
-        return self.steam_checkbox.get_active()
-
     def create_shortcuts(self) -> None:
         # NOTE: best-effort, permissive even on failure (page is already marked as complete)
         if self.steam_checkbox.get_active():
@@ -773,10 +709,10 @@ class SteamPathPage(EnumeratedWizardPage):
 
 
 class SetupWizard(ColorAwareApp, Gtk.Application):  # type: ignore
-    def __init__(self, is_deck: bool, XDG: "Xdg", xdg_paths: dict[str, str]) -> None:
+    def __init__(self, is_deck: bool, XDG: "Xdg") -> None:
         super().__init__()
         GLib.set_prgname(APP_NAME)
-        self.win = Window(is_deck, XDG, xdg_paths)
+        self.win = Window(is_deck, XDG)
         Gtk.main()
 
     def is_setup_complete(self) -> int:
@@ -784,9 +720,9 @@ class SetupWizard(ColorAwareApp, Gtk.Application):  # type: ignore
 
 
 class Window(Gtk.Window):
-    def __init__(self, is_deck: bool, XDG: "Xdg", xdg_paths: dict[str, str]) -> None:
+    def __init__(self, is_deck: bool, XDG: "Xdg") -> None:
         super().__init__(title=APP_NAME, icon_name=APP_NAME)
-        self.assistant = Assistant(is_deck, XDG, xdg_paths)
+        self.assistant = Assistant(is_deck, XDG)
 
 
 class Emitter(GObject.GObject):

dzgui/views/pages/options.py

@@ -266,6 +266,7 @@ class FlatpakToggleField(ToggleField):
 
     def _on_radio_toggled(self, button: Gtk.RadioButton, context: Preferences) -> None:
         cmd = FLATPAK_RUN_CMD if self.radio1.get_active() else FLATPAK_SANDBOX
+        print(context)
         self.controller.update_config(context, cmd)
 
 

dzgui/views/trees/tree_simple.py

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

tests/test_flatpak_toggle.py

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