From 3949dcfce95af4bd305f258ff5b170d7d50435f6 Mon Sep 17 00:00:00 2001 From: SulfurNitride Date: Sun, 12 Apr 2026 21:04:15 -0500 Subject: VFS perf fixes, icon/stylesheet compat, download filename fix VFS: - Open backing fd at mo2_open time for read-only handles so mo2_read can splice without re-opening the file on every read call. - Bump RLIMIT_NOFILE at mount time to fit the resulting fd pressure when the game keeps hundreds of BSAs open. - Dedicated node_cache_mutex so resolveByInode / mo2_lookup stop racing unordered_map writes while multiple tree_mutex readers are active. - max_read=1MB + matching conn->max_read and raised max_readahead/max_write so the kernel merges Wine's small sequential reads into bigger FUSE requests. - Per-op wall-clock counters in mo2_init() logs so we can distinguish VFS latency from game-side work. Proton launch: - Write dxvk.conf to the prefix and set DXVK_CONFIG_FILE to force dxvk.enableGraphicsPipelineLibrary=False, avoiding long GPL compile stalls on first run. UI / plugin compat: - Clamp IconDelegate's per-icon width to [8, 16] so narrow content columns don't trigger QIcon::pixmap(0,0) returning null and logging "failed to load icon" every repaint. - Pre-create lowercase symlinks in the stylesheet directory so QSS files authored on Windows resolve url(foo.svg) when on-disk files are Foo.svg. - Flip content icons empty-chessboard.png and facegen.png to 8-bit RGBA so Qt's built-in PNG reader loads them uniformly. - Add mobase.Version.canonicalString shim for legacy Python plugins that still call the old VersionInfo method on appVersion()'s return. - BSPluginList: compare normalized plugin name lists instead of byte hashes so the post-run case-fix refresh stops spuriously firing the "load order changed" dialog. - BSPluginList disabled by default. Download manager: - Parse CDN URL with QUrl + QUrlQuery and read the filename from the response-content-disposition query param (RFC 6266 quoted / unquoted / ext-value forms), not QFileInfo on the raw URL. - When the API or URL gives us a CDN object key (no archive extension), prefer the actual Content-Disposition header from the live response in metaDataChanged and downloadFinished. Co-Authored-By: Claude Opus 4.6 (1M context) --- libs/installer_bsplugins/src/MOPlugin/Settings.cpp | 254 +++++++++++++++++++++ 1 file changed, 254 insertions(+) create mode 100644 libs/installer_bsplugins/src/MOPlugin/Settings.cpp (limited to 'libs/installer_bsplugins/src/MOPlugin/Settings.cpp') diff --git a/libs/installer_bsplugins/src/MOPlugin/Settings.cpp b/libs/installer_bsplugins/src/MOPlugin/Settings.cpp new file mode 100644 index 0000000..8ca77ec --- /dev/null +++ b/libs/installer_bsplugins/src/MOPlugin/Settings.cpp @@ -0,0 +1,254 @@ +#include "Settings.h" +#include "BSPlugins.h" + +#include +#include +#include + +Settings* Instance = nullptr; + +static QString findIniPath(MOBase::IOrganizer* organizer) +{ + // FIXME: we can't find non-portable instance paths + return QDir(organizer->basePath()).filePath("ModOrganizer.ini"); +} + +Settings::Settings(MOBase::IOrganizer* organizer) + : Organizer{organizer}, MOSettings{findIniPath(organizer), QSettings::IniFormat} +{ + organizer->onPluginSettingChanged( + std::bind_front(&Settings::onPluginSettingChanged, this)); +} + +void Settings::init(MOBase::IOrganizer* organizer) +{ + Instance = new Settings(organizer); +} + +Settings* Settings::instance() +{ + return Instance; +} + +void Settings::set(const QString& setting, const QVariant& value) +{ + Organizer->setPersistent(BSPlugins::NAME, setting, value); +} + +[[nodiscard]] QVariant Settings::get(const QString& setting, const QVariant& def) const +{ + return Organizer->persistent(BSPlugins::NAME, setting, def); +} + +bool Settings::onSettingChanged( + const std::function& func) +{ + auto connection = SettingChanged.connect(func); + return connection.connected(); +} + +QColor Settings::overwrittenLooseFilesColor() const +{ + return MOSettings.value("Settings/overwrittenLooseFilesColor", QColor(0, 255, 0, 64)) + .value(); +} + +QColor Settings::overwritingLooseFilesColor() const +{ + return MOSettings.value("Settings/overwritingLooseFilesColor", QColor(255, 0, 0, 64)) + .value(); +} + +QColor Settings::overwrittenArchiveFilesColor() const +{ + return MOSettings + .value("Settings/overwrittenArchiveFilesColor", QColor(0, 255, 255, 64)) + .value(); +} + +QColor Settings::overwritingArchiveFilesColor() const +{ + return MOSettings + .value("Settings/overwritingArchiveFilesColor", QColor(255, 0, 255, 64)) + .value(); +} + +QColor Settings::containedColor() const +{ + return MOSettings.value("Settings/containedColor", QColor(0, 0, 255, 64)) + .value(); +} + +bool Settings::offlineMode() const +{ + return MOSettings.value("Settings/offline_mode", false).value(); +} + +lootcli::LogLevels Settings::lootLogLevel() const +{ + // LOOT integration removed for Fluorine port — return default. + return lootcli::LogLevels::Info; +} + +bool Settings::externalChangeWarning() const +{ + return Organizer->pluginSetting(BSPlugins::NAME, "external_change_warning") + .value(); +} + +bool Settings::enableSortButton() const +{ + return Organizer->pluginSetting(BSPlugins::NAME, "enable_sort_button").value(); +} + +bool Settings::lootShowDirty() const +{ + return Organizer->pluginSetting(BSPlugins::NAME, "loot_show_dirty").value(); +} + +bool Settings::lootShowMessages() const +{ + return Organizer->pluginSetting(BSPlugins::NAME, "loot_show_messages").value(); +} + +bool Settings::lootShowProblems() const +{ + return Organizer->pluginSetting(BSPlugins::NAME, "loot_show_problems").value(); +} + +static QString stateSettingName(const QHeaderView* header) +{ + return header->parent()->objectName() + "_header"; +} + +static void visitRows(const QAbstractItemModel* model, + std::function visit, + const QModelIndex& root = QModelIndex()) +{ + if (root.isValid()) { + visit(root); + } + + for (int i = 0, count = model->rowCount(root); i < count; ++i) { + const auto idx = model->index(i, 0, root); + visitRows(model, visit, idx); + } +} + +void Settings::saveTreeExpandState(const QTreeView* view) +{ + QVariantList expanded; + visitRows(view->model(), [&expanded, view](const QModelIndex& index) { + if (view->isExpanded(index)) { + expanded.append(index.data()); + } + }); + + Organizer->setPersistent(BSPlugins::NAME, view->objectName() + "_expanded", expanded); +} + +void Settings::restoreTreeExpandState(QTreeView* view) const +{ + // empty is serialized as invalid + const QVariant state = Organizer->persistent( + BSPlugins::NAME, view->objectName() + "_expanded", QVariantList()); + + if (!state.isValid()) { + view->collapseAll(); + } else { + const auto expanded = state.toList(); + if (!expanded.isEmpty()) { + view->collapseAll(); + visitRows(view->model(), [&expanded, view](const QModelIndex& index) { + if (expanded.contains(index.data())) { + view->expand(index); + } + }); + } + } +} + +void Settings::saveState(const QHeaderView* header) +{ + Organizer->setPersistent(BSPlugins::NAME, stateSettingName(header), + header->saveState()); +} + +void Settings::restoreState(QHeaderView* header) const +{ + const auto state = + Organizer->persistent(BSPlugins::NAME, stateSettingName(header)).toByteArray(); + if (!state.isEmpty()) { + header->restoreState(state); + } +} + +static QString stateSettingName(const QSplitter* splitter) +{ + return splitter->parentWidget()->objectName() + "_splitter"; +} + +void Settings::saveState(const QSplitter* splitter) +{ + Organizer->setPersistent(BSPlugins::NAME, stateSettingName(splitter), + splitter->saveState()); +} + +void Settings::restoreState(QSplitter* splitter) const +{ + const auto state = + Organizer->persistent(BSPlugins::NAME, stateSettingName(splitter)).toByteArray(); + if (!state.isEmpty()) { + splitter->restoreState(state); + } +} + +static QString stateSettingName(const MOBase::ExpanderWidget* expander) +{ + return expander->button()->objectName() + "_state"; +} + +void Settings::saveState(const MOBase::ExpanderWidget* expander) +{ + Organizer->setPersistent(BSPlugins::NAME, stateSettingName(expander), + expander->saveState()); +} + +void Settings::restoreState(MOBase::ExpanderWidget* expander) const +{ + const auto state = + Organizer->persistent(BSPlugins::NAME, stateSettingName(expander)).toByteArray(); + if (!state.isEmpty()) { + expander->restoreState(state); + } +} + +static QString geometrySettingName(const QDialog* dialog) +{ + return dialog->objectName() + "_geometry"; +} + +void Settings::saveGeometry(const QDialog* dialog) +{ + Organizer->setPersistent(BSPlugins::NAME, geometrySettingName(dialog), + dialog->saveGeometry()); +} + +void Settings::restoreGeometry(QDialog* dialog) const +{ + const auto geometry = + Organizer->persistent(BSPlugins::NAME, geometrySettingName(dialog)).toByteArray(); + if (!geometry.isEmpty()) { + dialog->restoreGeometry(geometry); + } +} + +void Settings::onPluginSettingChanged(const QString& pluginName, const QString& key, + const QVariant& oldValue, + const QVariant& newValue) +{ + if (pluginName != BSPlugins::NAME) + return; + + SettingChanged(key, oldValue, newValue); +} -- cgit v1.3.1