Switch current tab when opening a single-instance tab (#5651)

cockatrice/src/client/tabs/tab_supervisor.cpp

@@ -285,9 +285,15 @@ void TabSupervisor::initStartupTabs()
 {
     addDeckEditorTab(nullptr);
 
-    checkAndTrigger(aTabVisualDeckStorage, SettingsCache::instance().getTabVisualDeckStorageOpen());
+    if (SettingsCache::instance().getTabVisualDeckStorageOpen()) {
-    checkAndTrigger(aTabDeckStorage, SettingsCache::instance().getTabDeckStorageOpen());
+        openTabVisualDeckStorage();
-    checkAndTrigger(aTabReplays, SettingsCache::instance().getTabReplaysOpen());
+    }
+    if (SettingsCache::instance().getTabDeckStorageOpen()) {
+        openTabDeckStorage();
+    }
+    if (SettingsCache::instance().getTabReplaysOpen()) {
+        openTabReplays();
+    }
 }
 
 /**
@@ -360,8 +366,12 @@ void TabSupervisor::start(const ServerInfo_User &_userInfo)
     tabsMenu->addAction(aTabServer);
     tabsMenu->addAction(aTabAccount);
 
-    checkAndTrigger(aTabServer, SettingsCache::instance().getTabServerOpen());
+    if (SettingsCache::instance().getTabServerOpen()) {
-    checkAndTrigger(aTabAccount, SettingsCache::instance().getTabAccountOpen());
+        openTabServer();
+    }
+    if (SettingsCache::instance().getTabAccountOpen()) {
+        openTabAccount();
+    }
 
     updatePingTime(0, -1);
 
@@ -370,8 +380,12 @@ void TabSupervisor::start(const ServerInfo_User &_userInfo)
         tabsMenu->addAction(aTabAdmin);
         tabsMenu->addAction(aTabLog);
 
-        checkAndTrigger(aTabAdmin, SettingsCache::instance().getTabAdminOpen());
+        if (SettingsCache::instance().getTabAdminOpen()) {
-        checkAndTrigger(aTabLog, SettingsCache::instance().getTabLogOpen());
+            openTabAdmin();
+        }
+        if (SettingsCache::instance().getTabLogOpen()) {
+            openTabLog();
+        }
     }
 
     retranslateUi();
@@ -453,21 +467,37 @@ void TabSupervisor::actTabVisualDeckStorage(bool checked)
 {
     SettingsCache::instance().setTabVisualDeckStorageOpen(checked);
     if (checked && !tabVisualDeckStorage) {
+        openTabVisualDeckStorage();
+        setCurrentWidget(tabVisualDeckStorage);
+    } else if (!checked && tabVisualDeckStorage) {
+        tabVisualDeckStorage->closeRequest();
+    }
+}
+
+void TabSupervisor::openTabVisualDeckStorage()
+{
     tabVisualDeckStorage = new TabDeckStorageVisual(this);
     myAddTab(tabVisualDeckStorage, aTabVisualDeckStorage);
     connect(tabVisualDeckStorage, &Tab::closed, this, [this] {
         tabVisualDeckStorage = nullptr;
         aTabVisualDeckStorage->setChecked(false);
     });
-    } else if (!checked && tabVisualDeckStorage) {
+    aTabVisualDeckStorage->setChecked(true);
-        tabVisualDeckStorage->closeRequest();
-    }
 }
 
 void TabSupervisor::actTabServer(bool checked)
 {
     SettingsCache::instance().setTabServerOpen(checked);
     if (checked && !tabServer) {
+        openTabServer();
+        setCurrentWidget(tabServer);
+    } else if (!checked && tabServer) {
+        tabServer->closeRequest();
+    }
+}
+
+void TabSupervisor::openTabServer()
+{
     tabServer = new TabServer(this, client);
     connect(tabServer, &TabServer::roomJoined, this, &TabSupervisor::addRoomTab);
     myAddTab(tabServer, aTabServer);
@@ -475,15 +505,22 @@ void TabSupervisor::actTabServer(bool checked)
         tabServer = nullptr;
         aTabServer->setChecked(false);
     });
-    } else if (!checked && tabServer) {
+    aTabServer->setChecked(true);
-        tabServer->closeRequest();
-    }
 }
 
 void TabSupervisor::actTabAccount(bool checked)
 {
     SettingsCache::instance().setTabAccountOpen(checked);
     if (checked && !tabAccount) {
+        openTabAccount();
+        setCurrentWidget(tabAccount);
+    } else if (!checked && tabAccount) {
+        tabAccount->closeRequest();
+    }
+}
+
+void TabSupervisor::openTabAccount()
+{
     tabAccount = new TabAccount(this, client, *userInfo);
     connect(tabAccount, &TabAccount::openMessageDialog, this, &TabSupervisor::addMessageTab);
     connect(tabAccount, &TabAccount::userJoined, this, &TabSupervisor::processUserJoined);
@@ -493,15 +530,22 @@ void TabSupervisor::actTabAccount(bool checked)
         tabAccount = nullptr;
         aTabAccount->setChecked(false);
     });
-    } else if (!checked && tabAccount) {
+    aTabAccount->setChecked(true);
-        tabAccount->closeRequest();
-    }
 }
 
 void TabSupervisor::actTabDeckStorage(bool checked)
 {
     SettingsCache::instance().setTabDeckStorageOpen(checked);
     if (checked && !tabDeckStorage) {
+        openTabDeckStorage();
+        setCurrentWidget(tabDeckStorage);
+    } else if (!checked && tabDeckStorage) {
+        tabDeckStorage->closeRequest();
+    }
+}
+
+void TabSupervisor::openTabDeckStorage()
+{
     tabDeckStorage = new TabDeckStorage(this, client, userInfo);
     connect(tabDeckStorage, &TabDeckStorage::openDeckEditor, this, &TabSupervisor::addDeckEditorTab);
     myAddTab(tabDeckStorage, aTabDeckStorage);
@@ -509,15 +553,22 @@ void TabSupervisor::actTabDeckStorage(bool checked)
         tabDeckStorage = nullptr;
         aTabDeckStorage->setChecked(false);
     });
-    } else if (!checked && tabDeckStorage) {
+    aTabDeckStorage->setChecked(true);
-        tabDeckStorage->closeRequest();
-    }
 }
 
 void TabSupervisor::actTabReplays(bool checked)
 {
     SettingsCache::instance().setTabReplaysOpen(checked);
     if (checked && !tabReplays) {
+        openTabReplays();
+        setCurrentWidget(tabReplays);
+    } else if (!checked && tabReplays) {
+        tabReplays->closeRequest();
+    }
+}
+
+void TabSupervisor::openTabReplays()
+{
     tabReplays = new TabReplays(this, client, userInfo);
     connect(tabReplays, &TabReplays::openReplay, this, &TabSupervisor::openReplay);
     myAddTab(tabReplays, aTabReplays);
@@ -525,15 +576,22 @@ void TabSupervisor::actTabReplays(bool checked)
         tabReplays = nullptr;
         aTabReplays->setChecked(false);
     });
-    } else if (!checked && tabReplays) {
+    aTabReplays->setChecked(true);
-        tabReplays->closeRequest();
-    }
 }
 
 void TabSupervisor::actTabAdmin(bool checked)
 {
     SettingsCache::instance().setTabAdminOpen(checked);
     if (checked && !tabAdmin) {
+        openTabAdmin();
+        setCurrentWidget(tabAdmin);
+    } else if (!checked && tabAdmin) {
+        tabAdmin->closeRequest();
+    }
+}
+
+void TabSupervisor::openTabAdmin()
+{
     tabAdmin = new TabAdmin(this, client, (userInfo->user_level() & ServerInfo_User::IsAdmin));
     connect(tabAdmin, &TabAdmin::adminLockChanged, this, &TabSupervisor::adminLockChanged);
     myAddTab(tabAdmin, aTabAdmin);
@@ -541,24 +599,29 @@ void TabSupervisor::actTabAdmin(bool checked)
         tabAdmin = nullptr;
         aTabAdmin->setChecked(false);
     });
-    } else if (!checked && tabAdmin) {
+    aTabAdmin->setChecked(true);
-        tabAdmin->closeRequest();
-    }
 }
 
 void TabSupervisor::actTabLog(bool checked)
 {
     SettingsCache::instance().setTabLogOpen(checked);
     if (checked && !tabLog) {
+        openTabLog();
+        setCurrentWidget(tabLog);
+    } else if (!checked && tabLog) {
+        tabLog->closeRequest();
+    }
+}
+
+void TabSupervisor::openTabLog()
+{
     tabLog = new TabLog(this, client);
     myAddTab(tabLog, aTabLog);
     connect(tabLog, &Tab::closed, this, [this] {
         tabLog = nullptr;
         aTabAdmin->setChecked(false);
     });
-    } else if (!checked && tabLog) {
+    aTabAdmin->setChecked(true);
-        tabLog->closeRequest();
-    }
 }
 
 void TabSupervisor::updatePingTime(int value, int max)

cockatrice/src/client/tabs/tab_supervisor.h

@@ -163,6 +163,14 @@ private slots:
     void actTabAdmin(bool checked);
     void actTabLog(bool checked);
 
+    void openTabVisualDeckStorage();
+    void openTabServer();
+    void openTabAccount();
+    void openTabDeckStorage();
+    void openTabReplays();
+    void openTabAdmin();
+    void openTabLog();
+
     void updateCurrent(int index);
     void updatePingTime(int value, int max);
     void gameJoined(const Event_GameJoined &event);