Refactred settings to use settingscache & ini files

cockatrice/CMakeLists.txt

@@ -98,6 +98,12 @@ SET(cockatrice_SOURCES
     src/sequenceEdit/sequenceedit.cpp
     src/sequenceEdit/shortcutstab.cpp
     src/lineeditcompleter.cpp
+    src/settings/settingsmanager.cpp
+    src/settings/carddatabasesettings.cpp
+    src/settings/serverssettings.cpp
+    src/settings/messagesettings.cpp
+    src/settings/gamefilterssettings.cpp
+    src/settings/layoutssettings.cpp
     ${VERSION_STRING_CPP}
 )
 

cockatrice/src/carddatabase.cpp

@@ -5,7 +5,6 @@
 #include <QDirIterator>
 #include <QFile>
 #include <QTextStream>
-#include <QSettings>
 #include <QSvgRenderer>
 #include <QPainter>
 #include <QUrl>
@@ -50,46 +49,29 @@ QString CardSet::getCorrectedShortName() const
     return invalidFileNames.contains(shortName) ? shortName + "_" : shortName;
 }
 
-void CardSet::setSortKey(unsigned int _sortKey)
+void CardSet::loadSetOptions()
 {
-    sortKey = _sortKey;
-
-    QSettings settings;
-    settings.beginGroup("sets");
-    settings.beginGroup(shortName);
-    settings.setValue("sortkey", sortKey);
+    sortKey = settingsCache->cardDatabase().getSortKey(shortName);
+    enabled = settingsCache->cardDatabase().isEnabled(shortName);
+    isknown = settingsCache->cardDatabase().isKnown(shortName);
 }
 
-void CardSet::loadSetOptions()
+void CardSet::setSortKey(unsigned int _sortKey)
 {
-    QSettings settings;
-    settings.beginGroup("sets");
-    settings.beginGroup(shortName);
-
-    sortKey = settings.value("sortkey", 0).toInt();
-    enabled = settings.value("enabled", false).toBool();
-    isknown = settings.value("isknown", false).toBool();
-    // qDebug() << "load set" << shortName << "key" << sortKey;
+    sortKey = _sortKey;
+    settingsCache->cardDatabase().setSortKey(shortName,_sortKey);
 }
 
 void CardSet::setEnabled(bool _enabled)
 {
     enabled = _enabled;
-
-    QSettings settings;
-    settings.beginGroup("sets");
-    settings.beginGroup(shortName);
-    settings.setValue("enabled", enabled);
+    settingsCache->cardDatabase().setEnabled(shortName,_enabled);
 }
 
 void CardSet::setIsKnown(bool _isknown)
 {
     isknown = _isknown;
-
-    QSettings settings;
-    settings.beginGroup("sets");
-    settings.beginGroup(shortName);
-    settings.setValue("isknown", isknown);
+    settingsCache->cardDatabase().setIsKnown(shortName,_isknown);
 }
 
 class SetList::KeyCompareFunctor {

cockatrice/src/dlg_connect.cpp

-#include <QSettings>
 #include <QLabel>
 #include <QCheckBox>
 #include <QComboBox>
@@ -11,25 +10,23 @@
 #include <QKeyEvent>
 #include <iostream>
 #include "dlg_connect.h"
+#include "settingscache.h"
 
 DlgConnect::DlgConnect(QWidget *parent)
     : QDialog(parent)
 {
-    QSettings settings;
-    settings.beginGroup("server");
-
     previousHostButton = new QRadioButton(tr("Previous Host"), this);
-
     previousHosts = new QComboBox(this);
     previousHosts->installEventFilter(new DeleteHighlightedItemWhenShiftDelPressedEventFilter);
-    QStringList previousHostList = settings.value("previoushosts").toStringList();
+
+    QStringList previousHostList = settingsCache->servers().getPreviousHostList();
     if (previousHostList.isEmpty()) {
         previousHostList << "cockatrice.woogerworks.com";
         previousHostList << "vps.poixen.com";
         previousHostList << "chickatrice.net";
     }
     previousHosts->addItems(previousHostList);
-    previousHosts->setCurrentIndex(settings.value("previoushostindex").toInt());
+    previousHosts->setCurrentIndex(settingsCache->servers().getPrevioushostindex());
 
     newHostButton = new QRadioButton(tr("New Host"), this);
     
@@ -39,28 +36,28 @@ DlgConnect::DlgConnect(QWidget *parent)
     hostLabel->setBuddy(hostEdit);
 
     portLabel = new QLabel(tr("&Port:"));
-    portEdit = new QLineEdit(settings.value("port", "4747").toString());
+    portEdit = new QLineEdit(settingsCache->servers().getPort("4747"));
     portLabel->setBuddy(portEdit);
 
     playernameLabel = new QLabel(tr("Player &name:"));
-    playernameEdit = new QLineEdit(settings.value("playername", "Player").toString());
+    playernameEdit = new QLineEdit(settingsCache->servers().getPlayerName("Player"));
     playernameLabel->setBuddy(playernameEdit);
 
     passwordLabel = new QLabel(tr("P&assword:"));
-    passwordEdit = new QLineEdit(settings.value("password").toString());
+    passwordEdit = new QLineEdit(settingsCache->servers().getPassword());
     passwordLabel->setBuddy(passwordEdit);
     passwordEdit->setEchoMode(QLineEdit::Password);
     
     savePasswordCheckBox = new QCheckBox(tr("&Save password"));
-    savePasswordCheckBox->setChecked(settings.value("save_password", 1).toInt());
+    savePasswordCheckBox->setChecked(settingsCache->servers().getSavePassword());
 
     autoConnectCheckBox = new QCheckBox(tr("A&uto connect at start"));
     if(savePasswordCheckBox->isChecked())
     {
-        autoConnectCheckBox->setChecked(settings.value("auto_connect", 0).toInt());
+        autoConnectCheckBox->setChecked(settingsCache->servers().getAutoConnect());
         autoConnectCheckBox->setEnabled(true);
     } else {
-        settings.setValue("auto_connect", 0);
+        settingsCache->servers().setAutoConnect(0);
         autoConnectCheckBox->setChecked(0);
         autoConnectCheckBox->setEnabled(false);
     }
@@ -98,7 +95,7 @@ DlgConnect::DlgConnect(QWidget *parent)
     connect(previousHostButton, SIGNAL(toggled(bool)), this, SLOT(previousHostSelected(bool)));
     connect(newHostButton, SIGNAL(toggled(bool)), this, SLOT(newHostSelected(bool)));
 
-    if (settings.value("previoushostlogin", 1).toInt())
+    if (settingsCache->servers().getPreviousHostLogin())
         previousHostButton->setChecked(true);
     else
         newHostButton->setChecked(true);
@@ -133,14 +130,12 @@ void DlgConnect::passwordSaved(int state)
 
 void DlgConnect::actOk()
 {
-    QSettings settings;
-    settings.beginGroup("server");
-    settings.setValue("port", portEdit->text());
-    settings.setValue("playername", playernameEdit->text());
-    settings.setValue("password", savePasswordCheckBox->isChecked() ? passwordEdit->text() : QString());
-    settings.setValue("save_password", savePasswordCheckBox->isChecked() ? 1 : 0);
-    settings.setValue("auto_connect", autoConnectCheckBox->isChecked() ? 1 : 0);
-    settings.setValue("previoushostlogin", previousHostButton->isChecked() ? 1 : 0);
+    settingsCache->servers().setPort(portEdit->text());
+    settingsCache->servers().setPlayerName(playernameEdit->text());
+    settingsCache->servers().setPassword(savePasswordCheckBox->isChecked() ? passwordEdit->text() : QString());
+    settingsCache->servers().setSavePassword(savePasswordCheckBox->isChecked() ? 1 : 0);
+    settingsCache->servers().setAutoConnect(autoConnectCheckBox->isChecked() ? 1 : 0);
+    settingsCache->servers().setPreviousHostLogin(previousHostButton->isChecked() ? 1 : 0);
     
     QStringList hostList;
     if (newHostButton->isChecked())
@@ -151,9 +146,8 @@ void DlgConnect::actOk()
         if(!previousHosts->itemText(i).trimmed().isEmpty())
             hostList << previousHosts->itemText(i);
     
-    settings.setValue("previoushosts", hostList);
-    settings.setValue("previoushostindex", previousHosts->currentIndex());
-    settings.endGroup();
+    settingsCache->servers().setPreviousHostList(hostList);
+    settingsCache->servers().setPrevioushostindex(previousHosts->currentIndex());
 
     accept();
 }
@@ -165,12 +159,8 @@ QString DlgConnect::getHost() const {
 
 void DlgConnect::actCancel()
 {
-    QSettings settings;
-    settings.beginGroup("server");
-    settings.setValue("save_password", savePasswordCheckBox->isChecked() ? 1 : 0);
-    settings.setValue("auto_connect", autoConnectCheckBox->isChecked() ? 1 : 0);
-    settings.endGroup();
-    
+    settingsCache->servers().setSavePassword(savePasswordCheckBox->isChecked() ? 1 : 0);
+    settingsCache->servers().setAutoConnect( autoConnectCheckBox->isChecked() ? 1 : 0);
     reject();
 }
 

cockatrice/src/dlg_edit_password.cpp

@@ -3,21 +3,19 @@
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QMessageBox>
-#include <QSettings>
 
+#include "settingscache.h"
 #include "dlg_edit_password.h"
 
 DlgEditPassword::DlgEditPassword(QWidget *parent)
     : QDialog(parent)
 {
-    QSettings settings;
-    settings.beginGroup("server");
 
     oldPasswordLabel = new QLabel(tr("Old password:"));
     oldPasswordEdit = new QLineEdit();
 
-    if(settings.value("save_password", 1).toInt())
-        oldPasswordEdit->setText(settings.value("password").toString());
+    if(settingsCache->servers().getSavePassword())
+        oldPasswordEdit->setText(settingsCache->servers().getPassword());
 
     oldPasswordLabel->setBuddy(oldPasswordEdit);
     oldPasswordEdit->setEchoMode(QLineEdit::Password);
@@ -62,12 +60,8 @@ void DlgEditPassword::actOk()
         return;
     }
 
-    QSettings settings;
-    settings.beginGroup("server");
     // always save the password so it will be picked up by the connect dialog
-    settings.setValue("password", newPasswordEdit->text());
-    settings.endGroup();
-  
+    settingsCache->servers().setPassword(newPasswordEdit->text());
     accept();
 }
 

cockatrice/src/dlg_edit_user.cpp

-#include <QSettings>
 #include <QLabel>
 #include <QGridLayout>
 #include <QHBoxLayout>

cockatrice/src/dlg_filter_games.cpp

@@ -9,7 +9,6 @@
 #include <QVBoxLayout>
 #include <QGridLayout>
 #include <QDialogButtonBox>
-#include <QSettings>
 #include <QCryptographicHash>
 
 DlgFilterGames::DlgFilterGames(const QMap<int, QString> &_allGameTypes, const GamesProxyModel *_gamesProxyModel, QWidget *parent)
@@ -17,9 +16,6 @@ DlgFilterGames::DlgFilterGames(const QMap<int, QString> &_allGameTypes, const Ga
       allGameTypes(_allGameTypes),
       gamesProxyModel(_gamesProxyModel)
 {
-    QSettings settings;
-    settings.beginGroup("filter_games");
-
     unavailableGamesVisibleCheckBox = new QCheckBox(tr("Show &unavailable games"));
     unavailableGamesVisibleCheckBox->setChecked(gamesProxyModel->getUnavailableGamesVisible());
 

cockatrice/src/dlg_register.cpp

-#include <QSettings>
 #include <QLabel>
 #include <QCheckBox>
 #include <QGridLayout>
@@ -14,23 +13,20 @@
 DlgRegister::DlgRegister(QWidget *parent)
     : QDialog(parent)
 {
-    QSettings settings;
-    settings.beginGroup("server");
-
     hostLabel = new QLabel(tr("&Host:"));
-    hostEdit = new QLineEdit(settings.value("hostname", "cockatrice.woogerworks.com").toString());
+    hostEdit = new QLineEdit(settingsCache->servers().getHostname("cockatrice.woogerworks.com"));
     hostLabel->setBuddy(hostEdit);
 
     portLabel = new QLabel(tr("&Port:"));    
-    portEdit = new QLineEdit(settings.value("port", "4747").toString());
+    portEdit = new QLineEdit(settingsCache->servers().getPort("4747"));
     portLabel->setBuddy(portEdit);
 
     playernameLabel = new QLabel(tr("Player &name:"));    
-    playernameEdit = new QLineEdit(settings.value("playername", "Player").toString());
+    playernameEdit = new QLineEdit(settingsCache->servers().getPlayerName("Player"));
     playernameLabel->setBuddy(playernameEdit);
 
     passwordLabel = new QLabel(tr("P&assword:"));    
-    passwordEdit = new QLineEdit(settings.value("password").toString());
+    passwordEdit = new QLineEdit(settingsCache->servers().getPassword());
     passwordLabel->setBuddy(passwordEdit);
     passwordEdit->setEchoMode(QLineEdit::Password);
 
@@ -119,14 +115,11 @@ void DlgRegister::actOk()
         return;
     }
 
-    QSettings settings;
-    settings.beginGroup("server");
-    settings.setValue("hostname", hostEdit->text());
-    settings.setValue("port", portEdit->text());
-    settings.setValue("playername", playernameEdit->text());
+    settingsCache->servers().setHostName(hostEdit->text());
+    settingsCache->servers().setPort(portEdit->text());
+    settingsCache->servers().setPlayerName(playernameEdit->text());
     // always save the password so it will be picked up by the connect dialog
-    settings.setValue("password", passwordEdit->text());
-    settings.endGroup();
+    settingsCache->servers().setPassword(passwordEdit->text());
   
     accept();
 }

cockatrice/src/dlg_settings.cpp

@@ -13,7 +13,6 @@
 #include <QToolBar>
 #include <QTranslator>
 #include <QAction>
-#include <QSettings>
 #include <QApplication>
 #include <QInputDialog>
 #include <QSpinBox>
@@ -632,12 +631,11 @@ MessagesSettingsPage::MessagesSettingsPage()
     highlightGroupBox = new QGroupBox;
     highlightGroupBox->setLayout(highlightNotice);
 
-    QSettings settings;
     messageList = new QListWidget;
-    settings.beginGroup("messages");
-    int count = settings.value("count", 0).toInt();
+
+    int count = settingsCache->messages().getCount();
     for (int i = 0; i < count; i++)
-        messageList->addItem(settings.value(QString("msg%1").arg(i)).toString());
+        messageList->addItem(settingsCache->messages().getMessageAt(i));
     
     aAdd = new QAction(this);
     aAdd->setIcon(QIcon(":/resources/increment.svg"));
@@ -709,11 +707,9 @@ void MessagesSettingsPage::updateHighlightPreview() {
 
 void MessagesSettingsPage::storeSettings()
 {
-    QSettings settings;
-    settings.beginGroup("messages");
-    settings.setValue("count", messageList->count());
+    settingsCache->messages().setCount(messageList->count());
     for (int i = 0; i < messageList->count(); i++)
-        settings.setValue(QString("msg%1").arg(i), messageList->item(i)->text());
+        settingsCache->messages().setMessageAt(i, messageList->item(i)->text());
 }
 
 void MessagesSettingsPage::actAdd()

cockatrice/src/gamesmodel.cpp

 #include "gamesmodel.h"
 #include "pb/serverinfo_game.pb.h"
 #include "pixmapgenerator.h"
+#include "settingscache.h"
+
 #include <QDebug>
 #include <QIcon>
 #include <QStringList>
 #include <QDateTime>
-#include <QSettings>
-#include <QCryptographicHash>
 
 enum GameListColumn {ROOM, CREATED, DESCRIPTION, CREATOR, GAME_TYPE, RESTRICTIONS, PLAYERS, SPECTATORS};
 
@@ -283,19 +283,17 @@ void GamesProxyModel::resetFilterParameters()
 
 void GamesProxyModel::loadFilterParameters(const QMap<int, QString> &allGameTypes)
 {
-    QSettings settings;
-    settings.beginGroup("filter_games");
 
-    unavailableGamesVisible = settings.value("unavailable_games_visible", false).toBool();
-    showPasswordProtectedGames = settings.value("show_password_protected_games", true).toBool();
-    gameNameFilter = settings.value("game_name_filter", "").toString();
-    maxPlayersFilterMin = settings.value("min_players", 1).toInt();
-    maxPlayersFilterMax = settings.value("max_players", DEFAULT_MAX_PLAYERS_MAX).toInt();
+    unavailableGamesVisible = settingsCache->gameFilters().isUnavailableGamesVisible();
+    showPasswordProtectedGames = settingsCache->gameFilters().isShowPasswordProtectedGames();
+    gameNameFilter = settingsCache->gameFilters().getGameNameFilter();
+    maxPlayersFilterMin = settingsCache->gameFilters().getMinPlayers();
+    maxPlayersFilterMax = settingsCache->gameFilters().getMaxPlayers();
 
     QMapIterator<int, QString> gameTypesIterator(allGameTypes);
     while (gameTypesIterator.hasNext()) {
         gameTypesIterator.next();
-        if (settings.value("game_type/" + hashGameType(gameTypesIterator.value()), false).toBool()) {
+        if (settingsCache->gameFilters().isGameTypeEnabled(gameTypesIterator.value())){
             gameTypeFilter.insert(gameTypesIterator.key());
         }
     }
@@ -305,28 +303,19 @@ void GamesProxyModel::loadFilterParameters(const QMap<int, QString> &allGameType
 
 void GamesProxyModel::saveFilterParameters(const QMap<int, QString> &allGameTypes)
 {
-    QSettings settings;
-    settings.beginGroup("filter_games");
-
-    settings.setValue("unavailable_games_visible", unavailableGamesVisible);
-    settings.setValue(
-        "show_password_protected_games",
-        showPasswordProtectedGames
-        );
-    settings.setValue("game_name_filter", gameNameFilter);
+    settingsCache->gameFilters().setUnavailableGamesVisible(unavailableGamesVisible);
+    settingsCache->gameFilters().setShowPasswordProtectedGames(showPasswordProtectedGames);
+    settingsCache->gameFilters().setGameNameFilter(gameNameFilter);
     
     QMapIterator<int, QString> gameTypeIterator(allGameTypes);
     while (gameTypeIterator.hasNext()) {
         gameTypeIterator.next();
-
-        settings.setValue(
-            "game_type/" + hashGameType(gameTypeIterator.value()),
-            gameTypeFilter.contains(gameTypeIterator.key())
-            );
+        bool enabled = gameTypeFilter.contains(gameTypeIterator.key());
+        settingsCache->gameFilters().setGameTypeEnabled(gameTypeIterator.value(),enabled);
     }
 
-    settings.setValue("min_players", maxPlayersFilterMin);
-    settings.setValue("max_players", maxPlayersFilterMax);
+    settingsCache->gameFilters().setMinPlayers(maxPlayersFilterMin);
+    settingsCache->gameFilters().setMaxPlayers(maxPlayersFilterMax);
 }
 
 bool GamesProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &/*sourceParent*/) const
@@ -367,7 +356,3 @@ bool GamesProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &/*sourc
 
     return true;
 }
-
-QString GamesProxyModel::hashGameType(const QString &gameType) const {
-    return QCryptographicHash::hash(gameType.toUtf8(), QCryptographicHash::Md5).toHex();
-}

cockatrice/src/gamesmodel.h

@@ -53,12 +53,6 @@ private:
     int maxPlayersFilterMin, maxPlayersFilterMax;
 
     static const int DEFAULT_MAX_PLAYERS_MAX = 99;   
-
-    /*
-     * The game type might contain special characters, so to use it in
-     * QSettings we just hash it.
-     */
-    QString hashGameType(const QString &gameType) const;
 public:
     GamesProxyModel(QObject *parent = 0, ServerInfo_User *_ownUser = 0);
 

cockatrice/src/main.cpp

@@ -26,7 +26,6 @@
 #include <QTranslator>
 #include <QLibraryInfo>
 #include <QDateTime>
-#include <QSettings>
 #include <QIcon>
 #include <QDir>
 #include <QDesktopServices>

cockatrice/src/player.cpp

@@ -20,7 +20,6 @@
 #include "color.h"
 #include "deck_loader.h"
 #include "main.h"
-#include <QSettings>
 #include <QPainter>
 #include <QMenu>
 #include <QDebug>
@@ -832,12 +831,10 @@ void Player::initSayMenu()
 {
     sayMenu->clear();
 
-    QSettings settings;
-    settings.beginGroup("messages");
-    int count = settings.value("count", 0).toInt();
+    int count = settingsCache->messages().getCount();
 
     for (int i = 0; i < count; i++) {
-        QAction *newAction = new QAction(settings.value(QString("msg%1").arg(i)).toString(), this);
+        QAction *newAction = new QAction(settingsCache->messages().getMessageAt(i), this);
         if (i <= 10){
             newAction->setShortcut(QKeySequence("Ctrl+" + QString::number((i + 1) % 10)));
         }

cockatrice/src/settings/carddatabasesettings.cpp

+#include "carddatabasesettings.h"
+
+CardDatabaseSettings::CardDatabaseSettings(QString settingPath, QObject *parent)
+    : SettingsManager(settingPath+"cardDatabase.ini", parent)
+{
+}
+
+void CardDatabaseSettings::setSortKey(QString shortName, unsigned int sortKey)
+{
+    setValue(sortKey,"sortkey", "sets", shortName);
+}
+
+void CardDatabaseSettings::setEnabled(QString shortName, bool enabled)
+{
+    setValue(enabled, "enabled", "sets", shortName);
+}
+
+void CardDatabaseSettings::setIsKnown(QString shortName, bool isknown)
+{
+    setValue(isknown, "isknown", "sets", shortName);
+}
+
+unsigned int CardDatabaseSettings::getSortKey(QString shortName)
+{
+    return getValue("sortkey", "sets", shortName).toUInt();
+}
+
+bool CardDatabaseSettings::isEnabled(QString shortName)
+{
+    return getValue("enabled", "sets", shortName).toBool();
+}
+
+bool CardDatabaseSettings::isKnown(QString shortName)
+{
+    return getValue("isknown",  "sets", shortName).toBool();
+}

cockatrice/src/settings/carddatabasesettings.h

+#ifndef CARDDATABASESETTINGS_H
+#define CARDDATABASESETTINGS_H
+
+#include "settingsmanager.h"
+
+#include <QObject>
+#include <QVariant>
+#include <QSettings>
+
+class CardDatabaseSettings : public SettingsManager
+{
+    Q_OBJECT
+    friend class SettingsCache;
+public:    
+    void setSortKey(QString shortName, unsigned int sortKey);
+    void setEnabled(QString shortName, bool enabled);
+    void setIsKnown(QString shortName, bool isknown);
+
+    unsigned int getSortKey(QString shortName);
+    bool isEnabled(QString shortName);
+    bool isKnown(QString shortName);
+signals:
+
+public slots:
+
+private:
+    CardDatabaseSettings(QString settingPath, QObject *parent = 0);
+    CardDatabaseSettings( const CardDatabaseSettings& /*other*/ );
+    CardDatabaseSettings( CardDatabaseSettings& /*other*/ );
+    CardDatabaseSettings( volatile const CardDatabaseSettings& /*other*/ );
+    CardDatabaseSettings( volatile CardDatabaseSettings& /*other*/ );    
+};
+
+#endif // CARDDATABASESETTINGS_H

cockatrice/src/settings/gamefilterssettings.cpp

+#include "gamefilterssettings.h"
+#include <QCryptographicHash>
+
+GameFiltersSettings::GameFiltersSettings(QString settingPath, QObject *parent)
+    : SettingsManager(settingPath+"gamefilters.ini", parent)
+{
+}
+
+/*
+ * The game type might contain special characters, so to use it in
+ * QSettings we just hash it.
+ */
+QString GameFiltersSettings::hashGameType(const QString &gameType) const
+{
+    return QCryptographicHash::hash(gameType.toUtf8(), QCryptographicHash::Md5).toHex();
+}
+
+void GameFiltersSettings::setUnavailableGamesVisible(bool enabled)
+{
+    setValue(enabled, "unavailable_games_visible","filter_games");
+}
+
+bool GameFiltersSettings::isUnavailableGamesVisible()
+{
+    QVariant previous = getValue("unavailable_games_visible","filter_games");
+    return previous == QVariant() ? false : previous.toBool();
+}
+
+void GameFiltersSettings::setShowPasswordProtectedGames(bool show)
+{
+    setValue(show, "show_password_protected_games","filter_games");
+}
+
+bool GameFiltersSettings::isShowPasswordProtectedGames()
+{
+    QVariant previous = getValue("show_password_protected_games","filter_games");
+    return previous == QVariant() ? true : previous.toBool();
+}
+
+void GameFiltersSettings::setGameNameFilter(QString gameName)
+{
+    setValue(gameName, "game_name_filter","filter_games");
+}
+
+QString GameFiltersSettings::getGameNameFilter()
+{
+    return getValue("game_name_filter","filter_games").toString();
+}
+
+void GameFiltersSettings::setMinPlayers(int min)
+{
+    setValue(min, "min_players","filter_games");
+}
+
+int GameFiltersSettings::getMinPlayers()
+{
+    QVariant previous = getValue("min_players","filter_games");
+    return previous == QVariant() ? 1 : previous.toInt();
+}
+
+void GameFiltersSettings::setMaxPlayers(int max)
+{
+    setValue(max, "max_players","filter_games");
+}
+
+int GameFiltersSettings::getMaxPlayers()
+{
+    QVariant previous = getValue("max_players","filter_games");
+    return previous == QVariant() ? 99 : previous.toInt();
+}
+
+void GameFiltersSettings::setGameTypeEnabled(QString gametype, bool enabled)
+{
+    setValue(enabled, "game_type/"+hashGameType(gametype),"filter_games");
+}
+
+void GameFiltersSettings::setGameHashedTypeEnabled(QString gametypeHASHED, bool enabled)
+{
+    setValue(enabled, gametypeHASHED,"filter_games");
+}
+
+bool GameFiltersSettings::isGameTypeEnabled(QString gametype)
+{
+    QVariant previous = getValue("game_type/"+hashGameType(gametype),"filter_games");
+    return previous == QVariant() ? false : previous.toBool();
+}
+
+

cockatrice/src/settings/gamefilterssettings.h

+#ifndef GAMEFILTERSSETTINGS_H
+#define GAMEFILTERSSETTINGS_H
+
+#include "settingsmanager.h"
+
+class GameFiltersSettings : public SettingsManager
+{
+    Q_OBJECT
+    friend class SettingsCache;
+public:    
+    bool isUnavailableGamesVisible();
+    bool isShowPasswordProtectedGames();
+    QString getGameNameFilter();
+    int getMinPlayers();
+    int getMaxPlayers();
+    bool isGameTypeEnabled(QString gametype);
+
+    void setUnavailableGamesVisible(bool enabled);
+    void setShowPasswordProtectedGames(bool show);
+    void setGameNameFilter(QString gameName);
+    void setMinPlayers(int min);
+    void setMaxPlayers(int max);
+    void setGameTypeEnabled(QString gametype, bool enabled);
+    void setGameHashedTypeEnabled(QString gametypeHASHED, bool enabled);
+signals:
+
+public slots:
+
+private:
+    GameFiltersSettings(QString settingPath,QObject *parent = 0);
+    GameFiltersSettings( const GameFiltersSettings& /*other*/ );
+    GameFiltersSettings( GameFiltersSettings& /*other*/ );
+    GameFiltersSettings( volatile const GameFiltersSettings& /*other*/ );
+    GameFiltersSettings( volatile GameFiltersSettings& /*other*/ );
+
+    QString hashGameType(const QString &gameType) const;
+};
+
+#endif // GAMEFILTERSSETTINGS_H

cockatrice/src/settings/layoutssettings.cpp

+#include "layoutssettings.h"
+
+LayoutsSettings::LayoutsSettings(QString settingPath, QObject *parent)
+    : SettingsManager(settingPath+"layouts.ini", parent)
+{
+}
+
+const QByteArray LayoutsSettings::getDeckEditorLayoutState()
+{
+    return getValue("layouts/deckEditor_state").toByteArray();
+}
+
+void LayoutsSettings::setDeckEditorLayoutState(const QByteArray &value)
+{
+    setValue(value,"layouts/deckEditor_state");
+}
+
+const QByteArray LayoutsSettings::getDeckEditorGeometry()
+{
+    return getValue("layouts/deckEditor_geometry").toByteArray();
+}
+
+void LayoutsSettings::setDeckEditorGeometry(const QByteArray &value)
+{
+    setValue(value,"layouts/deckEditor_geometry");
+}
+
+const QSize LayoutsSettings::getDeckEditorCardSize()
+{
+    QVariant previous = getValue("layouts/deckEditor_CardSize");
+    return previous == QVariant() ? QSize(250,500) : previous.toSize();
+}
+
+void LayoutsSettings::setDeckEditorCardSize(const QSize &value)
+{
+    setValue(value,"layouts/deckEditor_CardSize");
+}
+
+const QSize LayoutsSettings::getDeckEditorDeckSize()
+{
+    QVariant previous = getValue("layouts/deckEditor_DeckSize");
+    return previous == QVariant() ? QSize(250,360) : previous.toSize();
+}
+
+void LayoutsSettings::setDeckEditorDeckSize(const QSize &value)
+{
+    setValue(value,"layouts/deckEditor_DeckSize");
+}
+
+const QSize LayoutsSettings::getDeckEditorFilterSize()
+{
+    QVariant previous = getValue("layouts/deckEditor_FilterSize");
+    return previous == QVariant() ? QSize(250,250) : previous.toSize();
+}
+
+void LayoutsSettings::setDeckEditorFilterSize(const QSize &value)
+{
+    setValue(value,"layouts/deckEditor_FilterSize");
+}

cockatrice/src/settings/layoutssettings.h

+#ifndef LAYOUTSSETTINGS_H
+#define LAYOUTSSETTINGS_H
+
+#include "settingsmanager.h"
+#include <QSize>
+
+class LayoutsSettings : public SettingsManager
+{
+    Q_OBJECT
+    friend class SettingsCache;
+public:    
+
+    void setDeckEditorLayoutState(const QByteArray &value);
+    void setDeckEditorGeometry(const QByteArray &value);
+    void setDeckEditorCardSize(const QSize &value);
+    void setDeckEditorDeckSize(const QSize &value);
+    void setDeckEditorFilterSize(const QSize &value);
+
+    const QByteArray getDeckEditorLayoutState();
+    const QByteArray getDeckEditorGeometry();
+    const QSize getDeckEditorCardSize();
+    const QSize getDeckEditorDeckSize();
+    const QSize getDeckEditorFilterSize();
+signals:
+
+public slots:
+
+private:
+    LayoutsSettings(QString settingPath,QObject *parent = 0);
+    LayoutsSettings( const LayoutsSettings& /*other*/ );
+    LayoutsSettings( LayoutsSettings& /*other*/ );
+    LayoutsSettings( volatile const LayoutsSettings& /*other*/ );
+    LayoutsSettings( volatile LayoutsSettings& /*other*/ );
+};
+
+#endif // LAYOUTSSETTINGS_H

cockatrice/src/settings/messagesettings.cpp

+#include "messagesettings.h"
+
+MessageSettings::MessageSettings(QString settingPath, QObject *parent)
+    : SettingsManager(settingPath+"messages.ini",parent)
+{
+}
+
+QString MessageSettings::getMessageAt(int index)
+{
+    return getValue(QString("msg%1").arg(index),"messages").toString();
+}
+
+int MessageSettings::getCount()
+{
+    return getValue("count", "messages").toInt();
+}
+
+void MessageSettings::setCount(int count)
+{
+    setValue(count,"count","messages");
+}
+
+void MessageSettings::setMessageAt(int index, QString message)
+{
+    setValue(message,QString("msg%1").arg(index),"messages");
+}

cockatrice/src/settings/messagesettings.h

+#ifndef MESSAGESETTINGS_H
+#define MESSAGESETTINGS_H
+
+#include "settingsmanager.h"
+
+class MessageSettings : public SettingsManager
+{
+    Q_OBJECT
+    friend class SettingsCache;
+
+public:
+    int getCount();
+    QString getMessageAt(int index);
+
+    void setCount(int count);
+    void setMessageAt(int index, QString message);
+signals:
+
+public slots:
+
+private:
+    MessageSettings(QString settingPath, QObject *parent = 0);
+    MessageSettings( const MessageSettings& /*other*/ );
+    MessageSettings( MessageSettings& /*other*/ );
+    MessageSettings( volatile const MessageSettings& /*other*/ );
+    MessageSettings( volatile MessageSettings& /*other*/ );
+};
+
+#endif // MESSAGESETTINGS_H