chore: drop print statement

CHANGELOG.md

@@ -40,6 +40,7 @@
 - Preboot progress dialog
 - Choose to jump into splash screen instead of server
 - Collapsible connection panel
+- Play offline (load mods directly)
 
 ## Changed
 - Conform to PEP 440 versioning for beta versions

dzgui/api/mods.py

@@ -87,15 +87,18 @@ def get_mod_size(path: Path) -> float:
     return size
 
 
-def get_delimited_mods(steam_path: Path) -> list[Any]:
-    workshop_path = get_local_mod_path(steam_path)
-    mods = get_local_mods(workshop_path)
+def get_custom_mods(path: Path) -> list[Any]:
+    mods = get_local_mods(path)
+    # TODO: error handling
+    return parse_mods(mods)
+
+
+def parse_mods(mods: list[Path]) -> list[Any]:
     clean = []
     for mod in mods:
         mod_dir = mod.name
         symlink = _hash(mod_dir)
         # FIXME: malformed .cpp files could break this
-        # mention that mods may be downloading
         meta = parse_meta(mod)
         if meta is None:
             continue
@@ -106,6 +109,12 @@ def get_delimited_mods(steam_path: Path) -> list[Any]:
     return clean
 
 
+def get_delimited_mods(steam_path: Path) -> list[Any]:
+    workshop_path = get_local_mod_path(steam_path)
+    mods = get_local_mods(workshop_path)
+    return parse_mods(mods)
+
+
 def get_missing_mods(local: list, remote: list) -> list:
     return [mod for mod in remote if mod not in local]
 

dzgui/api/steam.py

@@ -146,7 +146,7 @@ def connect(client: str, addr: str, appid: int, name: str, mods: list[str]) -> i
     return proc.returncode
 
 
-def load_to_menu(client: str, addr: str, appid: int, name: str, mods: list[str]) -> int:
+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)
@@ -162,6 +162,22 @@ def load_to_menu(client: str, addr: str, appid: int, name: str, mods: list[str])
     proc = subprocess.run([*client_args, *params])
     return proc.returncode
 
+def launch_offline(client: str, appid: int, name: str, mods: list[str], mission: str) -> int:
+    """Launch offline with specific mods/missions"""
+    concat = concat_mods(mods)
+    client_args = concat_bash_args(client)
+    params = [
+        "-applaunch",
+        str(appid),
+        "-nolauncher",
+        "-nosplash",
+        "-skipintro",
+        f"-name={name}",
+        f"-mod={concat}",
+        f"-mission={mission}"
+    ]
+    proc = subprocess.run([*client_args, *params])
+    return proc.returncode
 
 def find_user_id(path: Path) -> str | None:
     resolved_path = path / "config" / "loginusers.vdf"

dzgui/const/constants.py

@@ -35,6 +35,7 @@ HEX_ORANGE = "#FFAC1C"
 CARET_DOWN = "go-down-symbolic"
 CARET_UP = "go-up-symbolic"
 CLIPBOARD = "edit-copy-symbolic"
+FOLDER = "folder-symbolic"
 ERROR = "dialog-error-symbolic"
 HELP_BUBBLE = "help-about-symbolic"
 INPUT_KEYBOARD = "input-keyboard-symbolic"

dzgui/const/enum.py

@@ -103,6 +103,7 @@ class Preferences(EnumWithAttrs):
 
 
 class NotebookPage(EnumWithAttrs):
+    OFFLINE = {"crumbs": strings.crumbs.offline, "statusbar": True}
     CHANGELOG = {"crumbs": strings.crumbs.changelog, "statusbar": True}
     DEVELOPERS = {"crumbs": strings.crumbs.developers, "statusbar": False}
     HELP = {"crumbs": strings.crumbs._help, "statusbar": True}

dzgui/controllers/mc.py

@@ -20,13 +20,12 @@ from dzgui.controllers.emitter import Emitter
 from dzgui.managers.config import ConfigManager
 from dzgui.managers.connection import ConnectionManager
 from dzgui.managers.contextmenu import ContextMenuManager
-from dzgui.managers.mods import ModManager
 from dzgui.managers.notes import NoteManager
 from dzgui.model.servers import ServerModelManager
 from dzgui.util.diag import write_diagnostic
 from dzgui.util.format import format_player_count
 from dzgui.util.open_links import open_user_workshop, open_workshop_page
-from dzgui.views.dialogs.filepicker import FilePicker
+from dzgui.views.dialogs.filepicker import FilePicker, FolderPicker
 from dzgui.views.dialogs.generic import ExceptionDialog
 
 import gi
@@ -37,6 +36,7 @@ from gi.repository import Gtk, Gdk, GLib, GObject  # noqa E402
 logger = logging.getLogger(APP_NAME)
 
 if TYPE_CHECKING:
+    from pathlib import Path
     from dzgui.api.servers import Record
     from dzgui.const.enum import ServerTab
     from dzgui.managers.connection import Prerequisites
@@ -47,12 +47,13 @@ if TYPE_CHECKING:
     from dzgui.views.components.filter_panel import FilterPanel
     from dzgui.views.components.right_panel import RightPanel
     from dzgui.views.components.statusbar import Statusbar
+    from dzgui.views.pages.offline import OfflineLoader
     from dzgui.views.pages.options import Options
     from dzgui.views.pages.preconnect import PreConnectionAssistant
     from dzgui.views.pages.servers import ServerNotebook
     from dzgui.views.trees.tree_log import LogTreeView
     from dzgui.views.trees.tree_menu import MenuTreeView
-    from dzgui.views.trees.tree_mods import ModTreeView
+    from dzgui.views.trees.tree_mods import ModTreeView, OfflineModTreeView
     from dzgui.views.trees.tree_servers import ServerTreeView
 
 
@@ -72,6 +73,7 @@ class AppNavigation:
     filters: "FilterPanel"
     preconnect: "PreConnectionAssistant"
     options: "Options"
+    offline_loader: "OfflineLoader"
 
 
 class Controller(GObject.GObject):
@@ -218,19 +220,29 @@ class Controller(GObject.GObject):
         open_user_workshop(uid, client)
 
     def load_mods(self) -> None:
-        self.mod_man = ModManager(self)
+        self.mediator.modtreeview.load_mods()
 
     def uncolorize_mods(self) -> None:
-        self.mod_man.uncolorize_mods()
+        mod_man = self.mediator.modtreeview.get_mod_man()
+        mod_man.uncolorize_mods()
 
     def highlight_stale(self) -> None:
-        self.mod_man.highlight_stale()
+        mod_man = self.mediator.modtreeview.get_mod_man()
+        mod_man.highlight_stale()
 
     def toggle_mod_selection(self, state: bool) -> None:
-        self.mod_man.toggle_mod_selection(state)
+        mod_man = self.mediator.modtreeview.get_mod_man()
+        mod_man.toggle_mod_selection(state)
 
-    def delete_mods(self) -> None:
-        self.mod_man.delete_mods()
+    def delete_mods(
+        self, treeview: Union["ModTreeView", "OfflineModTreeView", None] = None
+    ) -> None:
+        if treeview is None:
+            view = self.mediator.modtreeview
+        else:
+            view = treeview
+        mod_man = view.get_mod_man()
+        mod_man.delete_mods()
 
     def get_mod_store(self) -> Gtk.TreeModel | None:
         return self.mediator.modtreeview.get_model()
@@ -257,7 +269,8 @@ class Controller(GObject.GObject):
             dialog.run()
 
     def select_colorized(self) -> None:
-        self.mod_man.select_colorized()
+        mod_man = self.mediator.modtreeview.get_mod_man()
+        mod_man.select_colorized()
 
     def get_all_tree_filters(self) -> dict[str, dict[str, bool]]:
         servers = self.get_servers()
@@ -288,6 +301,12 @@ class Controller(GObject.GObject):
                 dialog = ExceptionDialog(self, str(e))
                 dialog.run()
 
+    def set_custom_folder(self) -> Union["Path", None]:
+        picker = FolderPicker(self.mediator.window)
+        folder = picker.pick_folder()
+        picker.destroy()
+        return folder
+
     def update_api_key(self, key: Preferences, text: str) -> None:
         self.config_man.update_api_key(key, text)
 
@@ -533,3 +552,9 @@ class Controller(GObject.GObject):
             self.clear_cancel_event()
             return True
         return False
+
+    def open_offline(self) -> None:
+        self.open_page(NotebookPage.OFFLINE)
+        mod_man = self.mediator.modtreeview.get_mod_man()
+        store = mod_man.store
+        self.mediator.offline_loader.populate(store)

dzgui/managers/connection.py

@@ -265,7 +265,7 @@ class ConnectionManager:
         playername = self.controller.query_config(Preferences.NAME)
         client = self.controller.query_config(Preferences.CLIENT)
         if menu_only:
-            rc = load_to_menu(client, addr, self.appid, playername, self.remote_mod_ids)
+            rc = load_to_menu(client, self.appid, playername, self.remote_mod_ids)
         else:
             rc = connect(client, addr, self.appid, playername, self.remote_mod_ids)
         if rc != 0:

dzgui/managers/contextmenu.py

@@ -8,7 +8,7 @@ from dzgui.util.clip import copy_clipboard
 from dzgui.util.open_links import open_workshop_page
 
 from dzgui.views.dialogs.note import NoteDialog
-from dzgui.views.trees.tree_mods import ModTreeView
+from dzgui.views.trees.tree_mods import ModTreeView, OfflineModTreeView
 from dzgui.views.trees.tree_log import LogTreeView
 from dzgui.views.trees.tree_servers import ServerTreeView
 from dzgui.views.trees.tree_server_mods import ServerModTreeView
@@ -27,7 +27,13 @@ if TYPE_CHECKING:
 class ContextMenuManager:
     def __init__(
         self,
-        treeview: LogTreeView | ModTreeView | ServerTreeView | ServerModTreeView,
+        treeview: (
+            LogTreeView
+            | ModTreeView
+            | ServerTreeView
+            | ServerModTreeView
+            | OfflineModTreeView
+        ),
         controller: "Controller",
     ) -> None:
         self.controller = controller
@@ -72,10 +78,10 @@ class ContextMenuManager:
                 case ContextMenu.SHOW_MODS:
                     self.controller.get_modlist(record)
 
-        if isinstance(self.treeview, ModTreeView):
+        if isinstance(self.treeview, (ModTreeView, OfflineModTreeView)):
             match action:
                 case ContextMenu.DELETE_MOD:
-                    self.controller.delete_mods()
+                    self.controller.delete_mods(self.treeview)
                 case ContextMenu.OPEN_WORKSHOP:
                     self.open_mod_page()
 

dzgui/managers/mods.py

@@ -2,7 +2,7 @@ import logging
 import shutil
 
 from pathlib import Path
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from dzgui.api.mods import (
     get_delimited_mods,
@@ -40,20 +40,20 @@ class ModManager:
     this manager is instantiated each time the Mods page is opened
     """
 
-    def __init__(self, controller: "Controller") -> None:
+    def __init__(self, tree: Gtk.TreeView, controller: "Controller") -> None:
+        self.treeview = tree
         self.controller = controller
+
         self.emitter = controller.get_emitter()
         self.prefs = controller.get_prefs()
         self.path = controller.query_config(Preferences.DEFAULT)
-        self.treeview = self.controller.get_modtreeview()
 
         self.store: FastInsertListStore
 
         self.thread_man = ThreadingManager(controller)
-        self._get_mods()
 
     @call_on_thread(dialogs.fetching_mods)
-    def _get_mods(self) -> None:
+    def load_mods(self) -> None:
         mods = get_delimited_mods(self.path)
         if len(mods) < 1:
             msg = self.format_mod_statusbar()
@@ -61,12 +61,12 @@ class ModManager:
             self.thread_man.set_cleanup_func(func)
             return
 
-        func = StoredFunc(self._on_mods_loaded, mods)
-        self.thread_man.set_cleanup_func(func)
-
-    def _on_mods_loaded(self, mods: list[list[Any]]) -> None:
         self.store = ModelFactory().make_mod_store()
         self.store.extend(mods)
+        func = StoredFunc(self._on_mods_loaded)
+        self.thread_man.set_cleanup_func(func)
+
+    def _on_mods_loaded(self) -> None:
         self.treeview.set_model(self.store)
         msg = self.format_mod_statusbar()
         total_mods = len(self.store)

dzgui/managers/offline.py

@@ -0,0 +1,73 @@
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from dzgui.api.mods import get_custom_mods
+from dzgui.api.steam import launch_offline
+from dzgui.const.enum import Preferences
+from dzgui.managers.threading import call_on_thread, ThreadingManager
+from dzgui.model.model_factory import FastInsertListStore, ModelFactory
+from dzgui.strings import dialogs
+from dzgui.util.symlink import clone_symlinks
+
+if TYPE_CHECKING:
+    from dzgui.controllers.mc import Controller
+
+
+class OfflineManager:
+    def __init__(
+        self,
+        controller: "Controller",
+    ) -> None:
+        super().__init__()
+
+        self.controller = controller
+        self.thread_man = ThreadingManager(controller)
+
+        self.appid: int
+        self.mission_folder: str
+        self.local_mods: list[str] | None
+        self.custom_mods: list[str] | None
+
+    # TODO: strings
+    @call_on_thread("parsing")
+    def parse_custom_mods(self, folder: str) -> "FastInsertListStore":
+        mods = get_custom_mods(Path(folder))
+        store = ModelFactory().make_mod_store()
+        store.extend(mods)
+        # TODO: manipulate tree columns to only show name and size
+        return store
+
+    def setup(
+        self,
+        appid: int,
+        mission: str = "",
+        local_mods: list[str] | None = None,
+        custom_mods: list[str] | None = None,
+    ) -> None:
+
+        self.appid = appid
+        self.mission_folder = mission
+        self.local_mods = local_mods
+        self.custom_mods = custom_mods
+
+        self.launch()
+
+    @call_on_thread(dialogs.waiting_for_launch)
+    def launch(self) -> None:
+        client = self.controller.query_config(Preferences.CLIENT)
+        name = self.controller.query_config(Preferences.NAME)
+        steam_path = self.controller.query_config(Preferences.DEFAULT)
+
+        new_symlinks: list[str] = []
+
+        combined_mods: list[str] = []
+        if self.local_mods is not None:
+            combined_mods.extend(self.local_mods)
+
+        if self.custom_mods is not None:
+            # TODO: new function that creates symlinks in game path
+            # based on selected mods
+            clone_symlinks(Path(steam_path))
+            combined_mods.extend(new_symlinks)
+
+        launch_offline(client, self.appid, name, combined_mods, self.mission_folder)

dzgui/model/model_factory.py

@@ -165,3 +165,6 @@ class ModelFactory:
 
     def make_server_store(self) -> FastInsertListStore:
         return self.new_model_from_class(ServerCols)
+
+    # def convert_model_to_list(self, model: "FastInsertListStore") -> list:
+    #     return [[el for el in row] for row in model]

dzgui/strings/offline.py

@@ -0,0 +1,11 @@
+heading = "Play offline"
+
+mission_button = "Select mission folder"
+mission_frame = "Mission"
+
+version = "DayZ Version"
+
+custom_frame = "Custom mods"
+custom_button = "Set custom mod folder"
+
+local_frame = "Installed mods"

dzgui/util/strings.py

@@ -64,7 +64,7 @@ connect = "Connect"
 
 # Columns
 server_mod_cols = ["Mod", "ID", "Installed"]
-mod_cols = ["Mod", "Symlink", "Dir", "Size (MiB)", "Color"]
+mod_cols = ["Mod", "Symlink", "ID", "Size (MiB)", "Color"]
 log_cols = ["Timestamp", "Flag", "Traceback", "Message"]
 browser_cols = [
     "Name",
@@ -273,6 +273,7 @@ class Crumbs:
     thanks: str
     developers: str
     default: str
+    offline: str
 
 
 @dataclass(slots=True, frozen=True)
@@ -462,6 +463,7 @@ crumbs = Crumbs(
     thanks="Help > Special thanks",
     developers="Options > Developers",
     default="Servers > ",
+    offline="Mods > Play offline"
 )
 
 no_mods = "No local mods found."

dzgui/views/base.py

@@ -23,6 +23,8 @@ from dzgui.views.pages.help import Help
 from dzgui.views.pages.keys import Keybindings
 from dzgui.views.pages.log import Log
 from dzgui.views.pages.mods import Mods
+
+from dzgui.views.pages.offline import OfflineLoader
 from dzgui.views.pages.options import Options
 from dzgui.views.pages.preconnect import PreConnectionAssistant
 from dzgui.views.pages.servers import ServerNotebook
@@ -110,8 +112,11 @@ class Notebook(ScrollableMixin, Gtk.Notebook):  # type: ignore
 
         self.connection = PreConnectionAssistant(MainController)
 
+        self.offline = OfflineLoader(MainController)
+
         self.pages = {
             self.help: NotebookPage.HELP,
+            self.offline: NotebookPage.OFFLINE,
             self.clog: NotebookPage.CHANGELOG,
             self.keys: NotebookPage.KEYS,
             self.settings: NotebookPage.OPTIONS,

dzgui/views/components/buttons.py

@@ -48,8 +48,10 @@ class LargeIcon(Gtk.Image):
 
 
 class IconButton(Gtk.Button):
-    def __init__(self, icon: str, margin: int = 0) -> None:
-        super().__init__()
+    def __init__(
+        self, icon: str, margin: int = 0, halign: Gtk.Align = Gtk.Align.START
+    ) -> None:
+        super().__init__(halign=halign)
         self.icon = Icon(icon, l_margin=margin)
         self.set_image(self.icon)
         self.set_image_position(Gtk.PositionType.RIGHT)
@@ -57,8 +59,10 @@ class IconButton(Gtk.Button):
 
 
 class IconTextButton(IconButton):
-    def __init__(self, icon: str, label: str) -> None:
-        super().__init__(icon, margin=5)
+    def __init__(
+        self, icon: str, label: str, halign: Gtk.Align = Gtk.Align.START
+    ) -> None:
+        super().__init__(icon, margin=5, halign=halign)
         self.set_label(label)
 
 

dzgui/views/components/connect_box.py

@@ -0,0 +1,68 @@
+from dzgui.strings import preconnect
+import gi
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gdk, Gtk  # noqa E402
+
+
+class ConnectBox(Gtk.Box):
+    def __init__(self) -> None:
+        super().__init__(orientation=Gtk.Orientation.HORIZONTAL, spacing=5)
+
+        self.back = Gtk.Button(
+            label=preconnect.back, halign=Gtk.Align.END, hexpand=True
+        )
+
+        # TODO: dynamically update this
+        self.ok = Gtk.Button(label="Launch", halign=Gtk.Align.END)
+
+        for button in self.back, self.ok:
+            self.add(button)
+
+    def get_back_button(self) -> Gtk.Button:
+        return self.back
+
+    def get_ok_button(self) -> Gtk.Button:
+        return self.ok
+
+
+class PreconnectBox(Gtk.Box):
+    def __init__(self) -> None:
+        super().__init__(
+            orientation=Gtk.Orientation.VERTICAL,
+            valign=Gtk.Align.END,
+            vexpand=True,
+            spacing=5,
+        )
+
+        self.button_hbox = ConnectBox()
+        self.ok = self.button_hbox.get_ok_button()
+        self.ok.set_label(preconnect.update_mods)
+
+        self.connect_last = Gtk.Button(
+            label=preconnect.connect_last,
+            halign=Gtk.Align.END,
+            tooltip_text=preconnect.connect_last_tooltip,
+        )
+        self.button_hbox.add(self.connect_last)
+
+        self.raise_window = Gtk.CheckButton(
+            # TODO: strings
+            label="Foreground DZGUI while downloading",
+            halign=Gtk.Align.END,
+            hexpand=True,
+            valign=Gtk.Align.END,
+            visible=False,
+            has_tooltip=True,
+            sensitive=False,
+            tooltip_text="Foreground the DZGUI window after mod downloads are queued",
+            active=True,
+        )
+        self.add(self.button_hbox)
+        self.add(self.raise_window)
+
+    def get_back_button(self) -> Gtk.Button:
+        return self.button_hbox.get_back_button()
+
+    def get_ok_button(self) -> Gtk.Button:
+        return self.ok

dzgui/views/components/frame.py

@@ -1,3 +1,4 @@
+from typing import Self
 from dzgui.util import css
 
 import gi
@@ -6,16 +7,23 @@ gi.require_version("Gtk", "3.0")
 from gi.repository import Gtk  # noqa
 
 
+# TODO: subclass Gtk.Frame directly
 class HeadingFrame(Gtk.Box):
-    def __init__(self, widget: Gtk.Widget, heading: str) -> None:
+    def __init__(self, heading: str = "") -> None:
         super().__init__(orientation=Gtk.Orientation.VERTICAL)
 
-        label = Gtk.Label(label=heading)
-        label.set_halign(Gtk.Align.START)
-        css.add_class(label, "settings-subheading")
+        self.label = Gtk.Label(label=heading)
+        self.label.set_halign(Gtk.Align.START)
+        css.add_class(self.label, "settings-subheading")
 
-        frame = Gtk.Frame(hexpand=True)
-        frame.add(widget)
-        frame.set_label_widget(label)
+        self.frame = Gtk.Frame(hexpand=True)
+        self.frame.set_label_widget(self.label)
 
-        self.add(frame)
+        self.add(self.frame)
+
+    @classmethod
+    def new_with_widget_and_label(cls, widget: Gtk.Widget, label: str) -> Self:
+        n = cls()
+        n.frame.add(widget)
+        n.label.set_label(label)
+        return n

dzgui/views/components/statusbar.py

@@ -1,5 +1,4 @@
 from typing import Self, Union, TYPE_CHECKING
-from warnings import deprecated
 
 from dzgui.const.enum import NotebookPage, ServerTab
 from dzgui.util.strings import esc_to_return, question_to_return
@@ -70,6 +69,7 @@ class Statusbar(Gtk.Grid):
             NotebookPage.CHANGELOG,
             NotebookPage.LOG,
             NotebookPage.CONNECTION,
+            NotebookPage.OFFLINE,
         ):
             self.set_by_context(enum, esc_to_return)
             return

dzgui/views/dialogs/filepicker.py

@@ -33,3 +33,28 @@ class FilePicker(Gtk.FileChooserDialog):
                 self.destroy()
                 return Path(file)
         return None
+
+
+class FolderPicker(Gtk.FileChooserDialog):
+    def __init__(self, parent: Gtk.Window) -> None:
+        super().__init__(
+            title=picker.title,
+            action=Gtk.FileChooserAction.SELECT_FOLDER,
+            parent=parent,
+            resizable=True,
+        )
+        self.add_buttons("_Cancel", Gtk.ResponseType.CANCEL)
+        self.add_buttons("_OK", Gtk.ResponseType.OK)
+        self.set_default_response(Gtk.ResponseType.OK)
+
+    def pick_folder(self) -> Path | None:
+        res = self.run()
+        if res in (Gtk.ResponseType.CANCEL, Gtk.ResponseType.DELETE_EVENT):
+            self.destroy()
+            return None
+        if res == Gtk.ResponseType.OK:
+            folder = self.get_current_folder()
+            if folder is not None:
+                self.destroy()
+                return Path(folder)
+        return None

dzgui/views/mixins/context_mixin.py

@@ -44,6 +44,8 @@ class ContextMixin(TreeView):
         self.context_menu.connect("key-press-event", self._on_key)
 
         for row in group.value:
+            if row is None:
+                return False
             item = self._process_dynamic_row(row)
             self.context_menu.append(item)
 

dzgui/views/pages/mods.py

@@ -11,21 +11,36 @@ if TYPE_CHECKING:
     from dzgui.controllers.mc import Controller
 
 
-
-class Mods(NoOverlayScrolledWindow):
+class Mods(Gtk.Box):
     def __init__(self, controller: "Controller") -> None:
-        super().__init__()
+        super().__init__(orientation=Gtk.Orientation.VERTICAL)
+
+        self.box = NoOverlayScrolledWindow()
+        self.tree = ModTreeView(controller)
+        self.tree.set_vexpand(True)
+        self.box.add(self.tree)
 
         self.controller = controller
-        self.emitter = controller.get_emitter()
-        self.tree = ModTreeView(controller)
-
-        self.add(self.tree)
         self.controller.register_widget("modtreeview", self.tree)
+        self.emitter = controller.get_emitter()
+
+        self.offline_button = Gtk.Button(
+            label="Play offline",
+            halign=Gtk.Align.START,
+            margin_top=10,
+            margin_bottom=10,
+        )
+        self.offline_button.connect("clicked", self._on_offline_clicked)
+
+        self.add(self.offline_button)
+        self.add(self.box)
 
         self.connect("map", self._on_map)
         self.connect("unmap", self._on_unmap)
 
+    def _on_offline_clicked(self, button: Gtk.Button) -> None:
+        self.controller.open_offline()
+
     def _on_unmap(self, widget: Self) -> None:
         self.emitter.emit("mod_page_toggled", False)
 

dzgui/views/pages/offline.py

@@ -0,0 +1,274 @@
+from pathlib import Path
+from typing import Self, Sequence, TYPE_CHECKING
+
+from dzgui.util import css
+import dzgui.api.pefile as PeFile
+from dzgui.const.constants import (
+    APPID_DAYZ,
+    APPID_DAYZ_EXP,
+    APPNAME_DAYZ,
+    APPNAME_DAYZ_EXP_HUMAN,
+    FOLDER,
+)
+from dzgui.const.enum import NotebookPage, Preferences
+from dzgui.managers.offline import OfflineManager
+from dzgui.strings import offline
+from dzgui.views.components.buttons import IconTextButton
+from dzgui.views.components.frame import HeadingFrame
+from dzgui.views.components.scrollable import NoOverlayScrolledWindow
+from dzgui.views.trees.tree_mods import OfflineModTreeView
+
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, Gdk  # noqa
+
+if TYPE_CHECKING:
+    from dzgui.controllers.mc import Controller
+    from dzgui.model.model_factory import FastInsertListStore
+
+
+class GenericBox(Gtk.Box):
+    def __init__(self, orientation: Gtk.Orientation, spacing: int = 0) -> None:
+        super().__init__(orientation=orientation, spacing=spacing)
+
+    def extend(self, els: Sequence[Gtk.Widget]) -> None:
+        for el in els:
+            self.add(el)
+
+
+class HBox(GenericBox):
+    def __init__(self, spacing: int = 0) -> None:
+        super().__init__(orientation=Gtk.Orientation.HORIZONTAL, spacing=spacing)
+
+
+class VBox(GenericBox):
+    def __init__(self, spacing: int = 0) -> None:
+        super().__init__(orientation=Gtk.Orientation.VERTICAL, spacing=spacing)
+
+
+class PageHeading(Gtk.Label):
+    def __init__(self, label: str) -> None:
+        super().__init__(label=label, halign=Gtk.Align.CENTER)
+
+        css.add_class(self, "page-heading")
+
+
+class FolderHBox(HBox):
+    def __init__(self, btn_label: str) -> None:
+        super().__init__(spacing=5)
+
+        self.set_margin_start(10)
+        self.set_margin_bottom(10)
+
+        # TODO: alternate class for left-aligned icons
+        self.button = IconTextButton(FOLDER, btn_label)
+        self.button.set_image_position(Gtk.PositionType.LEFT)
+        self.label = Gtk.Label()
+        self.extend([self.button, self.label])
+
+    def get_button(self) -> Gtk.Button:
+        return self.button
+
+    def set_label(self, label: str) -> None:
+        self.label.set_label(label)
+
+
+class ModFrame(HeadingFrame):
+    def __init__(self, controller: "Controller", label: str) -> None:
+        super().__init__(heading=label)
+
+        self.vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
+
+        self.tree = OfflineModTreeView(controller)
+        self.tree.set_model(None)
+
+        self.scrolled = NoOverlayScrolledWindow()
+        self.scrolled.set_margin_end(10)
+        self.scrolled.set_size_request(600, 400)
+        self.scrolled.add(self.tree)
+
+        self.status = Gtk.Label(
+            halign=Gtk.Align.START, margin_start=5, margin_top=3, margin_bottom=3
+        )
+
+        self.tree_vbox = VBox()
+        self.tree_vbox.extend([self.scrolled, self.status])
+
+        self.vbox.add(self.tree_vbox)
+        self.frame.add(self.vbox)
+
+        sel = self.tree.get_selection()
+        sel.connect("changed", self._on_selection_changed)
+
+    def collapse_tree(self) -> None:
+        self.tree_vbox.hide()
+
+    def get_tree(self) -> OfflineModTreeView:
+        return self.tree
+
+    def pack(self, widget: Gtk.Widget) -> None:
+        self.vbox.pack_start(widget, expand=False, fill=False, padding=5)
+
+    def set_model(self, model: "FastInsertListStore") -> None:
+        self.tree.set_model(model)
+        self.tree.mod_man.store = model
+        self.set_cursor()
+
+    def _on_selection_changed(self, sel: Gtk.TreeSelection) -> None:
+        model, rows = sel.get_selected_rows()
+        if len(rows) == 0:
+            # TODO recycle (util.format)
+            status = "Ctrl-click to select multiple; Shift-click to select a range."
+        else:
+            status = f"Mods selected: {len(rows)}"
+        self.status.set_label(status)
+
+    def set_cursor(self) -> None:
+        path = Gtk.TreePath.new_from_indices([0])
+        self.tree.set_cursor(path)
+        self.tree.get_selection().unselect_all()
+
+
+class CustomModFrame(ModFrame):
+    def __init__(self, controller: "Controller", heading: str) -> None:
+        super().__init__(controller, heading)
+
+        self.controller = controller
+        # TODO: descriptive text here explaining how this area works
+        self.custom_hbox = FolderHBox(offline.custom_button)
+        self.custom_hbox.get_button().connect("clicked", self._on_custom_button_clicked)
+
+        self.pack(self.custom_hbox)
+
+    def _on_custom_button_clicked(self, button: Gtk.Button) -> None:
+        # TODO: recycle for mission folder
+        # TODO: propagate results back to parent
+        folder = self.controller.set_custom_folder()
+        if folder is not None:
+            self.custom_hbox.set_label(str(folder))
+
+    def get_mods(self) -> list[str]:
+        rows = self.tree.get_selection().get_selected_rows()
+        dirs = [str(col[0]) for col in rows]
+        return dirs
+
+
+class RadioFrame(HeadingFrame):
+    def __init__(self, controller: "Controller") -> None:
+        super().__init__(heading=offline.version)
+
+        self.controller = controller
+
+        self.id_map = {APPNAME_DAYZ: APPID_DAYZ, APPNAME_DAYZ_EXP_HUMAN: APPID_DAYZ_EXP}
+        self.appid = APPID_DAYZ
+
+        self.dayz = Gtk.RadioButton.new_with_label(None, APPNAME_DAYZ)
+        self.dayz_exp = Gtk.RadioButton.new_with_label_from_widget(
+            self.dayz, APPNAME_DAYZ_EXP_HUMAN
+        )
+
+        self.radio_box = HBox()
+        self.radio_box.extend([self.dayz, self.dayz_exp])
+        self.radio_box.set_margin_start(10)
+        self.radio_box.set_margin_bottom(5)
+
+        self.frame.add(self.radio_box)
+
+        # TODO: abstract out of here
+        default_steam_path = self.controller.query_config(Preferences.DEFAULT)
+        steam_path = Path(default_steam_path)
+        dayz_exp = PeFile.get_pretty_version(steam_path, APPID_DAYZ_EXP)
+
+        self.dayz.connect("toggled", self._on_radio_toggled)
+        if dayz_exp is None:
+            self.dayz_exp.set_sensitive(False)
+
+    def _on_radio_toggled(self, radio: Gtk.RadioButton) -> None:
+        for el in self.dayz, self.dayz_exp:
+            if el.get_active():
+                label = el.get_label()
+                self.appid = self.id_map[label]
+
+    def get_appid(self) -> int:
+        return self.appid
+
+
+class OfflineLoader(Gtk.Box):
+    def __init__(self, controller: "Controller"):
+        super().__init__(
+            orientation=Gtk.Orientation.VERTICAL,
+            margin_start=10,
+            margin_end=10,
+        )
+
+        self.controller = controller
+        self.controller.register_widget("offline_loader", self)
+        self.offline_man = OfflineManager(controller)
+
+        self.add(PageHeading(offline.heading))
+
+        self.local_frame = ModFrame(controller, offline.local_frame)
+        self.custom_frame = CustomModFrame(controller, offline.custom_frame)
+
+        # TODO: suppress symlink column
+        self.custom_tree = OfflineModTreeView(controller)
+
+        self.mission_hbox = FolderHBox(offline.mission_button)
+        self.mission_frame = HeadingFrame.new_with_widget_and_label(
+            self.mission_hbox, offline.mission_frame
+        )
+
+        self.radio_frame = RadioFrame(controller)
+
+        self.scrollable = Gtk.ScrolledWindow(
+            vexpand=True, propagate_natural_height=True
+        )
+
+        self.content_box = VBox(spacing=5)
+        self.content_box.extend(
+            [
+                self.local_frame,
+                self.custom_frame,
+                self.mission_frame,
+                self.radio_frame,
+            ]
+        )
+
+        # TODO: share ConnectBox class with preconnect dialog?
+        self.button_box = HBox(spacing=5)
+        self.button_box.set_halign(Gtk.Align.END)
+        self.button_box.set_margin_top(5)
+        self.back = Gtk.Button(label="Back")
+        self.ok = Gtk.Button(label="Launch")
+        self.back.connect("clicked", self._on_back_clicked)
+        self.ok.connect("clicked", self._on_ok_clicked)
+        self.connect("key-press-event", self._on_keypress)
+
+        self.button_box.extend([self.back, self.ok])
+
+        self.scrollable.add(self.content_box)
+        self.add(self.scrollable)
+        self.add(self.button_box)
+
+    def _on_keypress(self, widget: Self, event: Gdk.EventKey) -> None:
+        if event.keyval == Gdk.KEY_Escape:
+            self.back.emit("clicked")
+
+    def populate(self, store: "FastInsertListStore") -> None:
+        self.local_frame.set_model(store)
+        # TODO: toggle if empty model, show warning label
+        # TODO: suppress trees if there are no mods
+        self.custom_frame.collapse_tree()
+
+    def _on_back_clicked(self, button: Gtk.Button) -> None:
+        self.controller.open_page(NotebookPage.MODS)
+
+    def _on_ok_clicked(self, button: Gtk.Button) -> None:
+        # appid = self.radio_frame.get_appid()
+        # mission = self.mission_frame.get_mission()
+        # local_mods = self.local_frame.get_mods()
+        # custom_mods = self.custom_frame.get_mods()
+        # self.offline_man.setup(appid, mission, local_mods, custom_mods)
+        pass

dzgui/views/pages/options.py

@@ -187,12 +187,14 @@ class Options(Gtk.Box):
         if prefs.is_debug:
             grid.attach(developers, 1, 0, self.DEFAULT_WIDTH, self.DEFAULT_HEIGHT)
 
-        for frame in [
-            HeadingFrame(api_box, strings.options.api_keys),
-            HeadingFrame(prefs_grid, strings.options.prefs),
-            HeadingFrame(mods_grid, strings.options.mods),
-            HeadingFrame(version_grid, strings.options.version),
+        for pair in [
+            (api_box, strings.options.api_keys),
+            (prefs_grid, strings.options.prefs),
+            (mods_grid, strings.options.mods),
+            (version_grid, strings.options.version),
         ]:
+
+            frame = HeadingFrame.new_with_widget_and_label(*pair)
             grid.attach(frame, col, row, self.DEFAULT_WIDTH, self.DEFAULT_HEIGHT)
             row += 1
 

dzgui/views/pages/preconnect.py

@@ -154,7 +154,7 @@ class PreConnectionAssistant(Gtk.Box):
         self.progress_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=15)
         self.progress_box.add(self.mod_count)
 
-        self.scrolled = Gtk.ScrolledWindow()
+        self.scrolled = Gtk.ScrolledWindow(margin_end=10)
         self.scrolled.add(self.tree)
         self.scrolled.set_size_request(600, 400)
 
@@ -166,7 +166,9 @@ class PreConnectionAssistant(Gtk.Box):
         self.mods_placeholder = Placeholder("This server has no mods.")
         self.tree_box.add(self.mods_placeholder)
 
-        self.tree_frame = HeadingFrame(self.tree_box, preconnect.mods)
+        self.tree_frame = HeadingFrame.new_with_widget_and_label(
+            self.tree_box, preconnect.mods
+        )
 
         # TODO: abstract into components
         self.warning_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
@@ -175,7 +177,9 @@ class PreConnectionAssistant(Gtk.Box):
         self.warning_placeholder = Placeholder("No warnings.")
         self.warning_box.add(self.warning_tree)
         self.warning_box.add(self.warning_placeholder)
-        self.warning_frame = HeadingFrame(self.warning_box, preconnect.warnings)
+        self.warning_frame = HeadingFrame.new_with_widget_and_label(
+            self.warning_box, preconnect.warnings
+        )
 
         self.error_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
         self.error_tree = MaskedTree(ERROR)
@@ -183,7 +187,9 @@ class PreConnectionAssistant(Gtk.Box):
         self.error_placeholder = Placeholder("No errors.")
         self.error_box.add(self.error_tree)
         self.error_box.add(self.error_placeholder)
-        self.error_frame = HeadingFrame(self.error_box, preconnect.errors)
+        self.error_frame = HeadingFrame.new_with_widget_and_label(
+            self.error_box, preconnect.errors
+        )
 
         self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
         self.box.add(self.title)

dzgui/views/trees/tree_base.py

@@ -4,7 +4,7 @@ from typing import Any, Optional, TYPE_CHECKING
 from warnings import deprecated
 
 from dzgui.const.constants import APP_NAME, SEPARATOR
-from dzgui.util.keys import is_navkey
+from dzgui.util.keys import is_ctrl_mask, is_navkey
 from dzgui.views.mixins.cursor_mixin import CursorMixin
 
 import gi
@@ -85,10 +85,17 @@ class TreeView(CursorMixin, Gtk.TreeView):  # type: ignore
         model, rows = sel.get_selected_rows()
         return [model[row] for row in rows]
 
-    def _on_keypress(self, treeview: Gtk.TreeView, event: Gdk.EventKey) -> None:
+    def _on_keypress(self, treeview: Gtk.TreeView, event: Gdk.EventKey) -> bool:
+        from dzgui.views.trees.tree_servers import ServerTreeView
+
+        # NOTE: suppress popup search and delegate binding to server view (cf. request_keyword_focus)
+        if not isinstance(treeview, ServerTreeView):
+            if is_ctrl_mask(event) and event.keyval == Gdk.KEY_f:
+                return True
+
         if is_navkey(event.keyval):
             if self.get_model() is None:
-                return
+                return True
             if self.sel_blocked is False:
                 self.sel_blocked = True
                 self.controller.suppress_signal(
@@ -98,7 +105,7 @@ class TreeView(CursorMixin, Gtk.TreeView):  # type: ignore
                     True,
                 )
             self._vim_nav(event)
-        return
+        return False
 
     def _on_key_release(self, treeview: Gtk.TreeView, event: Gdk.EventKey) -> None:
         """

dzgui/views/trees/tree_mods.py

@@ -3,6 +3,7 @@ from typing import Any, TYPE_CHECKING
 
 from dzgui.const.constants import APP_NAME, HEX_RED
 from dzgui.const.enum import ContextMenuGroup
+from dzgui.managers.mods import ModManager
 from dzgui.util import strings, localize
 from dzgui.views.mixins.context_mixin import ContextMixin
 from dzgui.views.mixins.mods_mixin import ModsMixin
@@ -24,14 +25,15 @@ logger = logging.getLogger(APP_NAME)
 class ModTreeView(ModsMixin, ContextMixin, TreeView):  # type: ignore
     def __init__(self, controller: "Controller") -> None:
         super().__init__(controller, menu=ContextMenuGroup.MOD)
+
         self.controller = controller
+        self.mod_man = ModManager(self, controller)
+
         emitter = self.controller.get_emitter()
         emitter.connect("mods_updated", self._on_mods_updated)
         emitter.connect("mods_highlighted", self._on_mods_highlighted)
 
         self.set_fixed_height_mode(True)
-        self.set_headers_visible(True)
-
         self.set_model(None)
 
         for i, column_title in enumerate(strings.mod_cols):
@@ -58,12 +60,19 @@ class ModTreeView(ModsMixin, ContextMixin, TreeView):  # type: ignore
         self.connect("button-press-event", self.present_menu)
         self.connect("key-press-event", self.present_menu)
 
+    def get_mod_man(self) -> ModManager:
+        return self.mod_man
+
+    def load_mods(self) -> None:
+        self.mod_man.load_mods()
+
     def _on_mods_highlighted(self, emitter: "Emitter") -> None:
         self.get_selection().unselect_all()
 
     def _on_mods_updated(self, emitter: "Emitter", msg: str, mods: int) -> None:
         if mods < 1:
             return
+        self.set_headers_visible(True)
         path = Gtk.TreePath.new_from_indices([0])
         self.set_cursor(path)
 
@@ -106,3 +115,10 @@ class ModTreeView(ModsMixin, ContextMixin, TreeView):  # type: ignore
         val = model[it][3]
         formatted = localize.number(val)
         cell.set_property("text", formatted)
+
+    def set_menu(self, context: ContextMenuGroup) -> None:
+        self.menu = context
+
+class OfflineModTreeView(ModTreeView):
+    def __init__(self, controller: "Controller") -> None:
+        super().__init__(controller)

pyproject.toml

@@ -4,7 +4,7 @@ description = "DayZ server browser and mod manager for Linux"
 authors = [
     {name = "aclist"}
 ]
-version = "7.0.0b10"
+version = "7.0.0b12"
 license = "GPL-3.0-or-later"
 license-files = ["LICENSE"]
 readme = "README.md"