DocBook: simplify code to handle abstracts.

[lyx.git] / src / support / Systemcall.cpp

diff --git a/src/support/Systemcall.cpp b/src/support/Systemcall.cpp
index 2dbbba7c83010bdd6abcfdee2dc3accff12c33bc..6ec50e1238b305d4346aa1fc45e0eb76aea37d6a 100644 (file)
--- a/src/support/Systemcall.cpp
+++ b/src/support/Systemcall.cpp
@@ -24,13 +24,12 @@
 #include "support/ProgressInterface.h"
 
 #include "LyX.h"
-#include "LyXRC.h"
 
 #include <cstdlib>
 #include <iostream>
 
 #include <QProcess>
-#include <QTime>
+#include <QElapsedTimer>
 #include <QThread>
 #include <QCoreApplication>
 #include <QDebug>
@@ -79,7 +78,7 @@ public:
 };
 
 
-static ProgressInterface * progress_instance = 0;
+static ProgressInterface * progress_instance = nullptr;
 
 void ProgressInterface::setInstance(ProgressInterface* p)
 {
@@ -206,7 +205,7 @@ string const parsecmd(string const & incmd, string & infile, string & outfile,
                                in_double_quote = !in_double_quote;
                        }
                } else if (c == '\\' && !escaped) {
-                       escaped = !escaped;
+                       escaped = true;
                } else if (c == '>' && !(in_double_quote || escaped)) {
                        if (suffixIs(outcmd[o], " 2")) {
                                outcmd[o] = rtrim(outcmd[o], "2");
@@ -234,6 +233,12 @@ string const parsecmd(string const & incmd, string & infile, string & outfile,
 } // namespace
 
 
+void Systemcall::killscript()
+{
+       SystemcallPrivate::kill_script = true;
+}
+
+
 int Systemcall::startscript(Starttype how, string const & what,
                            string const & path, string const & lpath,
                            bool process_events)
@@ -251,42 +256,34 @@ int Systemcall::startscript(Starttype how, string const & what,
                        parsecmd(what_ss, infile, outfile, errfile).c_str());
 
        SystemcallPrivate d(infile, outfile, errfile);
+       bool do_events = process_events || how == WaitLoop;
 
-#ifdef Q_OS_WIN32
-       // QProcess::startDetached cannot provide environment variables. When the
-       // environment variables are set using the latexEnvCmdPrefix and the process
-       // is started with QProcess::startDetached, a console window is shown every
-       // time a viewer is started. To avoid this, we fall back on Windows to the
-       // original implementation that creates a QProcess object.
-       d.startProcess(cmd, path, lpath, false);
-       if (!d.waitWhile(SystemcallPrivate::Starting, process_events, -1)) {
-               LYXERR0("Systemcall: '" << cmd << "' did not start!");
-               LYXERR0("error " << d.errorMessage());
-               return 10;
-       }
-       if (how == DontWait) {
-               d.releaseProcess();
-               return 0;
-       }
-#else
        d.startProcess(cmd, path, lpath, how == DontWait);
        if (how == DontWait && d.state == SystemcallPrivate::Running)
-               return 0;
+               return OK;
 
        if (d.state == SystemcallPrivate::Error
-                       || !d.waitWhile(SystemcallPrivate::Starting, process_events, -1)) {
-               LYXERR0("Systemcall: '" << cmd << "' did not start!");
-               LYXERR0("error " << d.errorMessage());
-               return 10;
+                       || !d.waitWhile(SystemcallPrivate::Starting, do_events, -1)) {
+               if (d.state == SystemcallPrivate::Error) {
+                       LYXERR0("Systemcall: '" << cmd << "' did not start!");
+                       LYXERR0("error " << d.errorMessage());
+                       return NOSTART;
+               } else if (d.state == SystemcallPrivate::Killed) {
+                       LYXERR0("Killed: " << cmd);
+                       return KILLED;
+               }
        }
-#endif
 
-       if (!d.waitWhile(SystemcallPrivate::Running, process_events,
+       if (!d.waitWhile(SystemcallPrivate::Running, do_events,
                         os::timeout_min() * 60 * 1000)) {
+               if (d.state == SystemcallPrivate::Killed) {
+                       LYXERR0("Killed: " << cmd);
+                       return KILLED;
+               }
                LYXERR0("Systemcall: '" << cmd << "' did not finish!");
                LYXERR0("error " << d.errorMessage());
                LYXERR0("status " << d.exitStatusMessage());
-               return 20;
+               return TIMEOUT;
        }
 
        int const exit_code = d.exitCode();
@@ -298,6 +295,9 @@ int Systemcall::startscript(Starttype how, string const & what,
 }
 
 
+bool SystemcallPrivate::kill_script = false;
+
+
 SystemcallPrivate::SystemcallPrivate(std::string const & sf, std::string const & of,
                                      std::string const & ef)
        : state(Error), process_(new QProcess), out_index_(0), err_index_(0),
@@ -370,6 +370,15 @@ void SystemcallPrivate::startProcess(QString const & cmd, string const & path,
        cmd_ = cmd;
        if (detached) {
                state = SystemcallPrivate::Running;
+#ifdef Q_OS_WIN32
+               // Avoid opening a console window when a viewer is started
+               if (in_file_.empty())
+                       process_->setStandardInputFile(QProcess::nullDevice());
+               if (out_file_.empty())
+                       process_->setStandardOutputFile(QProcess::nullDevice());
+               if (err_file_.empty())
+                       process_->setStandardErrorFile(QProcess::nullDevice());
+#endif
                if (!QProcess::startDetached(toqstr(latexEnvCmdPrefix(path, lpath)) + cmd_)) {
                        state = SystemcallPrivate::Error;
                        return;
@@ -383,18 +392,19 @@ void SystemcallPrivate::startProcess(QString const & cmd, string const & path,
 }
 
 
-void SystemcallPrivate::processEvents()
-{
-       if (process_events_) {
-               QCoreApplication::processEvents(/*QEventLoop::ExcludeUserInputEvents*/);
-       }
-}
-
-
-void SystemcallPrivate::waitAndProcessEvents()
+bool SystemcallPrivate::waitAndCheck()
 {
        Sleep::millisec(100);
-       processEvents();
+       if (kill_script) {
+               // is there a better place to reset this?
+               process_->kill();
+               state = Killed;
+               kill_script = false;
+               LYXERR0("Export Canceled!!");
+               return false;
+       }
+       QCoreApplication::processEvents(/*QEventLoop::ExcludeUserInputEvents*/);
+       return true;
 }
 
 
@@ -430,7 +440,7 @@ bool SystemcallPrivate::waitWhile(State waitwhile, bool process_events, int time
                        while (!timedout) {
                                if (process_->waitForFinished(timeout))
                                        return true;
-                               bool stop = queryStopCommand(cmd_);
+                               bool const stop = queryStopCommand(cmd_);
                                // The command may have finished in the meantime
                                if (process_->state() == QProcess::NotRunning)
                                        return true;
@@ -449,18 +459,23 @@ bool SystemcallPrivate::waitWhile(State waitwhile, bool process_events, int time
        // process events while waiting, no timeout
        if (timeout == -1) {
                while (state == waitwhile && state != Error) {
-                       waitAndProcessEvents();
+                       // check for cancellation of background process
+                       if (!waitAndCheck())
+                               return false;
                }
                return state != Error;
        }
 
        // process events while waiting with timeout
-       QTime timer;
+       QElapsedTimer timer;
        timer.start();
        while (state == waitwhile && state != Error && !timedout) {
-               waitAndProcessEvents();
+               // check for cancellation of background process
+               if (!waitAndCheck())
+                       return false;
+
                if (timer.elapsed() > timeout) {
-                       bool stop = queryStopCommand(cmd_);
+                       bool const stop = queryStopCommand(cmd_);
                        // The command may have finished in the meantime
                        if (process_->state() == QProcess::NotRunning)
                                break;
@@ -624,7 +639,7 @@ int SystemcallPrivate::exitCode()
 QProcess* SystemcallPrivate::releaseProcess()
 {
        QProcess* released = process_;
-       process_ = 0;
+       process_ = nullptr;
        return released;
 }