refactor the opening to a separate method

cockatrice/src/client/tabs/tab_supervisor.cpp

@@ -466,112 +466,147 @@ void TabSupervisor::actTabVisualDeckStorage(bool checked)
 {
     SettingsCache::instance().setTabVisualDeckStorageOpen(checked);
     if (checked && !tabVisualDeckStorage) {
+        openTabVisualDeckStorage(true);
+    } else if (!checked && tabVisualDeckStorage) {
+        tabVisualDeckStorage->closeRequest();
+    }
+}
+
+void TabSupervisor::openTabVisualDeckStorage(bool setCurrent)
+{
     tabVisualDeckStorage = new TabDeckStorageVisual(this);
-        myAddTab(tabVisualDeckStorage, !isReopeningTabs, aTabVisualDeckStorage);
+    myAddTab(tabVisualDeckStorage, setCurrent, aTabVisualDeckStorage);
     connect(tabVisualDeckStorage, &Tab::closed, this, [this] {
         tabVisualDeckStorage = nullptr;
         aTabVisualDeckStorage->setChecked(false);
     });
-    } else if (!checked && tabVisualDeckStorage) {
-        tabVisualDeckStorage->closeRequest();
-    }
 }
 
 void TabSupervisor::actTabServer(bool checked)
 {
     SettingsCache::instance().setTabServerOpen(checked);
     if (checked && !tabServer) {
+        openTabServer(true);
+    } else if (!checked && tabServer) {
+        tabServer->closeRequest();
+    }
+}
+
+void TabSupervisor::openTabServer(bool setCurrent)
+{
     tabServer = new TabServer(this, client);
     connect(tabServer, &TabServer::roomJoined, this, &TabSupervisor::addRoomTab);
-        myAddTab(tabServer, !isReopeningTabs, aTabServer);
+    myAddTab(tabServer, setCurrent, aTabServer);
     connect(tabServer, &Tab::closed, this, [this] {
         tabServer = nullptr;
         aTabServer->setChecked(false);
     });
-    } else if (!checked && tabServer) {
-        tabServer->closeRequest();
-    }
 }
 
 void TabSupervisor::actTabAccount(bool checked)
 {
     SettingsCache::instance().setTabAccountOpen(checked);
     if (checked && !tabAccount) {
+        openTabAccount(true);
+    } else if (!checked && tabAccount) {
+        tabAccount->closeRequest();
+    }
+}
+
+void TabSupervisor::openTabAccount(bool setCurrent)
+{
     tabAccount = new TabAccount(this, client, *userInfo);
     connect(tabAccount, &TabAccount::openMessageDialog, this, &TabSupervisor::addMessageTab);
     connect(tabAccount, &TabAccount::userJoined, this, &TabSupervisor::processUserJoined);
     connect(tabAccount, &TabAccount::userLeft, this, &TabSupervisor::processUserLeft);
-        myAddTab(tabAccount, !isReopeningTabs, aTabAccount);
+    myAddTab(tabAccount, setCurrent, aTabAccount);
     connect(tabAccount, &Tab::closed, this, [this] {
         tabAccount = nullptr;
         aTabAccount->setChecked(false);
     });
-    } else if (!checked && tabAccount) {
-        tabAccount->closeRequest();
-    }
 }
 
 void TabSupervisor::actTabDeckStorage(bool checked)
 {
     SettingsCache::instance().setTabDeckStorageOpen(checked);
     if (checked && !tabDeckStorage) {
+        openTabDeckStorage(true);
+    } else if (!checked && tabDeckStorage) {
+        tabDeckStorage->closeRequest();
+    }
+}
+
+void TabSupervisor::openTabDeckStorage(bool setCurrent)
+{
     tabDeckStorage = new TabDeckStorage(this, client, userInfo);
     connect(tabDeckStorage, &TabDeckStorage::openDeckEditor, this, &TabSupervisor::addDeckEditorTab);
-        myAddTab(tabDeckStorage, !isReopeningTabs, aTabDeckStorage);
+    myAddTab(tabDeckStorage, setCurrent, aTabDeckStorage);
     connect(tabDeckStorage, &Tab::closed, this, [this] {
         tabDeckStorage = nullptr;
         aTabDeckStorage->setChecked(false);
     });
-    } else if (!checked && tabDeckStorage) {
-        tabDeckStorage->closeRequest();
-    }
 }
 
 void TabSupervisor::actTabReplays(bool checked)
 {
     SettingsCache::instance().setTabReplaysOpen(checked);
     if (checked && !tabReplays) {
+        openTabReplays(true);
+    } else if (!checked && tabReplays) {
+        tabReplays->closeRequest();
+    }
+}
+
+void TabSupervisor::openTabReplays(bool setCurrent)
+{
     tabReplays = new TabReplays(this, client, userInfo);
     connect(tabReplays, &TabReplays::openReplay, this, &TabSupervisor::openReplay);
-        myAddTab(tabReplays, !isReopeningTabs, aTabReplays);
+    myAddTab(tabReplays, setCurrent, aTabReplays);
     connect(tabReplays, &Tab::closed, this, [this] {
         tabReplays = nullptr;
         aTabReplays->setChecked(false);
     });
-    } else if (!checked && tabReplays) {
-        tabReplays->closeRequest();
-    }
 }
 
 void TabSupervisor::actTabAdmin(bool checked)
 {
     SettingsCache::instance().setTabAdminOpen(checked);
     if (checked && !tabAdmin) {
+        openTabAdmin(true);
+    } else if (!checked && tabAdmin) {
+        tabAdmin->closeRequest();
+    }
+}
+
+void TabSupervisor::openTabAdmin(bool setCurrent)
+{
     tabAdmin = new TabAdmin(this, client, (userInfo->user_level() & ServerInfo_User::IsAdmin));
     connect(tabAdmin, &TabAdmin::adminLockChanged, this, &TabSupervisor::adminLockChanged);
-        myAddTab(tabAdmin, !isReopeningTabs, aTabAdmin);
+    myAddTab(tabAdmin, setCurrent, aTabAdmin);
     connect(tabAdmin, &Tab::closed, this, [this] {
         tabAdmin = nullptr;
         aTabAdmin->setChecked(false);
     });
-    } else if (!checked && tabAdmin) {
-        tabAdmin->closeRequest();
-    }
 }
 
 void TabSupervisor::actTabLog(bool checked)
 {
     SettingsCache::instance().setTabLogOpen(checked);
     if (checked && !tabLog) {
+        openTabLog(true);
+    } else if (!checked && tabLog) {
+        tabLog->closeRequest();
+    }
+}
+
+void TabSupervisor::openTabLog(bool setCurrent)
+{
     tabLog = new TabLog(this, client);
-        myAddTab(tabLog, !isReopeningTabs, aTabLog);
+    myAddTab(tabLog, setCurrent, aTabLog);
     connect(tabLog, &Tab::closed, this, [this] {
         tabLog = nullptr;
         aTabAdmin->setChecked(false);
     });
-    } else if (!checked && tabLog) {
-        tabLog->closeRequest();
-    }
 }
 
 void TabSupervisor::updatePingTime(int value, int max)

cockatrice/src/client/tabs/tab_supervisor.h

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