- removed a the obsolete KShellProcess class

- added a few methods to OProcess to make it easier to port programs using
  QProcess

2 files changed, 56 insertions, 110 deletions

diff --git a/libopie/oprocess.cpp b/libopie/oprocess.cpp
index f3e52bd..5db2b6c 100644
--- a/libopie/oprocess.cpp
+++ b/libopie/oprocess.cpp
@@ -81,48 +81,68 @@
 
 /////////////////////////////
 // public member functions //
 /////////////////////////////
 
 class OProcessPrivate {
 public:
    OProcessPrivate() : useShell(false) { }
 
    bool useShell;
    QMap<QString,QString> env;
    QString wd;
    QCString shell;
 };
 
 
-OProcess::OProcess()
-  : QObject(),
-    run_mode(NotifyOnExit),
-    runs(false),
-    pid_(0),
-    status(0),
-    keepPrivs(false),
-    innot(0),
-    outnot(0),
-    errnot(0),
-    communication(NoCommunication),
-    input_data(0),
-    input_sent(0),
-    input_total(0),
-    d(0)
+OProcess::OProcess(QObject *parent, const char *name)
+  : QObject(parent, name)
 {
+  init ( );
+}
+
+OProcess::OProcess(const QString &arg0, QObject *parent, const char *name)
+  : QObject(parent, name)
+{
+  init ( );
+  *this << arg0;
+}
+
+OProcess::OProcess(const QStringList &args, QObject *parent, const char *name)
+  : QObject(parent, name)
+{
+  init ( );
+  *this << args;
+}
+
+void OProcess::init ( )
+{
+  run_mode = NotifyOnExit;
+  runs = false;
+  pid_ = 0;
+  status = 0;
+  keepPrivs = false;
+  innot = 0;
+  outnot = 0;
+  errnot = 0;
+  communication = NoCommunication;
+  input_data = 0;
+  input_sent = 0;
+  input_total = 0;
+  d = 0;
+
   if (0 == OProcessController::theOProcessController) {
         (void) new OProcessController();
         CHECK_PTR(OProcessController::theOProcessController);
   }
 
   OProcessController::theOProcessController->addOProcess(this);
   out[0] = out[1] = -1;
   in[0] = in[1] = -1;
   err[0] = err[1] = -1;
 }
 
 void
 OProcess::setEnvironment(const QString &name, const QString &value)
 {
    if (!d)
       d = new OProcessPrivate;
@@ -459,32 +479,46 @@ bool OProcess::writeStdin(const char *buffer, int buflen)
   // kprocess...
   if (0 != input_data)
     return false;
 
   if (runs && (communication & Stdin)) {
     input_data = buffer;
     input_sent = 0;
     input_total = buflen;
     slotSendData(0);
     innot->setEnabled(true);
     rv = true;
   } else
     rv = false;
   return rv;
 }
 
+void OProcess::flushStdin ( )
+{
+        if ( !input_data || ( input_sent == input_total ))
+                return;
+
+        int d1, d2;
+        
+        do {
+                d1 = input_total - input_sent;
+                slotSendData ( 0 );
+                d2 = input_total - input_sent;
+        } while ( d2 <= d1 );
+}
+
 void OProcess::suspend()
 {
   if ((communication & Stdout) && outnot)
      outnot->setEnabled(false);
 }
 
 void OProcess::resume()
 {
   if ((communication & Stdout) && outnot)
      outnot->setEnabled(true);
 }
 
 bool OProcess::closeStdin()
 {
   bool rv;
 
@@ -875,48 +909,18 @@ bool OProcess::isExecutable(const QCString &filename)
 #ifdef S_ISSOCK
        // CC: SYSVR4 systems don't have that macro
        (S_ISSOCK(fileinfo.st_mode)) ||
 #endif
        (S_ISFIFO(fileinfo.st_mode)) ||
        (S_ISDIR(fileinfo.st_mode)) ) {
     return false;
   }
 
   // CC: now check for permission to execute the file
   if (access(filename.data(), X_OK) != 0) return false;
 
   // CC: we've passed all the tests...
   return true;
 }
 
-void OProcess::virtual_hook( int, void* )
-{ /*BASE::virtual_hook( id, data );*/ }
-
-
-///////////////////////////
-// CC: Class KShellProcess
-///////////////////////////
-
-KShellProcess::KShellProcess(const char *shellname):
-  OProcess()
-{
-  setUseShell(true, shellname);
-}
-
-
-KShellProcess::~KShellProcess() {
-}
-
-QString KShellProcess::quote(const QString &arg)
-{
-    return OProcess::quote(arg);
-}
-
-bool KShellProcess::start(RunMode runmode, Communication comm)
-{
-  return OProcess::start(runmode, comm);
-}
 
-void KShellProcess::virtual_hook( int id, void* data )
-{ OProcess::virtual_hook( id, data ); }
 
-//#include "kprocess.moc"
diff --git a/libopie/oprocess.h b/libopie/oprocess.h
index fd726b4..bf5fe0e 100644
--- a/libopie/oprocess.h
+++ b/libopie/oprocess.h
@@ -174,33 +174,35 @@ public:
        * The application does not receive notifications from the subprocess when
        * it is finished or aborted.
        */
        DontCare,
        /**
         * The application is notified when the subprocess dies.
         */
        NotifyOnExit,
        /**
         * The application is suspended until the started process is finished.
         */
        Block };
 
   /**
    * Constructor
    */
-  OProcess();
+  OProcess(QObject *parent = 0, const char *name = 0);
+  OProcess(const QString &arg0, QObject *parent = 0, const char *name = 0);
+  OProcess(const QStringList &args, QObject *parent = 0, const char *name = 0);
 
   /**
    *Destructor:
    *
    *  If the process is running when the destructor for this class
    *  is called, the child process is killed with a SIGKILL, but
    *  only if the run mode is not of type @p DontCare.
    *  Processes started as @p DontCare keep running anyway.
   */
   virtual ~OProcess();
 
   /**
    @deprecated
 
          The use of this function is now deprecated. -- Please use the
          "operator<<" instead of "setExecutable".
@@ -347,32 +349,34 @@ public:
    * @ref writeStdin() is still in progress.
    *
    * Please note that the data is sent to the client asynchronously,
    * so when this function returns, the data might not have been
    * processed by the child process.
    *
    * If all the data has been sent to the client, the signal
    * @ref wroteStdin() will be emitted.
    *
    * Please note that you must not free "buffer" or call @ref writeStdin()
    * again until either a @ref wroteStdin() signal indicates that the
    * data has been sent or a @ref processHasExited() signal shows that
    * the child process is no longer alive...
    **/
   bool writeStdin(const char *buffer, int buflen);
 
+  void flushStdin();
+
   /**
    * This causes the stdin file descriptor of the child process to be
    * closed indicating an "EOF" to the child.
    *
    * @return @p false if no communication to the process's stdin
    *  had been specified in the call to @ref start().
   */
   bool closeStdin();
 
   /**
    * This causes the stdout file descriptor of the child process to be
    * closed.
    *
    * @return @p false if no communication to the process's stdout
    *  had been specified in the call to @ref start().
   */
@@ -718,88 +722,26 @@ private:
    *    not listed in /etc/shells will not used.
    *
    *    @li If no valid shell could be found, "/bin/sh" is used as a last resort.
    */
   QCString searchShell();
 
   /**
    * Used by @ref searchShell in order to find out whether the shell found
    * is actually executable at all.
    */
   bool isExecutable(const QCString &filename);
 
   // Disallow assignment and copy-construction
   OProcess( const OProcess& );
   OProcess& operator= ( const OProcess& );
 
-protected:
-  virtual void virtual_hook( int id, void* data );
-private:
-  OProcessPrivate *d;
-};
-
-class KShellProcessPrivate;
-
-/**
-* @obsolete
-*
-* This class is obsolete. Use OProcess and OProcess::setUseShell(true)
-* instead.
-*
-*   @short A class derived from @ref OProcess to start child
-        *   processes through a shell.
-*   @author Christian Czezakte <e9025461@student.tuwien.ac.at>
-*   @version $Id$
-*/
-class KShellProcess: public OProcess
-{
-  Q_OBJECT
-
-public:
-
-  /**
-   * Constructor
-   *
-   * By specifying the name of a shell (like "/bin/bash") you can override
-   * the mechanism for finding a valid shell as described in OProcess::searchShell()
-   */
-  KShellProcess(const char *shellname=0);
-
-  /**
-   * Destructor.
-   */
-  ~KShellProcess();
-
-  /**
-   * Starts up the process. -- For a detailed description
-   * have a look at the "start" member function and the detailed
-   * description of @ref OProcess .
-   */
-  virtual bool start(RunMode  runmode = NotifyOnExit,
-                  Communication comm = NoCommunication);
-
-  /**
-   * This function can be used to quote an argument string such that
-   * the shell processes it properly. This is e. g. necessary for
-   * user-provided file names which may contain spaces or quotes.
-   * It also prevents expansion of wild cards and environment variables.
-   */
-  static QString quote(const QString &arg);
-
 private:
+  void init ( );
 
-  QCString shell;
-
-  // Disallow assignment and copy-construction
-  KShellProcess( const KShellProcess& );
-  KShellProcess& operator= ( const KShellProcess& );
-
-protected:
-  virtual void virtual_hook( int id, void* data );
-private:
-  KShellProcessPrivate *d;
+  OProcessPrivate *d;
 };
 
 
 
 #endif