Fluorine Manager: full Linux port of Mod Organizer 2

Complete native Linux port with FUSE-based virtual filesystem,
Proton/umu-run integration, and Flatpak packaging.

Key features:
- FUSE VFS replacing Windows USVFS (in-process + standalone helper for Flatpak)
- Proton/GE-Proton/umu-run launcher with env var forwarding
- Flatpak support (sandbox-aware VFS, NXM handler, umu-run)
- Wine prefix management UI
- Case-insensitive path resolution for Linux filesystems
- QSettings-safe INI handling (avoids Bethesda INI corruption)
- Portable instance support with auto-generated launcher scripts

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

4 files changed, 331 insertions, 0 deletions

diff --git a/libs/basic_games/games/oblivion_remaster/ue4ss/__init__.py b/libs/basic_games/games/oblivion_remaster/ue4ss/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/libs/basic_games/games/oblivion_remaster/ue4ss/__init__.py
diff --git a/libs/basic_games/games/oblivion_remaster/ue4ss/model.py b/libs/basic_games/games/oblivion_remaster/ue4ss/model.py
new file mode 100644
index 0000000..a3804fe
--- /dev/null
+++ b/libs/basic_games/games/oblivion_remaster/ue4ss/model.py
@@ -0,0 +1,125 @@
+import json
+from json import JSONDecodeError
+from typing import Any, Iterable
+
+from PyQt6.QtCore import (
+    QDir,
+    QFileInfo,
+    QMimeData,
+    QModelIndex,
+    QStringListModel,
+    Qt,
+)
+from PyQt6.QtWidgets import QWidget
+
+import mobase
+
+from ..constants import DEFAULT_UE4SS_MODS
+
+
+class UE4SSListModel(QStringListModel):
+    def __init__(self, parent: QWidget | None, organizer: mobase.IOrganizer):
+        super().__init__(parent)
+        self._checked_items: set[str] = set()
+        self._organizer = organizer
+        self._init_mod_states()
+
+    def _init_mod_states(self):
+        profile = QDir(self._organizer.profilePath())
+        mods_json = QFileInfo(profile.absoluteFilePath("mods.json"))
+        if mods_json.exists():
+            with open(mods_json.absoluteFilePath(), "r") as json_file:
+                try:
+                    mod_data = json.load(json_file)
+                except JSONDecodeError:
+                    mod_data = DEFAULT_UE4SS_MODS
+                for mod in mod_data:
+                    if mod["mod_enabled"]:
+                        self._checked_items.add(mod["mod_name"])
+
+    def _set_mod_states(self):
+        profile = QDir(self._organizer.profilePath())
+        mods_json = QFileInfo(profile.absoluteFilePath("mods.json"))
+        mod_list: dict[str, bool] = {}
+        if mods_json.exists():
+            with open(mods_json.absoluteFilePath(), "r") as json_file:
+                try:
+                    mod_data = json.load(json_file)
+                except JSONDecodeError:
+                    mod_data = DEFAULT_UE4SS_MODS
+                for mod in mod_data:
+                    mod_list[mod["mod_name"]] = mod["mod_enabled"]
+            for i in range(self.rowCount()):
+                item = self.index(i, 0)
+                name = self.data(item, Qt.ItemDataRole.DisplayRole)
+                if name in mod_list:
+                    self.setData(
+                        item,
+                        True if mod_list[name] else False,
+                        Qt.ItemDataRole.CheckStateRole,
+                    )
+                else:
+                    self.setData(item, True, Qt.ItemDataRole.CheckStateRole)
+
+    def flags(self, index: QModelIndex) -> Qt.ItemFlag:
+        flags = super().flags(index)
+        if not index.isValid():
+            return (
+                Qt.ItemFlag.ItemIsSelectable
+                | Qt.ItemFlag.ItemIsDragEnabled
+                | Qt.ItemFlag.ItemIsDropEnabled
+                | Qt.ItemFlag.ItemIsEnabled
+            )
+        return (
+            flags
+            | Qt.ItemFlag.ItemIsUserCheckable
+            | Qt.ItemFlag.ItemIsDragEnabled & Qt.ItemFlag.ItemIsEditable
+        )
+
+    def setData(
+        self, index: QModelIndex, value: Any, role: int = Qt.ItemDataRole.EditRole
+    ) -> bool:
+        if not index.isValid() or role != Qt.ItemDataRole.CheckStateRole:
+            return False
+
+        if (
+            bool(value)
+            and self.data(index, Qt.ItemDataRole.DisplayRole) not in self._checked_items
+        ):
+            self._checked_items.add(self.data(index, Qt.ItemDataRole.DisplayRole))
+        elif (
+            not bool(value)
+            and self.data(index, Qt.ItemDataRole.DisplayRole) in self._checked_items
+        ):
+            self._checked_items.remove(self.data(index, Qt.ItemDataRole.DisplayRole))
+        self.dataChanged.emit(index, index, [role])
+        return True
+
+    def setStringList(self, strings: Iterable[str | None]):
+        super().setStringList(strings)
+        self._set_mod_states()
+
+    def data(self, index: QModelIndex, role: int = Qt.ItemDataRole.DisplayRole) -> Any:
+        if not index.isValid():
+            return None
+
+        if role == Qt.ItemDataRole.CheckStateRole:
+            return (
+                Qt.CheckState.Checked
+                if self.data(index, Qt.ItemDataRole.DisplayRole) in self._checked_items
+                else Qt.CheckState.Unchecked
+            )
+
+        return super().data(index, role)
+
+    def canDropMimeData(
+        self,
+        data: QMimeData | None,
+        action: Qt.DropAction,
+        row: int,
+        column: int,
+        parent: QModelIndex,
+    ) -> bool:
+        if action == Qt.DropAction.MoveAction and (row != -1 or column != -1):
+            return True
+        return False
diff --git a/libs/basic_games/games/oblivion_remaster/ue4ss/view.py b/libs/basic_games/games/oblivion_remaster/ue4ss/view.py
new file mode 100644
index 0000000..bb994ca
--- /dev/null
+++ b/libs/basic_games/games/oblivion_remaster/ue4ss/view.py
@@ -0,0 +1,31 @@
+from typing import Iterable
+
+from PyQt6.QtCore import QModelIndex, Qt, pyqtSignal
+from PyQt6.QtGui import QDropEvent
+from PyQt6.QtWidgets import QAbstractItemView, QListView, QWidget
+
+
+class UE4SSView(QListView):
+    data_dropped = pyqtSignal()
+
+    def __init__(self, parent: QWidget | None):
+        super().__init__(parent)
+        self.setAcceptDrops(True)
+        self.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
+        self.setDragEnabled(True)
+        self.setAcceptDrops(True)
+        self.setDropIndicatorShown(True)
+        self.setDragDropMode(QAbstractItemView.DragDropMode.InternalMove)
+        self.setDefaultDropAction(Qt.DropAction.MoveAction)
+        if (viewport := self.viewport()) is not None:
+            viewport.setAcceptDrops(True)
+
+    def dropEvent(self, e: QDropEvent | None):
+        super().dropEvent(e)
+        self.data_dropped.emit()
+
+    def dataChanged(
+        self, topLeft: QModelIndex, bottomRight: QModelIndex, roles: Iterable[int] = ()
+    ):
+        super().dataChanged(topLeft, bottomRight, roles)
+        self.repaint()
diff --git a/libs/basic_games/games/oblivion_remaster/ue4ss/widget.py b/libs/basic_games/games/oblivion_remaster/ue4ss/widget.py
new file mode 100644
index 0000000..246b7fa
--- /dev/null
+++ b/libs/basic_games/games/oblivion_remaster/ue4ss/widget.py
@@ -0,0 +1,175 @@
+import json
+from functools import cmp_to_key
+from json import JSONDecodeError
+from pathlib import Path
+
+from PyQt6.QtCore import QDir, QFileInfo, Qt
+from PyQt6.QtWidgets import QGridLayout, QWidget
+
+import mobase
+
+from ..constants import DEFAULT_UE4SS_MODS, UE4SSModInfo
+from .model import UE4SSListModel
+from .view import UE4SSView
+
+
+class UE4SSTabWidget(QWidget):
+    def __init__(self, parent: QWidget | None, organizer: mobase.IOrganizer):
+        super().__init__(parent)
+        self._organizer = organizer
+        self._view = UE4SSView(self)
+        self._layout = QGridLayout(self)
+        self._layout.addWidget(self._view)
+        self._model = UE4SSListModel(self._view, organizer)
+        self._view.setModel(self._model)
+        self._model.dataChanged.connect(self.write_mod_list)  # type: ignore
+        self._view.data_dropped.connect(self.write_mod_list)  # type: ignore
+        organizer.onProfileChanged(lambda profile_a, profile_b: self._parse_mod_files())
+        organizer.modList().onModInstalled(self.update_mod_files)
+        organizer.modList().onModRemoved(lambda mod: self._parse_mod_files())
+        organizer.modList().onModStateChanged(self.update_mod_files)
+        self._parse_mod_files()
+
+    def get_mod_list(self) -> list[str]:
+        mod_list: list[str] = []
+        for index in range(self._model.rowCount()):
+            mod_list.append(
+                self._model.data(
+                    self._model.index(index, 0), Qt.ItemDataRole.DisplayRole
+                )
+            )
+        return mod_list
+
+    def update_mod_files(
+        self, mods: dict[str, mobase.ModState] | mobase.IModInterface | str
+    ):
+        mod_list: list[mobase.IModInterface] = []
+        if isinstance(mods, dict):
+            for mod in mods.keys():
+                mod_list.append(self._organizer.modList().getMod(mod))
+        elif isinstance(mods, mobase.IModInterface):
+            mod_list.append(mods)
+        else:
+            mod_list.append(self._organizer.modList().getMod(mods))
+
+        for mod in mod_list:
+            tree = mod.fileTree()
+            ue4ss_files = tree.find("UE4SS")
+            if not ue4ss_files:
+                ue4ss_files = tree.find(
+                    "Root/OblivionRemastered/Binaries/Win64/ue4ss/Mods"
+                )
+            if isinstance(ue4ss_files, mobase.IFileTree):
+                for entry in ue4ss_files:
+                    if isinstance(entry, mobase.IFileTree):
+                        if enabled_txt := entry.find("enabled.txt"):
+                            try:
+                                Path(mod.absolutePath(), enabled_txt.path("/")).unlink()
+                                self._organizer.modDataChanged(mod)
+                            except FileNotFoundError:
+                                pass
+
+        self._parse_mod_files()
+
+    def _parse_mod_files(self):
+        from ...game_oblivion_remaster import OblivionRemasteredGame
+
+        mod_list: set[str] = set()
+        for mod in self._organizer.modList().allMods():
+            if (
+                mobase.ModState(self._organizer.modList().state(mod))
+                & mobase.ModState.ACTIVE
+            ):
+                tree = self._organizer.modList().getMod(mod).fileTree()
+                ue4ss_files = tree.find("UE4SS")
+                if not ue4ss_files:
+                    ue4ss_files = tree.find(
+                        "Root/OblivionRemastered/Binaries/Win64/ue4ss/Mods"
+                    )
+                if isinstance(ue4ss_files, mobase.IFileTree):
+                    for entry in ue4ss_files:
+                        if isinstance(entry, mobase.IFileTree):
+                            if entry.find("scripts/main.lua"):
+                                mod_list.add(entry.name())
+                            if enabled_txt := entry.find("enabled.txt"):
+                                try:
+                                    Path(
+                                        self._organizer.modList()
+                                        .getMod(mod)
+                                        .absolutePath(),
+                                        enabled_txt.path("/"),
+                                    ).unlink()
+                                    self._organizer.modDataChanged(
+                                        self._organizer.modList().getMod(mod)
+                                    )
+                                except FileNotFoundError:
+                                    pass
+
+        game = self._organizer.managedGame()
+        if isinstance(game, OblivionRemasteredGame):
+            if game.ue4ssDirectory().exists():
+                for dir_info in game.ue4ssDirectory().entryInfoList(
+                    QDir.Filter.Dirs | QDir.Filter.NoDotAndDotDot
+                ):
+                    if QFileInfo(
+                        QDir(dir_info.absoluteFilePath()).absoluteFilePath(
+                            "scripts/main.lua"
+                        )
+                    ).exists():
+                        mod_list.add(dir_info.fileName())
+                    if QFileInfo(
+                        QDir(dir_info.absoluteFilePath()).absoluteFilePath(
+                            "enabled.txt"
+                        )
+                    ).exists():
+                        Path(dir_info.absoluteFilePath(), "enabled.txt").unlink()
+
+        final_list = sorted(mod_list, key=cmp_to_key(self.sort_mods))
+        self._model.setStringList(final_list)
+
+    def write_mod_list(self):
+        mod_list: list[UE4SSModInfo] = []
+        profile = QDir(self._organizer.profilePath())
+        mods_txt = QFileInfo(profile.absoluteFilePath("mods.txt"))
+        with open(mods_txt.absoluteFilePath(), "w") as txt_file:
+            for i in range(self._model.rowCount()):
+                item = self._model.index(i, 0)
+                name = self._model.data(item, Qt.ItemDataRole.DisplayRole)
+                active = (
+                    self._model.data(item, Qt.ItemDataRole.CheckStateRole)
+                    == Qt.CheckState.Checked
+                )
+                mod_list.append({"mod_name": name, "mod_enabled": active})
+                txt_file.write(f"{name} : {1 if active else 0}\n")
+        mods_json = QFileInfo(profile.absoluteFilePath("mods.json"))
+        with open(mods_json.absoluteFilePath(), "w") as json_file:
+            json_file.write(json.dumps(mod_list, indent=4))
+
+    def sort_mods(self, mod_a: str, mod_b: str) -> int:
+        profile = QDir(self._organizer.profilePath())
+        mods_json = QFileInfo(profile.absoluteFilePath("mods.json"))
+        mods_list: list[str] = []
+        if mods_json.exists() and mods_json.isFile():
+            with open(mods_json.absoluteFilePath(), "r") as json_file:
+                try:
+                    mods = json.load(json_file)
+                except JSONDecodeError:
+                    mods = DEFAULT_UE4SS_MODS
+                for mod in mods:
+                    if mod["mod_enabled"]:
+                        mods_list.append(mod["mod_name"])
+        index_a = -1
+        if mod_a in mods_list:
+            index_a = mods_list.index(mod_a)
+        index_b = -1
+        if mod_b in mods_list:
+            index_b = mods_list.index(mod_b)
+        if index_a != -1 and index_b != -1:
+            return index_a - index_b
+        if index_a != -1:
+            return -1
+        if index_b != -1:
+            return 1
+        if mod_a < mod_b:
+            return -1
+        return 1