1 files changed, 197 insertions, 162 deletions

diff --git a/src/editexecutablesdialog.cpp b/src/editexecutablesdialog.cpp
index 941ab4e0..621c670f 100644
--- a/src/editexecutablesdialog.cpp
+++ b/src/editexecutablesdialog.cpp
@@ -40,7 +40,7 @@ EditExecutablesDialog::EditExecutablesDialog(
   , m_executablesList(executablesList)
   , m_profile(profile)
   , m_gamePlugin(game)
-  , m_dirty(false)
+  , m_settingUI(false)
 {
   ui->setupUi(this);
   ui->splitter->setSizes({200, 1});
@@ -48,108 +48,189 @@ EditExecutablesDialog::EditExecutablesDialog(
   ui->splitter->setStretchFactor(1, 1);
 
   refreshExecutablesWidget();
-  ui->newFilesModBox->addItems(modList.allMods());
+  ui->mods->addItems(modList.allMods());
 
-  m_forcedLibraries = m_profile->determineForcedLibraries(ui->titleEdit->text());
+  m_forcedLibraries = m_profile->determineForcedLibraries(ui->title->text());
+
+  // title textbox also has to change the list item, will call save manually
+  connect(ui->title, &QLineEdit::textChanged, [&](auto&& s){ onTitleChanged(s); });
+  connect(ui->binary, &QLineEdit::textChanged, [&]{ save(); });
+  connect(ui->workingDirectory, &QLineEdit::textChanged, [&]{ save(); });
+  connect(ui->arguments, &QLineEdit::textChanged, [&]{ save(); });
 
   updateUI(nullptr);
 }
 
 EditExecutablesDialog::~EditExecutablesDialog() = default;
 
+QListWidgetItem* EditExecutablesDialog::selectedItem()
+{
+  const auto selection = ui->list->selectedItems();
+
+  if (selection.empty()) {
+    return nullptr;
+  }
+
+  return selection[0];
+}
+
+Executable* EditExecutablesDialog::selectedExe()
+{
+  auto* item = selectedItem();
+  if (!item) {
+    return nullptr;
+  }
+
+  const auto& title = item->text();
+  auto itor = m_executablesList.find(title);
+
+  if (itor == m_executablesList.end()) {
+    return nullptr;
+  }
+
+  return &*itor;
+}
+
 void EditExecutablesDialog::updateUI(const Executable* e)
 {
+  m_settingUI = true;
+
   if (e) {
     setEdits(*e);
-    ui->removeButton->setEnabled(e->isCustom());
+    ui->remove->setEnabled(e->isCustom());
   } else {
     clearEdits();
-    ui->removeButton->setEnabled(false);
+    ui->remove->setEnabled(false);
   }
+
+  m_settingUI = false;
 }
 
 void EditExecutablesDialog::clearEdits()
 {
-  ui->titleEdit->clear();
-  ui->binaryEdit->clear();
-  ui->workingDirEdit->clear();
-  ui->argumentsEdit->clear();
-  ui->overwriteAppIDBox->setChecked(false);
-  ui->appIDOverwriteEdit->clear();
-  ui->newFilesModCheckBox->setChecked(false);
-  ui->newFilesModBox->setCurrentIndex(-1);
-  ui->forceLoadCheckBox->setChecked(false);
-  ui->useAppIconCheckBox->setChecked(false);
+  ui->title->clear();
+  ui->binary->clear();
+  ui->workingDirectory->clear();
+  ui->arguments->clear();
+  ui->overwriteSteamAppID->setChecked(false);
+  ui->steamAppID->clear();
+  ui->createFilesInMod->setChecked(false);
+  ui->mods->setCurrentIndex(-1);
+  ui->forceLoadLibraries->setChecked(false);
+  ui->useApplicationIcon->setChecked(false);
 
   ui->pluginProvidedLabel->setVisible(false);
 }
 
 void EditExecutablesDialog::setEdits(const Executable& e)
 {
-  ui->titleEdit->setText(e.title());
-  ui->binaryEdit->setText(QDir::toNativeSeparators(e.binaryInfo().absoluteFilePath()));
-  ui->workingDirEdit->setText(QDir::toNativeSeparators(e.workingDirectory()));
-  ui->argumentsEdit->setText(e.arguments());
-  ui->overwriteAppIDBox->setChecked(!e.steamAppID().isEmpty());
-  ui->appIDOverwriteEdit->setText(e.steamAppID());
-  ui->useAppIconCheckBox->setChecked(e.usesOwnIcon());
+  ui->title->setText(e.title());
+  ui->binary->setText(QDir::toNativeSeparators(e.binaryInfo().absoluteFilePath()));
+  ui->workingDirectory->setText(QDir::toNativeSeparators(e.workingDirectory()));
+  ui->arguments->setText(e.arguments());
+  ui->overwriteSteamAppID->setChecked(!e.steamAppID().isEmpty());
+  ui->steamAppID->setText(e.steamAppID());
+  ui->useApplicationIcon->setChecked(e.usesOwnIcon());
 
   int modIndex = -1;
 
   QString customOverwrite = m_profile->setting("custom_overwrites", e.title()).toString();
   if (!customOverwrite.isEmpty()) {
-    modIndex = ui->newFilesModBox->findText(customOverwrite);
+    modIndex = ui->mods->findText(customOverwrite);
   }
 
-  ui->newFilesModCheckBox->setChecked(modIndex != -1);
-  ui->newFilesModBox->setCurrentIndex(modIndex);
+  ui->createFilesInMod->setChecked(modIndex != -1);
+  ui->mods->setCurrentIndex(modIndex);
 
   const bool forcedLibraries = m_profile->forcedLibrariesEnabled(e.title());
-  ui->forceLoadCheckBox->setChecked(forcedLibraries);
-  ui->forceLoadButton->setEnabled(forcedLibraries);
+  ui->forceLoadLibraries->setChecked(forcedLibraries);
+  ui->configureLibraries->setEnabled(forcedLibraries);
 
   ui->pluginProvidedLabel->setVisible(!e.isCustom());
 
   // only enabled for custom executables
-  ui->titleEdit->setEnabled(e.isCustom());
-  ui->binaryEdit->setEnabled(e.isCustom());
-  ui->browseBinaryButton->setEnabled(e.isCustom());
-  ui->workingDirEdit->setEnabled(e.isCustom());
-  ui->browseWorkingDirButton->setEnabled(e.isCustom());
-  ui->argumentsEdit->setEnabled(e.isCustom());
-  ui->overwriteAppIDBox->setEnabled(e.isCustom());
-  ui->appIDOverwriteEdit->setEnabled(e.isCustom());
-  ui->useAppIconCheckBox->setEnabled(e.isCustom());
+  ui->title->setEnabled(e.isCustom());
+  ui->binary->setEnabled(e.isCustom());
+  ui->browseBinary->setEnabled(e.isCustom());
+  ui->workingDirectory->setEnabled(e.isCustom());
+  ui->browseWorkingDirectory->setEnabled(e.isCustom());
+  ui->arguments->setEnabled(e.isCustom());
+  ui->overwriteSteamAppID->setEnabled(e.isCustom());
+  ui->steamAppID->setEnabled(e.isCustom());
+  ui->useApplicationIcon->setEnabled(e.isCustom());
 
   // always enabled
-  ui->newFilesModCheckBox->setEnabled(true);
-  ui->newFilesModBox->setEnabled(true);
-  ui->forceLoadCheckBox->setEnabled(true);
+  ui->createFilesInMod->setEnabled(true);
+  ui->mods->setEnabled(true);
+  ui->forceLoadLibraries->setEnabled(true);
 }
 
+void EditExecutablesDialog::save()
+{
+  if (m_settingUI) {
+    // the ui is currently being set, ignore changes
+    return;
+  }
+
+  auto* e = selectedExe();
+  if (!e) {
+    qWarning("trying to save but nothing is selected");
+    return;
+  }
+
+  qDebug().nospace() << "saving '" << e->title() << "'";
+
+  e->title(ui->title->text());
+  e->binaryInfo(ui->binary->text());
+  e->workingDirectory(ui->workingDirectory->text());
+  e->arguments(ui->arguments->text());
+
+  if (ui->overwriteSteamAppID->isChecked()) {
+    e->steamAppID(ui->steamAppID->text());
+  } else {
+    e->steamAppID("");
+  }
+}
+
+void EditExecutablesDialog::onTitleChanged(const QString& s)
+{
+  if (m_settingUI) {
+    // the ui is currently being set, ignore changes
+    return;
+  }
 
+  // must save first because it relies on the text in the list to find the
+  // executable to modify
+  save();
 
+  // once the executable is saved, the list item must be changed to match the
+  // new name
+  if (auto* i=selectedItem()) {
+    i->setText(s);
+  }
+}
 
 
 void EditExecutablesDialog::resetInput()
 {
-  ui->binaryEdit->setText("");
-  ui->titleEdit->setText("");
-  ui->workingDirEdit->clear();
-  ui->argumentsEdit->setText("");
-  ui->appIDOverwriteEdit->clear();
-  ui->overwriteAppIDBox->setChecked(false);
-  ui->useAppIconCheckBox->setChecked(false);
-  ui->newFilesModCheckBox->setChecked(false);
-  ui->forceLoadCheckBox->setChecked(false);
+  ui->binary->setText("");
+  ui->title->setText("");
+  ui->workingDirectory->clear();
+  ui->arguments->setText("");
+  ui->overwriteSteamAppID->setChecked(false);
+  ui->createFilesInMod->setChecked(false);
+  ui->forceLoadLibraries->setChecked(false);
+  ui->steamAppID->clear();
+  ui->useApplicationIcon->setChecked(false);
+
   m_currentItem = nullptr;
 }
 
 ExecutablesList EditExecutablesDialog::getExecutablesList() const
 {
   ExecutablesList newList;
-  for (int i = 0; i < ui->executablesListBox->count(); ++i) {
-    const auto& title = ui->executablesListBox->item(i)->text();
+  for (int i = 0; i < ui->list->count(); ++i) {
+    const auto& title = ui->list->item(i)->text();
     auto itor = m_executablesList.find(title);
 
     if (itor == m_executablesList.end()) {
@@ -167,7 +248,7 @@ ExecutablesList EditExecutablesDialog::getExecutablesList() const
 
 void EditExecutablesDialog::refreshExecutablesWidget()
 {
-  ui->executablesListBox->clear();
+  ui->list->clear();
 
   for(const auto& exe : m_executablesList) {
     QListWidgetItem *newItem = new QListWidgetItem(exe.title());
@@ -179,7 +260,7 @@ void EditExecutablesDialog::refreshExecutablesWidget()
       newItem->setFont(f);
     }
 
-    ui->executablesListBox->addItem(newItem);
+    ui->list->addItem(newItem);
   }
 
   //ui->addButton->setEnabled(false);
@@ -187,28 +268,18 @@ void EditExecutablesDialog::refreshExecutablesWidget()
 }
 
 
-void EditExecutablesDialog::on_binaryEdit_textChanged(const QString &name)
-{
-  updateButtonStates();
-}
-
-void EditExecutablesDialog::on_workingDirEdit_textChanged(const QString &dir)
-{
-  updateButtonStates();
-}
-
 void EditExecutablesDialog::updateButtonStates()
 {
   bool enabled = true;
 
-  QString filePath(ui->binaryEdit->text());
+  QString filePath(ui->binary->text());
   QFileInfo fileInfo(filePath);
   if (!fileInfo.exists())
     enabled = false;
   if (!fileInfo.isFile())
     enabled = false;
 
-  QString dirPath(ui->workingDirEdit->text());
+  QString dirPath(ui->workingDirectory->text());
   if (!dirPath.isEmpty()) {
     QDir dirInfo(dirPath);
     if (!dirInfo.exists())
@@ -222,41 +293,41 @@ void EditExecutablesDialog::updateButtonStates()
 void EditExecutablesDialog::saveExecutable()
 {
   Executable::Flags flags = Executable::CustomExecutable;
-  if (ui->useAppIconCheckBox->isChecked())
+  if (ui->useApplicationIcon->isChecked())
     flags |= Executable::UseApplicationIcon;
 
   m_executablesList.setExecutable(Executable()
-    .title(ui->titleEdit->text())
-    .binaryInfo(QDir::fromNativeSeparators(ui->binaryEdit->text()))
-    .arguments(ui->argumentsEdit->text())
-    .steamAppID(ui->overwriteAppIDBox->isChecked() ? ui->appIDOverwriteEdit->text() : "")
-    .workingDirectory(QDir::fromNativeSeparators(ui->workingDirEdit->text()))
+    .title(ui->title->text())
+    .binaryInfo(QDir::fromNativeSeparators(ui->binary->text()))
+    .arguments(ui->arguments->text())
+    .steamAppID(ui->overwriteSteamAppID->isChecked() ? ui->steamAppID->text() : "")
+    .workingDirectory(QDir::fromNativeSeparators(ui->workingDirectory->text()))
     .flags(flags));
 
-  if (ui->newFilesModCheckBox->isChecked()) {
-    m_profile->storeSetting("custom_overwrites", ui->titleEdit->text(),
-                            ui->newFilesModBox->currentText());
+  if (ui->createFilesInMod->isChecked()) {
+    m_profile->storeSetting("custom_overwrites", ui->title->text(),
+                            ui->mods->currentText());
   }
   else {
-	  m_profile->removeSetting("custom_overwrites", ui->titleEdit->text());
+	  m_profile->removeSetting("custom_overwrites", ui->title->text());
   }
 
-  m_profile->removeForcedLibraries(ui->titleEdit->text());
-  m_profile->storeForcedLibraries(ui->titleEdit->text(), m_forcedLibraries);
-  m_profile->setForcedLibrariesEnabled(ui->titleEdit->text(), ui->forceLoadCheckBox->isChecked());
+  m_profile->removeForcedLibraries(ui->title->text());
+  m_profile->storeForcedLibraries(ui->title->text(), m_forcedLibraries);
+  m_profile->setForcedLibrariesEnabled(ui->title->text(), ui->forceLoadLibraries->isChecked());
 }
 
 
 void EditExecutablesDialog::delayedRefresh()
 {
-  QModelIndex index = ui->executablesListBox->currentIndex();
+  /*QModelIndex index = ui->executablesListBox->currentIndex();
   resetInput();
   refreshExecutablesWidget();
-  on_executablesListBox_clicked(index);
+  on_executablesListBox_clicked(index);*/
 }
 
 
-void EditExecutablesDialog::on_forceLoadButton_clicked()
+void EditExecutablesDialog::on_configureLibraries_clicked()
 {
   ForcedLoadDialog dialog(m_gamePlugin, this);
   dialog.setValues(m_forcedLibraries);
@@ -265,13 +336,13 @@ void EditExecutablesDialog::on_forceLoadButton_clicked()
   }
 }
 
-void EditExecutablesDialog::on_forceLoadCheckBox_toggled()
+void EditExecutablesDialog::on_forceLoadLibraries_toggled(bool checked)
 {
-  ui->forceLoadButton->setEnabled(ui->forceLoadCheckBox->isChecked());
+  ui->configureLibraries->setEnabled(ui->forceLoadLibraries->isChecked());
 }
 
 
-void EditExecutablesDialog::on_addButton_clicked()
+void EditExecutablesDialog::on_add_clicked()
 {
   if (executableChanged()) {
     saveExecutable();
@@ -281,7 +352,7 @@ void EditExecutablesDialog::on_addButton_clicked()
   refreshExecutablesWidget();
 }
 
-void EditExecutablesDialog::on_browseBinaryButton_clicked()
+void EditExecutablesDialog::on_browseBinary_clicked()
 {
   QString binaryName = FileDialogMemory::getOpenFileName(
       "editExecutableBinary", this, tr("Select a binary"), QString(),
@@ -319,21 +390,21 @@ void EditExecutablesDialog::on_browseBinaryButton_clicked()
                                tr("MO requires 32-bit java to run this application. If you already have it installed, select javaw.exe "
                                   "from that installation as the binary."));
     } else {
-      ui->binaryEdit->setText(binaryPath);
+      ui->binary->setText(binaryPath);
     }
 
-    ui->workingDirEdit->setText(QDir::toNativeSeparators(QFileInfo(binaryName).absolutePath()));
-    ui->argumentsEdit->setText("-jar \"" + QDir::toNativeSeparators(binaryName) + "\"");
+    ui->workingDirectory->setText(QDir::toNativeSeparators(QFileInfo(binaryName).absolutePath()));
+    ui->arguments->setText("-jar \"" + QDir::toNativeSeparators(binaryName) + "\"");
   } else {
-    ui->binaryEdit->setText(QDir::toNativeSeparators(binaryName));
+    ui->binary->setText(QDir::toNativeSeparators(binaryName));
   }
 
-  if (ui->titleEdit->text().isEmpty()) {
-    ui->titleEdit->setText(QFileInfo(binaryName).baseName());
+  if (ui->title->text().isEmpty()) {
+    ui->title->setText(QFileInfo(binaryName).baseName());
   }
 }
 
-void EditExecutablesDialog::on_browseWorkingDirButton_clicked()
+void EditExecutablesDialog::on_browseWorkingDirectory_clicked()
 {
   QString dirName = FileDialogMemory::getExistingDirectory("editExecutableDirectory", this,
                                                            tr("Select a directory"));
@@ -343,43 +414,22 @@ void EditExecutablesDialog::on_browseWorkingDirButton_clicked()
     return;
   }
 
-  ui->workingDirEdit->setText(dirName);
+  ui->workingDirectory->setText(dirName);
 }
 
-void EditExecutablesDialog::on_removeButton_clicked()
+void EditExecutablesDialog::on_remove_clicked()
 {
-  if (QMessageBox::question(this, tr("Confirm"), tr("Really remove \"%1\" from executables?").arg(ui->titleEdit->text()),
+  if (QMessageBox::question(this, tr("Confirm"), tr("Really remove \"%1\" from executables?").arg(ui->title->text()),
                             QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes) {
-    m_profile->removeSetting("custom_overwrites", ui->titleEdit->text());
-    m_profile->removeForcedLibraries(ui->titleEdit->text());
-    m_executablesList.remove(ui->titleEdit->text());
+    m_profile->removeSetting("custom_overwrites", ui->title->text());
+    m_profile->removeForcedLibraries(ui->title->text());
+    m_executablesList.remove(ui->title->text());
   }
 
   resetInput();
   refreshExecutablesWidget();
 }
 
-void EditExecutablesDialog::on_titleEdit_textChanged(const QString &arg1)
-{
-  /*QPushButton *addButton = findChild<QPushButton*>("addButton");
-  QPushButton *removeButton = findChild<QPushButton*>("removeButton");
-
-  QListWidget *executablesWidget = findChild<QListWidget*>("executablesListBox");
-
-  QList<QListWidgetItem*> existingItems = executablesWidget->findItems(arg1, Qt::MatchFixedString);
-
-  addButton->setEnabled(arg1.length() != 0);
-
-  if (existingItems.count() == 0) {
-    addButton->setText(tr("Add"));
-    removeButton->setEnabled(false);
-  } else {
-    // existing item. is it a custom one?
-    addButton->setText(tr("Modify"));
-    removeButton->setEnabled(true);
-  }*/
-}
-
 
 bool EditExecutablesDialog::executableChanged()
 {
@@ -409,58 +459,39 @@ bool EditExecutablesDialog::executableChanged()
                                                  lhs.library() == rhs.library() &&
                                                  lhs.process() == rhs.process();
                                         });
-    forcedLibrariesDirty |= m_profile->setting("forced_libraries", ui->titleEdit->text() + "/enabled", false).toBool() !=
-                            ui->forceLoadCheckBox->isChecked();
+    forcedLibrariesDirty |= m_profile->setting("forced_libraries", ui->title->text() + "/enabled", false).toBool() !=
+                            ui->forceLoadLibraries->isChecked();
 
-    return selectedExecutable.title() != ui->titleEdit->text()
-        || selectedExecutable.arguments() != ui->argumentsEdit->text()
-        || selectedExecutable.steamAppID() != ui->appIDOverwriteEdit->text()
-        || !storedCustomOverwrite.isEmpty() != ui->newFilesModCheckBox->isChecked()
-        || !storedCustomOverwrite.isEmpty() && (storedCustomOverwrite != ui->newFilesModBox->currentText())
-        || selectedExecutable.workingDirectory() != QDir::fromNativeSeparators(ui->workingDirEdit->text())
-        || selectedExecutable.binaryInfo().absoluteFilePath() != QDir::fromNativeSeparators(ui->binaryEdit->text())
-        || selectedExecutable.usesOwnIcon() != ui->useAppIconCheckBox->isChecked()
+    return selectedExecutable.title() != ui->title->text()
+        || selectedExecutable.arguments() != ui->arguments->text()
+        || selectedExecutable.steamAppID() != ui->steamAppID->text()
+        || !storedCustomOverwrite.isEmpty() != ui->createFilesInMod->isChecked()
+        || !storedCustomOverwrite.isEmpty() && (storedCustomOverwrite != ui->mods->currentText())
+        || selectedExecutable.workingDirectory() != QDir::fromNativeSeparators(ui->workingDirectory->text())
+        || selectedExecutable.binaryInfo().absoluteFilePath() != QDir::fromNativeSeparators(ui->binary->text())
+        || selectedExecutable.usesOwnIcon() != ui->useApplicationIcon->isChecked()
         || forcedLibrariesDirty
       ;
   } else {
-    QFileInfo fileInfo(ui->binaryEdit->text());
-    return !ui->binaryEdit->text().isEmpty()
-        && !ui->titleEdit->text().isEmpty()
+    QFileInfo fileInfo(ui->binary->text());
+    return !ui->binary->text().isEmpty()
+        && !ui->title->text().isEmpty()
         && fileInfo.exists()
         && fileInfo.isFile();
   }
 }
-void EditExecutablesDialog::on_executablesListBox_itemSelectionChanged()
-{
-  const auto selection = ui->executablesListBox->selectedItems();
-
-  if (selection.empty()) {
-    updateUI(nullptr);
-    return;
-  }
-
-  auto* item = selection[0];
-  if (!item) {
-    return;
-  }
-
-  const auto& title = item->text();
-  auto itor = m_executablesList.find(title);
 
-  if (itor == m_executablesList.end()) {
-    qWarning().nospace() << "selection: executable '" << title << "' not found";
-    return;
-  }
-
-  updateUI(&*itor);
+void EditExecutablesDialog::on_list_itemSelectionChanged()
+{
+  updateUI(selectedExe());
 }
 
-void EditExecutablesDialog::on_overwriteAppIDBox_toggled(bool checked)
+void EditExecutablesDialog::on_overwriteSteamAppID_toggled(bool checked)
 {
-  ui->appIDOverwriteEdit->setEnabled(checked);
+  ui->steamAppID->setEnabled(checked);
 }
 
-void EditExecutablesDialog::on_buttonBox_accepted()
+void EditExecutablesDialog::on_buttons_accepted()
 {
   if (executableChanged()) {
     QMessageBox::StandardButton res = QMessageBox::question(this, tr("Save Changes?"),
@@ -479,13 +510,13 @@ void EditExecutablesDialog::on_buttonBox_accepted()
   accept();
 }
 
-void EditExecutablesDialog::on_buttonBox_rejected()
+void EditExecutablesDialog::on_buttons_rejected()
 {
   reject();
 }
 
-void EditExecutablesDialog::on_executablesListBox_clicked(const QModelIndex &current)
-{/*
+/*void EditExecutablesDialog::on_executablesListBox_clicked(const QModelIndex &current)
+{
   if (current.isValid()) {
 
     if (executableChanged()) {
@@ -549,10 +580,14 @@ void EditExecutablesDialog::on_executablesListBox_clicked(const QModelIndex &cur
     bool forcedLibraries = m_Profile->forcedLibrariesEnabled(ui->titleEdit->text());
     ui->forceLoadButton->setEnabled(forcedLibraries);
     ui->forceLoadCheckBox->setChecked(forcedLibraries);
-  }*/
+  }
+}*/
+
+void EditExecutablesDialog::on_createFilesInMod_toggled(bool checked)
+{
+  ui->mods->setEnabled(checked);
 }
 
-void EditExecutablesDialog::on_newFilesModCheckBox_toggled(bool checked)
+void EditExecutablesDialog::on_useApplicationIcon_toggled(bool checked)
 {
-  ui->newFilesModBox->setEnabled(checked);
 }