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>

1 files changed, 193 insertions, 0 deletions

diff --git a/libs/usvfs/src/usvfs_dll/usvfsparameters.cpp b/libs/usvfs/src/usvfs_dll/usvfsparameters.cpp
new file mode 100644
index 0000000..7059ec2
--- /dev/null
+++ b/libs/usvfs/src/usvfs_dll/usvfsparameters.cpp
@@ -0,0 +1,193 @@
+#include "usvfsparametersprivate.h"
+#include <algorithm>
+
+usvfsParameters::usvfsParameters()
+    : debugMode(false), logLevel(LogLevel::Debug), crashDumpsType(CrashDumpsType::None),
+      delayProcessMs(0)
+{
+  std::fill(std::begin(instanceName), std::end(instanceName), 0);
+  std::fill(std::begin(currentSHMName), std::end(currentSHMName), 0);
+  std::fill(std::begin(currentInverseSHMName), std::end(currentInverseSHMName), 0);
+  std::fill(std::begin(crashDumpsPath), std::end(crashDumpsPath), 0);
+}
+
+usvfsParameters::usvfsParameters(const char* instanceName, const char* currentSHMName,
+                                 const char* currentInverseSHMName, bool debugMode,
+                                 LogLevel logLevel, CrashDumpsType crashDumpsType,
+                                 const char* crashDumpsPath, int delayProcessMs)
+    : usvfsParameters()
+{
+  strncpy_s(this->instanceName, instanceName, _TRUNCATE);
+  strncpy_s(this->currentSHMName, currentSHMName, _TRUNCATE);
+  strncpy_s(this->currentInverseSHMName, currentInverseSHMName, _TRUNCATE);
+  this->debugMode      = debugMode;
+  this->logLevel       = logLevel;
+  this->crashDumpsType = crashDumpsType;
+  strncpy_s(this->crashDumpsPath, crashDumpsPath, _TRUNCATE);
+  this->delayProcessMs = delayProcessMs;
+}
+
+usvfsParameters::usvfsParameters(const USVFSParameters& oldParams)
+    : usvfsParameters(oldParams.instanceName, oldParams.currentSHMName,
+                      oldParams.currentInverseSHMName, oldParams.debugMode,
+                      oldParams.logLevel, oldParams.crashDumpsType,
+                      oldParams.crashDumpsPath, 0)
+{}
+
+void usvfsParameters::setInstanceName(const char* name)
+{
+  strncpy_s(instanceName, name, _TRUNCATE);
+  strncpy_s(currentSHMName, 60, name, _TRUNCATE);
+  memset(currentInverseSHMName, '\0', _countof(currentInverseSHMName));
+  _snprintf(currentInverseSHMName, 60, "inv_%s", name);
+}
+
+void usvfsParameters::setDebugMode(bool b)
+{
+  debugMode = b;
+}
+
+void usvfsParameters::setLogLevel(LogLevel level)
+{
+  logLevel = level;
+}
+
+void usvfsParameters::setCrashDumpType(CrashDumpsType type)
+{
+  crashDumpsType = type;
+}
+
+void usvfsParameters::setCrashDumpPath(const char* path)
+{
+  if (path && *path && strlen(path) < _countof(crashDumpsPath)) {
+    memcpy(crashDumpsPath, path, strlen(path) + 1);
+  } else {
+    // crashDumpsPath invalid or overflow of USVFSParameters variable so disable
+    // crash dumps:
+    crashDumpsPath[0] = 0;
+    crashDumpsType    = CrashDumpsType::None;
+  }
+}
+
+void usvfsParameters::setProcessDelay(int milliseconds)
+{
+  delayProcessMs = milliseconds;
+}
+
+extern "C"
+{
+
+  const char* usvfsLogLevelToString(LogLevel lv)
+  {
+    switch (lv) {
+    case LogLevel::Debug:
+      return "debug";
+
+    case LogLevel::Info:
+      return "info";
+
+    case LogLevel::Warning:
+      return "warning";
+
+    case LogLevel::Error:
+      return "error";
+
+    default:
+      return "unknown";
+    }
+  }
+
+  const char* usvfsCrashDumpTypeToString(CrashDumpsType t)
+  {
+    switch (t) {
+    case CrashDumpsType::None:
+      return "none";
+
+    case CrashDumpsType::Mini:
+      return "mini";
+
+    case CrashDumpsType::Data:
+      return "data";
+
+    case CrashDumpsType::Full:
+      return "full";
+
+    default:
+      return "unknown";
+    }
+  }
+
+  usvfsParameters* usvfsCreateParameters()
+  {
+    return new (std::nothrow) usvfsParameters;
+  }
+
+  usvfsParameters* usvfsDupeParameters(usvfsParameters* p)
+  {
+    if (!p) {
+      return nullptr;
+    }
+
+    auto* dupe = usvfsCreateParameters();
+    if (!dupe) {
+      return nullptr;
+    }
+
+    *dupe = *p;
+
+    return dupe;
+  }
+
+  void usvfsCopyParameters(const usvfsParameters* source, usvfsParameters* dest)
+  {
+    *dest = *source;
+  }
+
+  void usvfsFreeParameters(usvfsParameters* p)
+  {
+    delete p;
+  }
+
+  void usvfsSetInstanceName(usvfsParameters* p, const char* name)
+  {
+    if (p) {
+      p->setInstanceName(name);
+    }
+  }
+
+  void usvfsSetDebugMode(usvfsParameters* p, BOOL debugMode)
+  {
+    if (p) {
+      p->setDebugMode(debugMode);
+    }
+  }
+
+  void usvfsSetLogLevel(usvfsParameters* p, LogLevel level)
+  {
+    if (p) {
+      p->setLogLevel(level);
+    }
+  }
+
+  void usvfsSetCrashDumpType(usvfsParameters* p, CrashDumpsType type)
+  {
+    if (p) {
+      p->setCrashDumpType(type);
+    }
+  }
+
+  void usvfsSetCrashDumpPath(usvfsParameters* p, const char* path)
+  {
+    if (p) {
+      p->setCrashDumpPath(path);
+    }
+  }
+
+  void usvfsSetProcessDelay(usvfsParameters* p, int milliseconds)
+  {
+    if (p) {
+      p->setProcessDelay(milliseconds);
+    }
+  }
+
+}  // extern "C"