diff --git a/src/global/preferences-generator.py b/src/global/preferences-generator.py index 3367693f..29124e5b 100644 --- a/src/global/preferences-generator.py +++ b/src/global/preferences-generator.py @@ -1,484 +1,484 @@ ########################################################################### # Copyright (C) 2019 by Thomas Fischer # # # # This script is free software; you can redistribute it and/or modify # # it under the terms of the GNU General Public License as published by # # the Free Software Foundation; either version 2 of the License, or # # (at your option) any later version. # # # # This script is distributed in the hope that it will be useful, # # but WITHOUT ANY WARRANTY; without even the implied warranty of # # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # # GNU General Public License for more details. # # # # You should have received a copy of the GNU General Public License # # along with this script; if not, see . # ########################################################################### import sys import json import datetime def print_copyright_header(outputdevice=sys.stdout): """Print the default copyright statement to the output device.""" print("""/*************************************************************************** * Copyright (C) 2004-{year} by Thomas Fischer * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, see . * ***************************************************************************/""" .format(year=datetime.date.today().year), file=outputdevice) print(file=outputdevice) print("""/// This file has been automatically generated using the script 'preferences-generator.py' /// based on configuration data from file 'preferences.json'. If there are any problems or /// bugs, you need to fix those two files and re-generated both 'preferences.h' and /// 'preferences.cpp'. Manual changes in this file will be overwritten the next time the /// script will be run. You have been warned.""", file=outputdevice) print(file=outputdevice) def needsReference(type): """Check if given Qt/C++ data type should be passed by reference rather than by value.""" return type in ["QString", "QStringList"] \ or type.startswith(('QPair<', 'QVector<', 'QSet<', 'QList<', 'QLinkedList<', 'QMap<', 'QVector<', 'QHash<')) def print_header(headerincludes, implementationincludes, enums, settings, outputdevice=sys.stdout): """Print the header file for the Preferences ('preferences.h').""" print_copyright_header(outputdevice) # Include guard definition print("#ifndef KBIBTEX_GLOBAL_PREFERENCES_H", file=outputdevice) print("#define KBIBTEX_GLOBAL_PREFERENCES_H", file=outputdevice) print(file=outputdevice) # Include other headers as necessary for includeline in headerincludes: print("#include", includeline, file=outputdevice) if headerincludes: print(file=outputdevice) print("class Preferences {", file=outputdevice) print("public:", file=outputdevice) print(" static Preferences &instance();", file=outputdevice) print(" ~Preferences();", file=outputdevice) print(file=outputdevice) for enum in sorted(enums): print(" enum " + enum + " {", end="", file=outputdevice) first = True for enumvaluepair in enums[enum]: if not first: print(",", end="", file=outputdevice) print(" ", end="", file=outputdevice) if isinstance(enumvaluepair, list): print(enumvaluepair[0], end="", file=outputdevice) if len(enumvaluepair) >= 2 and enumvaluepair[1] != None: print( " = " + str(enumvaluepair[1]), end="", file=outputdevice) elif isinstance(enumvaluepair, str): print(enumvaluepair, end="", file=outputdevice) first = False print(" };", file=outputdevice) if enums: print(file=outputdevice) for setting in settings: stem = setting['stem'] type = setting['type'] lowercasestart = stem[0].lower() + stem[1:] print(file=outputdevice) print(" /// ***", stem, "of type", type, "***", file=outputdevice) print(file=outputdevice) if 'predefined' in setting: for predefined in setting['predefined']: print(" static const " + type + " " + lowercasestart + predefined[0] + ";", file=outputdevice) print(" static const " + type + " default" + stem + ";", file=outputdevice) if 'availabletype' in setting: print(" static const " + setting['availabletype'] + " available" + stem + "s;", file=outputdevice) print((" const " if needsReference(type) else " ") + type + (" &" if needsReference(type) else " ") + lowercasestart + "();", file=outputdevice) print(" bool set" + stem + "(const " + type + (" &" if needsReference(type) else " ") + lowercasestart + ");", file=outputdevice) print("", file=outputdevice) print("private:", file=outputdevice) print(" Q_DISABLE_COPY(Preferences)", file=outputdevice) print(file=outputdevice) print(" explicit Preferences();", file=outputdevice) print(file=outputdevice) print(" class Private;", file=outputdevice) print(" Private *const d;", file=outputdevice) print("};", file=outputdevice) print(file=outputdevice) print("#endif // KBIBTEX_GLOBAL_PREFERENCES_H", file=outputdevice) def print_implementation(headerincludes, implementationincludes, enums, settings, outputdevice=sys.stdout): """Print the implementatiom file for the Preferences ('preferences.cpp').""" print_copyright_header(outputdevice) # Include headers that will always be necessary print('#include "preferences.h"', file=outputdevice) print(file=outputdevice) print('#include ', file=outputdevice) print('#ifdef HAVE_KF5', file=outputdevice) print('#include ', file=outputdevice) print('#include ', file=outputdevice) print('#include ', file=outputdevice) print('#include ', file=outputdevice) print('#else // HAVE_KF5', file=outputdevice) print('#define i18n(text) QStringLiteral(text)', file=outputdevice) print('#define i18nc(comment,text) QStringLiteral(text)', file=outputdevice) print('#endif // HAVE_KF5', file=outputdevice) print(file=outputdevice) print('#ifdef HAVE_KF5', file=outputdevice) print('#include "notificationhub.h"', file=outputdevice) print('#endif // HAVE_KF5', file=outputdevice) print(file=outputdevice) # Include other headers as necessary for includeline in implementationincludes: print("#include", includeline, file=outputdevice) if implementationincludes: print(file=outputdevice) print('class Preferences::Private', file=outputdevice) print('{', file=outputdevice) print('public:', file=outputdevice) print('#ifdef HAVE_KF5', file=outputdevice) print(' KSharedConfigPtr config;', file=outputdevice) print(' KConfigWatcher::Ptr watcher;', file=outputdevice) print(file=outputdevice) for setting in settings: stem = setting['stem'] type = setting['type'] if type in enums: type = "Preferences::" + type print(' bool dirtyFlag' + stem + ';', file=outputdevice) print(' ' + type + ' cached' + stem + ';', file=outputdevice) print('#endif // HAVE_KF5', file=outputdevice) # Constructor for Preferences::Private print(file=outputdevice) print(' Private(Preferences *)', file=outputdevice) print(' {', file=outputdevice) print('#ifdef HAVE_KF5', file=outputdevice) print(' config = KSharedConfig::openConfig(QStringLiteral("kbibtexrc"));', file=outputdevice) print(' watcher = KConfigWatcher::create(config);', file=outputdevice) for setting in settings: stem = setting['stem'] print(' dirtyFlag' + stem + ' = true;', file=outputdevice) print(' cached' + stem + ' = Preferences::default' + stem + ';', file=outputdevice) print('#endif // HAVE_KF5', file=outputdevice) print(' }', file=outputdevice) print(file=outputdevice) print('#ifdef HAVE_KF5', file=outputdevice) first = True for setting in settings: stem = setting['stem'] type = setting['type'] if type in enums: type = "Preferences::" + type if first: first = False else: print(file=outputdevice) print(' inline bool validateValueFor' + stem + '(const ' + type + (" &" if needsReference(type) else " ") + "valueToBeChecked) {", file=outputdevice) if 'validationcode' in setting: if isinstance(setting['validationcode'], list): for line in setting['validationcode']: print(' ' + line, file=outputdevice) if not setting['validationcode'][-1].startswith("return "): print(' return false;', file=outputdevice) elif isinstance(setting['validationcode'], str): print(' ' + setting['validationcode'], file=outputdevice) elif 'availabletype' in setting and setting['availabletype'].startswith('QVectorfirst == valueToBeChecked) return true;', file=outputdevice) print(' return false;', file=outputdevice) elif 'availabletype' in setting and setting['availabletype'] == "QStringList": print(' return Preferences::available' + stem + 's.contains(valueToBeChecked);', file=outputdevice) else: print(' Q_UNUSED(valueToBeChecked)', file=outputdevice) print(' return true;', file=outputdevice) print(' }', file=outputdevice) if 'readEntry' in setting: print(file=outputdevice) print(' ' + type + ' readEntry' + stem + '(const KConfigGroup &configGroup, const QString &key) const', file=outputdevice) print(' {', file=outputdevice) if isinstance(setting['readEntry'], list): for line in setting['readEntry']: print(' ' + line, file=outputdevice) elif isinstance(setting['readEntry'], str): print(' ' + setting['readEntry'], file=outputdevice) print(' }', file=outputdevice) if 'writeEntry' in setting: print(file=outputdevice) print(' void writeEntry' + stem + '(KConfigGroup &configGroup, const QString &key, const ' + type + (" &" if needsReference(type) else " ") + 'valueToBeWritten)', file=outputdevice) print(' {', file=outputdevice) if isinstance(setting['writeEntry'], list): for line in setting['writeEntry']: print(' ' + line, file=outputdevice) elif isinstance(setting['writeEntry'], str): print(' ' + setting['writeEntry'], file=outputdevice) print(' }', file=outputdevice) print('#endif // HAVE_KF5', file=outputdevice) print('};', file=outputdevice) # Singleton function Preferences::instance() print(file=outputdevice) print('Preferences &Preferences::instance()', file=outputdevice) print('{', file=outputdevice) print(' static Preferences singleton;', file=outputdevice) print(' return singleton;', file=outputdevice) print('}', file=outputdevice) print(file=outputdevice) # Constructor for class Preferences print('Preferences::Preferences()', file=outputdevice) print(' : d(new Preferences::Private(this))', file=outputdevice) print('{', file=outputdevice) print('#ifdef HAVE_KF5', file=outputdevice) print( ' QObject::connect(d->watcher.data(), &KConfigWatcher::configChanged, QCoreApplication::instance(), [this](const KConfigGroup &group, const QByteArrayList &names) {', file=outputdevice) print(' QSet eventsToPublish;', file=outputdevice) for setting in settings: stem = setting['stem'] configgroup = setting['configgroup'] if 'configgroup' in setting else 'General' print(' if (group.name() == QStringLiteral("' + configgroup + '") && names.contains("' + stem + '")) {', file=outputdevice) print(' /// Configuration setting ' + stem + ' got changed by another Preferences instance";', file=outputdevice) print(' d->dirtyFlag' + stem + ' = true;', file=outputdevice) if 'notificationevent' in setting: print(' eventsToPublish.insert(' + setting['notificationevent'] + ');', file=outputdevice) print(' }', file=outputdevice) print(file=outputdevice) print(' for (const int eventId : eventsToPublish)', file=outputdevice) print(' NotificationHub::publishEvent(eventId);', file=outputdevice) print(' });', file=outputdevice) print('#endif // HAVE_KF5', file=outputdevice) print('}', file=outputdevice) print(file=outputdevice) # Destructor for Preferences print('Preferences::~Preferences()', file=outputdevice) print('{', file=outputdevice) print(' delete d;', file=outputdevice) print('}', file=outputdevice) for setting in settings: stem = setting['stem'] configgroup = setting['configgroup'] if 'configgroup' in setting else 'General' type = type = setting['type'] typeInConfig = "int" if type in enums.keys() else type if 'podtype' in setting: typeInConfig = setting['podtype'] if type in enums: type = "Preferences::" + type lowercasestart = stem[0].lower() + stem[1:] print(file=outputdevice) if 'predefined' in setting: for predefined in setting['predefined']: print('const ' + type + ' Preferences::' + lowercasestart + predefined[0] + " = " + predefined[1] + ";", file=outputdevice) if 'available' in setting: available = setting['available'] print('const ' + setting['availabletype'] + ' Preferences::available' + stem + ('s ' if available.startswith("{") else "s = ") + available + ";", file=outputdevice) default = "nullptr" if 'default' in setting: default = setting['default'] if 'predefined' in setting and default in [pair[0] for pair in setting['predefined']]: default = "Preferences::" + lowercasestart + default - if 'availabletype' in setting: + elif 'availabletype' in setting: if setting['availabletype'].startswith("QVectordirtyFlag' + stem + ') {', file=outputdevice) print(' d->config->reparseConfiguration();', file=outputdevice) print(' static const KConfigGroup configGroup(d->config, QStringLiteral("' + configgroup + '"));', file=outputdevice) print(' const ' + type + ' valueFromConfig = ', end="", file=outputdevice) if 'readEntry' in setting: print('d->readEntry' + stem + '(configGroup, QStringLiteral("' + stem + '"));', file=outputdevice) else: if typeInConfig != type: print('static_cast<' + type + '>(', end="", file=outputdevice) print('configGroup.readEntry(QStringLiteral("' + stem + '"), ', end="", file=outputdevice) if typeInConfig != type: print('static_cast<' + typeInConfig + '>(', end="", file=outputdevice) print('Preferences::default' + stem, end="", file=outputdevice) if typeInConfig != type: print(')', end="", file=outputdevice) print(')', end="", file=outputdevice) if typeInConfig != type: print(')', end="", file=outputdevice) print(';', file=outputdevice) print(' if (d->validateValueFor' + stem + '(valueFromConfig)) {', file=outputdevice) print(' d->cached' + stem + ' = valueFromConfig;', file=outputdevice) print(' d->dirtyFlag' + stem + ' = false;', file=outputdevice) print(' } else {', file=outputdevice) print(' /// Configuration file setting for ' + stem + ' has an invalid value, using default as fallback', file=outputdevice) print(' set' + stem + '(Preferences::default' + stem + ');', file=outputdevice) print(' }', file=outputdevice) print(' }', file=outputdevice) print(' return d->cached' + stem + ";", file=outputdevice) print('#else // HAVE_KF5', file=outputdevice) print(' return default' + stem + ";", file=outputdevice) print('#endif // HAVE_KF5', file=outputdevice) print("}", file=outputdevice) print(file=outputdevice) print("bool Preferences::set" + stem + '(const ' + type + (" &" if needsReference(type) else " ") + 'newValue)', file=outputdevice) print("{", file=outputdevice) print('#ifdef HAVE_KF5', file=outputdevice) if 'sanitizecode' in setting: newValueVariable = 'sanitizedNewValue' if isinstance(setting['sanitizecode'], str): print(' ' + setting['sanitizecode'], file=outputdevice) elif isinstance(setting['sanitizecode'], list): for line in setting['sanitizecode']: print(' ' + line, file=outputdevice) else: newValueVariable = 'newValue' elif 'availabletype' in setting and setting['availabletype'] == 'QStringList': newValueVariable = 'sanitizedNewValue' print(' ' + type + ' sanitizedNewValue = newValue;', file=outputdevice) print(' const ' + type + ' lowerSanitizedNewValue = sanitizedNewValue.toLower();', file=outputdevice) print(' for (const QString &known' + stem + ' : available' + stem + 's)', file=outputdevice) print(' if (known' + stem + '.toLower() == lowerSanitizedNewValue) {', file=outputdevice) print(' sanitizedNewValue = known' + stem + ';', file=outputdevice) print(' break;', file=outputdevice) print(' }', file=outputdevice) else: newValueVariable = 'newValue' print(' if (!d->validateValueFor' + stem + '(' + newValueVariable + ')) return false;', file=outputdevice) print(' d->dirtyFlag' + stem + ' = false;', file=outputdevice) print(' d->cached' + stem + ' = ' + newValueVariable + ';', file=outputdevice) print(' static KConfigGroup configGroup(d->config, QStringLiteral("' + configgroup + '"));', file=outputdevice) print(' const ' + type + ' valueFromConfig = ', end="", file=outputdevice) if 'readEntry' in setting: print('d->readEntry' + stem + '(configGroup, QStringLiteral("' + stem + '"));', file=outputdevice) else: if typeInConfig != type: print('static_cast<' + type + '>(', end="", file=outputdevice) print('configGroup.readEntry(QStringLiteral("' + stem + '"), ', end="", file=outputdevice) if typeInConfig != type: print('static_cast<' + typeInConfig + '>(', end="", file=outputdevice) print('Preferences::default' + stem, end="", file=outputdevice) if typeInConfig != type: print(')', end="", file=outputdevice) print(')', end="", file=outputdevice) if typeInConfig != type: print(')', end="", file=outputdevice) print(';', file=outputdevice) print(' if (valueFromConfig == ' + newValueVariable + ') return false;', file=outputdevice) if 'writeEntry' in setting: print(' d->writeEntry' + stem + '(configGroup, QStringLiteral("' + stem + '"), ' + newValueVariable + ');', file=outputdevice) else: print(' configGroup.writeEntry(QStringLiteral("' + stem + '"), ', end="", file=outputdevice) if typeInConfig != type: print('static_cast<' + typeInConfig + '>(', end="", file=outputdevice) print(newValueVariable, end="", file=outputdevice) if typeInConfig != type: print(')', end="", file=outputdevice) print(', KConfig::Notify);', file=outputdevice) print(' d->config->sync();', file=outputdevice) # NotificationHub::publishEvent(notificationEventId); print(' return true;', file=outputdevice) print('#else // HAVE_KF5', file=outputdevice) print(' Q_UNUSED(newValue);', file=outputdevice) print(' return true;', file=outputdevice) print('#endif // HAVE_KF5', file=outputdevice) print("}", file=outputdevice) jsondata = {} with open("preferences.json") as jsonfile: jsondata = json.load(jsonfile) headerincludes = jsondata['headerincludes'] \ if 'headerincludes' in jsondata else {} implementationincludes = jsondata['implementationincludes'] \ if 'implementationincludes' in jsondata else {} enums = jsondata['enums'] \ if 'enums' in jsondata else {} settings = jsondata['settings'] \ if 'settings' in jsondata else {} with open("/tmp/preferences.h", "w") as headerfile: print_header(headerincludes, implementationincludes, enums, settings, outputdevice=headerfile) with open("/tmp/preferences.cpp", "w") as implementationfile: print_implementation(headerincludes, implementationincludes, enums, settings, outputdevice=implementationfile) diff --git a/src/global/preferences.cpp b/src/global/preferences.cpp index 6e712153..ef49d364 100644 --- a/src/global/preferences.cpp +++ b/src/global/preferences.cpp @@ -1,1255 +1,1255 @@ /*************************************************************************** * Copyright (C) 2004-2019 by Thomas Fischer * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, see . * ***************************************************************************/ /// This file has been automatically generated using the script 'preferences-generator.py' /// based on configuration data from file 'preferences.json'. If there are any problems or /// bugs, you need to fix those two files and re-generated both 'preferences.h' and /// 'preferences.cpp'. Manual changes in this file will be overwritten the next time the /// script will be run. You have been warned. #include "preferences.h" #include #ifdef HAVE_KF5 #include #include #include #include #else // HAVE_KF5 #define i18n(text) QStringLiteral(text) #define i18nc(comment,text) QStringLiteral(text) #endif // HAVE_KF5 #ifdef HAVE_KF5 #include "notificationhub.h" #endif // HAVE_KF5 #include #include class Preferences::Private { public: #ifdef HAVE_KF5 KSharedConfigPtr config; KConfigWatcher::Ptr watcher; bool dirtyFlagBibliographySystem; Preferences::BibliographySystem cachedBibliographySystem; bool dirtyFlagPersonNameFormat; QString cachedPersonNameFormat; bool dirtyFlagCopyReferenceCommand; QString cachedCopyReferenceCommand; bool dirtyFlagPageSize; QPageSize::PageSizeId cachedPageSize; bool dirtyFlagBackupScope; Preferences::BackupScope cachedBackupScope; bool dirtyFlagNumberOfBackups; int cachedNumberOfBackups; bool dirtyFlagIdSuggestionFormatStrings; QStringList cachedIdSuggestionFormatStrings; bool dirtyFlagActiveIdSuggestionFormatString; QString cachedActiveIdSuggestionFormatString; bool dirtyFlagLyXUseAutomaticPipeDetection; bool cachedLyXUseAutomaticPipeDetection; bool dirtyFlagLyXPipePath; QString cachedLyXPipePath; bool dirtyFlagBibTeXEncoding; QString cachedBibTeXEncoding; bool dirtyFlagBibTeXStringDelimiter; QString cachedBibTeXStringDelimiter; bool dirtyFlagBibTeXQuoteComment; Preferences::QuoteComment cachedBibTeXQuoteComment; bool dirtyFlagBibTeXKeywordCasing; KBibTeX::Casing cachedBibTeXKeywordCasing; bool dirtyFlagBibTeXProtectCasing; bool cachedBibTeXProtectCasing; bool dirtyFlagBibTeXListSeparator; QString cachedBibTeXListSeparator; bool dirtyFlagLaTeXBabelLanguage; QString cachedLaTeXBabelLanguage; bool dirtyFlagBibTeXBibliographyStyle; QString cachedBibTeXBibliographyStyle; bool dirtyFlagFileViewDoubleClickAction; Preferences::FileViewDoubleClickAction cachedFileViewDoubleClickAction; bool dirtyFlagColorCodes; QVector> cachedColorCodes; #endif // HAVE_KF5 Private(Preferences *) { #ifdef HAVE_KF5 config = KSharedConfig::openConfig(QStringLiteral("kbibtexrc")); watcher = KConfigWatcher::create(config); dirtyFlagBibliographySystem = true; cachedBibliographySystem = Preferences::defaultBibliographySystem; dirtyFlagPersonNameFormat = true; cachedPersonNameFormat = Preferences::defaultPersonNameFormat; dirtyFlagCopyReferenceCommand = true; cachedCopyReferenceCommand = Preferences::defaultCopyReferenceCommand; dirtyFlagPageSize = true; cachedPageSize = Preferences::defaultPageSize; dirtyFlagBackupScope = true; cachedBackupScope = Preferences::defaultBackupScope; dirtyFlagNumberOfBackups = true; cachedNumberOfBackups = Preferences::defaultNumberOfBackups; dirtyFlagIdSuggestionFormatStrings = true; cachedIdSuggestionFormatStrings = Preferences::defaultIdSuggestionFormatStrings; dirtyFlagActiveIdSuggestionFormatString = true; cachedActiveIdSuggestionFormatString = Preferences::defaultActiveIdSuggestionFormatString; dirtyFlagLyXUseAutomaticPipeDetection = true; cachedLyXUseAutomaticPipeDetection = Preferences::defaultLyXUseAutomaticPipeDetection; dirtyFlagLyXPipePath = true; cachedLyXPipePath = Preferences::defaultLyXPipePath; dirtyFlagBibTeXEncoding = true; cachedBibTeXEncoding = Preferences::defaultBibTeXEncoding; dirtyFlagBibTeXStringDelimiter = true; cachedBibTeXStringDelimiter = Preferences::defaultBibTeXStringDelimiter; dirtyFlagBibTeXQuoteComment = true; cachedBibTeXQuoteComment = Preferences::defaultBibTeXQuoteComment; dirtyFlagBibTeXKeywordCasing = true; cachedBibTeXKeywordCasing = Preferences::defaultBibTeXKeywordCasing; dirtyFlagBibTeXProtectCasing = true; cachedBibTeXProtectCasing = Preferences::defaultBibTeXProtectCasing; dirtyFlagBibTeXListSeparator = true; cachedBibTeXListSeparator = Preferences::defaultBibTeXListSeparator; dirtyFlagLaTeXBabelLanguage = true; cachedLaTeXBabelLanguage = Preferences::defaultLaTeXBabelLanguage; dirtyFlagBibTeXBibliographyStyle = true; cachedBibTeXBibliographyStyle = Preferences::defaultBibTeXBibliographyStyle; dirtyFlagFileViewDoubleClickAction = true; cachedFileViewDoubleClickAction = Preferences::defaultFileViewDoubleClickAction; dirtyFlagColorCodes = true; cachedColorCodes = Preferences::defaultColorCodes; #endif // HAVE_KF5 } #ifdef HAVE_KF5 inline bool validateValueForBibliographySystem(const Preferences::BibliographySystem valueToBeChecked) { for (QVector>::ConstIterator it = Preferences::availableBibliographySystems.constBegin(); it != Preferences::availableBibliographySystems.constEnd(); ++it) if (it->first == valueToBeChecked) return true; return false; } inline bool validateValueForPersonNameFormat(const QString &valueToBeChecked) { return valueToBeChecked.contains(QStringLiteral("%f")) && valueToBeChecked.contains(QStringLiteral("%l")) && valueToBeChecked.contains(QStringLiteral("%s")); } inline bool validateValueForCopyReferenceCommand(const QString &valueToBeChecked) { return Preferences::availableCopyReferenceCommands.contains(valueToBeChecked); } inline bool validateValueForPageSize(const QPageSize::PageSizeId valueToBeChecked) { for (QVector>::ConstIterator it = Preferences::availablePageSizes.constBegin(); it != Preferences::availablePageSizes.constEnd(); ++it) if (it->first == valueToBeChecked) return true; return false; } inline bool validateValueForBackupScope(const Preferences::BackupScope valueToBeChecked) { for (QVector>::ConstIterator it = Preferences::availableBackupScopes.constBegin(); it != Preferences::availableBackupScopes.constEnd(); ++it) if (it->first == valueToBeChecked) return true; return false; } inline bool validateValueForNumberOfBackups(const int valueToBeChecked) { return valueToBeChecked >= 0; } inline bool validateValueForIdSuggestionFormatStrings(const QStringList &valueToBeChecked) { return !valueToBeChecked.isEmpty() && (valueToBeChecked.front().contains(QLatin1Char('A')) || valueToBeChecked.front().contains(QLatin1Char('a')) || valueToBeChecked.front().contains(QLatin1Char('y')) || valueToBeChecked.front().contains(QLatin1Char('Y')) || valueToBeChecked.front().contains(QLatin1Char('T'))); } inline bool validateValueForActiveIdSuggestionFormatString(const QString &valueToBeChecked) { Q_UNUSED(valueToBeChecked) return true; } inline bool validateValueForLyXUseAutomaticPipeDetection(const bool valueToBeChecked) { Q_UNUSED(valueToBeChecked) return true; } inline bool validateValueForLyXPipePath(const QString &valueToBeChecked) { return valueToBeChecked.startsWith(QLatin1Char('/')); } inline bool validateValueForBibTeXEncoding(const QString &valueToBeChecked) { return Preferences::availableBibTeXEncodings.contains(valueToBeChecked); } inline bool validateValueForBibTeXStringDelimiter(const QString &valueToBeChecked) { return Preferences::availableBibTeXStringDelimiters.contains(valueToBeChecked); } inline bool validateValueForBibTeXQuoteComment(const Preferences::QuoteComment valueToBeChecked) { for (QVector>::ConstIterator it = Preferences::availableBibTeXQuoteComments.constBegin(); it != Preferences::availableBibTeXQuoteComments.constEnd(); ++it) if (it->first == valueToBeChecked) return true; return false; } inline bool validateValueForBibTeXKeywordCasing(const KBibTeX::Casing valueToBeChecked) { for (QVector>::ConstIterator it = Preferences::availableBibTeXKeywordCasings.constBegin(); it != Preferences::availableBibTeXKeywordCasings.constEnd(); ++it) if (it->first == valueToBeChecked) return true; return false; } inline bool validateValueForBibTeXProtectCasing(const bool valueToBeChecked) { Q_UNUSED(valueToBeChecked) return true; } inline bool validateValueForBibTeXListSeparator(const QString &valueToBeChecked) { return Preferences::availableBibTeXListSeparators.contains(valueToBeChecked); } inline bool validateValueForLaTeXBabelLanguage(const QString &valueToBeChecked) { return !valueToBeChecked.isEmpty(); } inline bool validateValueForBibTeXBibliographyStyle(const QString &valueToBeChecked) { return !valueToBeChecked.isEmpty(); } inline bool validateValueForFileViewDoubleClickAction(const Preferences::FileViewDoubleClickAction valueToBeChecked) { for (QVector>::ConstIterator it = Preferences::availableFileViewDoubleClickActions.constBegin(); it != Preferences::availableFileViewDoubleClickActions.constEnd(); ++it) if (it->first == valueToBeChecked) return true; return false; } inline bool validateValueForColorCodes(const QVector> &valueToBeChecked) { static const QColor white(Qt::white), black(Qt::black); for (QVector>::ConstIterator it = valueToBeChecked.constBegin(); it != valueToBeChecked.constEnd(); ++it) if (it->first == white || it->first == black || it->second.isEmpty()) return false; return true; } QVector> readEntryColorCodes(const KConfigGroup &configGroup, const QString &key) const { const QString rawEntry = configGroup.readEntry(key, QString()); if (rawEntry.isEmpty()) return Preferences::defaultColorCodes; const QStringList pairs = rawEntry.split(QStringLiteral("\0\0"), QString::SkipEmptyParts); if (pairs.isEmpty()) return Preferences::defaultColorCodes; QVector> result; for (const QString &pair : pairs) { const QStringList colorLabelPair = pair.split(QStringLiteral("\0"), QString::SkipEmptyParts); if (colorLabelPair.length() != 2) return Preferences::defaultColorCodes; result.append(qMakePair(QColor(colorLabelPair[0]), colorLabelPair[1])); } return result; } void writeEntryColorCodes(KConfigGroup &configGroup, const QString &key, const QVector> &valueToBeWritten) { QString rawEntry; for (QVector>::ConstIterator it = valueToBeWritten.constBegin(); it != valueToBeWritten.constEnd(); ++it) { if (!rawEntry.isEmpty()) rawEntry.append(QStringLiteral("\0\0")); rawEntry = rawEntry.append(it->first.name(QColor::HexRgb)).append(QStringLiteral("\0")).append(it->second); } configGroup.writeEntry(key, rawEntry, KConfig::Notify); } #endif // HAVE_KF5 }; Preferences &Preferences::instance() { static Preferences singleton; return singleton; } Preferences::Preferences() : d(new Preferences::Private(this)) { #ifdef HAVE_KF5 QObject::connect(d->watcher.data(), &KConfigWatcher::configChanged, QCoreApplication::instance(), [this](const KConfigGroup &group, const QByteArrayList &names) { QSet eventsToPublish; if (group.name() == QStringLiteral("General") && names.contains("BibliographySystem")) { /// Configuration setting BibliographySystem got changed by another Preferences instance"; d->dirtyFlagBibliographySystem = true; eventsToPublish.insert(NotificationHub::EventBibliographySystemChanged); } if (group.name() == QStringLiteral("General") && names.contains("PersonNameFormat")) { /// Configuration setting PersonNameFormat got changed by another Preferences instance"; d->dirtyFlagPersonNameFormat = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("LaTeX") && names.contains("CopyReferenceCommand")) { /// Configuration setting CopyReferenceCommand got changed by another Preferences instance"; d->dirtyFlagCopyReferenceCommand = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("General") && names.contains("PageSize")) { /// Configuration setting PageSize got changed by another Preferences instance"; d->dirtyFlagPageSize = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("InputOutput") && names.contains("BackupScope")) { /// Configuration setting BackupScope got changed by another Preferences instance"; d->dirtyFlagBackupScope = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("InputOutput") && names.contains("NumberOfBackups")) { /// Configuration setting NumberOfBackups got changed by another Preferences instance"; d->dirtyFlagNumberOfBackups = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("IdSuggestions") && names.contains("IdSuggestionFormatStrings")) { /// Configuration setting IdSuggestionFormatStrings got changed by another Preferences instance"; d->dirtyFlagIdSuggestionFormatStrings = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("IdSuggestions") && names.contains("ActiveIdSuggestionFormatString")) { /// Configuration setting ActiveIdSuggestionFormatString got changed by another Preferences instance"; d->dirtyFlagActiveIdSuggestionFormatString = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("LyX") && names.contains("LyXUseAutomaticPipeDetection")) { /// Configuration setting LyXUseAutomaticPipeDetection got changed by another Preferences instance"; d->dirtyFlagLyXUseAutomaticPipeDetection = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("LyX") && names.contains("LyXPipePath")) { /// Configuration setting LyXPipePath got changed by another Preferences instance"; d->dirtyFlagLyXPipePath = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("FileExporterBibTeX") && names.contains("BibTeXEncoding")) { /// Configuration setting BibTeXEncoding got changed by another Preferences instance"; d->dirtyFlagBibTeXEncoding = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("FileExporterBibTeX") && names.contains("BibTeXStringDelimiter")) { /// Configuration setting BibTeXStringDelimiter got changed by another Preferences instance"; d->dirtyFlagBibTeXStringDelimiter = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("FileExporterBibTeX") && names.contains("BibTeXQuoteComment")) { /// Configuration setting BibTeXQuoteComment got changed by another Preferences instance"; d->dirtyFlagBibTeXQuoteComment = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("FileExporterBibTeX") && names.contains("BibTeXKeywordCasing")) { /// Configuration setting BibTeXKeywordCasing got changed by another Preferences instance"; d->dirtyFlagBibTeXKeywordCasing = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("FileExporterBibTeX") && names.contains("BibTeXProtectCasing")) { /// Configuration setting BibTeXProtectCasing got changed by another Preferences instance"; d->dirtyFlagBibTeXProtectCasing = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("FileExporterBibTeX") && names.contains("BibTeXListSeparator")) { /// Configuration setting BibTeXListSeparator got changed by another Preferences instance"; d->dirtyFlagBibTeXListSeparator = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("FileExporterLaTeXbased") && names.contains("LaTeXBabelLanguage")) { /// Configuration setting LaTeXBabelLanguage got changed by another Preferences instance"; d->dirtyFlagLaTeXBabelLanguage = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("FileExporterLaTeXbased") && names.contains("BibTeXBibliographyStyle")) { /// Configuration setting BibTeXBibliographyStyle got changed by another Preferences instance"; d->dirtyFlagBibTeXBibliographyStyle = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("User Interface") && names.contains("FileViewDoubleClickAction")) { /// Configuration setting FileViewDoubleClickAction got changed by another Preferences instance"; d->dirtyFlagFileViewDoubleClickAction = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } if (group.name() == QStringLiteral("Color Labels") && names.contains("ColorCodes")) { /// Configuration setting ColorCodes got changed by another Preferences instance"; d->dirtyFlagColorCodes = true; eventsToPublish.insert(NotificationHub::EventConfigurationChanged); } for (const int eventId : eventsToPublish) NotificationHub::publishEvent(eventId); }); #endif // HAVE_KF5 } Preferences::~Preferences() { delete d; } const QVector> Preferences::availableBibliographySystems {{Preferences::BibTeX, i18n("BibTeX")}, {Preferences::BibLaTeX, i18n("BibLaTeX")}}; const Preferences::BibliographySystem Preferences::defaultBibliographySystem = Preferences::availableBibliographySystems.front().first; Preferences::BibliographySystem Preferences::bibliographySystem() { #ifdef HAVE_KF5 if (d->dirtyFlagBibliographySystem) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("General")); const Preferences::BibliographySystem valueFromConfig = static_cast(configGroup.readEntry(QStringLiteral("BibliographySystem"), static_cast(Preferences::defaultBibliographySystem))); if (d->validateValueForBibliographySystem(valueFromConfig)) { d->cachedBibliographySystem = valueFromConfig; d->dirtyFlagBibliographySystem = false; } else { /// Configuration file setting for BibliographySystem has an invalid value, using default as fallback setBibliographySystem(Preferences::defaultBibliographySystem); } } return d->cachedBibliographySystem; #else // HAVE_KF5 return defaultBibliographySystem; #endif // HAVE_KF5 } bool Preferences::setBibliographySystem(const Preferences::BibliographySystem newValue) { #ifdef HAVE_KF5 if (!d->validateValueForBibliographySystem(newValue)) return false; d->dirtyFlagBibliographySystem = false; d->cachedBibliographySystem = newValue; static KConfigGroup configGroup(d->config, QStringLiteral("General")); const Preferences::BibliographySystem valueFromConfig = static_cast(configGroup.readEntry(QStringLiteral("BibliographySystem"), static_cast(Preferences::defaultBibliographySystem))); if (valueFromConfig == newValue) return false; configGroup.writeEntry(QStringLiteral("BibliographySystem"), static_cast(newValue), KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const QString Preferences::personNameFormatLastFirst = QStringLiteral("<%l><, %s><, %f>"); const QString Preferences::personNameFormatFirstLast = QStringLiteral("<%f ><%l>< %s>"); const QString Preferences::defaultPersonNameFormat = Preferences::personNameFormatLastFirst; const QString &Preferences::personNameFormat() { #ifdef HAVE_KF5 if (d->dirtyFlagPersonNameFormat) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("General")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("PersonNameFormat"), Preferences::defaultPersonNameFormat); if (d->validateValueForPersonNameFormat(valueFromConfig)) { d->cachedPersonNameFormat = valueFromConfig; d->dirtyFlagPersonNameFormat = false; } else { /// Configuration file setting for PersonNameFormat has an invalid value, using default as fallback setPersonNameFormat(Preferences::defaultPersonNameFormat); } } return d->cachedPersonNameFormat; #else // HAVE_KF5 return defaultPersonNameFormat; #endif // HAVE_KF5 } bool Preferences::setPersonNameFormat(const QString &newValue) { #ifdef HAVE_KF5 if (!d->validateValueForPersonNameFormat(newValue)) return false; d->dirtyFlagPersonNameFormat = false; d->cachedPersonNameFormat = newValue; static KConfigGroup configGroup(d->config, QStringLiteral("General")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("PersonNameFormat"), Preferences::defaultPersonNameFormat); if (valueFromConfig == newValue) return false; configGroup.writeEntry(QStringLiteral("PersonNameFormat"), newValue, KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const QStringList Preferences::availableCopyReferenceCommands {QStringLiteral("cite"), QStringLiteral("citealt"), QStringLiteral("citeauthor"), QStringLiteral("citeauthor*"), QStringLiteral("citeyear"), QStringLiteral("citeyearpar"), QStringLiteral("shortcite"), QStringLiteral("citet"), QStringLiteral("citet*"), QStringLiteral("citep"), QStringLiteral("citep*")}; const QString Preferences::defaultCopyReferenceCommand = Preferences::availableCopyReferenceCommands.front(); const QString &Preferences::copyReferenceCommand() { #ifdef HAVE_KF5 if (d->dirtyFlagCopyReferenceCommand) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("LaTeX")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("CopyReferenceCommand"), Preferences::defaultCopyReferenceCommand); if (d->validateValueForCopyReferenceCommand(valueFromConfig)) { d->cachedCopyReferenceCommand = valueFromConfig; d->dirtyFlagCopyReferenceCommand = false; } else { /// Configuration file setting for CopyReferenceCommand has an invalid value, using default as fallback setCopyReferenceCommand(Preferences::defaultCopyReferenceCommand); } } return d->cachedCopyReferenceCommand; #else // HAVE_KF5 return defaultCopyReferenceCommand; #endif // HAVE_KF5 } bool Preferences::setCopyReferenceCommand(const QString &newValue) { #ifdef HAVE_KF5 QString sanitizedNewValue = newValue; const QString lowerSanitizedNewValue = sanitizedNewValue.toLower(); for (const QString &knownCopyReferenceCommand : availableCopyReferenceCommands) if (knownCopyReferenceCommand.toLower() == lowerSanitizedNewValue) { sanitizedNewValue = knownCopyReferenceCommand; break; } if (!d->validateValueForCopyReferenceCommand(sanitizedNewValue)) return false; d->dirtyFlagCopyReferenceCommand = false; d->cachedCopyReferenceCommand = sanitizedNewValue; static KConfigGroup configGroup(d->config, QStringLiteral("LaTeX")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("CopyReferenceCommand"), Preferences::defaultCopyReferenceCommand); if (valueFromConfig == sanitizedNewValue) return false; configGroup.writeEntry(QStringLiteral("CopyReferenceCommand"), sanitizedNewValue, KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const QVector> Preferences::availablePageSizes {{QPageSize::A4, QStringLiteral("a4paper")}, {QPageSize::Letter, QStringLiteral("letter")}, {QPageSize::Legal, QStringLiteral("legal")}}; const QPageSize::PageSizeId Preferences::defaultPageSize = Preferences::availablePageSizes.front().first; QPageSize::PageSizeId Preferences::pageSize() { #ifdef HAVE_KF5 if (d->dirtyFlagPageSize) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("General")); const QPageSize::PageSizeId valueFromConfig = static_cast(configGroup.readEntry(QStringLiteral("PageSize"), static_cast(Preferences::defaultPageSize))); if (d->validateValueForPageSize(valueFromConfig)) { d->cachedPageSize = valueFromConfig; d->dirtyFlagPageSize = false; } else { /// Configuration file setting for PageSize has an invalid value, using default as fallback setPageSize(Preferences::defaultPageSize); } } return d->cachedPageSize; #else // HAVE_KF5 return defaultPageSize; #endif // HAVE_KF5 } bool Preferences::setPageSize(const QPageSize::PageSizeId newValue) { #ifdef HAVE_KF5 if (!d->validateValueForPageSize(newValue)) return false; d->dirtyFlagPageSize = false; d->cachedPageSize = newValue; static KConfigGroup configGroup(d->config, QStringLiteral("General")); const QPageSize::PageSizeId valueFromConfig = static_cast(configGroup.readEntry(QStringLiteral("PageSize"), static_cast(Preferences::defaultPageSize))); if (valueFromConfig == newValue) return false; configGroup.writeEntry(QStringLiteral("PageSize"), static_cast(newValue), KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const QVector> Preferences::availableBackupScopes {{Preferences::NoBackup, i18n("No backups")}, {Preferences::LocalOnly, i18n("Local files only")}, {Preferences::BothLocalAndRemote, i18n("Both local and remote files")}}; const Preferences::BackupScope Preferences::defaultBackupScope = Preferences::availableBackupScopes.front().first; Preferences::BackupScope Preferences::backupScope() { #ifdef HAVE_KF5 if (d->dirtyFlagBackupScope) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("InputOutput")); const Preferences::BackupScope valueFromConfig = static_cast(configGroup.readEntry(QStringLiteral("BackupScope"), static_cast(Preferences::defaultBackupScope))); if (d->validateValueForBackupScope(valueFromConfig)) { d->cachedBackupScope = valueFromConfig; d->dirtyFlagBackupScope = false; } else { /// Configuration file setting for BackupScope has an invalid value, using default as fallback setBackupScope(Preferences::defaultBackupScope); } } return d->cachedBackupScope; #else // HAVE_KF5 return defaultBackupScope; #endif // HAVE_KF5 } bool Preferences::setBackupScope(const Preferences::BackupScope newValue) { #ifdef HAVE_KF5 if (!d->validateValueForBackupScope(newValue)) return false; d->dirtyFlagBackupScope = false; d->cachedBackupScope = newValue; static KConfigGroup configGroup(d->config, QStringLiteral("InputOutput")); const Preferences::BackupScope valueFromConfig = static_cast(configGroup.readEntry(QStringLiteral("BackupScope"), static_cast(Preferences::defaultBackupScope))); if (valueFromConfig == newValue) return false; configGroup.writeEntry(QStringLiteral("BackupScope"), static_cast(newValue), KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const int Preferences::defaultNumberOfBackups = 5; int Preferences::numberOfBackups() { #ifdef HAVE_KF5 if (d->dirtyFlagNumberOfBackups) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("InputOutput")); const int valueFromConfig = configGroup.readEntry(QStringLiteral("NumberOfBackups"), Preferences::defaultNumberOfBackups); if (d->validateValueForNumberOfBackups(valueFromConfig)) { d->cachedNumberOfBackups = valueFromConfig; d->dirtyFlagNumberOfBackups = false; } else { /// Configuration file setting for NumberOfBackups has an invalid value, using default as fallback setNumberOfBackups(Preferences::defaultNumberOfBackups); } } return d->cachedNumberOfBackups; #else // HAVE_KF5 return defaultNumberOfBackups; #endif // HAVE_KF5 } bool Preferences::setNumberOfBackups(const int newValue) { #ifdef HAVE_KF5 if (!d->validateValueForNumberOfBackups(newValue)) return false; d->dirtyFlagNumberOfBackups = false; d->cachedNumberOfBackups = newValue; static KConfigGroup configGroup(d->config, QStringLiteral("InputOutput")); const int valueFromConfig = configGroup.readEntry(QStringLiteral("NumberOfBackups"), Preferences::defaultNumberOfBackups); if (valueFromConfig == newValue) return false; configGroup.writeEntry(QStringLiteral("NumberOfBackups"), newValue, KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const QStringList Preferences::defaultIdSuggestionFormatStrings {QStringLiteral("A"), QStringLiteral("A2|y"), QStringLiteral("A3|y"), QStringLiteral("A4|y|\":|T5"), QStringLiteral("al|\":|T"), QStringLiteral("al|y"), QStringLiteral("al|Y"), QStringLiteral("Al\"-|\"-|y"), QStringLiteral("Al\"+|Y"), QStringLiteral("al|y|T"), QStringLiteral("al|Y|T3"), QStringLiteral("al|Y|T3l"), QStringLiteral("a|\":|Y|\":|T1"), QStringLiteral("a|y"), QStringLiteral("A|\":|Y")}; const QStringList &Preferences::idSuggestionFormatStrings() { #ifdef HAVE_KF5 if (d->dirtyFlagIdSuggestionFormatStrings) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("IdSuggestions")); const QStringList valueFromConfig = configGroup.readEntry(QStringLiteral("IdSuggestionFormatStrings"), Preferences::defaultIdSuggestionFormatStrings); if (d->validateValueForIdSuggestionFormatStrings(valueFromConfig)) { d->cachedIdSuggestionFormatStrings = valueFromConfig; d->dirtyFlagIdSuggestionFormatStrings = false; } else { /// Configuration file setting for IdSuggestionFormatStrings has an invalid value, using default as fallback setIdSuggestionFormatStrings(Preferences::defaultIdSuggestionFormatStrings); } } return d->cachedIdSuggestionFormatStrings; #else // HAVE_KF5 return defaultIdSuggestionFormatStrings; #endif // HAVE_KF5 } bool Preferences::setIdSuggestionFormatStrings(const QStringList &newValue) { #ifdef HAVE_KF5 if (!d->validateValueForIdSuggestionFormatStrings(newValue)) return false; d->dirtyFlagIdSuggestionFormatStrings = false; d->cachedIdSuggestionFormatStrings = newValue; static KConfigGroup configGroup(d->config, QStringLiteral("IdSuggestions")); const QStringList valueFromConfig = configGroup.readEntry(QStringLiteral("IdSuggestionFormatStrings"), Preferences::defaultIdSuggestionFormatStrings); if (valueFromConfig == newValue) return false; configGroup.writeEntry(QStringLiteral("IdSuggestionFormatStrings"), newValue, KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const QString Preferences::defaultActiveIdSuggestionFormatString {}; const QString &Preferences::activeIdSuggestionFormatString() { #ifdef HAVE_KF5 if (d->dirtyFlagActiveIdSuggestionFormatString) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("IdSuggestions")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("ActiveIdSuggestionFormatString"), Preferences::defaultActiveIdSuggestionFormatString); if (d->validateValueForActiveIdSuggestionFormatString(valueFromConfig)) { d->cachedActiveIdSuggestionFormatString = valueFromConfig; d->dirtyFlagActiveIdSuggestionFormatString = false; } else { /// Configuration file setting for ActiveIdSuggestionFormatString has an invalid value, using default as fallback setActiveIdSuggestionFormatString(Preferences::defaultActiveIdSuggestionFormatString); } } return d->cachedActiveIdSuggestionFormatString; #else // HAVE_KF5 return defaultActiveIdSuggestionFormatString; #endif // HAVE_KF5 } bool Preferences::setActiveIdSuggestionFormatString(const QString &newValue) { #ifdef HAVE_KF5 if (!d->validateValueForActiveIdSuggestionFormatString(newValue)) return false; d->dirtyFlagActiveIdSuggestionFormatString = false; d->cachedActiveIdSuggestionFormatString = newValue; static KConfigGroup configGroup(d->config, QStringLiteral("IdSuggestions")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("ActiveIdSuggestionFormatString"), Preferences::defaultActiveIdSuggestionFormatString); if (valueFromConfig == newValue) return false; configGroup.writeEntry(QStringLiteral("ActiveIdSuggestionFormatString"), newValue, KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const bool Preferences::defaultLyXUseAutomaticPipeDetection = true; bool Preferences::lyXUseAutomaticPipeDetection() { #ifdef HAVE_KF5 if (d->dirtyFlagLyXUseAutomaticPipeDetection) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("LyX")); const bool valueFromConfig = configGroup.readEntry(QStringLiteral("LyXUseAutomaticPipeDetection"), Preferences::defaultLyXUseAutomaticPipeDetection); if (d->validateValueForLyXUseAutomaticPipeDetection(valueFromConfig)) { d->cachedLyXUseAutomaticPipeDetection = valueFromConfig; d->dirtyFlagLyXUseAutomaticPipeDetection = false; } else { /// Configuration file setting for LyXUseAutomaticPipeDetection has an invalid value, using default as fallback setLyXUseAutomaticPipeDetection(Preferences::defaultLyXUseAutomaticPipeDetection); } } return d->cachedLyXUseAutomaticPipeDetection; #else // HAVE_KF5 return defaultLyXUseAutomaticPipeDetection; #endif // HAVE_KF5 } bool Preferences::setLyXUseAutomaticPipeDetection(const bool newValue) { #ifdef HAVE_KF5 if (!d->validateValueForLyXUseAutomaticPipeDetection(newValue)) return false; d->dirtyFlagLyXUseAutomaticPipeDetection = false; d->cachedLyXUseAutomaticPipeDetection = newValue; static KConfigGroup configGroup(d->config, QStringLiteral("LyX")); const bool valueFromConfig = configGroup.readEntry(QStringLiteral("LyXUseAutomaticPipeDetection"), Preferences::defaultLyXUseAutomaticPipeDetection); if (valueFromConfig == newValue) return false; configGroup.writeEntry(QStringLiteral("LyXUseAutomaticPipeDetection"), newValue, KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const QString Preferences::defaultLyXPipePath = QDir::homePath() + QStringLiteral("/.lyxpipe.in"); const QString &Preferences::lyXPipePath() { #ifdef HAVE_KF5 if (d->dirtyFlagLyXPipePath) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("LyX")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("LyXPipePath"), Preferences::defaultLyXPipePath); if (d->validateValueForLyXPipePath(valueFromConfig)) { d->cachedLyXPipePath = valueFromConfig; d->dirtyFlagLyXPipePath = false; } else { /// Configuration file setting for LyXPipePath has an invalid value, using default as fallback setLyXPipePath(Preferences::defaultLyXPipePath); } } return d->cachedLyXPipePath; #else // HAVE_KF5 return defaultLyXPipePath; #endif // HAVE_KF5 } bool Preferences::setLyXPipePath(const QString &newValue) { #ifdef HAVE_KF5 QString sanitizedNewValue = newValue; if (sanitizedNewValue.endsWith(QStringLiteral(".out"))) sanitizedNewValue = sanitizedNewValue.left(sanitizedNewValue.length() - 4); if (!sanitizedNewValue.endsWith(QStringLiteral(".in"))) sanitizedNewValue = sanitizedNewValue.append(QStringLiteral(".in")); if (!d->validateValueForLyXPipePath(sanitizedNewValue)) return false; d->dirtyFlagLyXPipePath = false; d->cachedLyXPipePath = sanitizedNewValue; static KConfigGroup configGroup(d->config, QStringLiteral("LyX")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("LyXPipePath"), Preferences::defaultLyXPipePath); if (valueFromConfig == sanitizedNewValue) return false; configGroup.writeEntry(QStringLiteral("LyXPipePath"), sanitizedNewValue, KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const QStringList Preferences::availableBibTeXEncodings {QStringLiteral("LaTeX"), QStringLiteral("US-ASCII"), QStringLiteral("ISO-8859-1"), QStringLiteral("ISO-8859-2"), QStringLiteral("ISO-8859-3"), QStringLiteral("ISO-8859-4"), QStringLiteral("ISO-8859-5"), QStringLiteral("ISO-8859-6"), QStringLiteral("ISO-8859-7"), QStringLiteral("ISO-8859-8"), QStringLiteral("ISO-8859-9"), QStringLiteral("ISO-8859-10"), QStringLiteral("ISO-8859-13"), QStringLiteral("ISO-8859-14"), QStringLiteral("ISO-8859-15"), QStringLiteral("ISO-8859-16"), QStringLiteral("UTF-8"), QStringLiteral("UTF-16"), QStringLiteral("UTF-16BE"), QStringLiteral("UTF-16LE"), QStringLiteral("UTF-32"), QStringLiteral("UTF-32BE"), QStringLiteral("UTF-32LE"), QStringLiteral("KOI8-R"), QStringLiteral("KOI8-U"), QStringLiteral("Big5"), QStringLiteral("Big5-HKSCS"), QStringLiteral("GB18030"), QStringLiteral("EUC-JP"), QStringLiteral("EUC-KR"), QStringLiteral("ISO 2022-JP"), QStringLiteral("Shift-JIS"), QStringLiteral("Windows-1250"), QStringLiteral("Windows-1251"), QStringLiteral("Windows-1252"), QStringLiteral("Windows-1253"), QStringLiteral("Windows-1254"), QStringLiteral("Windows-1255"), QStringLiteral("Windows-1256"), QStringLiteral("Windows-1257"), QStringLiteral("Windows-1258")}; -const QString Preferences::defaultBibTeXEncoding = Preferences::availableBibTeXEncodings.front(); +const QString Preferences::defaultBibTeXEncoding = QStringLiteral("UTF-8"); const QString &Preferences::bibTeXEncoding() { #ifdef HAVE_KF5 if (d->dirtyFlagBibTeXEncoding) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("FileExporterBibTeX")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("BibTeXEncoding"), Preferences::defaultBibTeXEncoding); if (d->validateValueForBibTeXEncoding(valueFromConfig)) { d->cachedBibTeXEncoding = valueFromConfig; d->dirtyFlagBibTeXEncoding = false; } else { /// Configuration file setting for BibTeXEncoding has an invalid value, using default as fallback setBibTeXEncoding(Preferences::defaultBibTeXEncoding); } } return d->cachedBibTeXEncoding; #else // HAVE_KF5 return defaultBibTeXEncoding; #endif // HAVE_KF5 } bool Preferences::setBibTeXEncoding(const QString &newValue) { #ifdef HAVE_KF5 QString sanitizedNewValue = newValue; const QString lowerSanitizedNewValue = sanitizedNewValue.toLower(); for (const QString &knownBibTeXEncoding : availableBibTeXEncodings) if (knownBibTeXEncoding.toLower() == lowerSanitizedNewValue) { sanitizedNewValue = knownBibTeXEncoding; break; } if (!d->validateValueForBibTeXEncoding(sanitizedNewValue)) return false; d->dirtyFlagBibTeXEncoding = false; d->cachedBibTeXEncoding = sanitizedNewValue; static KConfigGroup configGroup(d->config, QStringLiteral("FileExporterBibTeX")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("BibTeXEncoding"), Preferences::defaultBibTeXEncoding); if (valueFromConfig == sanitizedNewValue) return false; configGroup.writeEntry(QStringLiteral("BibTeXEncoding"), sanitizedNewValue, KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const QStringList Preferences::availableBibTeXStringDelimiters {QStringLiteral("{}"), QStringLiteral("\"\""), QStringLiteral("()")}; const QString Preferences::defaultBibTeXStringDelimiter = Preferences::availableBibTeXStringDelimiters.front(); const QString &Preferences::bibTeXStringDelimiter() { #ifdef HAVE_KF5 if (d->dirtyFlagBibTeXStringDelimiter) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("FileExporterBibTeX")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("BibTeXStringDelimiter"), Preferences::defaultBibTeXStringDelimiter); if (d->validateValueForBibTeXStringDelimiter(valueFromConfig)) { d->cachedBibTeXStringDelimiter = valueFromConfig; d->dirtyFlagBibTeXStringDelimiter = false; } else { /// Configuration file setting for BibTeXStringDelimiter has an invalid value, using default as fallback setBibTeXStringDelimiter(Preferences::defaultBibTeXStringDelimiter); } } return d->cachedBibTeXStringDelimiter; #else // HAVE_KF5 return defaultBibTeXStringDelimiter; #endif // HAVE_KF5 } bool Preferences::setBibTeXStringDelimiter(const QString &newValue) { #ifdef HAVE_KF5 QString sanitizedNewValue = newValue; const QString lowerSanitizedNewValue = sanitizedNewValue.toLower(); for (const QString &knownBibTeXStringDelimiter : availableBibTeXStringDelimiters) if (knownBibTeXStringDelimiter.toLower() == lowerSanitizedNewValue) { sanitizedNewValue = knownBibTeXStringDelimiter; break; } if (!d->validateValueForBibTeXStringDelimiter(sanitizedNewValue)) return false; d->dirtyFlagBibTeXStringDelimiter = false; d->cachedBibTeXStringDelimiter = sanitizedNewValue; static KConfigGroup configGroup(d->config, QStringLiteral("FileExporterBibTeX")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("BibTeXStringDelimiter"), Preferences::defaultBibTeXStringDelimiter); if (valueFromConfig == sanitizedNewValue) return false; configGroup.writeEntry(QStringLiteral("BibTeXStringDelimiter"), sanitizedNewValue, KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const QVector> Preferences::availableBibTeXQuoteComments {{Preferences::qcNone, i18nc("Comment Quoting", "None")}, {Preferences::qcCommand, i18nc("Comment Quoting", "@comment{\342\200\246}")}, {Preferences::qcPercentSign, i18nc("Comment Quoting", "% \342\200\246")}}; const Preferences::QuoteComment Preferences::defaultBibTeXQuoteComment = Preferences::availableBibTeXQuoteComments.front().first; Preferences::QuoteComment Preferences::bibTeXQuoteComment() { #ifdef HAVE_KF5 if (d->dirtyFlagBibTeXQuoteComment) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("FileExporterBibTeX")); const Preferences::QuoteComment valueFromConfig = static_cast(configGroup.readEntry(QStringLiteral("BibTeXQuoteComment"), static_cast(Preferences::defaultBibTeXQuoteComment))); if (d->validateValueForBibTeXQuoteComment(valueFromConfig)) { d->cachedBibTeXQuoteComment = valueFromConfig; d->dirtyFlagBibTeXQuoteComment = false; } else { /// Configuration file setting for BibTeXQuoteComment has an invalid value, using default as fallback setBibTeXQuoteComment(Preferences::defaultBibTeXQuoteComment); } } return d->cachedBibTeXQuoteComment; #else // HAVE_KF5 return defaultBibTeXQuoteComment; #endif // HAVE_KF5 } bool Preferences::setBibTeXQuoteComment(const Preferences::QuoteComment newValue) { #ifdef HAVE_KF5 if (!d->validateValueForBibTeXQuoteComment(newValue)) return false; d->dirtyFlagBibTeXQuoteComment = false; d->cachedBibTeXQuoteComment = newValue; static KConfigGroup configGroup(d->config, QStringLiteral("FileExporterBibTeX")); const Preferences::QuoteComment valueFromConfig = static_cast(configGroup.readEntry(QStringLiteral("BibTeXQuoteComment"), static_cast(Preferences::defaultBibTeXQuoteComment))); if (valueFromConfig == newValue) return false; configGroup.writeEntry(QStringLiteral("BibTeXQuoteComment"), static_cast(newValue), KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const QVector> Preferences::availableBibTeXKeywordCasings {{KBibTeX::cLowerCase, i18nc("Casing of strings", "lowercase")}, {KBibTeX::cInitialCapital, i18nc("Casing of strings", "Initial capital")}, {KBibTeX::cUpperCamelCase, i18nc("Casing of strings", "UpperCamelCase")}, {KBibTeX::cLowerCamelCase, i18nc("Casing of strings", "lowerCamelCase")}, {KBibTeX::cUpperCase, i18nc("Casing of strings", "UPPERCASE")}}; const KBibTeX::Casing Preferences::defaultBibTeXKeywordCasing = Preferences::availableBibTeXKeywordCasings.front().first; KBibTeX::Casing Preferences::bibTeXKeywordCasing() { #ifdef HAVE_KF5 if (d->dirtyFlagBibTeXKeywordCasing) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("FileExporterBibTeX")); const KBibTeX::Casing valueFromConfig = static_cast(configGroup.readEntry(QStringLiteral("BibTeXKeywordCasing"), static_cast(Preferences::defaultBibTeXKeywordCasing))); if (d->validateValueForBibTeXKeywordCasing(valueFromConfig)) { d->cachedBibTeXKeywordCasing = valueFromConfig; d->dirtyFlagBibTeXKeywordCasing = false; } else { /// Configuration file setting for BibTeXKeywordCasing has an invalid value, using default as fallback setBibTeXKeywordCasing(Preferences::defaultBibTeXKeywordCasing); } } return d->cachedBibTeXKeywordCasing; #else // HAVE_KF5 return defaultBibTeXKeywordCasing; #endif // HAVE_KF5 } bool Preferences::setBibTeXKeywordCasing(const KBibTeX::Casing newValue) { #ifdef HAVE_KF5 if (!d->validateValueForBibTeXKeywordCasing(newValue)) return false; d->dirtyFlagBibTeXKeywordCasing = false; d->cachedBibTeXKeywordCasing = newValue; static KConfigGroup configGroup(d->config, QStringLiteral("FileExporterBibTeX")); const KBibTeX::Casing valueFromConfig = static_cast(configGroup.readEntry(QStringLiteral("BibTeXKeywordCasing"), static_cast(Preferences::defaultBibTeXKeywordCasing))); if (valueFromConfig == newValue) return false; configGroup.writeEntry(QStringLiteral("BibTeXKeywordCasing"), static_cast(newValue), KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const bool Preferences::defaultBibTeXProtectCasing = true; bool Preferences::bibTeXProtectCasing() { #ifdef HAVE_KF5 if (d->dirtyFlagBibTeXProtectCasing) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("FileExporterBibTeX")); const bool valueFromConfig = configGroup.readEntry(QStringLiteral("BibTeXProtectCasing"), Preferences::defaultBibTeXProtectCasing); if (d->validateValueForBibTeXProtectCasing(valueFromConfig)) { d->cachedBibTeXProtectCasing = valueFromConfig; d->dirtyFlagBibTeXProtectCasing = false; } else { /// Configuration file setting for BibTeXProtectCasing has an invalid value, using default as fallback setBibTeXProtectCasing(Preferences::defaultBibTeXProtectCasing); } } return d->cachedBibTeXProtectCasing; #else // HAVE_KF5 return defaultBibTeXProtectCasing; #endif // HAVE_KF5 } bool Preferences::setBibTeXProtectCasing(const bool newValue) { #ifdef HAVE_KF5 if (!d->validateValueForBibTeXProtectCasing(newValue)) return false; d->dirtyFlagBibTeXProtectCasing = false; d->cachedBibTeXProtectCasing = newValue; static KConfigGroup configGroup(d->config, QStringLiteral("FileExporterBibTeX")); const bool valueFromConfig = configGroup.readEntry(QStringLiteral("BibTeXProtectCasing"), Preferences::defaultBibTeXProtectCasing); if (valueFromConfig == newValue) return false; configGroup.writeEntry(QStringLiteral("BibTeXProtectCasing"), newValue, KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const QStringList Preferences::availableBibTeXListSeparators {QStringLiteral("; "), QStringLiteral(", ")}; const QString Preferences::defaultBibTeXListSeparator = Preferences::availableBibTeXListSeparators.front(); const QString &Preferences::bibTeXListSeparator() { #ifdef HAVE_KF5 if (d->dirtyFlagBibTeXListSeparator) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("FileExporterBibTeX")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("BibTeXListSeparator"), Preferences::defaultBibTeXListSeparator); if (d->validateValueForBibTeXListSeparator(valueFromConfig)) { d->cachedBibTeXListSeparator = valueFromConfig; d->dirtyFlagBibTeXListSeparator = false; } else { /// Configuration file setting for BibTeXListSeparator has an invalid value, using default as fallback setBibTeXListSeparator(Preferences::defaultBibTeXListSeparator); } } return d->cachedBibTeXListSeparator; #else // HAVE_KF5 return defaultBibTeXListSeparator; #endif // HAVE_KF5 } bool Preferences::setBibTeXListSeparator(const QString &newValue) { #ifdef HAVE_KF5 QString sanitizedNewValue = newValue; const QString lowerSanitizedNewValue = sanitizedNewValue.toLower(); for (const QString &knownBibTeXListSeparator : availableBibTeXListSeparators) if (knownBibTeXListSeparator.toLower() == lowerSanitizedNewValue) { sanitizedNewValue = knownBibTeXListSeparator; break; } if (!d->validateValueForBibTeXListSeparator(sanitizedNewValue)) return false; d->dirtyFlagBibTeXListSeparator = false; d->cachedBibTeXListSeparator = sanitizedNewValue; static KConfigGroup configGroup(d->config, QStringLiteral("FileExporterBibTeX")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("BibTeXListSeparator"), Preferences::defaultBibTeXListSeparator); if (valueFromConfig == sanitizedNewValue) return false; configGroup.writeEntry(QStringLiteral("BibTeXListSeparator"), sanitizedNewValue, KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const QString Preferences::defaultLaTeXBabelLanguage = QStringLiteral("english"); const QString &Preferences::laTeXBabelLanguage() { #ifdef HAVE_KF5 if (d->dirtyFlagLaTeXBabelLanguage) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("FileExporterLaTeXbased")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("LaTeXBabelLanguage"), Preferences::defaultLaTeXBabelLanguage); if (d->validateValueForLaTeXBabelLanguage(valueFromConfig)) { d->cachedLaTeXBabelLanguage = valueFromConfig; d->dirtyFlagLaTeXBabelLanguage = false; } else { /// Configuration file setting for LaTeXBabelLanguage has an invalid value, using default as fallback setLaTeXBabelLanguage(Preferences::defaultLaTeXBabelLanguage); } } return d->cachedLaTeXBabelLanguage; #else // HAVE_KF5 return defaultLaTeXBabelLanguage; #endif // HAVE_KF5 } bool Preferences::setLaTeXBabelLanguage(const QString &newValue) { #ifdef HAVE_KF5 if (!d->validateValueForLaTeXBabelLanguage(newValue)) return false; d->dirtyFlagLaTeXBabelLanguage = false; d->cachedLaTeXBabelLanguage = newValue; static KConfigGroup configGroup(d->config, QStringLiteral("FileExporterLaTeXbased")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("LaTeXBabelLanguage"), Preferences::defaultLaTeXBabelLanguage); if (valueFromConfig == newValue) return false; configGroup.writeEntry(QStringLiteral("LaTeXBabelLanguage"), newValue, KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const QString Preferences::defaultBibTeXBibliographyStyle = QStringLiteral("plain"); const QString &Preferences::bibTeXBibliographyStyle() { #ifdef HAVE_KF5 if (d->dirtyFlagBibTeXBibliographyStyle) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("FileExporterLaTeXbased")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("BibTeXBibliographyStyle"), Preferences::defaultBibTeXBibliographyStyle); if (d->validateValueForBibTeXBibliographyStyle(valueFromConfig)) { d->cachedBibTeXBibliographyStyle = valueFromConfig; d->dirtyFlagBibTeXBibliographyStyle = false; } else { /// Configuration file setting for BibTeXBibliographyStyle has an invalid value, using default as fallback setBibTeXBibliographyStyle(Preferences::defaultBibTeXBibliographyStyle); } } return d->cachedBibTeXBibliographyStyle; #else // HAVE_KF5 return defaultBibTeXBibliographyStyle; #endif // HAVE_KF5 } bool Preferences::setBibTeXBibliographyStyle(const QString &newValue) { #ifdef HAVE_KF5 if (!d->validateValueForBibTeXBibliographyStyle(newValue)) return false; d->dirtyFlagBibTeXBibliographyStyle = false; d->cachedBibTeXBibliographyStyle = newValue; static KConfigGroup configGroup(d->config, QStringLiteral("FileExporterLaTeXbased")); const QString valueFromConfig = configGroup.readEntry(QStringLiteral("BibTeXBibliographyStyle"), Preferences::defaultBibTeXBibliographyStyle); if (valueFromConfig == newValue) return false; configGroup.writeEntry(QStringLiteral("BibTeXBibliographyStyle"), newValue, KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const QVector> Preferences::availableFileViewDoubleClickActions {{Preferences::ActionOpenEditor, i18nc("What to do if double-clicking on a file view item", "Open Editor")}, {Preferences::ActionViewDocument, i18nc("What to do if double-clicking on a file view item", "View Document")}}; const Preferences::FileViewDoubleClickAction Preferences::defaultFileViewDoubleClickAction = Preferences::availableFileViewDoubleClickActions.front().first; Preferences::FileViewDoubleClickAction Preferences::fileViewDoubleClickAction() { #ifdef HAVE_KF5 if (d->dirtyFlagFileViewDoubleClickAction) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("User Interface")); const Preferences::FileViewDoubleClickAction valueFromConfig = static_cast(configGroup.readEntry(QStringLiteral("FileViewDoubleClickAction"), static_cast(Preferences::defaultFileViewDoubleClickAction))); if (d->validateValueForFileViewDoubleClickAction(valueFromConfig)) { d->cachedFileViewDoubleClickAction = valueFromConfig; d->dirtyFlagFileViewDoubleClickAction = false; } else { /// Configuration file setting for FileViewDoubleClickAction has an invalid value, using default as fallback setFileViewDoubleClickAction(Preferences::defaultFileViewDoubleClickAction); } } return d->cachedFileViewDoubleClickAction; #else // HAVE_KF5 return defaultFileViewDoubleClickAction; #endif // HAVE_KF5 } bool Preferences::setFileViewDoubleClickAction(const Preferences::FileViewDoubleClickAction newValue) { #ifdef HAVE_KF5 if (!d->validateValueForFileViewDoubleClickAction(newValue)) return false; d->dirtyFlagFileViewDoubleClickAction = false; d->cachedFileViewDoubleClickAction = newValue; static KConfigGroup configGroup(d->config, QStringLiteral("User Interface")); const Preferences::FileViewDoubleClickAction valueFromConfig = static_cast(configGroup.readEntry(QStringLiteral("FileViewDoubleClickAction"), static_cast(Preferences::defaultFileViewDoubleClickAction))); if (valueFromConfig == newValue) return false; configGroup.writeEntry(QStringLiteral("FileViewDoubleClickAction"), static_cast(newValue), KConfig::Notify); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 } const QVector> Preferences::defaultColorCodes {{QColor(0xcc, 0x33, 0x00), i18nc("Color Labels", "Important")}, {QColor(0x00, 0x33, 0xff), i18nc("Color Labels", "Unread")}, {QColor(0x00, 0x99, 0x66), i18nc("Color Labels", "Read")}, {QColor(0xf0, 0xd0, 0x00), i18nc("Color Labels", "Watch")}}; const QVector> &Preferences::colorCodes() { #ifdef HAVE_KF5 if (d->dirtyFlagColorCodes) { d->config->reparseConfiguration(); static const KConfigGroup configGroup(d->config, QStringLiteral("Color Labels")); const QVector> valueFromConfig = d->readEntryColorCodes(configGroup, QStringLiteral("ColorCodes")); if (d->validateValueForColorCodes(valueFromConfig)) { d->cachedColorCodes = valueFromConfig; d->dirtyFlagColorCodes = false; } else { /// Configuration file setting for ColorCodes has an invalid value, using default as fallback setColorCodes(Preferences::defaultColorCodes); } } return d->cachedColorCodes; #else // HAVE_KF5 return defaultColorCodes; #endif // HAVE_KF5 } bool Preferences::setColorCodes(const QVector> &newValue) { #ifdef HAVE_KF5 if (!d->validateValueForColorCodes(newValue)) return false; d->dirtyFlagColorCodes = false; d->cachedColorCodes = newValue; static KConfigGroup configGroup(d->config, QStringLiteral("Color Labels")); const QVector> valueFromConfig = d->readEntryColorCodes(configGroup, QStringLiteral("ColorCodes")); if (valueFromConfig == newValue) return false; d->writeEntryColorCodes(configGroup, QStringLiteral("ColorCodes"), newValue); d->config->sync(); return true; #else // HAVE_KF5 Q_UNUSED(newValue); return true; #endif // HAVE_KF5 }