TR1: check in cmake for GCC version, fallback in checktr1.h for other build systems...

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

diff --git a/src/support/Systemcall.cpp b/src/support/Systemcall.cpp
index 13a000157973ba8e59a66ee54894205902b616fe..98d8d125dea618b29523f795670bb042f8b410d3 100644 (file)
--- a/src/support/Systemcall.cpp
+++ b/src/support/Systemcall.cpp
@@ -19,6 +19,7 @@
 #include "support/Systemcall.h"
 #include "support/SystemcallPrivate.h"
 #include "support/os.h"
+#include "support/ProgressInterface.h"
 
 
 #include <cstdlib>
@@ -43,12 +44,54 @@ struct Sleep : QThread
 
 
 
+
 using namespace std;
 
 namespace lyx {
 namespace support {
 
 
+class ProgressDummy : public ProgressInterface 
+{
+public:
+       ProgressDummy() {}
+
+       void processStarted(QString const &) {}
+       void processFinished(QString const &) {}
+       void appendMessage(QString const &) {}
+       void appendError(QString const &) {}
+       void clearMessages() {}
+       void lyxerrFlush() {}
+
+       void lyxerrConnect() {}
+       void lyxerrDisconnect() {}
+
+       void warning(QString const &, QString const &) {}
+       void toggleWarning(QString const &, QString const &, QString const &) {}
+       void error(QString const &, QString const &) {}
+       void information(QString const &, QString const &) {}
+};
+
+
+static ProgressInterface* progress_instance = 0;
+
+void ProgressInterface::setInstance(ProgressInterface* p)
+{
+       progress_instance = p;
+}
+
+
+ProgressInterface* ProgressInterface::instance()
+{
+       if (!progress_instance) {
+               static ProgressDummy dummy;
+               return &dummy;
+       }
+       return progress_instance;
+}
+
+
+
 
 // Reuse of instance
 #ifndef USE_QPROCESS
@@ -207,9 +250,9 @@ SystemcallPrivate::SystemcallPrivate(const std::string& of) :
                if (outfile != os::nulldev())
                        proc_->setStandardOutputFile(toqstr(outfile));
        } else if (os::is_terminal(os::STDOUT))
-               showout();
+               setShowOut(true);
        if (os::is_terminal(os::STDERR))
-               showerr();
+               setShowErr(true);
 
        connect(proc_, SIGNAL(readyReadStandardOutput()), SLOT(stdOut()));
        connect(proc_, SIGNAL(readyReadStandardError()), SLOT(stdErr()));
@@ -222,9 +265,10 @@ SystemcallPrivate::SystemcallPrivate(const std::string& of) :
 
 void SystemcallPrivate::startProcess(const QString& cmd)
 {
+       cmd_ = cmd;
        if (proc_) {
                state = SystemcallPrivate::Starting;
-               proc_->start(cmd);
+               proc_->start(cmd_);
        }
 }
 
@@ -232,8 +276,7 @@ void SystemcallPrivate::startProcess(const QString& cmd)
 void SystemcallPrivate::processEvents()
 {
        if(process_events) {
-               //static int count = 0; qDebug() << count++ << ": waitAndProcessEvents";
-               QCoreApplication::processEvents(QEventLoop::AllEvents);
+               QCoreApplication::processEvents(/*QEventLoop::ExcludeUserInputEvents*/);
        }
 }
 
@@ -287,13 +330,15 @@ SystemcallPrivate::~SystemcallPrivate()
        if (outindex_) {
                outdata_[outindex_] = '\0';
                outindex_ = 0;
-               cout << outdata_;
+               if (showout_)
+                       cout << outdata_;
        }
        cout.flush();
        if (errindex_) {
                errdata_[errindex_] = '\0';
                errindex_ = 0;
-               cerr << errdata_;
+               if (showerr_)
+                       cerr << errdata_;
        }
        cerr.flush();
 
@@ -307,19 +352,26 @@ void SystemcallPrivate::flush()
                // If the output has been redirected, we write it all at once.
                // Even if we are not running in a terminal, the output could go
                // to some log file, for example ~/.xsession-errors on *nix.
-               if (!os::is_terminal(os::STDOUT) && outfile.empty())
-                       cout << fromqstr(QString::fromLocal8Bit(
-                                               proc_->readAllStandardOutput().data()));
-               if (!os::is_terminal(os::STDERR))
-                       cerr << fromqstr(QString::fromLocal8Bit(
-                                               proc_->readAllStandardError().data()));
+               
+               QString data = QString::fromLocal8Bit(proc_->readAllStandardOutput().data());
+               if (showout_) 
+                       ProgressInterface::instance()->appendMessage(data);
+               if (!os::is_terminal(os::STDOUT) && outfile.empty()) 
+                       cout << fromqstr(data);
+               
+               data = QString::fromLocal8Bit(proc_->readAllStandardError().data());
+               if (showerr_) 
+                       ProgressInterface::instance()->appendError(data);
+               if (!os::is_terminal(os::STDERR)) 
+                       cerr << fromqstr(data);                 
+               
        }
 }
 
 
 void SystemcallPrivate::stdOut()
 {
-       if (proc_ && showout_) {
+       if (proc_) {
                char c;
                proc_->setReadChannel(QProcess::StandardOutput);
                while (proc_->getChar(&c)) {
@@ -327,17 +379,19 @@ void SystemcallPrivate::stdOut()
                        if (c == '\n' || outindex_ + 1 == bufsize_) {
                                outdata_[outindex_] = '\0';
                                outindex_ = 0;
-                               cout << outdata_;
+                               if (showout_) {
+                                       cout << outdata_;
+                                       ProgressInterface::instance()->appendMessage(QString::fromLocal8Bit(outdata_));         
+                               }
                        }
                }
        }
-       processEvents();
 }
 
 
 void SystemcallPrivate::stdErr()
 {
-       if (proc_ && showerr_) {
+       if (proc_) {
                char c;
                proc_->setReadChannel(QProcess::StandardError);
                while (proc_->getChar(&c)) {
@@ -345,31 +399,38 @@ void SystemcallPrivate::stdErr()
                        if (c == '\n' || errindex_ + 1 == bufsize_) {
                                errdata_[errindex_] = '\0';
                                errindex_ = 0;
-                               cerr << errdata_;
+                               if (showerr_) {
+                                       cerr << errdata_;
+                                       ProgressInterface::instance()->appendError(QString::fromLocal8Bit(errdata_));
+                               }
                        }
                }
        }
-       processEvents();
 }
 
 
 void SystemcallPrivate::processStarted()
 {
-       state = Running;
-       // why do we get two started signals?
-       //disconnect(proc_, SIGNAL(started()), this, SLOT(processStarted()));
+       if (state != Running) {
+               state = Running;
+               ProgressInterface::instance()->processStarted(cmd_);
+       }
 }
 
 
 void SystemcallPrivate::processFinished(int, QProcess::ExitStatus)
 {
-       state = Finished;
+       if (state != Finished) {
+               state = Finished;
+               ProgressInterface::instance()->processFinished(cmd_);
+       }
 }
 
 
 void SystemcallPrivate::processError(QProcess::ProcessError)
 {
        state = Error;
+       ProgressInterface::instance()->appendError(errorMessage());
 }