split nexus connection stuff into NexusConnectionUI so it can be reused in the instance creation dialog

removed the PluginContainer* parameter from NexusInterface::instance()
 - it's a singleton, so it only needs to be given once, not every time
 - it doesn't even matter because the first time instance() is called, it creates the singleton, but the plugin container is always null
 - and setPluginContainer() is called much later from OrganizerCore with the correct value
added non functional nexus page to instance creation dialog

14 files changed, 510 insertions, 268 deletions

diff --git a/src/createinstancedialog.cpp b/src/createinstancedialog.cpp
index 75ccc774..935b9ee9 100644
--- a/src/createinstancedialog.cpp
+++ b/src/createinstancedialog.cpp
@@ -25,6 +25,7 @@ CreateInstanceDialog::CreateInstanceDialog(
   m_pages.push_back(std::make_unique<EditionsPage>(*this));
   m_pages.push_back(std::make_unique<NamePage>(*this));
   m_pages.push_back(std::make_unique<PathsPage>(*this));
+  m_pages.push_back(std::make_unique<NexusPage>(*this));
   m_pages.push_back(std::make_unique<ConfirmationPage>(*this));
 
   ui->pages->setCurrentIndex(0);
diff --git a/src/createinstancedialog.ui b/src/createinstancedialog.ui
index a8f21c51..ebaef84d 100644
--- a/src/createinstancedialog.ui
+++ b/src/createinstancedialog.ui
@@ -266,8 +266,8 @@
                  <rect>
                   <x>0</x>
                   <y>0</y>
-                  <width>98</width>
-                  <height>28</height>
+                  <width>63</width>
+                  <height>16</height>
                  </rect>
                 </property>
                 <layout class="QVBoxLayout" name="verticalLayout_26">
@@ -283,13 +283,6 @@
                  <property name="bottomMargin">
                   <number>0</number>
                  </property>
-                 <item>
-                  <widget class="QPushButton" name="pushButton">
-                   <property name="text">
-                    <string>PushButton</string>
-                   </property>
-                  </widget>
-                 </item>
                 </layout>
                </widget>
               </widget>
@@ -409,8 +402,8 @@
               <rect>
                <x>0</x>
                <y>0</y>
-               <width>98</width>
-               <height>28</height>
+               <width>63</width>
+               <height>16</height>
               </rect>
              </property>
              <layout class="QVBoxLayout" name="verticalLayout_17">
@@ -886,6 +879,148 @@
        </item>
       </layout>
      </widget>
+     <widget class="QWidget" name="page_3">
+      <layout class="QVBoxLayout" name="verticalLayout_4">
+       <item>
+        <widget class="QWidget" name="widget_4" native="true">
+         <layout class="QVBoxLayout" name="verticalLayout_29">
+          <property name="leftMargin">
+           <number>0</number>
+          </property>
+          <property name="topMargin">
+           <number>0</number>
+          </property>
+          <property name="rightMargin">
+           <number>0</number>
+          </property>
+          <property name="bottomMargin">
+           <number>0</number>
+          </property>
+          <item>
+           <widget class="QLabel" name="label_7">
+            <property name="text">
+             <string>&lt;h3&gt;Link Mod Organizer with your Nexus account&lt;/h3&gt;</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QLabel" name="label_18">
+            <property name="text">
+             <string>Linking with Nexus allows you to download mods directly from Mod Organizer and automatically check for updates. This is optional.</string>
+            </property>
+            <property name="wordWrap">
+             <bool>true</bool>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QWidget" name="nexusBox" native="true">
+         <property name="minimumSize">
+          <size>
+           <width>0</width>
+           <height>100</height>
+          </size>
+         </property>
+         <layout class="QVBoxLayout" name="verticalLayout_30">
+          <property name="leftMargin">
+           <number>0</number>
+          </property>
+          <property name="topMargin">
+           <number>9</number>
+          </property>
+          <property name="rightMargin">
+           <number>0</number>
+          </property>
+          <property name="bottomMargin">
+           <number>0</number>
+          </property>
+          <item>
+           <widget class="QWidget" name="nexusBox_2" native="true">
+            <layout class="QVBoxLayout" name="verticalLayout_27">
+             <property name="leftMargin">
+              <number>0</number>
+             </property>
+             <property name="topMargin">
+              <number>0</number>
+             </property>
+             <property name="rightMargin">
+              <number>0</number>
+             </property>
+             <property name="bottomMargin">
+              <number>0</number>
+             </property>
+             <item>
+              <widget class="QWidget" name="widget_22" native="true">
+               <layout class="QHBoxLayout" name="horizontalLayout_7">
+                <property name="leftMargin">
+                 <number>0</number>
+                </property>
+                <property name="topMargin">
+                 <number>0</number>
+                </property>
+                <property name="rightMargin">
+                 <number>0</number>
+                </property>
+                <property name="bottomMargin">
+                 <number>0</number>
+                </property>
+                <item>
+                 <widget class="QPushButton" name="nexusConnect">
+                  <property name="text">
+                   <string>Connect to Nexus</string>
+                  </property>
+                 </widget>
+                </item>
+                <item>
+                 <spacer name="horizontalSpacer_2">
+                  <property name="orientation">
+                   <enum>Qt::Horizontal</enum>
+                  </property>
+                  <property name="sizeHint" stdset="0">
+                   <size>
+                    <width>40</width>
+                    <height>20</height>
+                   </size>
+                  </property>
+                 </spacer>
+                </item>
+                <item>
+                 <widget class="QPushButton" name="nexusManual">
+                  <property name="text">
+                   <string>Enter API Key Manually</string>
+                  </property>
+                 </widget>
+                </item>
+               </layout>
+              </widget>
+             </item>
+             <item>
+              <widget class="QListWidget" name="nexusLog"/>
+             </item>
+            </layout>
+           </widget>
+          </item>
+          <item>
+           <spacer name="verticalSpacer_8">
+            <property name="orientation">
+             <enum>Qt::Vertical</enum>
+            </property>
+            <property name="sizeHint" stdset="0">
+             <size>
+              <width>20</width>
+              <height>40</height>
+             </size>
+            </property>
+           </spacer>
+          </item>
+         </layout>
+        </widget>
+       </item>
+      </layout>
+     </widget>
      <widget class="QWidget" name="page_11">
       <layout class="QVBoxLayout" name="verticalLayout_22">
        <item>
@@ -1057,6 +1192,8 @@
    </item>
   </layout>
  </widget>
- <resources/>
+ <resources>
+  <include location="resources.qrc"/>
+ </resources>
  <connections/>
 </ui>
diff --git a/src/createinstancedialogpages.cpp b/src/createinstancedialogpages.cpp
index f37853f0..37d50ee1 100644
--- a/src/createinstancedialogpages.cpp
+++ b/src/createinstancedialogpages.cpp
@@ -997,6 +997,26 @@ bool PathsPage::checkPath(
 }
 
 
+NexusPage::NexusPage(CreateInstanceDialog& dlg)
+  : Page(dlg)
+{
+}
+
+bool NexusPage::ready() const
+{
+  return true;
+}
+
+bool NexusPage::skip() const
+{
+  return Settings::instance().nexus().hasApiKey();
+}
+
+void NexusPage::activated()
+{
+}
+
+
 ConfirmationPage::ConfirmationPage(CreateInstanceDialog& dlg)
   : Page(dlg)
 {
diff --git a/src/createinstancedialogpages.h b/src/createinstancedialogpages.h
index f2f4216d..88e49628 100644
--- a/src/createinstancedialogpages.h
+++ b/src/createinstancedialogpages.h
@@ -203,6 +203,20 @@ private:
 };
 
 
+class NexusPage : public Page
+{
+public:
+  NexusPage(CreateInstanceDialog& dlg);
+
+  bool ready() const override;
+  bool skip() const override;
+  void activated() override;
+
+private:
+
+};
+
+
 class ConfirmationPage : public Page
 {
 public:
diff --git a/src/main.cpp b/src/main.cpp
index 58e22466..93580931 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -395,7 +395,7 @@ int runApplication(
 
     QString apiKey;
     if (settings.nexus().apiKey(apiKey)) {
-      NexusInterface::instance(pluginContainer.get())->getAccessManager()->apiCheck(apiKey);
+      NexusInterface::instance().getAccessManager()->apiCheck(apiKey);
     }
 
     log::debug("initializing tutorials");
@@ -415,8 +415,8 @@ int runApplication(
       // set up main window and its data structures
       MainWindow mainWindow(settings, organizer, *pluginContainer);
 
-      NexusInterface::instance(pluginContainer.get())
-        ->getAccessManager()->setTopLevelWidget(&mainWindow);
+      NexusInterface::instance()
+        .getAccessManager()->setTopLevelWidget(&mainWindow);
 
       QObject::connect(&mainWindow, SIGNAL(styleChanged(QString)), &application,
                        SLOT(setStyleFile(QString)));
@@ -443,8 +443,8 @@ int runApplication(
       res = application.exec();
       mainWindow.close();
 
-      NexusInterface::instance(pluginContainer.get())
-        ->getAccessManager()->setTopLevelWidget(nullptr);
+      NexusInterface::instance()
+        .getAccessManager()->setTopLevelWidget(nullptr);
     }
 
     settings.geometry().resetIfNeeded();
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 60ad77a0..9144210c 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -291,7 +291,7 @@ MainWindow::MainWindow(Settings &settings
   ui->statusBar->setup(ui, settings);
 
   {
-    auto* ni = NexusInterface::instance(&m_PluginContainer);
+    auto* ni = &NexusInterface::instance();
 
     // there are two ways to get here:
     //  1) the user just started MO, and
@@ -439,24 +439,24 @@ MainWindow::MainWindow(Settings &settings
   connect(m_OrganizerCore.updater(), SIGNAL(updateAvailable()), this, SLOT(updateAvailable()));
   connect(m_OrganizerCore.updater(), SIGNAL(motdAvailable(QString)), this, SLOT(motdReceived(QString)));
 
-  connect(NexusInterface::instance(&pluginContainer), SIGNAL(requestNXMDownload(QString)), &m_OrganizerCore, SLOT(downloadRequestedNXM(QString)));
-  connect(NexusInterface::instance(&pluginContainer), SIGNAL(nxmDownloadURLsAvailable(QString,int,int,QVariant,QVariant,int)), this, SLOT(nxmDownloadURLs(QString,int,int,QVariant,QVariant,int)));
-  connect(NexusInterface::instance(&pluginContainer), SIGNAL(needLogin()), &m_OrganizerCore, SLOT(nexusApi()));
+  connect(&NexusInterface::instance(), SIGNAL(requestNXMDownload(QString)), &m_OrganizerCore, SLOT(downloadRequestedNXM(QString)));
+  connect(&NexusInterface::instance(), SIGNAL(nxmDownloadURLsAvailable(QString,int,int,QVariant,QVariant,int)), this, SLOT(nxmDownloadURLs(QString,int,int,QVariant,QVariant,int)));
+  connect(&NexusInterface::instance(), SIGNAL(needLogin()), &m_OrganizerCore, SLOT(nexusApi()));
 
   connect(
-    NexusInterface::instance(&pluginContainer)->getAccessManager(),
+    NexusInterface::instance().getAccessManager(),
     SIGNAL(credentialsReceived(const APIUserAccount&)),
     this,
     SLOT(updateWindowTitle(const APIUserAccount&)));
 
   connect(
-    NexusInterface::instance(&pluginContainer)->getAccessManager(),
+    NexusInterface::instance().getAccessManager(),
     SIGNAL(credentialsReceived(const APIUserAccount&)),
-    NexusInterface::instance(&m_PluginContainer),
+    &NexusInterface::instance(),
     SLOT(setUserAccount(const APIUserAccount&)));
 
   connect(
-    NexusInterface::instance(&pluginContainer),
+    &NexusInterface::instance(),
     SIGNAL(requestsChanged(const APIStats&, const APIUserAccount&)),
     this,
     SLOT(onRequestsChanged(const APIStats&, const APIUserAccount&)));
@@ -1911,9 +1911,9 @@ QDir MainWindow::currentSavesDir() const
 
     wchar_t path[MAX_PATH];
     if (::GetPrivateProfileStringW(
-      L"General", L"SLocalSavePath", L"",
-      path, MAX_PATH,
-      iniPath.toStdWString().c_str()
+          L"General", L"SLocalSavePath", L"",
+          path, MAX_PATH,
+          iniPath.toStdWString().c_str()
     )) {
       savesDir.setPath(m_OrganizerCore.managedGame()->documentsDirectory().absoluteFilePath(QString::fromWCharArray(path)));
     }
@@ -3288,7 +3288,7 @@ void MainWindow::visitOnNexus_clicked()
       int modID = info->nexusId();
       gameName = info->gameName();
       if (modID > 0)  {
-        linkClicked(NexusInterface::instance(&m_PluginContainer)->getModURL(modID, gameName));
+        linkClicked(NexusInterface::instance().getModURL(modID, gameName));
       } else {
         log::error("mod '{}' has no nexus id", info->name());
       }
@@ -3298,7 +3298,7 @@ void MainWindow::visitOnNexus_clicked()
     int modID = m_OrganizerCore.modList()->data(m_OrganizerCore.modList()->index(m_ContextRow, 0), Qt::UserRole).toInt();
     QString gameName = m_OrganizerCore.modList()->data(m_OrganizerCore.modList()->index(m_ContextRow, 0), Qt::UserRole + 4).toString();
     if (modID > 0)  {
-      linkClicked(NexusInterface::instance(&m_PluginContainer)->getModURL(modID, gameName));
+      linkClicked(NexusInterface::instance().getModURL(modID, gameName));
     } else {
       MessageDialog::showMessage(tr("Nexus ID for this mod is unknown"), this);
     }
@@ -3355,7 +3355,7 @@ void MainWindow::visitNexusOrWebPage(const QModelIndex& idx)
   const auto url = info->parseCustomURL();
 
   if (modID > 0) {
-    linkClicked(NexusInterface::instance(&m_PluginContainer)->getModURL(modID, gameName));
+    linkClicked(NexusInterface::instance().getModURL(modID, gameName));
   } else if (url.isValid()) {
     linkClicked(url.toString());
   } else {
@@ -4220,15 +4220,15 @@ void MainWindow::saveArchiveList()
 void MainWindow::checkModsForUpdates()
 {
   bool checkingModsForUpdate = false;
-  if (NexusInterface::instance(&m_PluginContainer)->getAccessManager()->validated()) {
-    checkingModsForUpdate = ModInfo::checkAllForUpdate(&m_PluginContainer, this);
-    NexusInterface::instance(&m_PluginContainer)->requestEndorsementInfo(this, QVariant(), QString());
-    NexusInterface::instance(&m_PluginContainer)->requestTrackingInfo(this, QVariant(), QString());
+  if (NexusInterface::instance().getAccessManager()->validated()) {
+    checkingModsForUpdate = ModInfo::checkAllForUpdate(this);
+    NexusInterface::instance().requestEndorsementInfo(this, QVariant(), QString());
+    NexusInterface::instance().requestTrackingInfo(this, QVariant(), QString());
   } else {
     QString apiKey;
     if (m_OrganizerCore.settings().nexus().apiKey(apiKey)) {
       m_OrganizerCore.doAfterLogin([this] () { this->checkModsForUpdates(); });
-      NexusInterface::instance(&m_PluginContainer)->getAccessManager()->apiCheck(apiKey);
+      NexusInterface::instance().getAccessManager()->apiCheck(apiKey);
     } else {
       log::warn("{}", tr("You are not currently authenticated with Nexus. Please do so under Settings -> Nexus."));
     }
@@ -4603,7 +4603,7 @@ void MainWindow::exportModListCSV()
 					if (nexus_ID->isChecked())
 						builder.setRowField("#Nexus_ID", info->nexusId());
 					if (mod_Nexus_URL->isChecked())
-						builder.setRowField("#Mod_Nexus_URL",(info->nexusId()>0)? NexusInterface::instance(&m_PluginContainer)->getModURL(info->nexusId(), info->gameName()) : "");
+						builder.setRowField("#Mod_Nexus_URL",(info->nexusId()>0)? NexusInterface::instance().getModURL(info->nexusId(), info->gameName()) : "");
 					if (mod_Version->isChecked())
 						builder.setRowField("#Mod_Version", info->version().canonicalString());
 					if (install_Date->isChecked())
@@ -5157,7 +5157,7 @@ void MainWindow::on_actionSettings_triggered()
   }
 
   if (settings.paths().cache() != oldCacheDirectory) {
-    NexusInterface::instance(&m_PluginContainer)->setCacheDirectory(
+    NexusInterface::instance().setCacheDirectory(
       settings.paths().cache());
   }
 
@@ -5191,7 +5191,7 @@ void MainWindow::on_actionNexus_triggered()
   QString gameName = game->gameShortName();
   if (game->gameNexusName().isEmpty() && game->primarySources().count())
     gameName = game->primarySources()[0];
-  QDesktopServices::openUrl(QUrl(NexusInterface::instance(&m_PluginContainer)->getGameURL(gameName)));
+  QDesktopServices::openUrl(QUrl(NexusInterface::instance().getGameURL(gameName)));
 }
 
 
@@ -5350,9 +5350,9 @@ void MainWindow::actionEndorseMO()
 
   if (QMessageBox::question(this, tr("Endorse Mod Organizer"),
                             tr("Do you want to endorse Mod Organizer on %1 now?").arg(
-                                      NexusInterface::instance(&m_PluginContainer)->getGameURL(game->gameShortName())),
+                                      NexusInterface::instance().getGameURL(game->gameShortName())),
                             QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes) {
-    NexusInterface::instance(&m_PluginContainer)->requestToggleEndorsement(
+    NexusInterface::instance().requestToggleEndorsement(
       game->gameShortName(), game->nexusModOrganizerID(), m_OrganizerCore.getVersion().canonicalString(), true, this, QVariant(), QString());
   }
 }
@@ -5366,9 +5366,9 @@ void MainWindow::actionWontEndorseMO()
   if (QMessageBox::question(this, tr("Abstain from Endorsing Mod Organizer"),
     tr("Are you sure you want to abstain from endorsing Mod Organizer 2?\n"
       "You will have to visit the mod page on the %1 Nexus site to change your mind.").arg(
-      NexusInterface::instance(&m_PluginContainer)->getGameURL(game->gameShortName())),
+      NexusInterface::instance().getGameURL(game->gameShortName())),
     QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes) {
-    NexusInterface::instance(&m_PluginContainer)->requestToggleEndorsement(
+    NexusInterface::instance().requestToggleEndorsement(
       game->gameShortName(), game->nexusModOrganizerID(), m_OrganizerCore.getVersion().canonicalString(), false, this, QVariant(), QString());
   }
 }
@@ -5430,13 +5430,13 @@ void MainWindow::updateDownloadView()
 
 void MainWindow::modUpdateCheck(std::multimap<QString, int> IDs)
 {
-  if (NexusInterface::instance(&m_PluginContainer)->getAccessManager()->validated()) {
-    ModInfo::manualUpdateCheck(&m_PluginContainer, this, IDs);
+  if (NexusInterface::instance().getAccessManager()->validated()) {
+    ModInfo::manualUpdateCheck(this, IDs);
   } else {
     QString apiKey;
     if (m_OrganizerCore.settings().nexus().apiKey(apiKey)) {
       m_OrganizerCore.doAfterLogin([=]() { this->modUpdateCheck(IDs); });
-      NexusInterface::instance(&m_PluginContainer)->getAccessManager()->apiCheck(apiKey);
+      NexusInterface::instance().getAccessManager()->apiCheck(apiKey);
     } else
       log::warn("{}", tr("You are not currently authenticated with Nexus. Please do so under Settings -> Nexus."));
   }
@@ -5588,7 +5588,7 @@ void MainWindow::finishUpdateInfo()
     log::warn("{}", tr("All of your mods have been checked recently. We restrict update checks to help preserve your available API requests."));
 
   for (auto game : organizedGames)
-    NexusInterface::instance(&m_PluginContainer)->requestUpdates(game.second, this, QVariant(), game.first, QString());
+    NexusInterface::instance().requestUpdates(game.second, this, QVariant(), game.first, QString());
 
   disconnect(sender());
   delete sender();
@@ -5675,7 +5675,7 @@ void MainWindow::nxmUpdatesAvailable(QString gameName, int modID, QVariant userD
   }
 
   if (requiresInfo)
-    NexusInterface::instance(&m_PluginContainer)->requestModInfo(gameNameReal, modID, this, QVariant(), QString());
+    NexusInterface::instance().requestModInfo(gameNameReal, modID, this, QVariant(), QString());
 }
 
 void MainWindow::nxmModInfoAvailable(QString gameName, int modID, QVariant userData, QVariant resultData, int requestID)
diff --git a/src/modinfo.cpp b/src/modinfo.cpp
index bbeefb12..04cb18ce 100644
--- a/src/modinfo.cpp
+++ b/src/modinfo.cpp
@@ -266,7 +266,7 @@ void ModInfo::updateFromDisc(const QString &modDirectory,
   createFromOverwrite(pluginContainer, game, directoryStructure);
 
   std::sort(s_Collection.begin(), s_Collection.end(), ModInfo::ByName);
-  
+
   parallelMap(std::begin(s_Collection), std::end(s_Collection), &ModInfo::prefetch, refreshThreadCount);
 
   updateIndices();
@@ -295,7 +295,7 @@ ModInfo::ModInfo(PluginContainer *pluginContainer)
 }
 
 
-bool ModInfo::checkAllForUpdate(PluginContainer *pluginContainer, QObject *receiver)
+bool ModInfo::checkAllForUpdate(QObject *receiver)
 {
   bool updatesAvailable = true;
 
@@ -348,19 +348,19 @@ bool ModInfo::checkAllForUpdate(PluginContainer *pluginContainer, QObject *recei
     }
 
     for (auto game : organizedGames)
-      NexusInterface::instance(pluginContainer)->requestUpdates(game.second, receiver, QVariant(), game.first, QString());
+      NexusInterface::instance().requestUpdates(game.second, receiver, QVariant(), game.first, QString());
   } else if (earliest < QDateTime::currentDateTimeUtc().addMonths(-1)) {
     for (auto gameName : games)
-      NexusInterface::instance(pluginContainer)->requestUpdateInfo(gameName, NexusInterface::UpdatePeriod::MONTH, receiver, QVariant(true), QString());
+      NexusInterface::instance().requestUpdateInfo(gameName, NexusInterface::UpdatePeriod::MONTH, receiver, QVariant(true), QString());
   } else if (earliest < QDateTime::currentDateTimeUtc().addDays(-7)) {
     for (auto gameName : games)
-      NexusInterface::instance(pluginContainer)->requestUpdateInfo(gameName, NexusInterface::UpdatePeriod::MONTH, receiver, QVariant(false), QString());
+      NexusInterface::instance().requestUpdateInfo(gameName, NexusInterface::UpdatePeriod::MONTH, receiver, QVariant(false), QString());
   } else if (earliest < QDateTime::currentDateTimeUtc().addDays(-1)) {
     for (auto gameName : games)
-      NexusInterface::instance(pluginContainer)->requestUpdateInfo(gameName, NexusInterface::UpdatePeriod::WEEK, receiver, QVariant(false), QString());
+      NexusInterface::instance().requestUpdateInfo(gameName, NexusInterface::UpdatePeriod::WEEK, receiver, QVariant(false), QString());
   } else {
     for (auto gameName : games)
-      NexusInterface::instance(pluginContainer)->requestUpdateInfo(gameName, NexusInterface::UpdatePeriod::DAY, receiver, QVariant(false), QString());
+      NexusInterface::instance().requestUpdateInfo(gameName, NexusInterface::UpdatePeriod::DAY, receiver, QVariant(false), QString());
   }
 
   return updatesAvailable;
@@ -400,7 +400,7 @@ std::set<QSharedPointer<ModInfo>> ModInfo::filteredMods(QString gameName, QVaria
   return finalMods;
 }
 
-void ModInfo::manualUpdateCheck(PluginContainer *pluginContainer, QObject *receiver, std::multimap<QString, int> IDs)
+void ModInfo::manualUpdateCheck(QObject *receiver, std::multimap<QString, int> IDs)
 {
   std::vector<QSharedPointer<ModInfo>> mods;
   std::set<std::pair<QString, int>> organizedGames;
@@ -438,7 +438,7 @@ void ModInfo::manualUpdateCheck(PluginContainer *pluginContainer, QObject *recei
     }
 
     for (auto game : organizedGames) {
-      NexusInterface::instance(pluginContainer)->requestUpdates(game.second, receiver, QVariant(), game.first, QString());
+      NexusInterface::instance().requestUpdates(game.second, receiver, QVariant(), game.first, QString());
     }
   } else {
     log::info("None of the selected mods can be updated.");
diff --git a/src/modinfo.h b/src/modinfo.h
index 7223cece..480fe013 100644
--- a/src/modinfo.h
+++ b/src/modinfo.h
@@ -190,15 +190,14 @@ public: // Static functions:
    * @brief Run a limited batch of mod update checks for "newest version" information.
    *
    */
-  static void manualUpdateCheck(
-    PluginContainer *pluginContainer, QObject *receiver, std::multimap<QString, int> IDs);
+  static void manualUpdateCheck(QObject *receiver, std::multimap<QString, int> IDs);
 
   /**
    * @brief Query nexus information for every mod and update the "newest version" information.
    *
    * @return true if any mods are checked for update.
    */
-  static bool checkAllForUpdate(PluginContainer *pluginContainer, QObject *receiver);
+  static bool checkAllForUpdate(QObject *receiver);
 
   /**
    *
diff --git a/src/modinfodialognexus.cpp b/src/modinfodialognexus.cpp
index dd95cdaa..b4099a8d 100644
--- a/src/modinfodialognexus.cpp
+++ b/src/modinfodialognexus.cpp
@@ -141,8 +141,8 @@ void NexusTab::updateWebpage()
   const int modID = mod().nexusId();
 
   if (isValidModID(modID)) {
-    const QString nexusLink = NexusInterface::instance(&plugin())
-      ->getModURL(modID, mod().gameName());
+    const QString nexusLink = NexusInterface::instance()
+      .getModURL(modID, mod().gameName());
 
     ui->visitNexus->setToolTip(nexusLink);
     refreshData(modID);
@@ -360,8 +360,8 @@ void NexusTab::onVisitNexus()
   const int modID = mod().nexusId();
 
   if (isValidModID(modID)) {
-    const QString nexusLink = NexusInterface::instance(&plugin())
-      ->getModURL(modID, mod().gameName());
+    const QString nexusLink = NexusInterface::instance()
+      .getModURL(modID, mod().gameName());
 
     shell::Open(QUrl(nexusLink));
   }
diff --git a/src/nexusinterface.cpp b/src/nexusinterface.cpp
index 9eb1540a..396cec11 100644
--- a/src/nexusinterface.cpp
+++ b/src/nexusinterface.cpp
@@ -26,6 +26,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include <utility.h>
 #include "shared/util.h"
 #include <log.h>
+#include <moassert.h>
 
 #include <QApplication>
 #include <QNetworkCookieJar>
@@ -50,7 +51,7 @@ void throttledWarning(const APIUserAccount& user)
 
 
 NexusBridge::NexusBridge(PluginContainer *pluginContainer, const QString &subModule)
-  : m_Interface(NexusInterface::instance(pluginContainer))
+  : m_Interface(&NexusInterface::instance())
   , m_SubModule(subModule)
 {
 }
@@ -234,8 +235,8 @@ APILimits NexusInterface::parseLimits(
 }
 
 
-NexusInterface::NexusInterface(PluginContainer *pluginContainer)
-  : m_PluginContainer(pluginContainer)
+NexusInterface::NexusInterface()
+  : m_PluginContainer(nullptr)
 {
   m_User.limits(defaultAPILimits());
   m_MOVersion = createVersionInfo();
@@ -255,10 +256,10 @@ NexusInterface::~NexusInterface()
   cleanup();
 }
 
-NexusInterface *NexusInterface::instance(PluginContainer *pluginContainer)
+NexusInterface& NexusInterface::instance()
 {
-  static NexusInterface s_Instance(pluginContainer);
-  return &s_Instance;
+  static NexusInterface ni;
+  return ni;
 }
 
 void NexusInterface::setCacheDirectory(const QString &directory)
@@ -284,7 +285,7 @@ void NexusInterface::interpretNexusFileName(const QString &fileName, QString &mo
   static const QRegularExpression complex(R"(^([a-zA-Z0-9_'"\-.() ]*?)([-_ ][VvRr]+[0-9]+(?:(?:[\.][0-9]+){0,2}|(?:[_][0-9]+){0,2}|(?:[-.][0-9]+){0,2})?[ab]?)??-([1-9][0-9]+)?-.*?\.(zip|rar|7z))");
   //complex regex explanation:
   //group 1: modname.
-  //group 2: optional version, 
+  //group 2: optional version,
   //  assumed to start with v (empty most of the time).
   //group 3: NexusId,
   //  assumed wrapped in "-", will miss single digit IDs for better accuracy.
diff --git a/src/nexusinterface.h b/src/nexusinterface.h
index 35362bdf..72f30a38 100644
--- a/src/nexusinterface.h
+++ b/src/nexusinterface.h
@@ -154,8 +154,7 @@ public:
   static APILimits parseLimits(const QList<QNetworkReply::RawHeaderPair>& headers);
 
   ~NexusInterface();
-
-  static NexusInterface *instance(PluginContainer *pluginContainer);
+  static NexusInterface& instance();
 
   /**
    * @return the access manager object used to connect to nexus
@@ -535,7 +534,7 @@ private:
 
 private:
 
-  NexusInterface(PluginContainer *pluginContainer);
+  NexusInterface();
   void nextRequest();
   void requestFinished(std::list<NXMRequestInfo>::iterator iter);
   MOBase::IPluginGame *getGame(QString gameName) const;
diff --git a/src/organizercore.cpp b/src/organizercore.cpp
index 0849d756..7fd8c33b 100644
--- a/src/organizercore.cpp
+++ b/src/organizercore.cpp
@@ -95,12 +95,12 @@ OrganizerCore::OrganizerCore(Settings &settings)
   , m_PluginContainer(nullptr)
   , m_CurrentProfile(nullptr)
   , m_Settings(settings)
-  , m_Updater(NexusInterface::instance(m_PluginContainer))
+  , m_Updater(&NexusInterface::instance())
   , m_ModList(m_PluginContainer, this)
   , m_PluginList(this)
   , m_DirectoryRefresher(new DirectoryRefresher(settings.refreshThreadCount()))
   , m_DirectoryStructure(new DirectoryEntry(L"data", nullptr, 0))
-  , m_DownloadManager(NexusInterface::instance(m_PluginContainer), this)
+  , m_DownloadManager(&NexusInterface::instance(), this)
   , m_DirectoryUpdate(false)
   , m_ArchivesInit(false)
   , m_PluginListsWriter(std::bind(&OrganizerCore::savePluginList, this))
@@ -108,8 +108,7 @@ OrganizerCore::OrganizerCore(Settings &settings)
   env::setHandleCloserThreadCount(settings.refreshThreadCount());
   m_DownloadManager.setOutputDirectory(m_Settings.paths().downloads(), false);
 
-  NexusInterface::instance(m_PluginContainer)->setCacheDirectory(
-    m_Settings.paths().cache());
+  NexusInterface::instance().setCacheDirectory(m_Settings.paths().cache());
 
   m_InstallationManager.setModsDirectory(m_Settings.paths().mods());
   m_InstallationManager.setDownloadDirectory(m_Settings.paths().downloads());
@@ -122,9 +121,9 @@ OrganizerCore::OrganizerCore(Settings &settings)
   connect(&m_ModList, SIGNAL(removeOrigin(QString)), this,
           SLOT(removeOrigin(QString)));
 
-  connect(NexusInterface::instance(m_PluginContainer)->getAccessManager(),
+  connect(NexusInterface::instance().getAccessManager(),
           SIGNAL(validateSuccessful(bool)), this, SLOT(loginSuccessful(bool)));
-  connect(NexusInterface::instance(m_PluginContainer)->getAccessManager(),
+  connect(NexusInterface::instance().getAccessManager(),
           SIGNAL(validateFailed(QString)), this, SLOT(loginFailed(QString)));
 
   // This seems awfully imperative
@@ -332,8 +331,7 @@ Settings &OrganizerCore::settings()
 
 bool OrganizerCore::nexusApi(bool retry)
 {
-  NXMAccessManager *accessManager
-      = NexusInterface::instance(m_PluginContainer)->getAccessManager();
+  auto* accessManager = NexusInterface::instance().getAccessManager();
 
   if ((accessManager->validateAttempted() || accessManager->validated())
       && !retry) {
@@ -1424,13 +1422,13 @@ void OrganizerCore::updateModsInDirectoryStructure(QMap<unsigned int, ModInfo::P
 
 void OrganizerCore::loggedInAction(QWidget* parent, std::function<void ()> f)
 {
-  if (NexusInterface::instance(m_PluginContainer)->getAccessManager()->validated()) {
+  if (NexusInterface::instance().getAccessManager()->validated()) {
     f();
   } else {
     QString apiKey;
     if (settings().nexus().apiKey(apiKey)) {
       doAfterLogin([f]{ f(); });
-      NexusInterface::instance(m_PluginContainer)->getAccessManager()->apiCheck(apiKey);
+      NexusInterface::instance().getAccessManager()->apiCheck(apiKey);
     } else {
       MessageDialog::showMessage(tr("You need to be logged in with Nexus"), parent);
     }
@@ -1704,7 +1702,7 @@ void OrganizerCore::loginSuccessful(bool necessary)
   }
 
   m_PostLoginTasks.clear();
-  NexusInterface::instance(m_PluginContainer)->loginCompleted();
+  NexusInterface::instance().loginCompleted();
 }
 
 void OrganizerCore::loginSuccessfulUpdate(bool necessary)
@@ -1742,7 +1740,7 @@ void OrganizerCore::loginFailed(const QString &message)
                                qApp->activeWindow());
     m_PostLoginTasks.clear();
   }
-  NexusInterface::instance(m_PluginContainer)->loginCompleted();
+  NexusInterface::instance().loginCompleted();
 }
 
 void OrganizerCore::loginFailedUpdate(const QString &message)
diff --git a/src/settingsdialognexus.cpp b/src/settingsdialognexus.cpp
index d49e0a33..a76b9ad7 100644
--- a/src/settingsdialognexus.cpp
+++ b/src/settingsdialognexus.cpp
@@ -71,112 +71,45 @@ private:
 };
 
 
-NexusSettingsTab::NexusSettingsTab(Settings& s, SettingsDialog& d)
-  : SettingsTab(s, d)
+NexusConnectionUI::NexusConnectionUI(Settings& s, QWidget* parent) :
+  m_parent(parent), m_settings(s),
+  m_connect(nullptr), m_disconnect(nullptr), m_manual(nullptr), m_log(nullptr)
 {
-  ui->offlineBox->setChecked(settings().network().offlineMode());
-  ui->proxyBox->setChecked(settings().network().useProxy());
-  ui->endorsementBox->setChecked(settings().nexus().endorsementIntegration());
-  ui->hideAPICounterBox->setChecked(settings().interface().hideAPICounter());
-
-  // display server preferences
-  for (const auto& server : s.network().servers()) {
-    QString descriptor = server.name();
-
-    if (!descriptor.compare("CDN", Qt::CaseInsensitive)) {
-      descriptor += QStringLiteral(" (automatic)");
-    }
-
-    const auto averageSpeed = server.averageSpeed();
-    if (averageSpeed > 0) {
-      descriptor += QString(" (%1)").arg(MOBase::localizedByteSpeed(averageSpeed));
-    }
-
-    QListWidgetItem *newItem = new ServerItem<int>(descriptor, Qt::UserRole + 1);
-
-    newItem->setData(Qt::UserRole, server.name());
-    newItem->setData(Qt::UserRole + 1, server.preferred());
-
-    if (server.preferred() > 0) {
-      ui->preferredServersList->addItem(newItem);
-    } else {
-      ui->knownServersList->addItem(newItem);
-    }
-
-    ui->preferredServersList->sortItems(Qt::DescendingOrder);
-  }
-
-  QObject::connect(ui->nexusConnect, &QPushButton::clicked, [&]{ on_nexusConnect_clicked(); });
-  QObject::connect(ui->nexusManualKey, &QPushButton::clicked, [&]{ on_nexusManualKey_clicked(); });
-  QObject::connect(ui->nexusDisconnect, &QPushButton::clicked, [&]{ on_nexusDisconnect_clicked(); });
-  QObject::connect(ui->clearCacheButton, &QPushButton::clicked, [&]{ on_clearCacheButton_clicked(); });
-  QObject::connect(ui->associateButton, &QPushButton::clicked, [&]{ on_associateButton_clicked(); });
-
-  if (settings().nexus().hasApiKey()) {
-    addNexusLog(QObject::tr("Connected."));
-  } else {
-    addNexusLog(QObject::tr("Not connected."));
-  }
-
-  updateNexusState();
 }
 
-void NexusSettingsTab::update()
+void NexusConnectionUI::set(
+  QAbstractButton* connectButton,
+  QAbstractButton* disconnectButton,
+  QAbstractButton* manualButton,
+  QListWidget* logList)
 {
-  settings().network().setOfflineMode(ui->offlineBox->isChecked());
-  settings().network().setUseProxy(ui->proxyBox->isChecked());
-  settings().nexus().setEndorsementIntegration(ui->endorsementBox->isChecked());
-  settings().interface().setHideAPICounter(ui->hideAPICounterBox->isChecked());
-
-  auto servers = settings().network().servers();
-
-  // store server preference
-  for (int i = 0; i < ui->knownServersList->count(); ++i) {
-    const QString key = ui->knownServersList->item(i)->data(Qt::UserRole).toString();
-
-    bool found = false;
-
-    for (auto& server : servers) {
-      if (server.name() == key) {
-        server.setPreferred(0);
-        found = true;
-        break;
-      }
-    }
-
-    if (!found) {
-      log::error("while setting preferred to 0, server '{}' not found", key);
-    }
+  m_connect = connectButton;
+  if (m_connect) {
+    QObject::connect(m_connect, &QPushButton::clicked, [&]{ connect(); });
   }
 
-  const int count = ui->preferredServersList->count();
-
-  for (int i = 0; i < count; ++i) {
-    const QString key = ui->preferredServersList->item(i)->data(Qt::UserRole).toString();
-    const int newPreferred = count - i;
+  m_disconnect = disconnectButton;
+  if (m_disconnect) {
+    QObject::connect(m_disconnect, &QPushButton::clicked, [&]{ disconnect(); });
+  }
 
-    bool found = false;
+  m_manual = manualButton;
+  if (m_manual) {
+    QObject::connect(manualButton, &QPushButton::clicked, [&]{ manual(); });
+  }
 
-    for (auto& server : servers) {
+  m_log = logList;
 
-      if (server.name() == key) {
-        server.setPreferred(newPreferred);
-        found = true;
-        break;
-      }
-    }
-
-    if (!found) {
-      log::error(
-        "while setting preference to {}, server '{}' not found",
-        newPreferred, key);
-    }
+  if (m_settings.nexus().hasApiKey()) {
+    addLog(tr("Connected."));
+  } else {
+    addLog(tr("Not connected."));
   }
 
-  settings().network().updateServers(servers);
+  updateState();
 }
 
-void NexusSettingsTab::on_nexusConnect_clicked()
+void NexusConnectionUI::connect()
 {
   if (m_nexusLogin && m_nexusLogin->isActive()) {
     m_nexusLogin->cancel();
@@ -195,19 +128,19 @@ void NexusSettingsTab::on_nexusConnect_clicked()
     };
   }
 
-  ui->nexusLog->clear();
+  m_log->clear();
   m_nexusLogin->start();
-  updateNexusState();
+  updateState();
 }
 
-void NexusSettingsTab::on_nexusManualKey_clicked()
+void NexusConnectionUI::manual()
 {
   if (m_nexusValidator && m_nexusValidator->isActive()) {
     m_nexusValidator->cancel();
     return;
   }
 
-  NexusManualKeyDialog d(&dialog());
+  NexusManualKeyDialog d(m_parent);
   if (d.exec() != QDialog::Accepted) {
     return;
   }
@@ -218,162 +151,273 @@ void NexusSettingsTab::on_nexusManualKey_clicked()
     return;
   }
 
-  ui->nexusLog->clear();
+  m_log->clear();
   validateKey(key);
 }
 
-void NexusSettingsTab::on_nexusDisconnect_clicked()
+void NexusConnectionUI::disconnect()
 {
   clearKey();
-  ui->nexusLog->clear();
-  addNexusLog(QObject::tr("Disconnected."));
-}
-
-void NexusSettingsTab::on_clearCacheButton_clicked()
-{
-  QDir(Settings::instance().paths().cache()).removeRecursively();
-  NexusInterface::instance(dialog().pluginContainer())->clearCache();
-}
-
-void NexusSettingsTab::on_associateButton_clicked()
-{
-  Settings::instance().nexus().registerAsNXMHandler(true);
+  m_log->clear();
+  addLog(tr("Disconnected."));
 }
 
-void NexusSettingsTab::validateKey(const QString& key)
+void NexusConnectionUI::validateKey(const QString& key)
 {
   if (!m_nexusValidator) {
     m_nexusValidator.reset(new NexusKeyValidator(
-      *NexusInterface::instance(dialog().pluginContainer())->getAccessManager()));
+      *NexusInterface::instance().getAccessManager()));
 
     m_nexusValidator->finished = [&](auto&& r, auto&& m, auto&& u) {
       onValidatorFinished(r, m, u);
     };
   }
 
-  addNexusLog(QObject::tr("Checking API key..."));
+  addLog(tr("Checking API key..."));
   m_nexusValidator->start(key, NexusKeyValidator::OneShot);
 }
 
-void NexusSettingsTab::onSSOKeyChanged(const QString& key)
+void NexusConnectionUI::onSSOKeyChanged(const QString& key)
 {
   if (key.isEmpty()) {
     clearKey();
   } else {
-    addNexusLog(QObject::tr("Received API key."));
+    addLog(tr("Received API key."));
     validateKey(key);
   }
 }
 
-void NexusSettingsTab::onSSOStateChanged(NexusSSOLogin::States s, const QString& e)
+void NexusConnectionUI::onSSOStateChanged(
+  NexusSSOLogin::States s, const QString& e)
 {
   if (s != NexusSSOLogin::Finished) {
     // finished state is handled in onSSOKeyChanged()
     const auto log = NexusSSOLogin::stateToString(s, e);
 
     for (auto&& line : log.split("\n")) {
-      addNexusLog(line);
+      addLog(line);
     }
   }
 
-  updateNexusState();
+  updateState();
 }
 
-void NexusSettingsTab::onValidatorFinished(
+void NexusConnectionUI::onValidatorFinished(
   ValidationAttempt::Result r, const QString& message,
   std::optional<APIUserAccount> user)
 {
   if (user) {
-    NexusInterface::instance(dialog().pluginContainer())->setUserAccount(*user);
-    addNexusLog(QObject::tr("Received user acount information"));
+    NexusInterface::instance().setUserAccount(*user);
+    addLog(tr("Received user account information"));
 
     if (setKey(user->apiKey())) {
-      addNexusLog(QObject::tr("Linked with Nexus successfully."));
+      addLog(tr("Linked with Nexus successfully."));
     } else {
-      addNexusLog(QObject::tr("Failed to set API key"));
+      addLog(tr("Failed to set API key"));
     }
   } else {
     if (message.isEmpty()) {
       // shouldn't happen
-      addNexusLog("Unknown error");
+      addLog("Unknown error");
     } else {
-      addNexusLog(message);
+      addLog(message);
     }
   }
 
-  updateNexusState();
+  updateState();
 }
 
-void NexusSettingsTab::addNexusLog(const QString& s)
+void NexusConnectionUI::addLog(const QString& s)
 {
-  ui->nexusLog->addItem(s);
-  ui->nexusLog->scrollToBottom();
+  m_log->addItem(s);
+  m_log->scrollToBottom();
 }
 
-bool NexusSettingsTab::setKey(const QString& key)
+bool NexusConnectionUI::setKey(const QString& key)
 {
-  dialog().setExitNeeded(Exit::Restart);
-  const bool ret = settings().nexus().setApiKey(key);
-  updateNexusState();
+  const bool ret = m_settings.nexus().setApiKey(key);
+  updateState();
+
+  emit keyChanged();
+
   return ret;
 }
 
-bool NexusSettingsTab::clearKey()
+bool NexusConnectionUI::clearKey()
 {
-  dialog().setExitNeeded(Exit::Restart);
-  const auto ret = settings().nexus().clearApiKey();
+  const auto ret = m_settings.nexus().clearApiKey();
+
+  NexusInterface::instance().getAccessManager()->clearApiKey();
+  updateState();
 
-  NexusInterface::instance(dialog().pluginContainer())->getAccessManager()->clearApiKey();
-  updateNexusState();
+  emit keyChanged();
 
   return ret;
 }
 
-void NexusSettingsTab::updateNexusState()
+void NexusConnectionUI::updateState()
 {
-  updateNexusButtons();
-  updateNexusData();
-}
+  auto setButton = [&](QAbstractButton* b, bool enabled, QString caption={}) {
+    if (b) {
+      b->setEnabled(enabled);
+      if (!caption.isEmpty()) {
+        b->setText(caption);
+      }
+    }
+  };
 
-void NexusSettingsTab::updateNexusButtons()
-{
   if (m_nexusLogin && m_nexusLogin->isActive()) {
     // api key is in the process of being retrieved
-    ui->nexusConnect->setText(QObject::tr("Cancel"));
-    ui->nexusConnect->setEnabled(true);
-    ui->nexusDisconnect->setEnabled(false);
-    ui->nexusManualKey->setText(QObject::tr("Enter API Key Manually"));
-    ui->nexusManualKey->setEnabled(false);
+    setButton(m_connect, true, QObject::tr("Cancel"));
+    setButton(m_disconnect, false);
+    setButton(m_manual, false,QObject::tr("Enter API Key Manually"));
   }
   else if (m_nexusValidator && m_nexusValidator->isActive()) {
     // api key is in the process of being tested
-    ui->nexusConnect->setText(QObject::tr("Connect to Nexus"));
-    ui->nexusConnect->setEnabled(false);
-    ui->nexusDisconnect->setEnabled(false);
-    ui->nexusManualKey->setText(QObject::tr("Cancel"));
-    ui->nexusManualKey->setEnabled(true);
+    setButton(m_connect, false, QObject::tr("Connect to Nexus"));
+    setButton(m_disconnect, false);
+    setButton(m_manual, true, QObject::tr("Cancel"));
   }
-  else if (settings().nexus().hasApiKey()) {
+  else if (m_settings.nexus().hasApiKey()) {
     // api key is present
-    ui->nexusConnect->setText(QObject::tr("Connect to Nexus"));
-    ui->nexusConnect->setEnabled(false);
-    ui->nexusDisconnect->setEnabled(true);
-    ui->nexusManualKey->setText(QObject::tr("Enter API Key Manually"));
-    ui->nexusManualKey->setEnabled(false);
+    setButton(m_connect, false, QObject::tr("Connect to Nexus"));
+    setButton(m_disconnect, true);
+    setButton(m_manual, false, QObject::tr("Enter API Key Manually"));
   } else {
     // api key not present
-    ui->nexusConnect->setText(QObject::tr("Connect to Nexus"));
-    ui->nexusConnect->setEnabled(true);
-    ui->nexusDisconnect->setEnabled(false);
-    ui->nexusManualKey->setText(QObject::tr("Enter API Key Manually"));
-    ui->nexusManualKey->setEnabled(true);
+    setButton(m_connect, true, QObject::tr("Connect to Nexus"));
+    setButton(m_disconnect, false);
+    setButton(m_manual, true, QObject::tr("Enter API Key Manually"));
+  }
+
+  emit stateChanged();
+}
+
+
+
+NexusSettingsTab::NexusSettingsTab(Settings& s, SettingsDialog& d)
+  : SettingsTab(s, d), m_connectionUI(s, &d)
+{
+  ui->offlineBox->setChecked(settings().network().offlineMode());
+  ui->proxyBox->setChecked(settings().network().useProxy());
+  ui->endorsementBox->setChecked(settings().nexus().endorsementIntegration());
+  ui->hideAPICounterBox->setChecked(settings().interface().hideAPICounter());
+
+  // display server preferences
+  for (const auto& server : s.network().servers()) {
+    QString descriptor = server.name();
+
+    if (!descriptor.compare("CDN", Qt::CaseInsensitive)) {
+      descriptor += QStringLiteral(" (automatic)");
+    }
+
+    const auto averageSpeed = server.averageSpeed();
+    if (averageSpeed > 0) {
+      descriptor += QString(" (%1)").arg(MOBase::localizedByteSpeed(averageSpeed));
+    }
+
+    QListWidgetItem *newItem = new ServerItem<int>(descriptor, Qt::UserRole + 1);
+
+    newItem->setData(Qt::UserRole, server.name());
+    newItem->setData(Qt::UserRole + 1, server.preferred());
+
+    if (server.preferred() > 0) {
+      ui->preferredServersList->addItem(newItem);
+    } else {
+      ui->knownServersList->addItem(newItem);
+    }
+
+    ui->preferredServersList->sortItems(Qt::DescendingOrder);
   }
+
+  m_connectionUI.set(
+    ui->nexusConnect,
+    ui->nexusDisconnect,
+    ui->nexusManualKey,
+    ui->nexusLog);
+
+  QObject::connect(
+    &m_connectionUI, &NexusConnectionUI::stateChanged, &d,
+    [&]{ updateNexusData(); }, Qt::QueuedConnection);
+
+  QObject::connect(
+    &m_connectionUI, &NexusConnectionUI::keyChanged, &d,
+    [&]{ dialog().setExitNeeded(Exit::Restart); });
+
+
+  QObject::connect(ui->clearCacheButton, &QPushButton::clicked, [&]{ on_clearCacheButton_clicked(); });
+  QObject::connect(ui->associateButton, &QPushButton::clicked, [&]{ on_associateButton_clicked(); });
+}
+
+void NexusSettingsTab::update()
+{
+  settings().network().setOfflineMode(ui->offlineBox->isChecked());
+  settings().network().setUseProxy(ui->proxyBox->isChecked());
+  settings().nexus().setEndorsementIntegration(ui->endorsementBox->isChecked());
+  settings().interface().setHideAPICounter(ui->hideAPICounterBox->isChecked());
+
+  auto servers = settings().network().servers();
+
+  // store server preference
+  for (int i = 0; i < ui->knownServersList->count(); ++i) {
+    const QString key = ui->knownServersList->item(i)->data(Qt::UserRole).toString();
+
+    bool found = false;
+
+    for (auto& server : servers) {
+      if (server.name() == key) {
+        server.setPreferred(0);
+        found = true;
+        break;
+      }
+    }
+
+    if (!found) {
+      log::error("while setting preferred to 0, server '{}' not found", key);
+    }
+  }
+
+  const int count = ui->preferredServersList->count();
+
+  for (int i = 0; i < count; ++i) {
+    const QString key = ui->preferredServersList->item(i)->data(Qt::UserRole).toString();
+    const int newPreferred = count - i;
+
+    bool found = false;
+
+    for (auto& server : servers) {
+
+      if (server.name() == key) {
+        server.setPreferred(newPreferred);
+        found = true;
+        break;
+      }
+    }
+
+    if (!found) {
+      log::error(
+        "while setting preference to {}, server '{}' not found",
+        newPreferred, key);
+    }
+  }
+
+  settings().network().updateServers(servers);
+}
+
+void NexusSettingsTab::on_clearCacheButton_clicked()
+{
+  QDir(Settings::instance().paths().cache()).removeRecursively();
+  NexusInterface::instance().clearCache();
+}
+
+void NexusSettingsTab::on_associateButton_clicked()
+{
+  Settings::instance().nexus().registerAsNXMHandler(true);
 }
 
 void NexusSettingsTab::updateNexusData()
 {
-  const auto user = NexusInterface::instance(dialog().pluginContainer())
-    ->getAPIUserAccount();
+  const auto user = NexusInterface::instance().getAPIUserAccount();
 
   if (user.isValid()) {
     ui->nexusUserID->setText(user.id());
diff --git a/src/settingsdialognexus.h b/src/settingsdialognexus.h
index 2cb1cc1e..0adf67c7 100644
--- a/src/settingsdialognexus.h
+++ b/src/settingsdialognexus.h
@@ -5,38 +5,67 @@
 #include "settingsdialog.h"
 #include "nxmaccessmanager.h"
 
-class NexusSettingsTab : public SettingsTab
+class NexusConnectionUI : public QObject
 {
+  Q_OBJECT;
+
 public:
-  NexusSettingsTab(Settings& settings, SettingsDialog& dialog);
-  void update();
+  NexusConnectionUI(Settings& s, QWidget* parent=nullptr);
+
+  void set(
+    QAbstractButton* connectButton,
+    QAbstractButton* disconnectButton,
+    QAbstractButton* manualButton,
+    QListWidget* logList);
+
+  void connect();
+  void manual();
+  void disconnect();
+
+signals:
+  void stateChanged();
+  void keyChanged();
 
 private:
+  QWidget* m_parent;
+  Settings& m_settings;
+  QAbstractButton* m_connect;
+  QAbstractButton* m_disconnect;
+  QAbstractButton* m_manual;
+  QListWidget* m_log;
+
   std::unique_ptr<NexusSSOLogin> m_nexusLogin;
   std::unique_ptr<NexusKeyValidator> m_nexusValidator;
 
-  void on_nexusConnect_clicked();
-  void on_nexusManualKey_clicked();
-  void on_nexusDisconnect_clicked();
-  void on_clearCacheButton_clicked();
-  void on_associateButton_clicked();
+  void addLog(const QString& s);
+
+  void updateState();
 
   void validateKey(const QString& key);
   bool setKey(const QString& key);
   bool clearKey();
 
-  void updateNexusState();
-  void updateNexusButtons();
-  void updateNexusData();
-
   void onSSOKeyChanged(const QString& key);
   void onSSOStateChanged(NexusSSOLogin::States s, const QString& e);
 
   void onValidatorFinished(
     ValidationAttempt::Result r, const QString& message,
     std::optional<APIUserAccount> useR);
+};
+
 
-  void addNexusLog(const QString& s);
+class NexusSettingsTab : public SettingsTab
+{
+public:
+  NexusSettingsTab(Settings& settings, SettingsDialog& dialog);
+  void update();
+
+private:
+  NexusConnectionUI m_connectionUI;
+
+  void on_clearCacheButton_clicked();
+  void on_associateButton_clicked();
+  void updateNexusData();
 };
 
 #endif // SETTINGSDIALOGNEXUS_H