renamed LockWidget to UILocker

lock interface up to two processes

7 files changed, 95 insertions, 86 deletions

diff --git a/src/lockwidget.cpp b/src/lockwidget.cpp
index 8b654674..150d2847 100644
--- a/src/lockwidget.cpp
+++ b/src/lockwidget.cpp
@@ -4,12 +4,12 @@
 #include <QMenuBar>
 #include <QStatusBar>
 
-class LockInterface
+class UILockerInterface
 {
 public:
-  LockInterface(QWidget* mainUI) :
+  UILockerInterface(QWidget* mainUI) :
     m_mainUI(mainUI), m_target(nullptr), m_message(nullptr), m_info(nullptr),
-    m_buttons(nullptr), m_reason(LockWidget::NoReason)
+    m_buttons(nullptr), m_reason(UILocker::NoReason)
   {
     m_timer.reset(new QTimer);
     QObject::connect(m_timer.get(), &QTimer::timeout, [&]{ checkTarget(); });
@@ -18,7 +18,7 @@ public:
     set();
   }
 
-  ~LockInterface()
+  ~UILockerInterface()
   {
   }
 
@@ -71,17 +71,28 @@ public:
     return true;
   }
 
-  void update(LockWidget::Reasons reason)
+  void update(UILocker::Reasons reason)
   {
     m_reason = reason;
     updateMessage(reason);
     updateButtons(reason);
-    setInfo(m_infoText);
+    setInfo(m_labels);
   }
 
-  void setInfo(const QString& s)
+  void setInfo(const QStringList& labels)
   {
-    m_infoText = s;
+    const int MaxLabels = 2;
+
+    m_labels = labels;
+
+    QString s;
+
+    if (labels.size() > MaxLabels) {
+      s = labels.mid(0, MaxLabels).join(", ") + "...";
+    } else {
+      s = labels.join(", ");
+    }
+
     m_info->setText(s);
   }
 
@@ -121,10 +132,10 @@ private:
   std::unique_ptr<QWidget> m_topLevel;
   QLabel* m_message;
   QLabel* m_info;
-  QString m_infoText;
+  QStringList m_labels;
   QWidget* m_buttons;
   std::unique_ptr<Filter> m_filter;
-  LockWidget::Reasons m_reason;
+  UILocker::Reasons m_reason;
 
 
   bool hasMainUI() const
@@ -206,6 +217,7 @@ private:
   void createMessageLabel()
   {
     m_message = new QLabel;
+    m_message->setAlignment(Qt::AlignCenter | Qt::AlignHCenter);
   }
 
   void createInfoLabel()
@@ -221,11 +233,11 @@ private:
   }
 
 
-  void updateMessage(LockWidget::Reasons reason)
+  void updateMessage(UILocker::Reasons reason)
   {
     switch (reason)
     {
-      case LockWidget::LockUI:
+      case UILocker::LockUI:
       {
         QString s;
 
@@ -241,7 +253,7 @@ private:
         break;
       }
 
-      case LockWidget::OutputRequired:
+      case UILocker::OutputRequired:
       {
         m_message->setText(QObject::tr(
           "The application must run to completion because its output is "
@@ -250,7 +262,7 @@ private:
         break;
       }
 
-      case LockWidget::PreventExit:
+      case UILocker::PreventExit:
       {
         m_message->setText(QObject::tr(
           "Mod Organizer is waiting on application to close before exiting."));
@@ -260,20 +272,20 @@ private:
     }
   }
 
-  void updateButtons(LockWidget::Reasons reason)
+  void updateButtons(UILocker::Reasons reason)
   {
     MOBase::deleteChildWidgets(m_buttons);
     auto* ly = m_buttons->layout();
 
     switch (reason)
     {
-      case LockWidget::LockUI: // fall-through
-      case LockWidget::OutputRequired:
+      case UILocker::LockUI: // fall-through
+      case UILocker::OutputRequired:
       {
         auto* unlock = new QPushButton(QObject::tr("Unlock"));
 
         QObject::connect(unlock, &QPushButton::clicked, [&]{
-          LockWidget::instance().onForceUnlock();
+          UILocker::instance().onForceUnlock();
         });
 
         ly->addWidget(unlock);
@@ -281,18 +293,18 @@ private:
         break;
       }
 
-      case LockWidget::PreventExit:
+      case UILocker::PreventExit:
       {
         auto* exit = new QPushButton(QObject::tr("Exit Now"));
         QObject::connect(exit, &QPushButton::clicked, [&]{
-          LockWidget::instance().onForceUnlock();
+          UILocker::instance().onForceUnlock();
         });
 
         ly->addWidget(exit);
 
         auto* cancel = new QPushButton(QObject::tr("Cancel"));
         QObject::connect(cancel, &QPushButton::clicked, [&]{
-          LockWidget::instance().onCancel();
+          UILocker::instance().onCancel();
         });
 
         ly->addWidget(cancel);
@@ -303,19 +315,19 @@ private:
   }
 };
 
-LockWidget::Session::~Session()
+UILocker::Session::~Session()
 {
   unlock();
 }
 
-void LockWidget::Session::unlock()
+void UILocker::Session::unlock()
 {
   QMetaObject::invokeMethod(qApp, [this]{
-    LockWidget::instance().unlock(this);
+    UILocker::instance().unlock(this);
   });
 }
 
-void LockWidget::Session::setInfo(DWORD pid, const QString& name)
+void UILocker::Session::setInfo(DWORD pid, const QString& name)
 {
   {
     std::scoped_lock lock(m_mutex);
@@ -324,39 +336,39 @@ void LockWidget::Session::setInfo(DWORD pid, const QString& name)
   }
 
   QMetaObject::invokeMethod(qApp, [this]{
-    LockWidget::instance().updateLabel();
+    UILocker::instance().updateLabel();
   });
 }
 
-DWORD LockWidget::Session::pid() const
+DWORD UILocker::Session::pid() const
 {
   std::scoped_lock lock(m_mutex);
   return m_pid;
 }
 
-const QString& LockWidget::Session::name() const
+const QString& UILocker::Session::name() const
 {
   std::scoped_lock lock(m_mutex);
   return m_name;
 }
 
-LockWidget::Results LockWidget::Session::result() const
+UILocker::Results UILocker::Session::result() const
 {
-  return LockWidget::instance().result();
+  return UILocker::instance().result();
 }
 
 
-static LockWidget* g_instance = nullptr;
+static UILocker* g_instance = nullptr;
 
 
-LockWidget::LockWidget()
+UILocker::UILocker()
   : m_parent(nullptr), m_result(NoResult)
 {
   Q_ASSERT(!g_instance);
   g_instance = this;
 }
 
-LockWidget::~LockWidget()
+UILocker::~UILocker()
 {
   const auto v = m_sessions;
 
@@ -367,18 +379,18 @@ LockWidget::~LockWidget()
   }
 }
 
-LockWidget& LockWidget::instance()
+UILocker& UILocker::instance()
 {
   Q_ASSERT(g_instance);
   return *g_instance;
 }
 
-void LockWidget::setUserInterface(QWidget* parent)
+void UILocker::setUserInterface(QWidget* parent)
 {
   m_parent = parent;
 }
 
-std::shared_ptr<LockWidget::Session> LockWidget::lock(Reasons reason)
+std::shared_ptr<UILocker::Session> UILocker::lock(Reasons reason)
 {
   m_result = StillLocked;
   createUi(reason);
@@ -391,7 +403,7 @@ std::shared_ptr<LockWidget::Session> LockWidget::lock(Reasons reason)
   return ls;
 }
 
-void LockWidget::unlock(Session* s)
+void UILocker::unlock(Session* s)
 {
   auto itor = m_sessions.begin();
   for (;;) {
@@ -420,7 +432,7 @@ void LockWidget::unlock(Session* s)
   }
 }
 
-void LockWidget::unlockCurrent()
+void UILocker::unlockCurrent()
 {
   if (m_sessions.empty()) {
     return;
@@ -435,29 +447,28 @@ void LockWidget::unlockCurrent()
   unlock(s.get());
 }
 
-void LockWidget::updateLabel()
+void UILocker::updateLabel()
 {
-  QString label;
+  QStringList labels;
 
   for (auto itor=m_sessions.rbegin(); itor!=m_sessions.rend(); ++itor) {
     if (auto ss=itor->lock()) {
-      label += QString("%1 (%2)").arg(ss->name()).arg(ss->pid());
-      break;
+      labels.push_back(QString("%1 (%2)").arg(ss->name()).arg(ss->pid()));
     }
   }
 
-  m_ui->setInfo(label);
+  m_ui->setInfo(labels);
 }
 
-LockWidget::Results LockWidget::result() const
+UILocker::Results UILocker::result() const
 {
   return m_result;
 }
 
-void LockWidget::createUi(Reasons reason)
+void UILocker::createUi(Reasons reason)
 {
   if (!m_ui) {
-    m_ui.reset(new LockInterface(m_parent));
+    m_ui.reset(new UILockerInterface(m_parent));
   }
 
   m_ui->update(reason);
@@ -465,13 +476,13 @@ void LockWidget::createUi(Reasons reason)
   disableAll();
 }
 
-void LockWidget::onForceUnlock()
+void UILocker::onForceUnlock()
 {
   m_result = ForceUnlocked;
   unlockCurrent();
 }
 
-void LockWidget::onCancel()
+void UILocker::onCancel()
 {
   m_result = Cancelled;
   unlockCurrent();
@@ -483,7 +494,7 @@ QList<T> findChildrenImmediate(QWidget* parent)
   return parent->findChildren<T>(QString(), Qt::FindDirectChildrenOnly);
 }
 
-void LockWidget::disableAll()
+void UILocker::disableAll()
 {
   const auto topLevels = QApplication::topLevelWidgets();
 
@@ -517,7 +528,7 @@ void LockWidget::disableAll()
   }
 }
 
-void LockWidget::enableAll()
+void UILocker::enableAll()
 {
   for (auto w : m_disabled) {
     if (w) {
@@ -528,7 +539,7 @@ void LockWidget::enableAll()
   m_disabled.clear();
 }
 
-void LockWidget::disable(QWidget* w)
+void UILocker::disable(QWidget* w)
 {
   if (w->isEnabled()) {
     w->setEnabled(false);
diff --git a/src/lockwidget.h b/src/lockwidget.h
index 640d0076..d8c22999 100644
--- a/src/lockwidget.h
+++ b/src/lockwidget.h
@@ -3,11 +3,11 @@
 #include <QMainWindow>
 #include <mutex>
 
-class LockInterface;
+class UILockerInterface;
 
-class LockWidget
+class UILocker
 {
-  friend class LockInterface;
+  friend class UILockerInterface;
 
 public:
   // reason to show the widget
@@ -62,12 +62,10 @@ public:
   };
 
 
-  // if `reason` is not NoReason, lock() is called with it
-  //
-  LockWidget();
-  ~LockWidget();
+  UILocker();
+  ~UILocker();
 
-  static LockWidget& instance();
+  static UILocker& instance();
 
   void setUserInterface(QWidget* parent);
 
@@ -77,7 +75,7 @@ public:
 
 private:
   QWidget* m_parent;
-  std::unique_ptr<LockInterface> m_ui;
+  std::unique_ptr<UILockerInterface> m_ui;
   std::vector<std::weak_ptr<Session>> m_sessions;
   std::atomic<Results> m_result;
   std::vector<QPointer<QWidget>> m_disabled;
diff --git a/src/organizercore.cpp b/src/organizercore.cpp
index 3d4d8e4b..9ceb149e 100644
--- a/src/organizercore.cpp
+++ b/src/organizercore.cpp
@@ -250,7 +250,7 @@ void OrganizerCore::setUserInterface(IUserInterface* ui)
 
   m_InstallationManager.setParentWidget(w);
   m_Updater.setUserInterface(w);
-  m_LockWidget.setUserInterface(w);
+  m_UILocker.setUserInterface(w);
 
   checkForUpdates();
 }
@@ -1797,7 +1797,7 @@ void OrganizerCore::afterRun(const QFileInfo& binary, DWORD exitCode)
 }
 
 ProcessRunner::Results OrganizerCore::waitForAllUSVFSProcesses(
-  LockWidget::Reasons reason)
+  UILocker::Reasons reason)
 {
   return processRunner().waitForAllUSVFSProcessesWithLock(reason);
 }
diff --git a/src/organizercore.h b/src/organizercore.h
index 7e0e4b7f..47630dc2 100644
--- a/src/organizercore.h
+++ b/src/organizercore.h
@@ -145,7 +145,7 @@ public:
   void afterRun(const QFileInfo& binary, DWORD exitCode);

 

   ProcessRunner::Results waitForAllUSVFSProcesses(

-    LockWidget::Reasons reason=LockWidget::PreventExit);

+    UILocker::Reasons reason=UILocker::PreventExit);

 

   void refreshESPList(bool force = false);

   void refreshBSAList();

@@ -344,7 +344,7 @@ private:
   MOBase::DelayedFileWriter m_PluginListsWriter;

   UsvfsConnector m_USVFS;

 

-  LockWidget m_LockWidget;

+  UILocker m_UILocker;

 

   static CrashDumpsType m_globalCrashDumpsType;

 };

diff --git a/src/organizerproxy.cpp b/src/organizerproxy.cpp
index 420e2d82..613de742 100644
--- a/src/organizerproxy.cpp
+++ b/src/organizerproxy.cpp
@@ -144,7 +144,7 @@ bool OrganizerProxy::waitForApplication(HANDLE handle, LPDWORD exitCode) const
   auto runner = m_Proxied->processRunner();

 

   const auto r = runner

-    .setWaitForCompletion(ProcessRunner::ForceWait, LockWidget::OutputRequired)

+    .setWaitForCompletion(ProcessRunner::ForceWait, UILocker::OutputRequired)

     .attachToProcess(handle);

 

   if (exitCode) {

diff --git a/src/processrunner.cpp b/src/processrunner.cpp
index 68acca92..cfddbb63 100644
--- a/src/processrunner.cpp
+++ b/src/processrunner.cpp
@@ -190,7 +190,7 @@ const std::chrono::milliseconds Infinite(-1);
 // waits for completion, times out after `wait` if not Infinite
 //
 std::optional<ProcessRunner::Results> timedWait(
-  HANDLE handle, DWORD pid, LockWidget::Session& ls,
+  HANDLE handle, DWORD pid, UILocker::Session& ls,
   std::chrono::milliseconds wait)
 {
   using namespace std::chrono;
@@ -214,24 +214,24 @@ std::optional<ProcessRunner::Results> timedWait(
     // check the lock widget
     switch (ls.result())
     {
-      case LockWidget::StillLocked:
+      case UILocker::StillLocked:
       {
         break;
       }
 
-      case LockWidget::ForceUnlocked:
+      case UILocker::ForceUnlocked:
       {
         log::debug("waiting for {} force unlocked by user", pid);
         return ProcessRunner::ForceUnlocked;
       }
 
-      case LockWidget::Cancelled:
+      case UILocker::Cancelled:
       {
         log::debug("waiting for {} cancelled by user", pid);
         return ProcessRunner::Cancelled;
       }
 
-      case LockWidget::NoResult:  // fall-through
+      case UILocker::NoResult:  // fall-through
       default:
       {
         // shouldn't happen
@@ -255,7 +255,7 @@ std::optional<ProcessRunner::Results> timedWait(
 }
 
 ProcessRunner::Results waitForProcessesThreadImpl(
-  const std::vector<HANDLE>& initialProcesses, LockWidget::Session& ls)
+  const std::vector<HANDLE>& initialProcesses, UILocker::Session& ls)
 {
   using namespace std::chrono;
 
@@ -315,14 +315,14 @@ ProcessRunner::Results waitForProcessesThreadImpl(
 
 void waitForProcessesThread(
   ProcessRunner::Results& result,
-  const std::vector<HANDLE>& initialProcesses, LockWidget::Session& ls)
+  const std::vector<HANDLE>& initialProcesses, UILocker::Session& ls)
 {
   result = waitForProcessesThreadImpl(initialProcesses, ls);
   ls.unlock();
 }
 
 ProcessRunner::Results waitForProcesses(
-  const std::vector<HANDLE>& initialProcesses, LockWidget::Session& ls)
+  const std::vector<HANDLE>& initialProcesses, UILocker::Session& ls)
 {
   auto results = ProcessRunner::Running;
 
@@ -343,7 +343,7 @@ ProcessRunner::Results waitForProcesses(
 }
 
 ProcessRunner::Results waitForProcess(
-  HANDLE initialProcess, LPDWORD exitCode, LockWidget::Session& ls)
+  HANDLE initialProcess, LPDWORD exitCode, UILocker::Session& ls)
 {
   std::vector<HANDLE> processes = {initialProcess};
 
@@ -364,7 +364,7 @@ ProcessRunner::Results waitForProcess(
 
 
 ProcessRunner::ProcessRunner(OrganizerCore& core, IUserInterface* ui) :
-  m_core(core), m_ui(ui), m_lockReason(LockWidget::NoReason),
+  m_core(core), m_ui(ui), m_lockReason(UILocker::NoReason),
   m_waitFlags(NoFlags), m_handle(INVALID_HANDLE_VALUE), m_exitCode(-1)
 {
   // all processes started in ProcessRunner are hooked
@@ -414,7 +414,7 @@ ProcessRunner& ProcessRunner::setProfileName(const QString& profileName)
 }
 
 ProcessRunner& ProcessRunner::setWaitForCompletion(
-  WaitFlags flags, LockWidget::Reasons reason)
+  WaitFlags flags, UILocker::Reasons reason)
 {
   m_waitFlags = flags;
   m_lockReason = reason;
@@ -670,13 +670,13 @@ ProcessRunner::Results ProcessRunner::postRun()
 {
   const bool mustWait = (m_waitFlags & ForceWait);
 
-  if (mustWait && m_lockReason == LockWidget::NoReason) {
+  if (mustWait && m_lockReason == UILocker::NoReason) {
     // never lock the ui without an escape hatch for the user
     log::debug(
       "the ForceWait flag is set but the lock reason wasn't, "
       "defaulting to LockUI");
 
-    m_lockReason = LockWidget::LockUI;
+    m_lockReason = UILocker::LockUI;
   }
 
   if (mustWait) {
@@ -689,7 +689,7 @@ ProcessRunner::Results ProcessRunner::postRun()
   } else {
     // no force wait
 
-    if (m_lockReason == LockWidget::NoReason) {
+    if (m_lockReason == UILocker::NoReason) {
       // no locking requested
       return Running;
     }
@@ -750,7 +750,7 @@ env::HandlePtr ProcessRunner::stealProcessHandle()
 }
 
 ProcessRunner::Results ProcessRunner::waitForAllUSVFSProcessesWithLock(
-  LockWidget::Reasons reason)
+  UILocker::Reasons reason)
 {
   m_lockReason = reason;
 
@@ -784,8 +784,8 @@ ProcessRunner::Results ProcessRunner::waitForAllUSVFSProcessesWithLock(
   return r;
 }
 
-void ProcessRunner::withLock(std::function<void (LockWidget::Session&)> f)
+void ProcessRunner::withLock(std::function<void (UILocker::Session&)> f)
 {
-  auto ls = LockWidget::instance().lock(m_lockReason);
+  auto ls = UILocker::instance().lock(m_lockReason);
   f(*ls);
 }
diff --git a/src/processrunner.h b/src/processrunner.h
index 276c46b1..af5cd416 100644
--- a/src/processrunner.h
+++ b/src/processrunner.h
@@ -65,7 +65,7 @@ public:
   ProcessRunner& setForcedLibraries(const ForcedLibraries& forcedLibraries);
   ProcessRunner& setProfileName(const QString& profileName);
   ProcessRunner& setWaitForCompletion(
-    WaitFlags flags=NoFlags, LockWidget::Reasons reason=LockWidget::LockUI);
+    WaitFlags flags=NoFlags, UILocker::Reasons reason=UILocker::LockUI);
 
   // if the target is an executable file, runs that; for anything else, calls
   // ShellExecute() on it
@@ -134,7 +134,7 @@ public:
   // running a process, but it uses the same internal stuff as when running a
   // process
   //
-  Results waitForAllUSVFSProcessesWithLock(LockWidget::Reasons reason);
+  Results waitForAllUSVFSProcessesWithLock(UILocker::Reasons reason);
 
 private:
   OrganizerCore& m_core;
@@ -143,7 +143,7 @@ private:
   QString m_customOverwrite;
   ForcedLibraries m_forcedLibraries;
   QString m_profileName;
-  LockWidget::Reasons m_lockReason;
+  UILocker::Reasons m_lockReason;
   WaitFlags m_waitFlags;
   QString m_shellOpen;
   env::HandlePtr m_handle;
@@ -164,7 +164,7 @@ private:
 
   // creates the lock widget and calls f()
   //
-  void withLock(std::function<void (LockWidget::Session&)> f);
+  void withLock(std::function<void (UILocker::Session&)> f);
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(ProcessRunner::WaitFlags);