mirror of
https://gitlab.com/OpenMW/openmw.git
synced 2025-03-29 04:20:29 +00:00
29af981345
Previously, comments would be associated with the openmw.cfg line that followed them, but only up to the first comma. This meant that if you had fallback=thing,otherthing and fallback=thing,thirdthing, comments above the thirdthing line would be moved above the otherthing line, even though both lines would be kept when the file was written out. This seemed to be an attempt at a feature when cc9cii first implemented the comment preservation system, but it only seems to cause confusion.
619 lines
21 KiB
C++
619 lines
21 KiB
C++
#include "gamesettings.hpp"
|
|
|
|
#include <QDir>
|
|
#include <QRegularExpression>
|
|
|
|
#include <components/files/configurationmanager.hpp>
|
|
#include <components/files/qtconversion.hpp>
|
|
#include <components/misc/utf8qtextstream.hpp>
|
|
|
|
const char Config::GameSettings::sArchiveKey[] = "fallback-archive";
|
|
const char Config::GameSettings::sContentKey[] = "content";
|
|
const char Config::GameSettings::sDirectoryKey[] = "data";
|
|
|
|
namespace
|
|
{
|
|
template <typename T>
|
|
QList<T> reverse(QList<T> values)
|
|
{
|
|
std::reverse(values.begin(), values.end());
|
|
return values;
|
|
}
|
|
}
|
|
|
|
Config::GameSettings::GameSettings(const Files::ConfigurationManager& cfg)
|
|
: mCfgMgr(cfg)
|
|
{
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
|
// this needs calling once so Qt can see its stream operators, which it needs when dragging and dropping
|
|
// it's automatic with Qt 6
|
|
qRegisterMetaTypeStreamOperators<SettingValue>("Config::SettingValue");
|
|
#endif
|
|
}
|
|
|
|
void Config::GameSettings::validatePaths()
|
|
{
|
|
QList<SettingValue> paths = mSettings.values(QString("data"));
|
|
|
|
mDataDirs.clear();
|
|
|
|
for (const auto& dataDir : paths)
|
|
{
|
|
if (QDir(dataDir.value).exists())
|
|
{
|
|
SettingValue copy = dataDir;
|
|
copy.value = QDir(dataDir.value).canonicalPath();
|
|
mDataDirs.append(copy);
|
|
}
|
|
}
|
|
|
|
// Do the same for data-local
|
|
const QString& local = mSettings.value(QString("data-local")).value;
|
|
|
|
if (!local.isEmpty() && QDir(local).exists())
|
|
{
|
|
mDataLocal = QDir(local).canonicalPath();
|
|
}
|
|
}
|
|
|
|
QString Config::GameSettings::getResourcesVfs() const
|
|
{
|
|
QString resources = mSettings.value(QString("resources"), { "./resources", "", "" }).value;
|
|
resources += "/vfs";
|
|
return QFileInfo(resources).canonicalFilePath();
|
|
}
|
|
|
|
QList<Config::SettingValue> Config::GameSettings::values(
|
|
const QString& key, const QList<SettingValue>& defaultValues) const
|
|
{
|
|
if (!mSettings.values(key).isEmpty())
|
|
return mSettings.values(key);
|
|
return defaultValues;
|
|
}
|
|
|
|
bool Config::GameSettings::containsValue(const QString& key, const QString& value) const
|
|
{
|
|
auto [itr, end] = mSettings.equal_range(key);
|
|
while (itr != end)
|
|
{
|
|
if (itr->value == value)
|
|
return true;
|
|
++itr;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Config::GameSettings::readFile(QTextStream& stream, const QString& context, bool ignoreContent)
|
|
{
|
|
if (readFile(stream, mSettings, context, ignoreContent))
|
|
{
|
|
mContexts.push_back(context);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Config::GameSettings::readUserFile(QTextStream& stream, const QString& context, bool ignoreContent)
|
|
{
|
|
return readFile(stream, mUserSettings, context, ignoreContent);
|
|
}
|
|
|
|
bool Config::GameSettings::readFile(
|
|
QTextStream& stream, QMultiMap<QString, SettingValue>& settings, const QString& context, bool ignoreContent)
|
|
{
|
|
QMultiMap<QString, SettingValue> cache;
|
|
QRegularExpression replaceRe("^\\s*replace\\s*=\\s*(.+)$");
|
|
QRegularExpression keyRe("^([^=]+)\\s*=\\s*(.+)$");
|
|
|
|
auto initialPos = stream.pos();
|
|
|
|
while (!stream.atEnd())
|
|
{
|
|
QString line = stream.readLine();
|
|
|
|
if (line.isEmpty() || line.startsWith("#"))
|
|
continue;
|
|
|
|
QRegularExpressionMatch match = replaceRe.match(line);
|
|
if (match.hasMatch())
|
|
{
|
|
QString key = match.captured(1).trimmed();
|
|
// Replace composing entries with a replace= line
|
|
if (key == QLatin1String("config") || key == QLatin1String("replace") || key == QLatin1String("data")
|
|
|| key == QLatin1String("fallback-archive") || key == QLatin1String("content")
|
|
|| key == QLatin1String("groundcover") || key == QLatin1String("fallback"))
|
|
settings.remove(key);
|
|
}
|
|
}
|
|
|
|
stream.seek(initialPos);
|
|
|
|
while (!stream.atEnd())
|
|
{
|
|
QString line = stream.readLine();
|
|
|
|
if (line.isEmpty() || line.startsWith("#"))
|
|
continue;
|
|
|
|
QRegularExpressionMatch match = keyRe.match(line);
|
|
if (match.hasMatch())
|
|
{
|
|
QString key = match.captured(1).trimmed();
|
|
SettingValue value{ match.captured(2).trimmed(), value.value, context };
|
|
|
|
// Don't remove composing entries
|
|
if (key != QLatin1String("config") && key != QLatin1String("replace") && key != QLatin1String("data")
|
|
&& key != QLatin1String("fallback-archive") && key != QLatin1String("content")
|
|
&& key != QLatin1String("groundcover") && key != QLatin1String("fallback"))
|
|
settings.remove(key);
|
|
|
|
if (key == QLatin1String("config") || key == QLatin1String("user-data") || key == QLatin1String("resources")
|
|
|| key == QLatin1String("data") || key == QLatin1String("data-local")
|
|
|| key == QLatin1String("load-savegame"))
|
|
{
|
|
// Path line (e.g. 'data=...'), so needs processing to deal with ampersands and quotes
|
|
// The following is based on boost::io::detail::quoted_manip.hpp, but we don't actually use
|
|
// boost::filesystem::path anymore, and use a custom class MaybeQuotedPath which uses Boost-like quoting
|
|
// rules but internally stores as a std::filesystem::path.
|
|
// Caution: This is intentional behaviour to duplicate how Boost and what we replaced it with worked,
|
|
// and we rely on that.
|
|
QChar delim = '\"';
|
|
QChar escape = '&';
|
|
|
|
if (value.value.at(0) == delim)
|
|
{
|
|
QString valueOriginal = value.value;
|
|
value.value = "";
|
|
|
|
for (QString::const_iterator it = valueOriginal.begin() + 1; it != valueOriginal.end(); ++it)
|
|
{
|
|
if (*it == escape)
|
|
++it;
|
|
else if (*it == delim)
|
|
break;
|
|
value.value += *it;
|
|
}
|
|
value.originalRepresentation = value.value;
|
|
}
|
|
|
|
value = processPathSettingValue(value);
|
|
}
|
|
if (ignoreContent && (key == QLatin1String("content") || key == QLatin1String("data")))
|
|
continue;
|
|
|
|
QList<SettingValue> values = cache.values(key);
|
|
values.append(settings.values(key));
|
|
|
|
bool exists = false;
|
|
for (const auto& existingValue : values)
|
|
{
|
|
if (existingValue.value == value.value)
|
|
{
|
|
exists = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!exists)
|
|
{
|
|
cache.insert(key, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (settings.isEmpty())
|
|
{
|
|
settings = cache; // This is the first time we read a file
|
|
validatePaths();
|
|
return true;
|
|
}
|
|
|
|
// Merge the changed keys with those which didn't
|
|
settings.unite(cache);
|
|
validatePaths();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Config::GameSettings::writeFile(QTextStream& stream)
|
|
{
|
|
// Iterate in reverse order to preserve insertion order
|
|
auto i = mUserSettings.end();
|
|
while (i != mUserSettings.begin())
|
|
{
|
|
i--;
|
|
|
|
// path lines (e.g. 'data=...') need quotes and ampersands escaping to match how boost::filesystem::path uses
|
|
// boost::io::quoted
|
|
// We don't actually use boost::filesystem::path anymore, but use a custom class MaybeQuotedPath which uses
|
|
// Boost-like quoting rules but internally stores as a std::filesystem::path.
|
|
// Caution: This is intentional behaviour to duplicate how Boost and what we replaced it with worked, and we
|
|
// rely on that.
|
|
if (i.key() == QLatin1String("config") || i.key() == QLatin1String("user-data")
|
|
|| i.key() == QLatin1String("resources") || i.key() == QLatin1String("data")
|
|
|| i.key() == QLatin1String("data-local") || i.key() == QLatin1String("load-savegame"))
|
|
{
|
|
stream << i.key() << "=";
|
|
|
|
// Equivalent to stream << std::quoted(i.value(), '"', '&'), which won't work on QStrings.
|
|
QChar delim = '\"';
|
|
QChar escape = '&';
|
|
QString string = i.value().originalRepresentation;
|
|
|
|
stream << delim;
|
|
for (auto& it : string)
|
|
{
|
|
if (it == delim || it == escape)
|
|
stream << escape;
|
|
stream << it;
|
|
}
|
|
stream << delim;
|
|
|
|
stream << '\n';
|
|
continue;
|
|
}
|
|
|
|
stream << i.key() << "=" << i.value().originalRepresentation << "\n";
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Config::GameSettings::isOrderedLine(const QString& line)
|
|
{
|
|
return line.contains(QRegularExpression("^\\s*fallback-archive\\s*="))
|
|
|| line.contains(QRegularExpression("^\\s*fallback\\s*="))
|
|
|| line.contains(QRegularExpression("^\\s*data\\s*="))
|
|
|| line.contains(QRegularExpression("^\\s*data-local\\s*="))
|
|
|| line.contains(QRegularExpression("^\\s*resources\\s*="))
|
|
|| line.contains(QRegularExpression("^\\s*groundcover\\s*="))
|
|
|| line.contains(QRegularExpression("^\\s*content\\s*="));
|
|
}
|
|
|
|
// Policy:
|
|
//
|
|
// - Always ignore a line beginning with '#' or empty lines; added above a config
|
|
// entry.
|
|
//
|
|
// - If a line in file exists with matching key and first part of value (before ',',
|
|
// '\n', etc) also matches, then replace the line with that of mUserSettings.
|
|
// - else remove line
|
|
//
|
|
// - If there is no corresponding line in file, add at the end
|
|
//
|
|
// - Removed content items are saved as comments if the item had any comments.
|
|
// Content items prepended with '##' are considered previously removed.
|
|
//
|
|
bool Config::GameSettings::writeFileWithComments(QFile& file)
|
|
{
|
|
QTextStream stream(&file);
|
|
Misc::ensureUtf8Encoding(stream);
|
|
|
|
// slurp
|
|
std::vector<QString> fileCopy;
|
|
QString line = stream.readLine();
|
|
while (!line.isNull())
|
|
{
|
|
fileCopy.push_back(line);
|
|
line = stream.readLine();
|
|
}
|
|
stream.seek(0);
|
|
|
|
// empty file, no comments to keep
|
|
if (fileCopy.empty())
|
|
return writeFile(stream);
|
|
|
|
// start
|
|
// |
|
|
// | +----------------------------------------------------------+
|
|
// | | |
|
|
// v v |
|
|
// skip non-"ordered" lines (remove "ordered" lines) |
|
|
// | ^ |
|
|
// | | |
|
|
// | non-"ordered" line, write saved comments |
|
|
// | ^ |
|
|
// v | |
|
|
// blank or comment line, save in temp buffer <--------+ |
|
|
// | | | |
|
|
// | +------- comment line ------+ |
|
|
// v (special processing '##') |
|
|
// "ordered" line |
|
|
// | |
|
|
// v |
|
|
// save in a separate map of comments keyed by "ordered" line |
|
|
// | |
|
|
// +----------------------------------------------------------+
|
|
//
|
|
//
|
|
QRegularExpression settingRegex("^([^=]+)\\s*=\\s*(.+?)\\s*$");
|
|
std::vector<QString> comments;
|
|
auto commentStart = fileCopy.end();
|
|
std::map<QString, std::vector<QString>> commentsMap;
|
|
for (auto iter = fileCopy.begin(); iter != fileCopy.end(); ++iter)
|
|
{
|
|
if (isOrderedLine(*iter))
|
|
{
|
|
// save in a separate map of comments keyed by "ordered" line
|
|
if (!comments.empty())
|
|
{
|
|
QRegularExpressionMatch match = settingRegex.match(*iter);
|
|
if (match.hasMatch())
|
|
{
|
|
commentsMap[match.captured(1) + "=" + match.captured(2)] = comments;
|
|
comments.clear();
|
|
commentStart = fileCopy.end();
|
|
}
|
|
// else do nothing, malformed line
|
|
}
|
|
|
|
*iter = QString(); // "ordered" lines to be removed later
|
|
}
|
|
else if ((*iter).isEmpty() || (*iter).contains(QRegularExpression("^\\s*#")))
|
|
{
|
|
// comment line, save in temp buffer
|
|
if (comments.empty())
|
|
commentStart = iter;
|
|
|
|
// special removed content processing
|
|
if ((*iter).contains(QRegularExpression("^##content\\s*=")))
|
|
{
|
|
if (!comments.empty())
|
|
{
|
|
commentsMap[*iter] = comments;
|
|
comments.clear();
|
|
commentStart = fileCopy.end();
|
|
}
|
|
}
|
|
else
|
|
comments.push_back(*iter);
|
|
|
|
*iter = QString(); // assume to be deleted later
|
|
}
|
|
else
|
|
{
|
|
QRegularExpressionMatch match = settingRegex.match(*iter);
|
|
|
|
// blank or non-"ordered" line, write saved comments
|
|
if (!comments.empty() && match.hasMatch() && settingRegex.captureCount() >= 2
|
|
&& mUserSettings.find(match.captured(1)) != mUserSettings.end())
|
|
{
|
|
if (commentStart == fileCopy.end())
|
|
throw std::runtime_error(
|
|
"Config::GameSettings: failed to parse settings - iterator is past of end of settings file");
|
|
|
|
for (const auto& comment : comments)
|
|
{
|
|
*commentStart = comment;
|
|
++commentStart;
|
|
}
|
|
comments.clear();
|
|
commentStart = fileCopy.end();
|
|
}
|
|
|
|
// keep blank lines and non-"ordered" lines other than comments
|
|
|
|
// look for a key in the line
|
|
if (!match.hasMatch() || settingRegex.captureCount() < 2)
|
|
{
|
|
// no key or first part of value found in line, replace with a null string which
|
|
// will be removed later
|
|
*iter = QString();
|
|
comments.clear();
|
|
commentStart = fileCopy.end();
|
|
continue;
|
|
}
|
|
|
|
// look for a matching key in user settings
|
|
*iter = QString(); // assume no match
|
|
QString key = match.captured(1);
|
|
QString keyVal = match.captured(1) + "=" + match.captured(2);
|
|
QMultiMap<QString, SettingValue>::const_iterator i = mUserSettings.find(key);
|
|
while (i != mUserSettings.end() && i.key() == key)
|
|
{
|
|
// todo: does this need to handle paths?
|
|
QString settingLine = i.key() + "=" + i.value().originalRepresentation;
|
|
QRegularExpressionMatch keyMatch = settingRegex.match(settingLine);
|
|
if (keyMatch.hasMatch())
|
|
{
|
|
if ((keyMatch.captured(1) + "=" + keyMatch.captured(2)) == keyVal)
|
|
{
|
|
*iter = std::move(settingLine);
|
|
break;
|
|
}
|
|
}
|
|
++i;
|
|
}
|
|
}
|
|
}
|
|
|
|
// comments at top of file
|
|
for (auto& iter : fileCopy)
|
|
{
|
|
if (iter.isNull())
|
|
continue;
|
|
|
|
// Below is based on readFile() code, if that changes corresponding change may be
|
|
// required (for example duplicates may be inserted if the rules don't match)
|
|
if (/*(*iter).isEmpty() ||*/ iter.contains(QRegularExpression("^\\s*#")))
|
|
{
|
|
stream << iter << "\n";
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Iterate in reverse order to preserve insertion order
|
|
QString settingLine;
|
|
auto it = mUserSettings.end();
|
|
while (it != mUserSettings.begin())
|
|
{
|
|
it--;
|
|
|
|
// path lines (e.g. 'data=...') need quotes and ampersands escaping to match how boost::filesystem::path uses
|
|
// boost::io::quoted
|
|
// We don't actually use boost::filesystem::path anymore, but use a custom class MaybeQuotedPath which uses
|
|
// Boost-like quoting rules but internally stores as a std::filesystem::path.
|
|
// Caution: This is intentional behaviour to duplicate how Boost and what we replaced it with worked, and we
|
|
// rely on that.
|
|
if (it.key() == QLatin1String("config") || it.key() == QLatin1String("user-data")
|
|
|| it.key() == QLatin1String("resources") || it.key() == QLatin1String("data")
|
|
|| it.key() == QLatin1String("data-local") || it.key() == QLatin1String("load-savegame"))
|
|
{
|
|
settingLine = it.key() + "=";
|
|
|
|
// Equivalent to settingLine += std::quoted(it.value(), '"', '&'), which won't work on QStrings.
|
|
QChar delim = '\"';
|
|
QChar escape = '&';
|
|
QString string = it.value().originalRepresentation;
|
|
|
|
settingLine += delim;
|
|
for (auto& iter : string)
|
|
{
|
|
if (iter == delim || iter == escape)
|
|
settingLine += escape;
|
|
settingLine += iter;
|
|
}
|
|
settingLine += delim;
|
|
}
|
|
else
|
|
settingLine = it.key() + "=" + it.value().originalRepresentation;
|
|
|
|
QRegularExpressionMatch match = settingRegex.match(settingLine);
|
|
if (match.hasMatch())
|
|
{
|
|
auto i = commentsMap.find(match.captured(1) + "=" + match.captured(2));
|
|
|
|
// check if previous removed content item with comments
|
|
if (i == commentsMap.end())
|
|
i = commentsMap.find("##" + match.captured(1) + "=" + match.captured(2));
|
|
|
|
if (i != commentsMap.end())
|
|
{
|
|
std::vector<QString> cLines = i->second;
|
|
for (const auto& cLine : cLines)
|
|
stream << cLine << "\n";
|
|
|
|
commentsMap.erase(i);
|
|
}
|
|
}
|
|
|
|
stream << settingLine << "\n";
|
|
}
|
|
|
|
// flush any removed settings
|
|
if (!commentsMap.empty())
|
|
{
|
|
auto i = commentsMap.begin();
|
|
for (; i != commentsMap.end(); ++i)
|
|
{
|
|
if (i->first.contains(QRegularExpression("^\\s*content\\s*=")))
|
|
{
|
|
std::vector<QString> cLines = i->second;
|
|
for (const auto& cLine : cLines)
|
|
stream << cLine << "\n";
|
|
|
|
// mark the content line entry for future preocessing
|
|
stream << "##" << i->first << "\n";
|
|
|
|
// commentsMap.erase(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
// flush any end comments
|
|
if (!comments.empty())
|
|
{
|
|
for (const auto& comment : comments)
|
|
stream << comment << "\n";
|
|
}
|
|
|
|
file.resize(file.pos());
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Config::GameSettings::hasMaster()
|
|
{
|
|
bool result = false;
|
|
QList<SettingValue> content = mSettings.values(QString(Config::GameSettings::sContentKey));
|
|
for (int i = 0; i < content.count(); ++i)
|
|
{
|
|
if (content.at(i).value.endsWith(QLatin1String(".omwgame"), Qt::CaseInsensitive)
|
|
|| content.at(i).value.endsWith(QLatin1String(".esm"), Qt::CaseInsensitive))
|
|
{
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void Config::GameSettings::setContentList(
|
|
const QList<SettingValue>& dirNames, const QList<SettingValue>& archiveNames, const QStringList& fileNames)
|
|
{
|
|
remove(sDirectoryKey);
|
|
for (auto const& item : dirNames)
|
|
setMultiValue(sDirectoryKey, item);
|
|
remove(sArchiveKey);
|
|
for (auto const& item : archiveNames)
|
|
setMultiValue(sArchiveKey, item);
|
|
remove(sContentKey);
|
|
for (auto const& item : fileNames)
|
|
setMultiValue(sContentKey, { item });
|
|
}
|
|
|
|
QList<Config::SettingValue> Config::GameSettings::getDataDirs() const
|
|
{
|
|
return reverse(mDataDirs);
|
|
}
|
|
|
|
QList<Config::SettingValue> Config::GameSettings::getArchiveList() const
|
|
{
|
|
// QMap returns multiple rows in LIFO order, so need to reverse
|
|
return reverse(values(sArchiveKey));
|
|
}
|
|
|
|
QList<Config::SettingValue> Config::GameSettings::getContentList() const
|
|
{
|
|
// QMap returns multiple rows in LIFO order, so need to reverse
|
|
return reverse(values(sContentKey));
|
|
}
|
|
|
|
bool Config::GameSettings::isUserSetting(const SettingValue& settingValue) const
|
|
{
|
|
return settingValue.context.isEmpty() || settingValue.context == getUserContext();
|
|
}
|
|
|
|
Config::SettingValue Config::GameSettings::processPathSettingValue(const SettingValue& value)
|
|
{
|
|
std::filesystem::path path = Files::pathFromQString(value.value);
|
|
std::filesystem::path basePath = Files::pathFromQString(value.context.isEmpty() ? getUserContext() : value.context);
|
|
mCfgMgr.processPath(path, basePath);
|
|
return SettingValue{ Files::pathToQString(path), value.originalRepresentation, value.context };
|
|
}
|
|
|
|
void Config::GameSettings::clear()
|
|
{
|
|
mSettings.clear();
|
|
mContexts.clear();
|
|
mUserSettings.clear();
|
|
mDataDirs.clear();
|
|
mDataLocal.clear();
|
|
}
|
|
|
|
QDataStream& Config::operator<<(QDataStream& out, const SettingValue& settingValue)
|
|
{
|
|
out << settingValue.value;
|
|
out << settingValue.originalRepresentation;
|
|
out << settingValue.context;
|
|
return out;
|
|
}
|
|
|
|
QDataStream& Config::operator>>(QDataStream& in, SettingValue& settingValue)
|
|
{
|
|
in >> settingValue.value;
|
|
in >> settingValue.originalRepresentation;
|
|
in >> settingValue.context;
|
|
return in;
|
|
}
|