PathChecker is unnecessary, refactored its guts into NamePage and PathsPage

made existing paths just a warning, don't check for portable instances

6 files changed, 205 insertions, 172 deletions

diff --git a/src/createinstancedialog.cpp b/src/createinstancedialog.cpp
index 63be7346..4b9f24ae 100644
--- a/src/createinstancedialog.cpp
+++ b/src/createinstancedialog.cpp
@@ -2,10 +2,8 @@
 #include "ui_createinstancedialog.h"
 #include "createinstancedialogpages.h"
 #include "instancemanager.h"
-//#include "plugincontainer.h"
 #include "settings.h"
 #include "shared/appconfig.h"
-//#include <report.h>
 #include <iplugingame.h>
 #include <utility.h>
 
@@ -80,6 +78,9 @@ void CreateInstanceDialog::changePage(int d)
 {
   std::size_t i = static_cast<std::size_t>(ui->pages->currentIndex());
 
+  // goes back or forwards until an unskippable page is reached, or the
+  // first/last page
+
   if (d > 0) {
     for (;;) {
       ++i;
@@ -359,7 +360,7 @@ QString CreateInstanceDialog::dataPath() const
   QString s;
 
   if (instanceType() == Portable) {
-    s = QDir(qApp->applicationDirPath()).absolutePath();
+    s = QDir(InstanceManager::portablePath()).absolutePath();
   } else {
     s = InstanceManager::instance().instancePath(instanceName());
   }
@@ -372,8 +373,31 @@ CreateInstanceDialog::Paths CreateInstanceDialog::paths() const
   return getSelected(&cid::Page::selectedPaths);
 }
 
+void fixVarDir(QString& path, const std::wstring& defaultDir)
+{
+  if (path.isEmpty()) {
+    path = cid::makeDefaultPath(defaultDir);
+  } else if (!path.contains(PathSettings::BaseDirVariable)) {
+    path = QDir(path).absolutePath();
+  }
+
+  path = QDir::toNativeSeparators(path);
+}
+
+void fixDirPath(QString& path)
+{
+  path = QDir::toNativeSeparators(QDir(path).absolutePath());
+}
+
+void fixFilePath(QString& path)
+{
+  path = QDir::toNativeSeparators(QFileInfo(path).absolutePath());
+}
+
 CreateInstanceDialog::CreationInfo CreateInstanceDialog::creationInfo() const
 {
+  const auto iniFilename = QString::fromStdWString(AppConfig::iniFileName());
+
   CreationInfo ci;
 
   ci.type         = getSelected(&cid::Page::selectedInstanceType);
@@ -383,43 +407,15 @@ CreateInstanceDialog::CreationInfo CreateInstanceDialog::creationInfo() const
   ci.instanceName = getSelected(&cid::Page::selectedInstanceName);
   ci.paths        = getSelected(&cid::Page::selectedPaths);
   ci.dataPath     = dataPath();
+  ci.iniPath      = ci.dataPath + "/" + iniFilename;
 
-  ci.paths.base = QDir(ci.paths.base).absolutePath();
-
-  if (ci.paths.downloads.isEmpty()) {
-    ci.paths.downloads = cid::makeDefaultPath(AppConfig::downloadPath());
-  } else if (!ci.paths.downloads.contains(PathSettings::BaseDirVariable)) {
-    ci.paths.downloads = QDir(ci.paths.downloads).absolutePath();
-  }
-
-  if (ci.paths.mods.isEmpty()) {
-    ci.paths.mods = cid::makeDefaultPath(AppConfig::modsPath());
-  } else if (!ci.paths.mods.contains(PathSettings::BaseDirVariable)) {
-    ci.paths.mods = QDir(ci.paths.mods).absolutePath();
-  }
-
-  if (ci.paths.profiles.isEmpty()) {
-    ci.paths.profiles = cid::makeDefaultPath(AppConfig::profilesPath());
-  } else if (!ci.paths.profiles.contains(PathSettings::BaseDirVariable)) {
-    ci.paths.profiles = QDir(ci.paths.profiles).absolutePath();
-  }
-
-  if (ci.paths.overwrite.isEmpty()) {
-    ci.paths.overwrite = cid::makeDefaultPath(AppConfig::overwritePath());
-  } else if (!ci.paths.overwrite.contains(PathSettings::BaseDirVariable)) {
-    ci.paths.overwrite = QDir(ci.paths.overwrite).absolutePath();
-  }
-
-  ci.iniPath = QFileInfo(
-    ci.dataPath + "/" + QString::fromStdWString(AppConfig::iniFileName()))
-      .absoluteFilePath();
+  fixDirPath(ci.paths.base);
+  fixFilePath(ci.paths.ini);
 
-  ci.paths.base = QDir::toNativeSeparators(ci.paths.base);
-  ci.paths.downloads = QDir::toNativeSeparators(ci.paths.downloads);
-  ci.paths.mods = QDir::toNativeSeparators(ci.paths.mods);
-  ci.paths.profiles = QDir::toNativeSeparators(ci.paths.profiles);
-  ci.paths.overwrite = QDir::toNativeSeparators(ci.paths.overwrite);
-  ci.paths.ini = QDir::toNativeSeparators(ci.paths.ini);
+  fixVarDir(ci.paths.downloads, AppConfig::downloadPath());
+  fixVarDir(ci.paths.mods, AppConfig::modsPath());
+  fixVarDir(ci.paths.profiles, AppConfig::profilesPath());
+  fixVarDir(ci.paths.overwrite, AppConfig::overwritePath());
 
   return ci;
 }
diff --git a/src/createinstancedialog.ui b/src/createinstancedialog.ui
index cfb343fa..4d9d8b06 100644
--- a/src/createinstancedialog.ui
+++ b/src/createinstancedialog.ui
@@ -588,7 +588,7 @@
                  <item row="2" column="0" colspan="3">
                   <widget class="QLabel" name="locationExists">
                    <property name="text">
-                    <string>This folder already exists.</string>
+                    <string>Warning: This folder already exists.</string>
                    </property>
                   </widget>
                  </item>
@@ -602,7 +602,7 @@
                  <item row="1" column="0" colspan="3">
                   <widget class="QLabel" name="locationInvalid">
                    <property name="text">
-                    <string>The folder contains invalid characters.</string>
+                    <string>Warning: The folder contains invalid characters.</string>
                    </property>
                   </widget>
                  </item>
@@ -706,7 +706,7 @@
                  <item row="5" column="0" colspan="4">
                   <widget class="QLabel" name="advancedDirExists">
                    <property name="text">
-                    <string>The folder %1 already exists.</string>
+                    <string>Warning: The folder %1 already exists.</string>
                    </property>
                    <property name="wordWrap">
                     <bool>true</bool>
@@ -778,7 +778,7 @@
                  <item row="6" column="0" colspan="4">
                   <widget class="QLabel" name="advancedDirInvalid">
                    <property name="text">
-                    <string>The folder %1 contains invalid characters.</string>
+                    <string>Warning: The folder %1 contains invalid characters.</string>
                    </property>
                    <property name="wordWrap">
                     <bool>true</bool>
diff --git a/src/createinstancedialogpages.cpp b/src/createinstancedialogpages.cpp
index ab020c66..4d2c5b8b 100644
--- a/src/createinstancedialogpages.cpp
+++ b/src/createinstancedialogpages.cpp
@@ -15,19 +15,11 @@ using MOBase::TaskDialog;
 
 QString makeDefaultPath(const std::wstring& dir)
 {
-  return QDir::toNativeSeparators(
-    PathSettings::makeDefaultPath(QString::fromStdWString(dir)));
+  return QDir::toNativeSeparators(PathSettings::makeDefaultPath(
+    QString::fromStdWString(dir)));
 }
 
-
-PathChecker::PathChecker(QLabel* existsLabel, QLabel* invalidLabel)
-  : m_exists(existsLabel), m_invalid(invalidLabel)
-{
-  m_existsOriginal = m_exists->text();
-  m_invalidOriginal = m_invalid->text();
-}
-
-QString PathChecker::sanitizeFileName(const QString& name) const
+QString sanitizeFileName(const QString& name)
 {
   QString new_name = name;
 
@@ -48,7 +40,7 @@ QString PathChecker::sanitizeFileName(const QString& name) const
 
 // same thing as above, but allows path separators and colons
 //
-QString PathChecker::sanitizePath(const QString& path) const
+QString sanitizePath(const QString& path)
 {
   QString new_name = path;
 
@@ -67,93 +59,31 @@ QString PathChecker::sanitizePath(const QString& path) const
   return new_name;
 }
 
-bool PathChecker::checkName(QString parentDir, QString name) const
+void setPossiblePlaceholder(
+  QLabel* label, const QString& s, const QString& arg)
 {
-  bool exists = false;
-  bool invalid = false;
-  bool empty = false;
-
-  name = name.trimmed();
-
-  if (name.isEmpty()) {
-    empty = true;
-  } else {
-    const QString sanitized = sanitizeFileName(name);
-
-    if (name != sanitized) {
-      invalid = true;
-    } else {
-      exists = QDir(parentDir).exists(name);
-    }
-  }
+}
 
-  bool okay = false;
 
-  if (exists) {
-    m_exists->setVisible(true);
-    setPossiblePlaceholder(m_exists, m_existsOriginal, QDir(parentDir).filePath(name));
-    m_invalid->setVisible(false);
-  } else if (invalid) {
-    m_exists->setVisible(false);
-    m_invalid->setVisible(true);
-    setPossiblePlaceholder(m_invalid, m_invalidOriginal, name);
-  } else {
-    okay = !empty;
-    m_exists->setVisible(false);
-    m_invalid->setVisible(false);
-  }
-
-  return okay;
+PlaceholderLabel::PlaceholderLabel(QLabel* label)
+  : m_label(label), m_original(label->text())
+{
 }
 
-bool PathChecker::checkPath(QString path) const
+void PlaceholderLabel::setText(const QString& arg)
 {
-  bool exists = false;
-  bool invalid = false;
-  bool empty = false;
-
-  path = path.trimmed();
-
-  if (path.isEmpty()) {
-    empty = true;
-  } else {
-    const QString sanitized = sanitizePath(path);
-
-    if (path != sanitized) {
-      invalid = true;
-    } else {
-      exists = QDir(path).exists();
-    }
-  }
-
-  bool okay = false;
-
-  if (exists) {
-    m_exists->setVisible(true);
-    setPossiblePlaceholder(m_exists, m_existsOriginal, path);
-    m_invalid->setVisible(false);
-  } else if (invalid) {
-    m_exists->setVisible(false);
-    m_invalid->setVisible(true);
-    setPossiblePlaceholder(m_invalid, m_invalidOriginal, path);
-  } else {
-    okay = !empty;
-    m_exists->setVisible(false);
-    m_invalid->setVisible(false);
+  if (m_original.contains("%1")) {
+    m_label->setText(m_original.arg(arg));
   }
-
-  return okay;
 }
 
-void PathChecker::setPossiblePlaceholder(
-  QLabel* label, const QString& s, const QString& arg) const
+void PlaceholderLabel::setVisible(bool b)
 {
-  if (label->text().contains("%1")) {
-    label->setText(s.arg(arg));
-  }
+  m_label->setVisible(b);
 }
 
 
+
 Page::Page(CreateInstanceDialog& dlg)
   : ui(dlg.getUI()), m_dlg(dlg), m_pc(dlg.pluginContainer())
 {
@@ -238,7 +168,7 @@ TypePage::TypePage(CreateInstanceDialog& dlg)
 
   ui->createPortable->setDescription(
     ui->createPortable->description()
-    .arg(qApp->applicationDirPath()));
+    .arg(InstanceManager::portablePath()));
 
   QObject::connect(
     ui->createGlobal, &QAbstractButton::clicked, [&]{ global(); });
@@ -727,10 +657,9 @@ void EditionsPage::fillList()
 
 NamePage::NamePage(CreateInstanceDialog& dlg) :
   Page(dlg), m_modified(false), m_okay(false),
-  m_checker(ui->instanceNameExists, ui->instanceNameInvalid)
+  m_label(ui->instanceNameLabel), m_exists(ui->instanceNameExists),
+  m_invalid(ui->instanceNameInvalid)
 {
-  m_originalLabel = ui->instanceNameLabel->text();
-
   QObject::connect(
     ui->instanceName, &QLineEdit::textEdited, [&]{ onChanged(); });
 }
@@ -753,7 +682,7 @@ void NamePage::activated()
     return;
   }
 
-  ui->instanceNameLabel->setText(m_originalLabel.arg(g->gameName()));
+  m_label.setText(g->gameName());
 
   if (!m_modified || ui->instanceName->text().isEmpty()) {
     const auto n = InstanceManager::instance().makeUniqueName(g->gameName());
@@ -771,7 +700,7 @@ QString NamePage::selectedInstanceName() const
   }
 
   const auto text = ui->instanceName->text().trimmed();
-  return m_checker.sanitizeFileName(text);
+  return sanitizeFileName(text);
 }
 
 void NamePage::onChanged()
@@ -784,15 +713,55 @@ void NamePage::updateWarnings()
 {
   const auto root = InstanceManager::instance().instancesPath();
 
-  m_okay = m_checker.checkName(root, ui->instanceName->text());
+  m_okay = checkName(root, ui->instanceName->text());
   updateNavigation();
 }
 
+bool NamePage::checkName(QString parentDir, QString name)
+{
+  bool exists = false;
+  bool invalid = false;
+  bool empty = false;
+
+  name = name.trimmed();
+
+  if (name.isEmpty()) {
+    empty = true;
+  } else {
+    const QString sanitized = sanitizeFileName(name);
+
+    if (name != sanitized) {
+      invalid = true;
+    } else {
+      exists = QDir(parentDir).exists(name);
+    }
+  }
+
+  bool okay = false;
+
+  if (exists) {
+    m_exists.setVisible(true);
+    m_exists.setText(QDir(parentDir).filePath(name));
+    m_invalid.setVisible(false);
+  } else if (invalid) {
+    m_exists.setVisible(false);
+    m_invalid.setVisible(true);
+    m_invalid.setText(name);
+  } else {
+    okay = !empty;
+    m_exists.setVisible(false);
+    m_invalid.setVisible(false);
+  }
+
+  return okay;
+}
+
 
 PathsPage::PathsPage(CreateInstanceDialog& dlg) :
-  Page(dlg),
-  m_checker(ui->locationExists, ui->locationInvalid),
-  m_advancedChecker(ui->advancedDirExists, ui->advancedDirInvalid)
+  Page(dlg), m_lastType(CreateInstanceDialog::NoType),
+  m_simpleExists(ui->locationExists), m_simpleInvalid(ui->locationInvalid),
+  m_advancedExists(ui->advancedDirExists),
+  m_advancedInvalid(ui->advancedDirInvalid)
 {
   QObject::connect(ui->location, &QLineEdit::textEdited, [&]{ onChanged(); });
   QObject::connect(ui->base, &QLineEdit::textEdited, [&]{ onChanged(); });
@@ -816,12 +785,16 @@ bool PathsPage::ready() const
 void PathsPage::activated()
 {
   const auto name = m_dlg.instanceName();
+  const auto type = m_dlg.instanceType();
+
+  const bool changed = (m_lastInstanceName != name) || (m_lastType != type);
 
-  setPaths(name, (m_lastInstanceName != name));
+  setPaths(name, changed);
   checkPaths();
   updateNavigation();
 
   m_lastInstanceName = name;
+  m_lastType = type;
 }
 
 CreateInstanceDialog::Paths PathsPage::selectedPaths() const
@@ -852,21 +825,23 @@ bool PathsPage::checkPaths() const
   if (ui->advancedPathOptions->isChecked()) {
     return
       checkAdvancedPath(ui->base->text()) &&
-      checkVarPath(ui->downloads->text());
+      checkAdvancedPath(resolve(ui->downloads->text())) &&
+      checkAdvancedPath(resolve(ui->mods->text())) &&
+      checkAdvancedPath(resolve(ui->profiles->text())) &&
+      checkAdvancedPath(resolve(ui->overwrite->text()));
   } else {
-    return m_checker.checkPath(ui->location->text());
+    return checkPath(ui->location->text(), m_simpleExists, m_simpleInvalid);
   }
 }
 
 bool PathsPage::checkAdvancedPath(const QString& path) const
 {
-  return m_advancedChecker.checkPath(path);
+  return checkPath(path, m_advancedExists, m_advancedInvalid);
 }
 
-bool PathsPage::checkVarPath(QString path) const
+QString PathsPage::resolve(const QString& path) const
 {
-  path = PathSettings::resolve(path, ui->base->text());
-  return checkAdvancedPath(path);
+  return PathSettings::resolve(path, ui->base->text());
 }
 
 void PathsPage::onAdvanced()
@@ -884,12 +859,20 @@ void PathsPage::onAdvanced()
 
 void PathsPage::setPaths(const QString& name, bool force)
 {
-  const auto root = InstanceManager::instance().instancesPath();
-  const auto path = QDir::toNativeSeparators(root + "/" + name);
+  QString path;
 
-  setIfEmpty(ui->location, path, force);
+  if (m_dlg.instanceType() == CreateInstanceDialog::Portable) {
+    path = InstanceManager::portablePath();
+  } else {
+    const auto root = InstanceManager::instance().instancesPath();
+    path = root + "/" + name;
+  }
+
+  path = QDir::toNativeSeparators(QDir(path).canonicalPath());
 
+  setIfEmpty(ui->location, path, force);
   setIfEmpty(ui->base, path, force);
+
   setIfEmpty(ui->downloads, makeDefaultPath(AppConfig::downloadPath()), force);
   setIfEmpty(ui->mods, makeDefaultPath(AppConfig::modsPath()), force);
   setIfEmpty(ui->profiles, makeDefaultPath(AppConfig::profilesPath()), force);
@@ -903,6 +886,61 @@ void PathsPage::setIfEmpty(QLineEdit* e, const QString& path, bool force)
   }
 }
 
+bool PathsPage::checkPath(
+  QString path,
+  PlaceholderLabel& existsLabel, PlaceholderLabel& invalidLabel) const
+{
+  bool exists = false;
+  bool invalid = false;
+  bool empty = false;
+
+  path = QDir::toNativeSeparators(path.trimmed());
+
+  if (path.isEmpty()) {
+    empty = true;
+  } else {
+    const QString sanitized = sanitizePath(path);
+
+    if (path != sanitized) {
+      invalid = true;
+    } else {
+      if (m_dlg.instanceType() == CreateInstanceDialog::Portable) {
+        // the default data path for a portable instance is the application
+        // directory, so it's not an error if it exists
+        if (QDir(path) != InstanceManager::instance().portablePath()) {
+          exists = QDir(path).exists();
+        }
+      } else {
+        exists = QDir(path).exists();
+      }
+    }
+  }
+
+  bool okay = true;
+
+  if (invalid) {
+    okay = false;
+    existsLabel.setVisible(false);
+    invalidLabel.setVisible(true);
+    invalidLabel.setText(path);
+  } else if (empty) {
+    okay = false;
+    existsLabel.setVisible(false);
+    invalidLabel.setVisible(false);
+  } else if (exists) {
+    // this is just a warning
+    existsLabel.setVisible(true);
+    existsLabel.setText(path);
+    invalidLabel.setVisible(false);
+  } else {
+    okay = true;
+    existsLabel.setVisible(false);
+    invalidLabel.setVisible(false);
+  }
+
+  return okay;
+}
+
 
 ConfirmationPage::ConfirmationPage(CreateInstanceDialog& dlg)
   : Page(dlg)
diff --git a/src/createinstancedialogpages.h b/src/createinstancedialogpages.h
index 0baff666..0d210493 100644
--- a/src/createinstancedialogpages.h
+++ b/src/createinstancedialogpages.h
@@ -13,29 +13,17 @@ namespace cid
 
 QString makeDefaultPath(const std::wstring& dir);
 
-class PathChecker
+
+class PlaceholderLabel
 {
 public:
-  PathChecker(QLabel* existsLabel, QLabel* invalidLabel);
-
-  QString sanitizeFileName(const QString& name) const;
-
-  // same thing as above, but allows path separators and colons
-  //
-  QString sanitizePath(const QString& path) const;
-
-  bool checkName(QString parentDir, QString name) const;
-  bool checkPath(QString path) const;
+  PlaceholderLabel(QLabel* label);
+  void setText(const QString& arg);
+  void setVisible(bool b);
 
 private:
-  QLabel* m_exists;
-  QString m_existsOriginal;
-
-  QLabel* m_invalid;
-  QString m_invalidOriginal;
-
-  void setPossiblePlaceholder(
-    QLabel* label, const QString& s, const QString& arg) const;
+  QLabel* m_label;
+  QString m_original;
 };
 
 
@@ -168,13 +156,13 @@ public:
   QString selectedInstanceName() const override;
 
 private:
-  PathChecker m_checker;
-  QString m_originalLabel;
+  mutable PlaceholderLabel m_label, m_exists, m_invalid;
   bool m_modified;
   bool m_okay;
 
   void onChanged();
   void updateWarnings();
+  bool checkName(QString parentDir, QString name);
 };
 
 
@@ -189,16 +177,21 @@ public:
   CreateInstanceDialog::Paths selectedPaths() const override;
 
 private:
-  PathChecker m_checker, m_advancedChecker;
   QString m_lastInstanceName;
+  CreateInstanceDialog::Types m_lastType;
+  mutable PlaceholderLabel m_simpleExists, m_simpleInvalid;
+  mutable PlaceholderLabel m_advancedExists, m_advancedInvalid;
 
   void onChanged();
   bool checkPaths() const;
   bool checkAdvancedPath(const QString& path) const;
-  bool checkVarPath(QString path) const;
+  QString resolve(const QString& path) const;
   void onAdvanced();
   void setPaths(const QString& name, bool force);
   void setIfEmpty(QLineEdit* e, const QString& path, bool force);
+  bool checkPath(
+    QString path,
+    PlaceholderLabel& existsLabel, PlaceholderLabel& invalidLabel) const;
 };
 
 
diff --git a/src/instancemanager.cpp b/src/instancemanager.cpp
index b135cac1..849cdb5e 100644
--- a/src/instancemanager.cpp
+++ b/src/instancemanager.cpp
@@ -353,7 +353,12 @@ QStringList InstanceManager::instanceNames() const
 
 bool InstanceManager::isPortablePath(const QString& dataPath)
 {
-  return (dataPath == qApp->applicationDirPath());
+  return (dataPath == portablePath());
+}
+
+QString InstanceManager::portablePath()
+{
+  return qApp->applicationDirPath();
 }
 
 bool InstanceManager::portableInstall() const
diff --git a/src/instancemanager.h b/src/instancemanager.h
index 6a6b52ac..33a751c2 100644
--- a/src/instancemanager.h
+++ b/src/instancemanager.h
@@ -48,6 +48,7 @@ public:
 
   bool allowedToChangeInstance() const;
   static bool isPortablePath(const QString& dataPath);
+  static QString portablePath();
 
   QString instancesPath() const;
   QStringList instanceNames() const;