jeirmeister/Cockatrice
1
0
Fork 0
mirror of https://github.com/Cockatrice/Cockatrice.git synced 2026-09-21 09:05:10 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
Cockatrice/libcockatrice_settings/libcockatrice/settings/settings_migration.cpp
BruebachL adf574e038
[Settings] Shuffle some settings around (#7084) 
* [Settings] Shuffle some settings around

Took 21 minutes


Took 1 hour 25 minutes

* [Settings] Camel case everything

* Revert debug schema change

* Add new classes

* Fix card counters writing to global

* Fix CI tests

* Fix Windows CI

* interface() is a protected keyword for MSVC

Took 5 minutes

Took 5 seconds

* [Settings] Keep menu settings on the appearance settings page

Leave the 'Menu settings' group box on the appearance settings page for
now; relocating it to the user interface settings page will be done in a
separate PR.

Took 6 minutes

---------

Co-authored-by: Lukas Brübach <Bruebach.Lukas@bdosecurity.de>
2026-08-08 22:27:41 +02:00

698 lines
29 KiB
C++
Raw Blame History

#include "settings_migration.h"
#include <QFile>
#include <QMap>
#include <QSettings>
#include <QStringList>
static const QString MIGRATION_SENTINEL_KEY = QStringLiteral("migration/perfile_complete");
static void migrateTabsSettings(const QString &settingsPath, QSettings &globalIni)
{
if (!globalIni.contains("tabs/visualDeckStorage") && !globalIni.contains("tabs/server") &&
!globalIni.contains("tabs/account") && !globalIni.contains("tabs/deckStorage") &&
!globalIni.contains("tabs/replays") && !globalIni.contains("tabs/admin") && !globalIni.contains("tabs/log")) {
return;
}
QSettings tabsIni(settingsPath + "tabs.ini", QSettings::IniFormat);
tabsIni.setValue("tabs/visualDeckStorage", globalIni.value("tabs/visualDeckStorage", true));
tabsIni.setValue("tabs/server", globalIni.value("tabs/server", true));
tabsIni.setValue("tabs/account", globalIni.value("tabs/account", true));
tabsIni.setValue("tabs/deckStorage", globalIni.value("tabs/deckStorage", true));
tabsIni.setValue("tabs/replays", globalIni.value("tabs/replays", true));
tabsIni.setValue("tabs/admin", globalIni.value("tabs/admin", true));
tabsIni.setValue("tabs/log", globalIni.value("tabs/log", true));
}
static void migrateSoundSettings(const QString &settingsPath, QSettings &globalIni)
{
if (!globalIni.contains("sound/enabled") && !globalIni.contains("sound/theme") &&
!globalIni.contains("sound/mastervolume")) {
return;
}
QSettings soundIni(settingsPath + "sound.ini", QSettings::IniFormat);
soundIni.setValue("sound/enabled", globalIni.value("sound/enabled", false));
soundIni.setValue("sound/theme", globalIni.value("sound/theme"));
soundIni.setValue("sound/masterVolume", globalIni.value("sound/mastervolume", 100));
}
static void migrateGameSettings(const QString &settingsPath, QSettings &globalIni)
{
const QMap<QString, QString> gameKeyMap = {
{"game/maxplayers", "game/maxPlayers"},
{"game/gamedescription", "game/gameDescription"},
{"game/gametypes", "game/gameTypes"},
{"game/onlybuddies", "game/onlyBuddies"},
{"game/onlyregistered", "game/onlyRegistered"},
{"game/spectatorsallowed", "game/spectatorsAllowed"},
{"game/spectatorsneedpassword", "game/spectatorsNeedPassword"},
{"game/spectatorscantalk", "game/spectatorsCanTalk"},
{"game/spectatorscanseeeverything", "game/spectatorsCanSeeEverything"},
{"game/creategameasspectator", "game/createGameAsSpectator"},
{"game/defaultstartinglifetotal", "game/defaultStartingLifeTotal"},
{"game/sharedecklistsonload", "game/shareDecklistsOnLoad"},
{"game/remembergamesettings", "game/rememberGameSettings"},
{"localgameoptions/maxplayers", "localgameoptions/maxPlayers"},
{"localgameoptions/startinglifetotal", "localgameoptions/startingLifeTotal"},
{"localgameoptions/remembersettings", "localgameoptions/rememberSettings"},
};
bool hasAny = false;
for (auto it = gameKeyMap.constBegin(); it != gameKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
hasAny = true;
break;
}
}
if (!hasAny) {
return;
}
QSettings gameIni(settingsPath + "game.ini", QSettings::IniFormat);
for (auto it = gameKeyMap.constBegin(); it != gameKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
gameIni.setValue(it.value(), globalIni.value(it.key()));
}
}
}
static void migrateChatSettings(const QString &settingsPath, QSettings &globalIni)
{
const QMap<QString, QString> chatKeyMap = {
{"chat/mention", "chat/mention"},
{"chat/mentioncompleter", "chat/mentionCompleter"},
{"chat/mentioncolor", "chat/mentionColor"},
{"chat/highlightcolor", "chat/highlightColor"},
{"chat/mentionforeground", "chat/mentionForeground"},
{"chat/highlightforeground", "chat/highlightForeground"},
{"chat/ignore_unregistered", "chat/ignoreUnregistered"},
{"chat/ignore_unregistered_messages", "chat/ignoreUnregisteredMessages"},
{"chat/ignore_nonbuddy_messages", "chat/ignoreNonBuddyMessages"},
{"chat/showmessagepopups", "chat/showMessagePopups"},
{"chat/showmentionpopups", "chat/showMentionPopups"},
{"chat/roomhistory", "chat/roomHistory"},
{"chat/highlightwords", "chat/highlightWords"},
// Legacy highlight words lived under [personal], but the chat settings
// class reads them from [chat]
{"personal/highlightWords", "chat/highlightWords"},
};
bool hasAny = false;
for (auto it = chatKeyMap.constBegin(); it != chatKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
hasAny = true;
break;
}
}
if (!hasAny) {
return;
}
QSettings chatIni(settingsPath + "chat.ini", QSettings::IniFormat);
for (auto it = chatKeyMap.constBegin(); it != chatKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
chatIni.setValue(it.value(), globalIni.value(it.key()));
}
}
}
static void migrateCacheStorageSettings(const QString &settingsPath, QSettings &globalIni)
{
const QMap<QString, QString> cacheStorageKeyMap = {
{"personal/pixmapCacheSize", "cache_storage/pixmapCacheSize"},
{"personal/networkCacheSize", "cache_storage/networkCacheSize"},
{"personal/redirectCacheTtl", "cache_storage/redirectCacheTtl"},
{"personal/cardPictureLoaderCacheMethod", "cache_storage/cardPictureLoaderCacheMethod"},
{"personal/localCardImageStorageNamingScheme", "cache_storage/localCardImageStorageNamingScheme"},
};
bool hasAny = false;
for (auto it = cacheStorageKeyMap.constBegin(); it != cacheStorageKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
hasAny = true;
break;
}
}
if (!hasAny) {
return;
}
QSettings cacheStorageIni(settingsPath + "cache_storage.ini", QSettings::IniFormat);
for (auto it = cacheStorageKeyMap.constBegin(); it != cacheStorageKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
cacheStorageIni.setValue(it.value(), globalIni.value(it.key()));
}
}
}
static void migrateUpdatesSettings(const QString &settingsPath, QSettings &globalIni)
{
const QMap<QString, QString> updateKeyMap = {
{"personal/startupUpdateCheck", "updates/startupUpdateCheck"},
{"personal/startupCardUpdateCheckPromptForUpdate", "updates/startupCardUpdateCheckPromptForUpdate"},
{"personal/startupCardUpdateCheckAlwaysUpdate", "updates/startupCardUpdateCheckAlwaysUpdate"},
{"personal/cardUpdateCheckInterval", "updates/cardUpdateCheckInterval"},
{"personal/lastCardUpdateCheck", "updates/lastCardUpdateCheck"},
{"personal/alwaysEnableNewSets", "updates/alwaysEnableNewSets"},
{"personal/updatenotification", "updates/updateNotification"},
{"personal/newversionnotification", "updates/newVersionNotification"},
{"personal/updatereleasechannel", "updates/updateReleaseChannel"},
};
bool hasAny = false;
for (auto it = updateKeyMap.constBegin(); it != updateKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
hasAny = true;
break;
}
}
if (!hasAny) {
return;
}
QSettings updatesIni(settingsPath + "updates.ini", QSettings::IniFormat);
for (auto it = updateKeyMap.constBegin(); it != updateKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
updatesIni.setValue(it.value(), globalIni.value(it.key()));
}
}
}
static void migratePersonalSettings(const QString &settingsPath, QSettings &globalIni)
{
const QStringList personalRootKeys = {"personal/lang"};
const QStringList tipKeys = {"tipOfDay/showTips", "tipOfDay/seenTips"};
bool hasAny = false;
for (const auto &key : personalRootKeys) {
if (globalIni.contains(key)) {
hasAny = true;
}
}
for (const auto &key : tipKeys) {
if (globalIni.contains(key)) {
hasAny = true;
}
}
if (!hasAny) {
return;
}
QSettings personalIni(settingsPath + "personal.ini", QSettings::IniFormat);
for (const auto &key : personalRootKeys) {
if (globalIni.contains(key)) {
personalIni.setValue(key, globalIni.value(key));
}
}
for (const auto &key : tipKeys) {
if (globalIni.contains(key)) {
personalIni.setValue(key, globalIni.value(key));
}
}
}
static void migrateCardsDisplaySettings(const QString &settingsPath, QSettings &globalIni)
{
const QMap<QString, QString> cardsKeyMap = {
{"cards/displaycardnames", "cards/displayCardNames"},
{"cards/roundcardcorners", "cards/roundCardCorners"},
{"cards/overrideallcardartwithpersonalpreference", "cards/overrideAllCardArtWithPersonalPreference"},
{"cards/bumpsetswithcardsindecktotop", "cards/bumpSetsWithCardsInDeckToTop"},
{"cards/includerebalancedcards", "cards/includerebalancedcards"},
{"cards/tapanimation", "cards/tapAnimation"},
{"cards/autorotatesidewayslayoutcards", "cards/autoRotateSidewaysLayoutCards"},
{"cards/scaleCards", "cards/scaleCards"},
{"cards/verticalCardOverlapPercent", "cards/verticalCardOverlapPercent"},
{"cards/cardinfoviewmode", "cards/cardInfoViewMode"},
{"cards/printingselectorsortorder", "cards/printingSelector/sortOrder"},
{"cards/printingselectornavigationbuttonsvisible", "cards/printingSelector/navigationButtonsVisible"},
{"cards/printingselectorcardsize", "cards/cardSize/printingSelector"},
{"interface/visualdeckstoragecardsize", "cards/cardSize/visualDeckStorage"},
{"interface/visualdatabasedisplaycardsize", "cards/cardSize/visualDatabaseDisplay"},
{"interface/visualdeckeditorcardsize", "cards/cardSize/visualDeckEditor"},
{"interface/edhreccardsize", "cards/cardSize/edhrec"},
{"interface/archidektpreviewsize", "cards/cardSize/archidektPreview"},
{"interface/visualdeckeditorsamplehandsize", "cards/cardSize/sampleHandSize"},
};
bool hasAny = false;
for (auto it = cardsKeyMap.constBegin(); it != cardsKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
hasAny = true;
break;
}
}
if (!hasAny) {
return;
}
QSettings cardsIni(settingsPath + "cards_display.ini", QSettings::IniFormat);
for (auto it = cardsKeyMap.constBegin(); it != cardsKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
cardsIni.setValue(it.value(), globalIni.value(it.key()));
}
}
}
static void migrateCardCounterSettings(const QString &settingsPath, QSettings &globalIni)
{
QStringList counterKeys;
const QStringList allKeys = globalIni.allKeys();
for (const auto &key : allKeys) {
if (key.startsWith("cards/counters/")) {
counterKeys.append(key);
}
}
if (counterKeys.isEmpty()) {
return;
}
QSettings countersIni(settingsPath + "card_counters.ini", QSettings::IniFormat);
for (const auto &key : counterKeys) {
countersIni.setValue(key, globalIni.value(key));
}
}
static void migrateInterfaceSettings(const QString &settingsPath, QSettings &globalIni)
{
const QMap<QString, QString> interfaceKeyMap = {
{"interface/usetearoffmenus", "interface/useTearOffMenus"},
{"interface/cardViewInitialRowsMax", "interface/cardViewInitialRowsMax"},
{"interface/cardViewExpandedRowsMax", "interface/cardViewExpandedRowsMax"},
{"interface/closeEmptyCardView", "interface/closeEmptyCardView"},
{"interface/focusCardViewSearchBar", "interface/focusCardViewSearchBar"},
{"interface/keepGameChatFocus", "interface/keepGameChatFocus"},
{"interface/doubleclicktoplay", "interface/doubleClickToPlay"},
{"interface/clickPlaysAllSelected", "interface/clickPlaysAllSelected"},
{"interface/playtostack", "interface/playToStack"},
{"interface/doNotDeleteArrowsInSubPhases", "interface/doNotDeleteArrowsInSubPhases"},
{"interface/startinghandsize", "interface/startingHandSize"},
{"interface/annotatetokens", "interface/annotateTokens"},
{"interface/showlassoselectioncount", "interface/showLassoSelectionCount"},
{"interface/showpersistentselectioncount", "interface/showPersistentSelectionCount"},
{"interface/tallyType", "interface/tallyType"},
{"interface/leftjustified", "interface/leftJustified"},
{"interface/min_players_multicolumn", "interface/minPlayersMulticolumn"},
{"hand/horizontal", "hand/horizontal"},
{"table/invert_vertical", "table/invertVertical"},
{"replay/rewindBufferingMs", "replay/rewindBufferingMs"},
{"replay/fastForwardSpeed", "replay/fastForwardSpeed"},
{"zoneview/groupby", "zoneview/groupBy"},
{"zoneview/sortby", "zoneview/sortBy"},
{"zoneview/pileview", "zoneview/pileView"},
{"personal/showStatusBar", "interface/showStatusBar"},
{"menu/showshortcuts", "interface/showShortcuts"},
{"menu/showgameselectorfiltertoolbar", "interface/showGameSelectorFilterToolbar"},
{"interface/notificationsenabled", "interface/notifications/enabled"},
{"interface/specnotificationsenabled", "interface/notifications/spectatorsEnabled"},
{"interface/buddyconnectnotificationsenabled", "interface/notifications/buddyConnectEnabled"},
};
bool hasAny = false;
for (auto it = interfaceKeyMap.constBegin(); it != interfaceKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
hasAny = true;
break;
}
}
if (!hasAny) {
return;
}
QSettings interfaceIni(settingsPath + "interface.ini", QSettings::IniFormat);
for (auto it = interfaceKeyMap.constBegin(); it != interfaceKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
interfaceIni.setValue(it.value(), globalIni.value(it.key()));
}
}
}
static void migrateDownloadSettings(const QString &settingsPath, QSettings &globalIni)
{
const QMap<QString, QString> downloadKeyMap = {
{"personal/picturedownload", "downloads/pictureDownload"},
{"personal/downloadspoilers", "downloads/downloadSpoilers"},
};
bool hasAny = false;
for (auto it = downloadKeyMap.constBegin(); it != downloadKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
hasAny = true;
break;
}
}
if (!hasAny) {
return;
}
QSettings downloadsIni(settingsPath + "downloads.ini", QSettings::IniFormat);
for (auto it = downloadKeyMap.constBegin(); it != downloadKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
downloadsIni.setValue(it.value(), globalIni.value(it.key()));
}
}
}
static void migrateAppearanceSettings(const QString &settingsPath, QSettings &globalIni)
{
const QMap<QString, QString> appearanceKeyMap = {
{"theme/name", "appearance/themeName"},
{"game/maxfontsize", "appearance/maxFontSize"},
{"home/background", "appearance/homeTabBackgroundSource"},
{"home/background/shuffleTimer", "appearance/homeTabBackgroundShuffleFrequency"},
{"home/background/displayCardName", "appearance/homeTabDisplayCardName"},
{"appearance/styleUserList", "appearance/styleUserList"},
};
bool hasAny = false;
for (auto it = appearanceKeyMap.constBegin(); it != appearanceKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
hasAny = true;
break;
}
}
if (!hasAny) {
return;
}
QSettings appearanceIni(settingsPath + "appearance.ini", QSettings::IniFormat);
for (auto it = appearanceKeyMap.constBegin(); it != appearanceKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
appearanceIni.setValue(it.value(), globalIni.value(it.key()));
}
}
}
static void migrateNetworkSettings(const QString &settingsPath, QSettings &globalIni)
{
const QMap<QString, QString> networkKeyMap = {
{"personal/clientid", "network/clientId"},
{"personal/clientversion", "network/clientVersion"},
{"personal/keepalive", "network/keepAlive"},
{"personal/timeout", "network/timeout"},
{"interface/knownmissingfeatures", "network/knownMissingFeatures"},
};
bool hasAny = false;
for (auto it = networkKeyMap.constBegin(); it != networkKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
hasAny = true;
break;
}
}
if (!hasAny) {
return;
}
QSettings networkIni(settingsPath + "network.ini", QSettings::IniFormat);
for (auto it = networkKeyMap.constBegin(); it != networkKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
networkIni.setValue(it.value(), globalIni.value(it.key()));
}
}
}
static void migratePathsSettings(const QString &settingsPath, QSettings &globalIni)
{
const QMap<QString, QString> pathsKeyMap = {
{"paths/decks", "paths/decks"},
{"paths/filters", "paths/filters"},
{"paths/replays", "paths/replays"},
{"paths/pics", "paths/pics"},
{"paths/custompics", "paths/customPics"},
{"paths/themes", "paths/themes"},
{"paths/carddatabase", "paths/cardDatabase"},
{"paths/customsets", "paths/customSets"},
{"paths/tokendatabase", "paths/tokenDatabase"},
{"paths/spoilerdatabase", "paths/spoilerDatabase"},
{"paths/redirects", "paths/redirects"},
};
bool hasAny = false;
for (auto it = pathsKeyMap.constBegin(); it != pathsKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
hasAny = true;
break;
}
}
if (!hasAny) {
return;
}
QSettings pathsIni(settingsPath + "paths.ini", QSettings::IniFormat);
for (auto it = pathsKeyMap.constBegin(); it != pathsKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
pathsIni.setValue(it.value(), globalIni.value(it.key()));
}
}
}
static void migrateVisualDeckStorageSettings(const QString &settingsPath, QSettings &globalIni)
{
const QMap<QString, QString> vdsKeyMap = {
{"interface/visualdeckstoragesortingorder", "interface/visualDeckStorage/sortingOrder"},
{"interface/visualdeckstorageshowfolders", "interface/visualDeckStorage/showFolders"},
{"interface/visualdeckstorageshowtagfilter", "interface/visualDeckStorage/showTagFilter"},
{"interface/visualdeckstoragedefaulttagslist", "interface/visualDeckStorage/defaultTagsList"},
{"interface/visualdeckstoragesearchfoldernames", "interface/visualDeckStorage/searchFolderNames"},
{"interface/visualdeckstorageshowcoloridentity", "interface/visualDeckStorage/showColorIdentity"},
{"interface/visualdeckstorageshowbannercardcombobox", "interface/visualDeckStorage/showBannerCardComboBox"},
{"interface/visualdeckstorageshowtagsondeckpreviews", "interface/visualDeckStorage/showTagsOnDeckPreviews"},
{"interface/visualdeckstoragedrawunusedcoloridentities",
"interface/visualDeckStorage/drawUnusedColorIdentities"},
{"interface/visualdeckstorageunusedcoloridentitiesopacity",
"interface/visualDeckStorage/unusedColorIdentitiesOpacity"},
{"interface/visualdeckstoragetooltiptype", "interface/visualDeckStorage/tooltipType"},
{"interface/visualdeckstoragepromptforconversion", "interface/visualDeckStorage/promptForConversion"},
{"interface/visualdeckstoragealwaysconvert", "interface/visualDeckStorage/alwaysConvert"},
{"interface/visualdeckstorageingame", "interface/visualDeckStorage/inGame"},
{"interface/visualdeckstorageselectionanimation", "interface/visualDeckStorage/selectionAnimation"},
{"interface/visualdatabasedisplayfiltertomostrecentsetsenabled",
"interface/visualDatabaseDisplay/filterToMostRecentSetsEnabled"},
{"interface/visualdatabasedisplayfiltertomostrecentsetsamount",
"interface/visualDatabaseDisplay/filterToMostRecentSetsAmount"},
};
bool hasAny = false;
for (auto it = vdsKeyMap.constBegin(); it != vdsKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
hasAny = true;
break;
}
}
if (!hasAny) {
return;
}
QSettings vdsIni(settingsPath + "visual_deck_storage.ini", QSettings::IniFormat);
for (auto it = vdsKeyMap.constBegin(); it != vdsKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
vdsIni.setValue(it.value(), globalIni.value(it.key()));
}
}
}
static void migrateDeckEditorSettings(const QString &settingsPath, QSettings &globalIni)
{
const QMap<QString, QString> deckEditorKeyMap = {
{"editor/openDeckInNewTab", "deckeditor/openDeckInNewTab"},
{"interface/deckeditorbannercardcomboboxvisible", "deckeditor/bannerCardComboBoxVisible"},
{"interface/deckeditortagswidgetvisible", "deckeditor/tagsWidgetVisible"},
{"interface/defaultDeckEditorType", "deckeditor/defaultDeckEditorType"},
};
bool hasAny = false;
for (auto it = deckEditorKeyMap.constBegin(); it != deckEditorKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
hasAny = true;
break;
}
}
if (!hasAny) {
return;
}
QSettings deckEditorIni(settingsPath + "deck_editor.ini", QSettings::IniFormat);
for (auto it = deckEditorKeyMap.constBegin(); it != deckEditorKeyMap.constEnd(); ++it) {
if (globalIni.contains(it.key())) {
deckEditorIni.setValue(it.value(), globalIni.value(it.key()));
}
}
}
static void migrateLegacySets(const QString &settingsPath)
{
QSettings legacySetting;
legacySetting.beginGroup("sets");
QStringList groups = legacySetting.childGroups();
if (groups.isEmpty()) {
legacySetting.endGroup();
return;
}
QSettings cardDbIni(settingsPath + "cardDatabase.ini", QSettings::IniFormat);
for (const auto &shortName : groups) {
legacySetting.beginGroup(shortName);
cardDbIni.setValue("sets/" + shortName + "/sortKey", legacySetting.value("sortkey"));
cardDbIni.setValue("sets/" + shortName + "/enabled", legacySetting.value("enabled"));
cardDbIni.setValue("sets/" + shortName + "/isKnown", legacySetting.value("isknown"));
legacySetting.endGroup();
}
legacySetting.endGroup();
}
static void migrateLegacyServers(const QString &settingsPath)
{
QSettings legacySetting;
legacySetting.beginGroup("server");
QStringList keys = legacySetting.allKeys();
if (keys.isEmpty()) {
legacySetting.endGroup();
return;
}
const QMap<QString, QString> serverKeyMap = {
{"previoushostlogin", "previousHostLogin"},
{"previoushosts", "previousHosts"},
{"previoushostName", "previousHostName"},
{"auto_connect", "autoConnect"},
{"fphostname", "fpHostName"},
{"fpport", "fpPort"},
{"fpplayername", "fpPlayerName"},
{"save_debug_log", "saveDebugLog"},
};
QSettings serversIni(settingsPath + "servers.ini", QSettings::IniFormat);
for (auto it = serverKeyMap.constBegin(); it != serverKeyMap.constEnd(); ++it) {
if (legacySetting.contains(it.key())) {
serversIni.setValue("server/" + it.value(), legacySetting.value(it.key()));
}
}
legacySetting.beginGroup("server_details");
const QStringList detailsKeys = legacySetting.allKeys();
for (const auto &key : detailsKeys) {
serversIni.setValue("server/server_details/" + key, legacySetting.value(key));
}
legacySetting.endGroup();
legacySetting.endGroup();
}
static void migrateLegacyMessages(const QString &settingsPath)
{
QSettings legacySetting;
legacySetting.beginGroup("messages");
QStringList keys = legacySetting.allKeys();
if (keys.isEmpty()) {
legacySetting.endGroup();
return;
}
QSettings messageIni(settingsPath + "messages.ini", QSettings::IniFormat);
for (const auto &key : keys) {
if (key == "count") {
messageIni.setValue("messages/count", legacySetting.value("count"));
} else {
messageIni.setValue("messages/" + key, legacySetting.value(key));
}
}
legacySetting.endGroup();
}
static void migrateLegacyGameFilters(const QString &settingsPath)
{
QSettings legacySetting;
legacySetting.beginGroup("filter_games");
QStringList keys = legacySetting.allKeys();
if (keys.isEmpty()) {
legacySetting.endGroup();
return;
}
const QMap<QString, QString> filterKeyMap = {
{"hide_buddies_only_games", "hideBuddiesOnlyGames"},
{"hide_full_games", "hideFullGames"},
{"hide_games_that_started", "hideGamesThatStarted"},
{"hide_password_protected_games", "hidePasswordProtectedGames"},
{"hide_ignored_user_games", "hideIgnoredUserGames"},
{"hide_not_buddy_created_games", "hideNotBuddyCreatedGames"},
{"hide_open_decklist_games", "hideOpenDecklistGames"},
{"game_name_filter", "gameNameFilter"},
{"creator_name_filter", "creatorNameFilter"},
{"min_players", "minPlayers"},
{"max_players", "maxPlayers"},
{"max_game_age_time", "maxGameAgeTime"},
{"show_only_if_spectators_can_watch", "showOnlyIfSpectatorsCanWatch"},
{"show_spectator_password_protected", "showSpectatorPasswordProtected"},
{"show_only_if_spectators_can_chat", "showOnlyIfSpectatorsCanChat"},
{"show_only_if_spectators_can_see_hands", "showOnlyIfSpectatorsCanSeeHands"},
};
QSettings filtersIni(settingsPath + "gamefilters.ini", QSettings::IniFormat);
for (auto it = filterKeyMap.constBegin(); it != filterKeyMap.constEnd(); ++it) {
if (legacySetting.contains(it.key())) {
filtersIni.setValue("filter_games/" + it.value(), legacySetting.value(it.key()));
}
}
const QString gameTypePrefix = "game_type/";
for (const auto &key : keys) {
if (key.startsWith(gameTypePrefix)) {
filtersIni.setValue("filter_games/gameType/" + key.mid(gameTypePrefix.size()), legacySetting.value(key));
}
}
legacySetting.endGroup();
}
bool SettingsMigration::migrateLegacySettings(const QString &settingsPath)
{
QSettings personalIni(settingsPath + "personal.ini", QSettings::IniFormat);
if (personalIni.value("migration/legacy_complete", false).toBool()) {
return false;
}
migrateLegacySets(settingsPath);
migrateLegacyServers(settingsPath);
migrateLegacyMessages(settingsPath);
migrateLegacyGameFilters(settingsPath);
personalIni.setValue("migration/legacy_complete", true);
personalIni.sync();
return true;
}
bool SettingsMigration::migrateSettingsFromGlobalIni(const QString &settingsPath)
{
if (!QFile::exists(settingsPath + "global.ini")) {
return false;
}
QSettings globalIni(settingsPath + "global.ini", QSettings::IniFormat);
if (globalIni.value(MIGRATION_SENTINEL_KEY, false).toBool()) {
// If a user runs an older Cockatrice build that writes to global.ini (non-sentinel keys)
// and then upgrades back, those new keys will be silently ignored. Re-migrate them.
globalIni.sync();
auto allKeys = globalIni.allKeys();
allKeys.removeAll(MIGRATION_SENTINEL_KEY);
if (allKeys.isEmpty()) {
return false;
}
}
migrateTabsSettings(settingsPath, globalIni);
migrateSoundSettings(settingsPath, globalIni);
migrateGameSettings(settingsPath, globalIni);
migrateChatSettings(settingsPath, globalIni);
migrateCacheStorageSettings(settingsPath, globalIni);
migrateUpdatesSettings(settingsPath, globalIni);
migratePersonalSettings(settingsPath, globalIni);
migrateDownloadSettings(settingsPath, globalIni);
migrateCardsDisplaySettings(settingsPath, globalIni);
migrateCardCounterSettings(settingsPath, globalIni);
migrateInterfaceSettings(settingsPath, globalIni);
migrateAppearanceSettings(settingsPath, globalIni);
migrateNetworkSettings(settingsPath, globalIni);
migratePathsSettings(settingsPath, globalIni);
migrateVisualDeckStorageSettings(settingsPath, globalIni);
migrateDeckEditorSettings(settingsPath, globalIni);
QFile::remove(settingsPath + "global.ini.old");
QFile::rename(settingsPath + "global.ini", settingsPath + "global.ini.old");
QSettings newGlobalIni(settingsPath + "global.ini", QSettings::IniFormat);
newGlobalIni.setValue(MIGRATION_SENTINEL_KEY, true);
newGlobalIni.sync();
return true;
}
Reference in a new issue View git blame Copy permalink