Refactred settings to use settingscache & ini files

cockatrice/src/settings/serverssettings.cpp

+#include "serverssettings.h"
+
+ServersSettings::ServersSettings(QString settingPath, QObject *parent)
+    : SettingsManager(settingPath+"servers.ini", parent)
+{
+}
+
+void ServersSettings::setPreviousHostLogin(int previous)
+{
+    setValue(previous, "previoushostlogin", "server");
+}
+
+int ServersSettings::getPreviousHostLogin()
+{
+    QVariant previous = getValue("previoushostlogin", "server");
+    return previous == QVariant() ? 1 : previous.toInt();
+}
+
+void ServersSettings::setPreviousHostList(QStringList list)
+{
+    setValue(list, "previoushosts", "server");
+}
+
+QStringList ServersSettings::getPreviousHostList()
+{
+    return getValue("previoushosts", "server").toStringList();
+}
+
+void ServersSettings::setPrevioushostindex(int index)
+{
+    setValue(index, "previoushostindex", "server");
+}
+
+int ServersSettings::getPrevioushostindex()
+{
+    return getValue("previoushostindex", "server").toInt();
+}
+
+void ServersSettings::setHostName(QString hostname)
+{
+    setValue(hostname, "hostname", "server");
+}
+
+QString ServersSettings::getHostname(QString defaultHost)
+{
+    QVariant hostname = getValue("hostname","server");
+    return hostname == QVariant() ? defaultHost : hostname.toString();
+}
+
+void ServersSettings::setPort(QString port)
+{
+    setValue(port, "port", "server");
+}
+
+QString ServersSettings::getPort(QString defaultPort)
+{
+    QVariant port = getValue("port","server");
+    return port == QVariant() ? defaultPort : port.toString();
+}
+
+void ServersSettings::setPlayerName(QString playerName)
+{
+    setValue(playerName, "playername", "server");
+}
+
+QString ServersSettings::getPlayerName(QString defaultName)
+{
+    QVariant name = getValue("playername", "server");
+    return name == QVariant() ? defaultName : name.toString();
+}
+
+void ServersSettings::setPassword(QString password)
+{
+    setValue(password, "password", "server");
+}
+
+QString ServersSettings::getPassword()
+{
+    return getValue("password", "server").toString();
+}
+
+void ServersSettings::setSavePassword(int save)
+{
+    setValue(save, "save_password", "server");
+}
+
+int ServersSettings::getSavePassword()
+{
+    QVariant save = getValue("save_password", "server");
+    return save == QVariant() ? 1 : save.toInt();
+}
+
+void ServersSettings::setAutoConnect(int autoconnect)
+{
+    setValue(autoconnect, "auto_connect", "server");
+}
+
+int ServersSettings::getAutoConnect()
+{
+    QVariant autoconnect = getValue("auto_connect", "server");
+    return autoconnect == QVariant() ? 0 : autoconnect.toInt();
+}

cockatrice/src/settings/serverssettings.h

+#ifndef SERVERSSETTINGS_H
+#define SERVERSSETTINGS_H
+
+#include "settingsmanager.h"
+#include <QObject>
+
+class ServersSettings : public SettingsManager
+{
+    Q_OBJECT
+    friend class SettingsCache;
+
+public:    
+    int getPreviousHostLogin();
+    QStringList getPreviousHostList();
+    int getPrevioushostindex();
+    QString getHostname(QString defaultHost = "");
+    QString getPort(QString defaultPort = "");
+    QString getPlayerName(QString defaultName = "");
+    QString getPassword();
+    int getSavePassword();
+    int getAutoConnect();
+
+    void setPreviousHostLogin(int previous);
+    void setPreviousHostList(QStringList list);
+    void setPrevioushostindex(int index);
+    void setHostName(QString hostname);
+    void setPort(QString port);
+    void setPlayerName(QString playerName);
+    void setPassword(QString password);
+    void setSavePassword(int save);
+    void setAutoConnect(int autoconnect);
+signals:
+
+public slots:
+
+private:
+    ServersSettings(QString settingPath,QObject *parent = 0);
+    ServersSettings( const ServersSettings& /*other*/ );
+    ServersSettings( ServersSettings& /*other*/ );
+    ServersSettings( volatile const ServersSettings& /*other*/ );
+    ServersSettings( volatile ServersSettings& /*other*/ );       
+};
+
+#endif // SERVERSSETTINGS_H

cockatrice/src/settings/settingsmanager.cpp

+#include "settingsmanager.h"
+
+SettingsManager::SettingsManager(QString settingPath, QObject *parent)
+    : QObject(parent),
+      settings(settingPath, QSettings::IniFormat)
+{
+}
+
+void SettingsManager::setValue(QVariant value, QString name, QString group, QString subGroup)
+{
+    if(!group.isEmpty())
+        settings.beginGroup(group);
+
+    if(!subGroup.isEmpty())
+        settings.beginGroup(subGroup);
+
+    settings.setValue(name, value);
+
+    if(!subGroup.isEmpty())
+        settings.endGroup();
+
+    if(!group.isEmpty())
+        settings.endGroup();
+}
+
+QVariant SettingsManager::getValue(QString name, QString group, QString subGroup)
+{
+    if(!group.isEmpty())
+        settings.beginGroup(group);
+
+    if(!subGroup.isEmpty())
+        settings.beginGroup(subGroup);
+
+    QVariant value = settings.value(name);
+
+    if(!subGroup.isEmpty())
+        settings.endGroup();
+
+    if(!group.isEmpty())
+        settings.endGroup();
+
+    return value;
+}

cockatrice/src/settings/settingsmanager.h

+#ifndef SETTINGSMANAGER_H
+#define SETTINGSMANAGER_H
+
+#include <QObject>
+#include <QSettings>
+#include <QStringList>
+#include <QVariant>
+
+class SettingsManager : public QObject
+{
+    Q_OBJECT
+public:
+    SettingsManager(QString settingPath, QObject *parent = 0);
+
+signals:
+
+public slots:
+
+protected:
+    QSettings settings;
+    QVariant getValue(QString name, QString group = "", QString subGroup = "" );
+    void setValue(QVariant value, QString name, QString group = "", QString subGroup = "" );
+};
+
+#endif // SETTINGSMANAGER_H

cockatrice/src/settingscache.cpp

 #include "settingscache.h"
 #include <QSettings>
+#include <QFile>
 #if QT_VERSION >= 0x050000
     #include <QStandardPaths>
 #else
@@ -11,7 +12,7 @@ QString SettingsCache::getSettingsPath()
     QString file = "";
 
 #ifndef PORTABLE_BUILD
-#if QT_VERSION >= 0x050000
+    #if QT_VERSION >= 0x050000
         file = QStandardPaths::writableLocation(QStandardPaths::DataLocation);
     #else
         file = QDesktopServices::storageLocation(QDesktopServices::DataLocation);
@@ -19,17 +20,117 @@ QString SettingsCache::getSettingsPath()
         file.append("/settings/");
 #endif
 
-    return file;
+        return file;
+}
+
+void SettingsCache::translateLegacySettings()
+{
+    //NOTE Please remove this legacy setting translation after 2016-9-1 (+1 year after creation)
+
+    //Layouts
+    QFile layoutFile(getSettingsPath()+"layouts/deckLayout.ini");
+    if(layoutFile.exists())
+        if(layoutFile.copy(getSettingsPath()+"layouts.ini"))
+            layoutFile.remove();
+
+    QStringList usedKeys;
+    QSettings legacySetting;
+
+    //Sets
+    legacySetting.beginGroup("sets");
+    QStringList setsGroups = legacySetting.childGroups();
+    for(int i = 0; i < setsGroups.size(); i++){        
+        legacySetting.beginGroup(setsGroups.at(i));
+        cardDatabase().setEnabled(setsGroups.at(i), legacySetting.value("enabled").toBool());
+        cardDatabase().setIsKnown(setsGroups.at(i), legacySetting.value("isknown").toBool());
+        cardDatabase().setSortKey(setsGroups.at(i), legacySetting.value("sortkey").toUInt());
+        legacySetting.endGroup();
+    }
+    QStringList setsKeys = legacySetting.allKeys();
+    for (int i = 0; i < setsKeys.size(); ++i) {
+        usedKeys.append("sets/"+setsKeys.at(i));
+    }
+    legacySetting.endGroup();
+
+    //Servers
+    legacySetting.beginGroup("server");
+    servers().setPreviousHostLogin(legacySetting.value("previoushostlogin").toInt());
+    servers().setPreviousHostList(legacySetting.value("previoushosts").toStringList());
+    servers().setPrevioushostindex(legacySetting.value("previoushostindex").toInt());
+    servers().setHostName(legacySetting.value("hostname").toString());
+    servers().setPort(legacySetting.value("port").toString());
+    servers().setPlayerName(legacySetting.value("playername").toString());
+    servers().setPassword(legacySetting.value("password").toString());
+    servers().setSavePassword(legacySetting.value("save_password").toInt());
+    servers().setAutoConnect(legacySetting.value("auto_connect").toInt());
+    usedKeys.append(legacySetting.allKeys());
+    QStringList allKeysServer = legacySetting.allKeys();
+    for (int i = 0; i < allKeysServer.size(); ++i) {
+        usedKeys.append("server/"+allKeysServer.at(i));
+    }
+    legacySetting.endGroup();
+
+    //Messages
+    legacySetting.beginGroup("messages");
+    QStringList allMessages = legacySetting.allKeys();
+    for (int i = 0; i < allMessages.size(); ++i) {
+        if(allMessages.at(i) != "count"){
+            QString temp = allMessages.at(i);
+            int index = temp.remove("msg").toInt();
+            messages().setMessageAt(index,legacySetting.value(allMessages.at(i)).toString());
+        }
+    }
+    messages().setCount(legacySetting.value("count").toInt());
+    QStringList allKeysmessages = legacySetting.allKeys();
+    for (int i = 0; i < allKeysmessages.size(); ++i) {
+        usedKeys.append("messages/"+allKeysmessages.at(i));
+    }
+    legacySetting.endGroup();
+
+    //Game filters
+    legacySetting.beginGroup("filter_games");
+    gameFilters().setUnavailableGamesVisible(legacySetting.value("unavailable_games_visible").toBool());
+    gameFilters().setShowPasswordProtectedGames(legacySetting.value("show_password_protected_games").toBool());
+    gameFilters().setGameNameFilter(legacySetting.value("game_name_filter").toString());
+    gameFilters().setMinPlayers(legacySetting.value("min_players").toInt());
+    gameFilters().setMaxPlayers(legacySetting.value("max_players").toInt());
+
+    QStringList allFilters = legacySetting.allKeys();
+    for (int i = 0; i < allFilters.size(); ++i) {
+        if(allFilters.at(i).startsWith("game_type")){
+            gameFilters().setGameTypeEnabled(allFilters.at(i), legacySetting.value(allFilters.at(i)).toBool());
+        }
+    }
+    QStringList allKeysfilter_games = legacySetting.allKeys();
+    for (int i = 0; i < allKeysfilter_games.size(); ++i) {
+        usedKeys.append("filter_games/"+allKeysfilter_games.at(i));
+    }
+    legacySetting.endGroup();
+
+    QStringList allLegacyKeys = legacySetting.allKeys();
+    for (int i = 0; i < allLegacyKeys.size(); ++i) {
+        if(usedKeys.contains(allLegacyKeys.at(i)))
+            continue;
+        settings->setValue(allLegacyKeys.at(i), legacySetting.value(allLegacyKeys.at(i)));
+    }
 }
 
 SettingsCache::SettingsCache()
 {
-    settings = new QSettings(this);
-    shortcutsSettings = new ShortcutsSettings(getSettingsPath(),this);
+    QString settingsPath = getSettingsPath();
+    settings = new QSettings(settingsPath+"global.ini", QSettings::IniFormat, this);
+    shortcutsSettings = new ShortcutsSettings(settingsPath,this);
+    cardDatabaseSettings = new CardDatabaseSettings(settingsPath,this);
+    serversSettings = new ServersSettings(settingsPath,this);
+    messageSettings = new MessageSettings(settingsPath,this);
+    gameFiltersSettings = new GameFiltersSettings(settingsPath, this);
+    layoutsSettings = new LayoutsSettings(settingsPath, this);
+
+    if(!QFile(settingsPath+"global.ini").exists())
+        translateLegacySettings();
 
     lang = settings->value("personal/lang").toString();
     keepalive = settings->value("personal/keepalive", 5).toInt();
-
     deckPath = settings->value("paths/decks").toString();
     replaysPath = settings->value("paths/replays").toString();
     picsPath = settings->value("paths/pics").toString();
@@ -119,17 +220,6 @@ SettingsCache::SettingsCache()
     spectatorsCanTalk = settings->value("game/spectatorscantalk", false).toBool();
     spectatorsCanSeeEverything = settings->value("game/spectatorscanseeeverything", false).toBool();
     clientID = settings->value("personal/clientid", "notset").toString();
-
-    QString file = getSettingsPath();
-    file.append("layouts/deckLayout.ini");
-
-    QSettings layout_settings(file , QSettings::IniFormat);
-    deckEditorLayoutState = layout_settings.value("layouts/deckEditor_state").toByteArray();
-    deckEditorGeometry = layout_settings.value("layouts/deckEditor_geometry").toByteArray();
-
-    deckEditorCardSize = layout_settings.value("layouts/deckEditor_CardSize", QSize(250,500)).toSize();
-    deckEditorFilterSize = layout_settings.value("layouts/deckEditor_FilterSize", QSize(250,250)).toSize();
-    deckEditorDeckSize = layout_settings.value("layouts/deckEditor_DeckSize", QSize(250,360)).toSize();
 }
 
 void SettingsCache::setCardInfoViewMode(const int _viewMode) {
@@ -502,56 +592,6 @@ QStringList SettingsCache::getCountries() const
     return countries;
 }
 
-void SettingsCache::setDeckEditorLayoutState(const QByteArray &value)
-{
-    deckEditorLayoutState = value;
-
-    QString file = getSettingsPath();
-    file.append("layouts/deckLayout.ini");
-    QSettings layout_settings(file , QSettings::IniFormat);
-    layout_settings.setValue("layouts/deckEditor_state",value);
-}
-
-void SettingsCache::setDeckEditorGeometry(const QByteArray &value)
-{
-    deckEditorGeometry = value;
-
-    QString file = getSettingsPath();
-    file.append("layouts/deckLayout.ini");
-    QSettings layout_settings(file , QSettings::IniFormat);
-    layout_settings.setValue("layouts/deckEditor_geometry",value);
-}
-
-void SettingsCache::setDeckEditorCardSize(const QSize &value)
-{
-    deckEditorCardSize = value;
-
-    QString file = getSettingsPath();
-    file.append("layouts/deckLayout.ini");
-    QSettings layout_settings(file , QSettings::IniFormat);
-    layout_settings.setValue("layouts/deckEditor_CardSize",value);
-}
-
-void SettingsCache::setDeckEditorDeckSize(const QSize &value)
-{
-    deckEditorDeckSize = value;
-
-    QString file = getSettingsPath();
-    file.append("layouts/deckLayout.ini");
-    QSettings layout_settings(file , QSettings::IniFormat);
-    layout_settings.setValue("layouts/deckEditor_DeckSize",value);
-}
-
-void SettingsCache::setDeckEditorFilterSize(const QSize &value)
-{
-    deckEditorFilterSize = value;
-
-    QString file = getSettingsPath();
-    file.append("layouts/deckLayout.ini");
-    QSettings layout_settings(file , QSettings::IniFormat);
-    layout_settings.setValue("layouts/deckEditor_FilterSize",value);
-}
-
 void SettingsCache::setGameDescription(const QString _gameDescription)
 {
     gameDescription = _gameDescription;

cockatrice/src/settingscache.h

@@ -5,6 +5,11 @@
 #include <QSize>
 #include <QStringList>
 #include "shortcutssettings.h"
+#include "settings/carddatabasesettings.h"
+#include "settings/serverssettings.h"
+#include "settings/messagesettings.h"
+#include "settings/gamefilterssettings.h"
+#include "settings/layoutssettings.h"
 
 // the falbacks are used for cards without a muid
 #define PIC_URL_DEFAULT "http://gatherer.wizards.com/Handlers/Image.ashx?multiverseid=!cardid!&type=card"
@@ -48,6 +53,12 @@ signals:
 private:
     QSettings *settings;
     ShortcutsSettings *shortcutsSettings;
+    CardDatabaseSettings *cardDatabaseSettings;
+    ServersSettings *serversSettings;
+    MessageSettings *messageSettings;
+    GameFiltersSettings *gameFiltersSettings;
+    LayoutsSettings *layoutsSettings;
+
     QByteArray mainWindowGeometry;
     QString lang;
     QString deckPath, replaysPath, picsPath, cardDatabasePath, tokenDatabasePath;
@@ -103,10 +114,8 @@ private:
     bool spectatorsCanTalk;
     bool spectatorsCanSeeEverything;
     int keepalive;
-    QByteArray deckEditorLayoutState, deckEditorGeometry;
-    QSize deckEditorFilterSize, deckEditorDeckSize, deckEditorCardSize;
     QString getSettingsPath();
-
+    void translateLegacySettings();
 public:
     SettingsCache();
     const QByteArray &getMainWindowGeometry() const { return mainWindowGeometry; }
@@ -180,19 +189,13 @@ public:
     bool getSpectatorsCanSeeEverything() const { return spectatorsCanSeeEverything; }
     int getKeepAlive() const { return keepalive; }
     void setClientID(QString clientID);
-    QString getClientID() { return clientID; }
-    QByteArray getDeckEditorLayoutState() const { return deckEditorLayoutState; }
-    void setDeckEditorLayoutState(const QByteArray &value);
-    QByteArray getDeckEditorGeometry() const { return deckEditorGeometry; }
-    void setDeckEditorGeometry(const QByteArray &value);
-    QSize getDeckEditorCardSize() const { return deckEditorCardSize; }
-    void setDeckEditorCardSize(const QSize &value);
-    QSize getDeckEditorDeckSize() const { return deckEditorDeckSize; }
-    void setDeckEditorDeckSize(const QSize &value);
-    QSize getDeckEditorFilterSize() const { return deckEditorFilterSize; }
-    void setDeckEditorFilterSize(const QSize &value);
+    QString getClientID() { return clientID; }    
     ShortcutsSettings& shortcuts() const { return *shortcutsSettings; }
-
+    CardDatabaseSettings& cardDatabase() const { return *cardDatabaseSettings; }
+    ServersSettings& servers() const { return *serversSettings; }
+    MessageSettings& messages() const { return *messageSettings; }
+    GameFiltersSettings& gameFilters() const { return *gameFiltersSettings; }
+    LayoutsSettings& layouts() const { return *layoutsSettings; }
 public slots:
     void setMainWindowGeometry(const QByteArray &_mainWindowGeometry);
     void setLang(const QString &_lang);

cockatrice/src/tab_deck_editor.cpp

@@ -494,21 +494,21 @@ void TabDeckEditor::refreshShortcuts()
 
 void TabDeckEditor::loadLayout()
 {
-    MainWindow->restoreState(settingsCache->getDeckEditorLayoutState());
-    MainWindow->restoreGeometry(settingsCache->getDeckEditorGeometry());
+    MainWindow->restoreState(settingsCache->layouts().getDeckEditorLayoutState());
+    MainWindow->restoreGeometry(settingsCache->layouts().getDeckEditorGeometry());
 
     btnCard->setChecked(!cardInfoDock->isHidden());
     btnFilter->setChecked(!filterDock->isHidden());
     btnDeck->setChecked(!deckDock->isHidden());
 
-    cardInfoDock->setMinimumSize(settingsCache->getDeckEditorCardSize());
-    cardInfoDock->setMaximumSize(settingsCache->getDeckEditorCardSize());
+    cardInfoDock->setMinimumSize(settingsCache->layouts().getDeckEditorCardSize());
+    cardInfoDock->setMaximumSize(settingsCache->layouts().getDeckEditorCardSize());
 
-    filterDock->setMinimumSize(settingsCache->getDeckEditorFilterSize());
-    filterDock->setMaximumSize(settingsCache->getDeckEditorFilterSize());
+    filterDock->setMinimumSize(settingsCache->layouts().getDeckEditorFilterSize());
+    filterDock->setMaximumSize(settingsCache->layouts().getDeckEditorFilterSize());
 
-    deckDock->setMinimumSize(settingsCache->getDeckEditorDeckSize());
-    deckDock->setMaximumSize(settingsCache->getDeckEditorDeckSize());
+    deckDock->setMinimumSize(settingsCache->layouts().getDeckEditorDeckSize());
+    deckDock->setMaximumSize(settingsCache->layouts().getDeckEditorDeckSize());
 
     QTimer::singleShot(100, this, SLOT(freeDocksSize()));
 }
@@ -1009,11 +1009,11 @@ bool TabDeckEditor::eventFilter(QObject * o, QEvent * e)
             btnFilter->setChecked(false);            
     }   
     if( o == this && e->type() == QEvent::Hide){
-        settingsCache->setDeckEditorLayoutState(MainWindow->saveState());
-        settingsCache->setDeckEditorGeometry(MainWindow->saveGeometry());
-        settingsCache->setDeckEditorCardSize(cardInfoDock->size());
-        settingsCache->setDeckEditorFilterSize(filterDock->size());
-        settingsCache->setDeckEditorDeckSize(deckDock->size());
+        settingsCache->layouts().setDeckEditorLayoutState(MainWindow->saveState());
+        settingsCache->layouts().setDeckEditorGeometry(MainWindow->saveGeometry());
+        settingsCache->layouts().setDeckEditorCardSize(cardInfoDock->size());
+        settingsCache->layouts().setDeckEditorFilterSize(filterDock->size());
+        settingsCache->layouts().setDeckEditorDeckSize(deckDock->size());
     }
     return false;
 }

common/server_database_interface.h

@@ -2,8 +2,6 @@
 #define SERVER_DATABASE_INTERFACE_H
 
 #include <QObject>
-#include <QSettings>
-
 #include "server.h"
 
 class Server_DatabaseInterface : public QObject {

oracle/CMakeLists.txt

@@ -14,6 +14,12 @@ SET(oracle_SOURCES
     ../cockatrice/src/carddatabase.cpp
     ../cockatrice/src/settingscache.cpp
     ../cockatrice/src/shortcutssettings.cpp
+    ../cockatrice/src/settings/carddatabasesettings.cpp
+    ../cockatrice/src/settings/serverssettings.cpp
+    ../cockatrice/src/settings/settingsmanager.cpp
+    ../cockatrice/src/settings/messagesettings.cpp
+    ../cockatrice/src/settings/gamefilterssettings.cpp
+    ../cockatrice/src/settings/layoutssettings.cpp
     ../cockatrice/src/qt-json/json.cpp
  )