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/TESData/DataItem.cpp | 231 ++++++++++++++++++++++ 1 file changed, 231 insertions(+) create mode 100644 libs/installer_bsplugins/src/TESData/DataItem.cpp (limited to 'libs/installer_bsplugins/src/TESData/DataItem.cpp') diff --git a/libs/installer_bsplugins/src/TESData/DataItem.cpp b/libs/installer_bsplugins/src/TESData/DataItem.cpp new file mode 100644 index 0000000..c083aae --- /dev/null +++ b/libs/installer_bsplugins/src/TESData/DataItem.cpp @@ -0,0 +1,231 @@ +#include "DataItem.h" + +#include +#include + +using namespace Qt::Literals::StringLiterals; + +namespace TESData +{ + +QString DataItem::makeName(TESFile::Type signature, const QString& name) +{ + const QByteArray sig = + QByteArray(signature.data(), signature.size()).toPercentEncoding("@"_ba); + + if (!name.isEmpty()) { + return QStringLiteral("%1 - %2").arg(QString::fromLatin1(sig), name); + } else { + return QString::fromLatin1(sig); + } +} + +QVariant DataItem::data(int fileIndex) const +{ + if (fileIndex < m_Data.size()) { + return m_Data[fileIndex]; + } + + return QVariant(); +} + +QVariant DataItem::displayData(int fileIndex) const +{ + if (fileIndex < m_DisplayData.size()) { + const auto& displayData = m_DisplayData[fileIndex]; + if (displayData.isValid()) { + return displayData; + } + } + + return data(fileIndex); +} + +bool DataItem::isLosingConflict(int fileIndex, int fileCount) const +{ + if (m_ConflictType == ConflictType::Ignore || + m_ConflictType == ConflictType::Benign || + m_ConflictType == ConflictType::BenignIfAdded) { + return false; + } + + if (!m_Data.isEmpty()) { + if (fileIndex >= m_Data.length()) { + return false; + } else if (fileCount > m_Data.length() && + m_ConflictType != ConflictType::NormalIgnoreEmpty) { + return true; + } + + for (int i = fileIndex + 1; i < m_Data.length(); ++i) { + if (hasConflict(m_Data[i], m_Data[fileIndex])) { + return true; + } + } + } + + for (const auto& child : m_Children) { + if (child->isLosingConflict(fileIndex, fileCount)) { + return true; + } + } + + return false; +} + +bool DataItem::isOverriding(int fileIndex) const +{ + if (m_ConflictType == ConflictType::Ignore) { + return false; + } + + if (!m_Data.isEmpty()) { + if (fileIndex >= m_Data.length() && + m_ConflictType != ConflictType::NormalIgnoreEmpty) { + return m_ConflictType != ConflictType::Benign; + } + + for (int i = 0; i < std::min(fileIndex, static_cast(m_Data.length())); ++i) { + if (m_ConflictType == ConflictType::Benign && !m_Data[i].isValid()) { + continue; + } + + if (hasConflict(m_Data[i], m_Data[fileIndex])) { + return true; + } + } + } + + for (const auto& child : m_Children) { + if (child->isOverriding(fileIndex)) { + return true; + } + } + + return false; +} + +bool DataItem::isConflicted(int fileCount) const +{ + if (m_ConflictType == ConflictType::Ignore) { + return false; + } + + if (!m_Data.isEmpty()) { + if (fileCount > m_Data.length() && + m_ConflictType != ConflictType::NormalIgnoreEmpty) { + return true; + } + + for (int i = 1; i < m_Data.length(); ++i) { + if (hasConflict(m_Data[i], m_Data[0])) { + return true; + } + } + } + + for (const auto& child : m_Children) { + if (child->isConflicted(fileCount)) { + return true; + } + } + + return false; +} + +DataItem* DataItem::findChild(TESFile::Type signature) const +{ + const auto it = std::ranges::find_if(m_Children, [&](auto&& child) { + return child->signature() == signature; + }); + + return it != std::end(m_Children) ? it->get() : nullptr; +} + +QVariant DataItem::childData(TESFile::Type signature, int fileIndex) const +{ + const auto it = std::ranges::find_if(m_Children, [&](auto&& child) { + return child->signature() == signature; + }); + + if (it == std::end(m_Children)) { + return QVariant(); + } + + return (*it)->data(fileIndex); +} + +QVariant DataItem::childData(const QString& name, int fileIndex) const +{ + const auto it = std::ranges::find_if(m_Children, [&](auto&& child) { + return child->name() == name; + }); + + if (it == std::end(m_Children)) { + return QVariant(); + } + + return (*it)->data(fileIndex); +} + +int DataItem::indexOf(const DataItem* child) const +{ + const auto it = std::ranges::find(m_Children, child, &std::shared_ptr::get); + if (it == std::end(m_Children)) { + return -1; + } + return std::distance(std::begin(m_Children), it); +} + +DataItem* DataItem::getOrInsertChild(int index, const QString& name, + ConflictType conflictType) +{ + if (index < m_Children.size()) { + const auto& child = m_Children[index]; + if (child->name() == name) { + return child.get(); + } + } + return insertChild(index, name, conflictType); +} + +DataItem* DataItem::getOrInsertChild(int index, TESFile::Type signature, + const QString& name, ConflictType conflictType) +{ + if (index < m_Children.size()) { + const auto& child = m_Children[index]; + if (child->signature() == signature) { + return child.get(); + } + } + return insertChild(index, signature, name, conflictType); +} + +void DataItem::setData(int fileIndex, const QVariant& data, bool caseSensitive) +{ + if (m_Data.size() <= fileIndex) { + m_Data.resize(fileIndex + 1); + } + m_Data[fileIndex] = data; + m_CaseSensitive = caseSensitive; +} + +void DataItem::setDisplayData(int fileIndex, const QVariant& data) +{ + if (m_DisplayData.size() <= fileIndex) { + m_DisplayData.resize(fileIndex + 1); + } + m_DisplayData[fileIndex] = data; +} + +bool DataItem::hasConflict(const QVariant& var1, const QVariant& var2) const +{ + if (!m_CaseSensitive && var1.userType() == QMetaType::QString && + var2.userType() == QMetaType::QString) { + return var1.toString().compare(var2.toString(), Qt::CaseInsensitive) != 0; + } else { + return var1 != var2; + } +} + +} // namespace TESData -- cgit v1.3.1