removed redundant checkBinary(), which used to check for non existing binaries, that's handled when spawning

removed useless checkEnvironment(), which checked for EventLog
removed CREATE_BREAKAWAY_FROM_JOB from CreateProcess() calls, didn't do anything
fixed setFromFileOrExecutable() when running just a filename that's not an executable name
split run()
fixed lock widget being disabled when running without a ui

1 files changed, 75 insertions, 1 deletions

diff --git a/src/processrunner.h b/src/processrunner.h
index 0fb3f59a..fd451e38 100644
--- a/src/processrunner.h
+++ b/src/processrunner.h
@@ -19,22 +19,34 @@ class ProcessRunner
 public:
   enum Results
   {
+    // the process is still running
     Running = 1,
+
+    // the process has run to completion
     Completed,
+
+    // the process couldn't be started or waited for
     Error,
+
+    // the user has clicked the cancel button in the lock widget
     Cancelled,
+
+    // the user has clicked the unlock button in the lock widget
     ForceUnlocked
   };
 
   enum WaitFlag
   {
     NoFlags   = 0x00,
+
+    // the ui will be refreshed once the process has completed
     Refresh   = 0x01,
+
+    // the process will be waited for even if locking is disabled
     ForceWait = 0x02
   };
 
   using WaitFlags = QFlags<WaitFlag>;
-
   using ForcedLibraries = QList<MOBase::ExecutableForcedLoadSetting>;
 
   ProcessRunner(OrganizerCore& core, IUserInterface* ui);
@@ -55,10 +67,29 @@ public:
   ProcessRunner& setWaitForCompletion(
     WaitFlags flags=NoFlags, LockWidget::Reasons reason=LockWidget::LockUI);
 
+  // if the target is an executable file, runs that; for anything else, calls
+  // ShellExecute() on it
+  //
   ProcessRunner& setFromFile(QWidget* parent, const QFileInfo& targetInfo);
+
   ProcessRunner& setFromExecutable(const Executable& exe);
   ProcessRunner& setFromShortcut(const MOShortcut& shortcut);
 
+  // this is a messy one that's used for running an arbitrary file from the
+  // command line, or by plugins (see OrganizerProxy::startApplication())
+  //
+  // 1) if `executable` contains a path separator, it's treated as a binary on
+  //    disk and will be launched with given settings; it's also looked up in
+  //    the list of configured executables, which sets the steam ID and forced
+  //    libraries
+  //
+  // 2) if `executable` has no path separators, it's treated purely as an
+  //    executable, but its arguments, current directory and custom overwrite
+  //    can also be overridden
+  //
+  //    if the executable is not found in the list, the binary is run solely
+  //    based on the parameters given
+  //
   ProcessRunner& setFromFileOrExecutable(
     const QString &executable,
     const QStringList &args,
@@ -67,13 +98,42 @@ public:
     const QString &forcedCustomOverwrite={},
     bool ignoreCustomOverwrite=false);
 
+  // spawns the process and waits for it if required
+  //
   Results run();
+
+  // takes ownership of the given handle and waits for it if required
+  //
   Results attachToProcess(HANDLE h);
 
+  // exit code of the process, will return -1 if the process wasn't waited for
+  //
   DWORD exitCode() const;
+
+  // this may be INVALID_HANDLE_VALUE if:
+  //
+  //  1) no process was started, or
+  //  2) the process was started successfully, but the system didn't return a
+  //     handle for it; this can happen for inproc handlers, for example, such
+  //     the photo viewer
+  //
+  // note that the handle is still owned by this ProcessRunner and will be
+  // closed when destroyed; see stealProcessHandle()
+  //
   HANDLE getProcessHandle() const;
+
+  // releases ownership of the process handle; if this is called after the
+  // process is completed, exitCode() will still return the correct value
+  //
   env::HandlePtr stealProcessHandle();
 
+  // waits for all usvfs processes spawned by this instance of MO; returns
+  // immediately with ForceUnlocked if locking is disabled
+  //
+  // strictly speaking, this shouldn't be here, as it has nothing to do with
+  // running a process, but it uses the same internal stuff as when running a
+  // process
+  //
   Results waitForAllUSVFSProcessesWithLock(LockWidget::Reasons reason);
 
 private:
@@ -89,7 +149,21 @@ private:
   env::HandlePtr m_handle;
   DWORD m_exitCode;
 
+
+  // runs the command in m_shellOpen; returns empty if it can be waited for
+  //
+  std::optional<Results> runShell();
+
+  // runs the binary; returns empty if it can be waited for
+  //
+  std::optional<Results> runBinary();
+
+  // waits for process completion if required
+  //
   Results postRun();
+
+  // creates the lock widget and calls f()
+  //
   void withLock(std::function<void (LockWidget&)> f);
 };