CamelCase

git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@34911 a592a061-630c-0410-9148-cb99ea01b6c8

diff --git a/src/support/Systemcall.cpp b/src/support/Systemcall.cpp
index fad4f4dcc59463f9db7dc9399d7d8fedf21448bd..a42e7abef46be21081e2a2e28eec218e52a6c459 100644 (file)
--- a/src/support/Systemcall.cpp
+++ b/src/support/Systemcall.cpp
@@ -242,23 +242,25 @@ int Systemcall::startscript(Starttype how, string const & what, bool process_eve
 
 
 SystemcallPrivate::SystemcallPrivate(const std::string& of) :
-                                proc_(new QProcess), outindex_(0), errindex_(0),
-                                outfile(of), 
+                                process_(new QProcess), 
+                                outIndex_(0),
+                                errIndex_(0),
+                                outFile_(of), 
                                 terminalOutExists_(os::is_terminal(os::STDOUT)),
                                 terminalErrExists_(os::is_terminal(os::STDERR)),
-                                process_events(false)
+                                processEvents_(false)
 {
-       if (!outfile.empty()) {
+       if (!outFile_.empty()) {
                // Check whether we have to simply throw away the output.
-               if (outfile != os::nulldev())
-                       proc_->setStandardOutputFile(toqstr(outfile));
+               if (outFile_ != os::nulldev())
+                       process_->setStandardOutputFile(toqstr(outFile_));
        }
 
-       connect(proc_, SIGNAL(readyReadStandardOutput()), SLOT(stdOut()));
-       connect(proc_, SIGNAL(readyReadStandardError()), SLOT(stdErr()));
-       connect(proc_, SIGNAL(error(QProcess::ProcessError)), SLOT(processError(QProcess::ProcessError)));
-       connect(proc_, SIGNAL(started()), this, SLOT(processStarted()));
-       connect(proc_, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(processFinished(int, QProcess::ExitStatus)));
+       connect(process_, SIGNAL(readyReadStandardOutput()), SLOT(stdOut()));
+       connect(process_, SIGNAL(readyReadStandardError()), SLOT(stdErr()));
+       connect(process_, SIGNAL(error(QProcess::ProcessError)), SLOT(processError(QProcess::ProcessError)));
+       connect(process_, SIGNAL(started()), this, SLOT(processStarted()));
+       connect(process_, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(processFinished(int, QProcess::ExitStatus)));
 }
 
 
@@ -266,16 +268,16 @@ SystemcallPrivate::SystemcallPrivate(const std::string& of) :
 void SystemcallPrivate::startProcess(const QString& cmd)
 {
        cmd_ = cmd;
-       if (proc_) {
+       if (process_) {
                state = SystemcallPrivate::Starting;
-               proc_->start(cmd_);
+               process_->start(cmd_);
        }
 }
 
 
 void SystemcallPrivate::processEvents()
 {
-       if(process_events) {
+       if(processEvents_) {
                QCoreApplication::processEvents(/*QEventLoop::ExcludeUserInputEvents*/);
        }
 }
@@ -288,20 +290,20 @@ void SystemcallPrivate::waitAndProcessEvents()
 }
 
 
-bool SystemcallPrivate::waitWhile(State waitwhile, bool proc_events, int timeout)
+bool SystemcallPrivate::waitWhile(State waitwhile, bool process_events, int timeout)
 {
-       if (!proc_)
+       if (!process_)
                return false;
 
-       process_events = proc_events;
+       process_events = process_events;
 
        // Block GUI while waiting,
        // relay on QProcess' wait functions
        if (!process_events) {
                if (waitwhile == Starting)
-                       return proc_->waitForStarted(timeout);
+                       return process_->waitForStarted(timeout);
                if (waitwhile == Running)
-                       return proc_->waitForFinished(timeout);
+                       return process_->waitForFinished(timeout);
                return false;
        }
 
@@ -327,18 +329,18 @@ SystemcallPrivate::~SystemcallPrivate()
 {
        flush();
 
-       if (outindex_) {
-               outdata_[outindex_] = '\0';
-               outindex_ = 0;
+       if (outIndex_) {
+               outData_[outIndex_] = '\0';
+               outIndex_ = 0;
                if (terminalOutExists_)
-                       cout << outdata_;
+                       cout << outData_;
        }
        cout.flush();
-       if (errindex_) {
-               errdata_[errindex_] = '\0';
-               errindex_ = 0;
+       if (errIndex_) {
+               errData_[errIndex_] = '\0';
+               errIndex_ = 0;
                if (terminalErrExists_)
-                       cerr << errdata_;
+                       cerr << errData_;
        }
        cerr.flush();
 
@@ -348,17 +350,17 @@ SystemcallPrivate::~SystemcallPrivate()
 
 void SystemcallPrivate::flush()
 {
-       if (proc_) {
+       if (process_) {
                // 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.
                
-               QString data = QString::fromLocal8Bit(proc_->readAllStandardOutput().data());
+               QString data = QString::fromLocal8Bit(process_->readAllStandardOutput().data());
                ProgressInterface::instance()->appendMessage(data);
-               if (!terminalOutExists_ && outfile.empty())
+               if (!terminalOutExists_ && outFile_.empty())
                        cout << fromqstr(data);
                
-               data = QString::fromLocal8Bit(proc_->readAllStandardError().data());
+               data = QString::fromLocal8Bit(process_->readAllStandardError().data());
                ProgressInterface::instance()->appendError(data);
                if (!terminalErrExists_)
                        cerr << fromqstr(data);
@@ -368,17 +370,17 @@ void SystemcallPrivate::flush()
 
 void SystemcallPrivate::stdOut()
 {
-       if (proc_) {
+       if (process_) {
                char c;
-               proc_->setReadChannel(QProcess::StandardOutput);
-               while (proc_->getChar(&c)) {
-                       outdata_[outindex_++] = c;
-                       if (c == '\n' || outindex_ + 1 == bufsize_) {
-                               outdata_[outindex_] = '\0';
-                               outindex_ = 0;
-                               ProgressInterface::instance()->appendMessage(QString::fromLocal8Bit(outdata_));
+               process_->setReadChannel(QProcess::StandardOutput);
+               while (process_->getChar(&c)) {
+                       outData_[outIndex_++] = c;
+                       if (c == '\n' || outIndex_ + 1 == bufferSize_) {
+                               outData_[outIndex_] = '\0';
+                               outIndex_ = 0;
+                               ProgressInterface::instance()->appendMessage(QString::fromLocal8Bit(outData_));
                                if (terminalOutExists_)
-                                       cout << outdata_;
+                                       cout << outData_;
                        }
                }
        }
@@ -387,17 +389,17 @@ void SystemcallPrivate::stdOut()
 
 void SystemcallPrivate::stdErr()
 {
-       if (proc_) {
+       if (process_) {
                char c;
-               proc_->setReadChannel(QProcess::StandardError);
-               while (proc_->getChar(&c)) {
-                       errdata_[errindex_++] = c;
-                       if (c == '\n' || errindex_ + 1 == bufsize_) {
-                               errdata_[errindex_] = '\0';
-                               errindex_ = 0;
-                               ProgressInterface::instance()->appendError(QString::fromLocal8Bit(errdata_));
+               process_->setReadChannel(QProcess::StandardError);
+               while (process_->getChar(&c)) {
+                       errData_[errIndex_++] = c;
+                       if (c == '\n' || errIndex_ + 1 == bufferSize_) {
+                               errData_[errIndex_] = '\0';
+                               errIndex_ = 0;
+                               ProgressInterface::instance()->appendError(QString::fromLocal8Bit(errData_));
                                if (terminalErrExists_)
-                                       cerr << errdata_;
+                                       cerr << errData_;
                        }
                }
        }
@@ -431,11 +433,11 @@ void SystemcallPrivate::processError(QProcess::ProcessError)
 
 QString SystemcallPrivate::errorMessage() const 
 {
-       if (!proc_)
+       if (!process_)
                return "No QProcess available";
 
        QString message;
-       switch (proc_->error()) {
+       switch (process_->error()) {
                case QProcess::FailedToStart:
                        message = "The process failed to start. Either the invoked program is missing, "
                                      "or you may have insufficient permissions to invoke the program.";
@@ -465,11 +467,11 @@ QString SystemcallPrivate::errorMessage() const
 
 QString SystemcallPrivate::exitStatusMessage() const
 {
-       if (!proc_)
+       if (!process_)
                return "No QProcess available";
 
        QString message;
-       switch (proc_->exitStatus()) {
+       switch (process_->exitStatus()) {
                case QProcess::NormalExit:
                        message = "The process exited normally.";
                        break;
@@ -486,24 +488,24 @@ QString SystemcallPrivate::exitStatusMessage() const
 
 int SystemcallPrivate::exitCode()
 {
-       if (!proc_)
+       if (!process_)
                return -1;
 
-       return proc_->exitCode();
+       return process_->exitCode();
 }
 
 
 QProcess* SystemcallPrivate::releaseProcess()
 {
-       QProcess* released = proc_;
-       proc_ = 0;
+       QProcess* released = process_;
+       process_ = 0;
        return released;
 }
 
 
 void SystemcallPrivate::killProcess()
 {
-       killProcess(proc_);
+       killProcess(process_);
 }
 
 

diff --git a/src/support/SystemcallPrivate.h b/src/support/SystemcallPrivate.h
index 6cfb12f081ca0e5188481bfc97f9d976ea66dc8f..0b616dcd3c2dfd7dd91cc6f26d5783f200375a5e 100644 (file)
--- a/src/support/SystemcallPrivate.h
+++ b/src/support/SystemcallPrivate.h
@@ -30,6 +30,7 @@ class Systemcall;
 class SystemcallPrivate : public QObject
 {
        Q_OBJECT
+
 public:
        SystemcallPrivate(std::string const & outfile);
        ~SystemcallPrivate();
@@ -56,41 +57,41 @@ public:
        
        static void killProcess(QProcess * p);
 
+
+public Q_SLOTS:
+       void stdOut();
+       void stdErr();
+       void processError(QProcess::ProcessError);
+       void processStarted();
+       void processFinished(int, QProcess::ExitStatus status);
+
+
 private:
        /// Pointer to the process to monitor.
-       QProcess * proc_;
+       QProcess * process_;
+
        /// Index to the standard output buffer.
-       size_t outindex_;
+       size_t outIndex_;
        /// Index to the standard error buffer.
-       size_t errindex_;
+       size_t errIndex_;
        ///
-       std::string outfile;
+       std::string outFile_;
+
        /// Size of buffers.
-       static size_t const bufsize_ = 200;
+       static size_t const bufferSize_ = 200;
        /// Standard output buffer.
-       char outdata_[bufsize_];
+       char outData_[bufferSize_];
        /// Standard error buffer.
-       char errdata_[bufsize_];
-       /// 
+       char errData_[bufferSize_];
+
        bool terminalErrExists_;
-       /// 
        bool terminalOutExists_;
-       bool process_events;
-       QString cmd_;
 
+       bool processEvents_;
        void waitAndProcessEvents();
        void processEvents();
-
        void killProcess();
-
-public Q_SLOTS:
-       void stdOut();
-       void stdErr();
-       void processError(QProcess::ProcessError);
-       void processStarted();
-       void processFinished(int, QProcess::ExitStatus status);
-
-Q_SIGNALS:
+       QString cmd_;
 
 };