Invert "Show" games, so all games are visible by default

- Fix #4185

cockatrice/src/dialogs/dlg_filter_games.cpp

@@ -24,19 +24,19 @@ DlgFilterGames::DlgFilterGames(const QMap<int, QString> &_allGameTypes,
                   {QTime(1, 0), tr("1 hour")},
                   {QTime(2, 0), tr("2 hours")}})
 {
-    showBuddiesOnlyGames = new QCheckBox(tr("Show '&buddies only' games"));
+    showBuddiesOnlyGames = new QCheckBox(tr("Hide 'buddies only' games"));
     showBuddiesOnlyGames->setChecked(gamesProxyModel->getShowBuddiesOnlyGames());
 
-    showFullGames = new QCheckBox(tr("Show &full games"));
+    showFullGames = new QCheckBox(tr("Hide full games"));
     showFullGames->setChecked(gamesProxyModel->getShowFullGames());
 
-    showGamesThatStarted = new QCheckBox(tr("Show games &that have started"));
+    showGamesThatStarted = new QCheckBox(tr("Hide games that have started"));
     showGamesThatStarted->setChecked(gamesProxyModel->getShowGamesThatStarted());
 
-    showPasswordProtectedGames = new QCheckBox(tr("Show &password protected games"));
+    showPasswordProtectedGames = new QCheckBox(tr("Hide password protected games"));
     showPasswordProtectedGames->setChecked(gamesProxyModel->getShowPasswordProtectedGames());
 
-    hideIgnoredUserGames = new QCheckBox(tr("Hide '&ignored user' games"));
+    hideIgnoredUserGames = new QCheckBox(tr("Hide 'ignored user' games"));
     hideIgnoredUserGames->setChecked(gamesProxyModel->getHideIgnoredUserGames());
 
     maxGameAgeComboBox = new QComboBox();

cockatrice/src/game/games_model.cpp

@@ -26,15 +26,6 @@ enum GameListColumn
     SPECTATORS
 };
 
-const bool DEFAULT_SHOW_FULL_GAMES = true;
-const bool DEFAULT_SHOW_GAMES_THAT_STARTED = true;
-const bool DEFAULT_SHOW_PASSWORD_PROTECTED_GAMES = true;
-const bool DEFAULT_SHOW_BUDDIES_ONLY_GAMES = true;
-const bool DEFAULT_HIDE_IGNORED_USER_GAMES = false;
-const bool DEFAULT_SHOW_ONLY_IF_SPECTATORS_CAN_WATCH = false;
-const bool DEFAULT_SHOW_SPECTATOR_PASSWORD_PROTECTED = true;
-const bool DEFAULT_SHOW_ONLY_IF_SPECTATORS_CAN_CHAT = false;
-const bool DEFAULT_SHOW_ONLY_IF_SPECTATORS_CAN_SEE_HANDS = false;
 const int DEFAULT_MAX_PLAYERS_MIN = 1;
 const int DEFAULT_MAX_PLAYERS_MAX = 99;
 constexpr QTime DEFAULT_MAX_GAME_AGE = QTime();
@@ -295,7 +286,7 @@ GamesProxyModel::GamesProxyModel(QObject *parent, const UserListProxy *_userList
 
 void GamesProxyModel::setShowBuddiesOnlyGames(bool _showBuddiesOnlyGames)
 {
-    showBuddiesOnlyGames = _showBuddiesOnlyGames;
+    hideBuddiesOnlyGames = _showBuddiesOnlyGames;
     invalidateFilter();
 }
 
@@ -307,19 +298,19 @@ void GamesProxyModel::setHideIgnoredUserGames(bool _hideIgnoredUserGames)
 
 void GamesProxyModel::setShowFullGames(bool _showFullGames)
 {
-    showFullGames = _showFullGames;
+    hideFullGames = _showFullGames;
     invalidateFilter();
 }
 
 void GamesProxyModel::setShowGamesThatStarted(bool _showGamesThatStarted)
 {
-    showGamesThatStarted = _showGamesThatStarted;
+    hideGamesThatStarted = _showGamesThatStarted;
     invalidateFilter();
 }
 
 void GamesProxyModel::setShowPasswordProtectedGames(bool _showPasswordProtectedGames)
 {
-    showPasswordProtectedGames = _showPasswordProtectedGames;
+    hidePasswordProtectedGames = _showPasswordProtectedGames;
     invalidateFilter();
 }
 
@@ -395,47 +386,43 @@ int GamesProxyModel::getNumFilteredGames() const
 
 void GamesProxyModel::resetFilterParameters()
 {
-    showFullGames = DEFAULT_SHOW_FULL_GAMES;
+    hideFullGames = false;
-    showGamesThatStarted = DEFAULT_SHOW_GAMES_THAT_STARTED;
+    hideGamesThatStarted = false;
-    showPasswordProtectedGames = DEFAULT_SHOW_PASSWORD_PROTECTED_GAMES;
+    hidePasswordProtectedGames = false;
-    showBuddiesOnlyGames = DEFAULT_SHOW_BUDDIES_ONLY_GAMES;
+    hideBuddiesOnlyGames = false;
-    hideIgnoredUserGames = DEFAULT_HIDE_IGNORED_USER_GAMES;
+    hideIgnoredUserGames = false;
     gameNameFilter = QString();
     creatorNameFilter = QString();
     gameTypeFilter.clear();
     maxPlayersFilterMin = DEFAULT_MAX_PLAYERS_MIN;
     maxPlayersFilterMax = DEFAULT_MAX_PLAYERS_MAX;
     maxGameAge = DEFAULT_MAX_GAME_AGE;
-    showOnlyIfSpectatorsCanWatch = DEFAULT_SHOW_ONLY_IF_SPECTATORS_CAN_WATCH;
+    showOnlyIfSpectatorsCanWatch = false;
-    showSpectatorPasswordProtected = DEFAULT_SHOW_SPECTATOR_PASSWORD_PROTECTED;
+    showSpectatorPasswordProtected = false;
-    showOnlyIfSpectatorsCanChat = DEFAULT_SHOW_ONLY_IF_SPECTATORS_CAN_CHAT;
+    showOnlyIfSpectatorsCanChat = false;
-    showOnlyIfSpectatorsCanSeeHands = DEFAULT_SHOW_ONLY_IF_SPECTATORS_CAN_SEE_HANDS;
+    showOnlyIfSpectatorsCanSeeHands = false;
 
     invalidateFilter();
 }
 
 bool GamesProxyModel::areFilterParametersSetToDefaults() const
 {
-    return showFullGames == DEFAULT_SHOW_FULL_GAMES && showGamesThatStarted == DEFAULT_SHOW_GAMES_THAT_STARTED &&
+    return !hideFullGames && !hideGamesThatStarted && !hidePasswordProtectedGames && !hideBuddiesOnlyGames &&
-           showPasswordProtectedGames == DEFAULT_SHOW_PASSWORD_PROTECTED_GAMES &&
+           !hideIgnoredUserGames && gameNameFilter.isEmpty() && creatorNameFilter.isEmpty() &&
-           showBuddiesOnlyGames == DEFAULT_SHOW_BUDDIES_ONLY_GAMES &&
+           gameTypeFilter.isEmpty() && maxPlayersFilterMin == DEFAULT_MAX_PLAYERS_MIN &&
-           hideIgnoredUserGames == DEFAULT_HIDE_IGNORED_USER_GAMES && gameNameFilter.isEmpty() &&
-           creatorNameFilter.isEmpty() && gameTypeFilter.isEmpty() && maxPlayersFilterMin == DEFAULT_MAX_PLAYERS_MIN &&
            maxPlayersFilterMax == DEFAULT_MAX_PLAYERS_MAX && maxGameAge == DEFAULT_MAX_GAME_AGE &&
-           showOnlyIfSpectatorsCanWatch == DEFAULT_SHOW_ONLY_IF_SPECTATORS_CAN_WATCH &&
+           !showOnlyIfSpectatorsCanWatch && !showSpectatorPasswordProtected && !showOnlyIfSpectatorsCanChat &&
-           showSpectatorPasswordProtected == DEFAULT_SHOW_SPECTATOR_PASSWORD_PROTECTED &&
+           !showOnlyIfSpectatorsCanSeeHands;
-           showOnlyIfSpectatorsCanChat == DEFAULT_SHOW_ONLY_IF_SPECTATORS_CAN_CHAT &&
-           showOnlyIfSpectatorsCanSeeHands == DEFAULT_SHOW_ONLY_IF_SPECTATORS_CAN_SEE_HANDS;
 }
 
 void GamesProxyModel::loadFilterParameters(const QMap<int, QString> &allGameTypes)
 {
     GameFiltersSettings &gameFilters = SettingsCache::instance().gameFilters();
-    showFullGames = gameFilters.isShowFullGames();
+    hideFullGames = gameFilters.isHideFullGames();
-    showGamesThatStarted = gameFilters.isShowGamesThatStarted();
+    hideGamesThatStarted = gameFilters.isHideGamesThatStarted();
-    showPasswordProtectedGames = gameFilters.isShowPasswordProtectedGames();
+    hidePasswordProtectedGames = gameFilters.isHidePasswordProtectedGames();
     hideIgnoredUserGames = gameFilters.isHideIgnoredUserGames();
-    showBuddiesOnlyGames = gameFilters.isShowBuddiesOnlyGames();
+    hideBuddiesOnlyGames = gameFilters.isHideBuddiesOnlyGames();
     gameNameFilter = gameFilters.getGameNameFilter();
     creatorNameFilter = gameFilters.getCreatorNameFilter();
     maxPlayersFilterMin = gameFilters.getMinPlayers();
@@ -460,10 +447,10 @@ void GamesProxyModel::loadFilterParameters(const QMap<int, QString> &allGameType
 void GamesProxyModel::saveFilterParameters(const QMap<int, QString> &allGameTypes)
 {
     GameFiltersSettings &gameFilters = SettingsCache::instance().gameFilters();
-    gameFilters.setShowBuddiesOnlyGames(showBuddiesOnlyGames);
+    gameFilters.setHideBuddiesOnlyGames(hideBuddiesOnlyGames);
-    gameFilters.setShowFullGames(showFullGames);
+    gameFilters.setHideFullGames(hideFullGames);
-    gameFilters.setShowGamesThatStarted(showGamesThatStarted);
+    gameFilters.setHideGamesThatStarted(hideGamesThatStarted);
-    gameFilters.setShowPasswordProtectedGames(showPasswordProtectedGames);
+    gameFilters.setHidePasswordProtectedGames(hidePasswordProtectedGames);
     gameFilters.setHideIgnoredUserGames(hideIgnoredUserGames);
     gameFilters.setGameNameFilter(gameNameFilter);
     gameFilters.setCreatorNameFilter(creatorNameFilter);
@@ -505,20 +492,20 @@ bool GamesProxyModel::filterAcceptsRow(int sourceRow) const
 
     const ServerInfo_Game &game = model->getGame(sourceRow);
 
-    if (!showBuddiesOnlyGames && game.only_buddies()) {
+    if (hideBuddiesOnlyGames && game.only_buddies()) {
         return false;
     }
     if (hideIgnoredUserGames && userListProxy->isUserIgnored(QString::fromStdString(game.creator_info().name()))) {
         return false;
     }
-    if (!showFullGames && game.player_count() == game.max_players())
+    if (hideFullGames && game.player_count() == game.max_players())
         return false;
-    if (!showGamesThatStarted && game.started())
+    if (hideGamesThatStarted && game.started())
         return false;
     if (!userListProxy->isOwnUserRegistered())
         if (game.only_registered())
             return false;
-    if (!showPasswordProtectedGames && game.with_password())
+    if (hidePasswordProtectedGames && game.with_password())
         return false;
     if (!gameNameFilter.isEmpty())
         if (!QString::fromStdString(game.description()).contains(gameNameFilter, Qt::CaseInsensitive))

cockatrice/src/game/games_model.h

@@ -75,11 +75,11 @@ private:
     // - loadFilterParameters()
     // - saveFilterParameters()
     // - filterAcceptsRow()
-    bool showBuddiesOnlyGames;
+    bool hideBuddiesOnlyGames;
     bool hideIgnoredUserGames;
-    bool showFullGames;
+    bool hideFullGames;
-    bool showGamesThatStarted;
+    bool hideGamesThatStarted;
-    bool showPasswordProtectedGames;
+    bool hidePasswordProtectedGames;
     QString gameNameFilter, creatorNameFilter;
     QSet<int> gameTypeFilter;
     quint32 maxPlayersFilterMin, maxPlayersFilterMax;
@@ -92,7 +92,7 @@ public:
 
     bool getShowBuddiesOnlyGames() const
     {
-        return showBuddiesOnlyGames;
+        return hideBuddiesOnlyGames;
     }
     void setShowBuddiesOnlyGames(bool _showBuddiesOnlyGames);
     bool getHideIgnoredUserGames() const
@@ -102,17 +102,17 @@ public:
     void setHideIgnoredUserGames(bool _hideIgnoredUserGames);
     bool getShowFullGames() const
     {
-        return showFullGames;
+        return hideFullGames;
     }
     void setShowFullGames(bool _showFullGames);
     bool getShowGamesThatStarted() const
     {
-        return showGamesThatStarted;
+        return hideGamesThatStarted;
     }
     void setShowGamesThatStarted(bool _showGamesThatStarted);
     bool getShowPasswordProtectedGames() const
     {
-        return showPasswordProtectedGames;
+        return hidePasswordProtectedGames;
     }
     void setShowPasswordProtectedGames(bool _showPasswordProtectedGames);
     QString getGameNameFilter() const

cockatrice/src/settings/cache_settings.cpp

@@ -104,11 +104,7 @@ void SettingsCache::translateLegacySettings()
 
     // Game filters
     legacySetting.beginGroup("filter_games");
-    gameFilters().setShowFullGames(legacySetting.value("unavailable_games_visible").toBool());
-    gameFilters().setShowGamesThatStarted(legacySetting.value("unavailable_games_visible").toBool());
-    gameFilters().setShowPasswordProtectedGames(legacySetting.value("show_password_protected_games").toBool());
     gameFilters().setGameNameFilter(legacySetting.value("game_name_filter").toString());
-    gameFilters().setShowBuddiesOnlyGames(legacySetting.value("show_buddies_only_games").toBool());
     gameFilters().setHideIgnoredUserGames(legacySetting.value("hide_ignored_user_games").toBool());
     gameFilters().setMinPlayers(legacySetting.value("min_players").toInt());
 

cockatrice/src/settings/game_filters_settings.cpp

@@ -17,48 +17,48 @@ QString GameFiltersSettings::hashGameType(const QString &gameType) const
     return QCryptographicHash::hash(gameType.toUtf8(), QCryptographicHash::Md5).toHex();
 }
 
-void GameFiltersSettings::setShowBuddiesOnlyGames(bool show)
+void GameFiltersSettings::setHideBuddiesOnlyGames(bool hide)
 {
-    setValue(show, "show_buddies_only_games", "filter_games");
+    setValue(hide, "hide_buddies_only_games", "filter_games");
 }
 
-bool GameFiltersSettings::isShowBuddiesOnlyGames()
+bool GameFiltersSettings::isHideBuddiesOnlyGames()
 {
-    QVariant previous = getValue("show_buddies_only_games", "filter_games");
+    QVariant previous = getValue("hide_buddies_only_games", "filter_games");
-    return previous == QVariant() ? true : previous.toBool();
+    return previous == QVariant() || previous.toBool();
 }
 
-void GameFiltersSettings::setShowFullGames(bool show)
+void GameFiltersSettings::setHideFullGames(bool hide)
 {
-    setValue(show, "show_full_games", "filter_games");
+    setValue(hide, "hide_full_games", "filter_games");
 }
 
-bool GameFiltersSettings::isShowFullGames()
+bool GameFiltersSettings::isHideFullGames()
 {
-    QVariant previous = getValue("show_full_games", "filter_games");
+    QVariant previous = getValue("hide_full_games", "filter_games");
-    return previous == QVariant() ? false : previous.toBool();
+    return !(previous == QVariant()) && previous.toBool();
 }
 
-void GameFiltersSettings::setShowGamesThatStarted(bool show)
+void GameFiltersSettings::setHideGamesThatStarted(bool hide)
 {
-    setValue(show, "show_games_that_started", "filter_games");
+    setValue(hide, "hide_games_that_started", "filter_games");
 }
 
-bool GameFiltersSettings::isShowGamesThatStarted()
+bool GameFiltersSettings::isHideGamesThatStarted()
 {
-    QVariant previous = getValue("show_games_that_started", "filter_games");
+    QVariant previous = getValue("hide_games_that_started", "filter_games");
-    return previous == QVariant() ? false : previous.toBool();
+    return !(previous == QVariant()) && previous.toBool();
 }
 
-void GameFiltersSettings::setShowPasswordProtectedGames(bool show)
+void GameFiltersSettings::setHidePasswordProtectedGames(bool hide)
 {
-    setValue(show, "show_password_protected_games", "filter_games");
+    setValue(hide, "hide_password_protected_games", "filter_games");
 }
 
-bool GameFiltersSettings::isShowPasswordProtectedGames()
+bool GameFiltersSettings::isHidePasswordProtectedGames()
 {
-    QVariant previous = getValue("show_password_protected_games", "filter_games");
+    QVariant previous = getValue("hide_password_protected_games", "filter_games");
-    return previous == QVariant() ? true : previous.toBool();
+    return previous == QVariant() || previous.toBool();
 }
 
 void GameFiltersSettings::setHideIgnoredUserGames(bool hide)
@@ -69,7 +69,7 @@ void GameFiltersSettings::setHideIgnoredUserGames(bool hide)
 bool GameFiltersSettings::isHideIgnoredUserGames()
 {
     QVariant previous = getValue("hide_ignored_user_games", "filter_games");
-    return previous == QVariant() ? false : previous.toBool();
+    return !(previous == QVariant()) && previous.toBool();
 }
 
 void GameFiltersSettings::setGameNameFilter(QString gameName)

cockatrice/src/settings/game_filters_settings.h

@@ -9,10 +9,10 @@ class GameFiltersSettings : public SettingsManager
     friend class SettingsCache;
 
 public:
-    bool isShowBuddiesOnlyGames();
+    bool isHideBuddiesOnlyGames();
-    bool isShowFullGames();
+    bool isHideFullGames();
-    bool isShowGamesThatStarted();
+    bool isHideGamesThatStarted();
-    bool isShowPasswordProtectedGames();
+    bool isHidePasswordProtectedGames();
     bool isHideIgnoredUserGames();
     QString getGameNameFilter();
     QString getCreatorNameFilter();
@@ -25,11 +25,11 @@ public:
     bool isShowOnlyIfSpectatorsCanChat();
     bool isShowOnlyIfSpectatorsCanSeeHands();
 
-    void setShowBuddiesOnlyGames(bool show);
+    void setHideBuddiesOnlyGames(bool hide);
     void setHideIgnoredUserGames(bool hide);
-    void setShowFullGames(bool show);
+    void setHideFullGames(bool hide);
-    void setShowGamesThatStarted(bool show);
+    void setHideGamesThatStarted(bool hide);
-    void setShowPasswordProtectedGames(bool show);
+    void setHidePasswordProtectedGames(bool hide);
     void setGameNameFilter(QString gameName);
     void setCreatorNameFilter(QString creatorName);
     void setMinPlayers(int min);