1 files changed, 76 insertions, 76 deletions

diff --git a/libopie2/opiecore/oprocess.h b/libopie2/opiecore/oprocess.h
index 8dd19b5..352485b 100644
--- a/libopie2/opiecore/oprocess.h
+++ b/libopie2/opiecore/oprocess.h
@@ -1,45 +1,49 @@
-/* This file is part of the KDE libraries
-    Copyright (C) 1997 Christian Czezakte (e9025461@student.tuwien.ac.at)
- 
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
- 
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
- 
-    You should have received a copy of the GNU Library General Public License
-    along with this library; see the file COPYING.LIB.  If not, write to
-    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-    Boston, MA 02111-1307, USA.
+/*
+                            This file is part of the Opie Project
+                            Copyright (C) 2003-2004 Holger Freyther <zecke@handhelds.org>
+                            Copyright (C) The Opie Team <opie-devel@handhelds.org>
+             =.             Based on KProcess (C) 1997 Christian Czezatke (e9025461@student.tuwien.ac.at)
+           .=l.
+          .>+-=
+_;:,     .>    :=|.         This program is free software; you can
+.> <`_,   >  .   <=         redistribute it and/or  modify it under
+:`=1 )Y*s>-.--   :          the terms of the GNU Library General Public
+.="- .-=="i,     .._        License as published by the Free Software
+- .   .-<_>     .<>         Foundation; either version 2 of the License,
+    ._= =}       :          or (at your option) any later version.
+   .%`+i>       _;_.
+   .i_,=:_.      -<s.       This program is distributed in the hope that
+    +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
+   : ..    .:,     . . .    without even the implied warranty of
+   =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
+ _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
+..}^=.=       =       ;     Library General Public License for more
+++=   -.     .`     .:      details.
+:     =  ...= . :.=-
+-.   .:....=;==+<;          You should have received a copy of the GNU
+ -_. . .   )=.  =           Library General Public License along with
+   --        :-=`           this library; see the file COPYING.LIB.
+                            If not, write to the Free Software Foundation,
+                            Inc., 59 Temple Place - Suite 330,
+                            Boston, MA 02111-1307, USA.
 */
-//
-//  KPROCESS -- A class for handling child processes in KDE without
-//  having to take care of Un*x specific implementation details
-//
-//  version 0.3.1, Jan 8th 1998
-//
-//  (C) Christian Czezatke
-//  e9025461@student.tuwien.ac.at
-//  Ported by Holger Freyther to the Open Palmtop Integrated Environment
-//
-
-#ifndef __kprocess_h__
-#define __kprocess_h__
 
+#ifndef OPROCESS_H
+#define OPROCESS_H
+
+/* QT */
+#include <qcstring.h>
+#include <qobject.h>
+#include <qvaluelist.h>
+
+/* STD */
 #include <sys/types.h> // for pid_t
 #include <sys/wait.h>
 #include <signal.h>
 #include <unistd.h>
-#include <qvaluelist.h>
-#include <qcstring.h>
-#include <qobject.h>
 
 class QSocketNotifier;
 class OProcessPrivate;
 
 /**
  * Child process invocation, monitoring and control.
@@ -138,13 +142,13 @@ class OProcessPrivate;
  *@li  void @ref wroteStdin(OProcess  *proc);
  *@li  -- Indicates that all data that has been sent to the child process
  *by a prior call to @ref writeStdin() has actually been transmitted to the
  *client .
  *
  *@author Christian Czezakte e9025461@student.tuwien.ac.at
- *
+ *@author Holger Freyther (Opie Port)
  *
  **/
 class OProcess : public QObject
 {
     Q_OBJECT
 
@@ -184,21 +188,21 @@ public:
          */
         Block };
 
     /**
      * Constructor
      */
-    OProcess(QObject *parent = 0, const char *name = 0);
+    OProcess( QObject *parent = 0, const char *name = 0 );
     /**
      * Constructor
      */
-    OProcess(const QString &arg0, QObject *parent = 0, const char *name = 0);
+    OProcess( const QString &arg0, QObject *parent = 0, const char *name = 0 );
     /**
      * Constructor
      */
-    OProcess(const QStringList &args, 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
@@ -217,13 +221,13 @@ public:
     Returns false if the process is currently running (in that
     case the executable remains unchanged.)
 
     @see operator<<
 
     */
-    bool setExecutable(const QString& proc);
+    bool setExecutable( const QString& proc );
 
 
     /**
      * Sets the executable and the command line argument list for this process.
      *
      * For example, doing an "ls -l /usr/local/bin" can be achieved by:
@@ -231,27 +235,27 @@ public:
      *  OProcess p;
      *  ...
      *  p << "ls" << "-l" << "/usr/local/bin"
      *  </pre>
      *
      **/
-    OProcess &operator<<(const QString& arg);
+    OProcess &operator<<( const QString& arg );
     /**
      * Similar to previous method, takes a char *, supposed to be in locale 8 bit already.
      */
-    OProcess &operator<<(const char * arg);
+    OProcess &operator<<( const char * arg );
     /**
      * Similar to previous method, takes a QCString, supposed to be in locale 8 bit already.
      */
-    OProcess &operator<<(const QCString & arg);
+    OProcess &operator<<( const QCString & arg );
 
     /**
      * Sets the executable and the command line argument list for this process,
      * in a single method call, or add a list of arguments.
      **/
-    OProcess &operator<<(const QStringList& args);
+    OProcess &operator<<( const QStringList& args );
 
     /**
      * Clear a command line argument list that has been set by using
      * the "operator<<".
     */
     void clearArguments();
@@ -275,22 +279,22 @@ public:
      *  no communication takes place and the respective communication
      *  signals will never get emitted.
      *
      *  @return true on success, false on error
      *  (see above for error conditions)
      **/
-    virtual bool start(RunMode  runmode = NotifyOnExit,
-                       Communication comm = NoCommunication);
+    virtual bool start( RunMode runmode = NotifyOnExit,
+                        Communication comm = NoCommunication );
 
     /**
      * Stop the process (by sending it a signal).
      *
              * @param signoThe signal to send. The default is SIGTERM.
      * @return @p true if the signal was delivered successfully.
     */
-    virtual bool kill(int signo = SIGTERM);
+    virtual bool kill( int signo = SIGTERM );
 
     /**
        @return @p true if the process is (still) considered to be running
     */
     bool isRunning() const;
 
@@ -330,13 +334,13 @@ public:
      * Please use
      * @ref OProcess::normalExit() to check whether the process has exited
      * cleanly (i.e., @ref OProcess::normalExit() returns @p true) before calling
      * this function because if the process did not exit normally,
      * it does not have a valid exit status.
     */
-    int  exitStatus() const;
+    int exitStatus() const;
 
 
     /**
              * Transmit data to the child process's stdin.
      *
      * OProcess::writeStdin may return false in the following cases:
@@ -357,13 +361,13 @@ public:
      *
      * 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);
+    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.
@@ -392,81 +396,82 @@ public:
     bool closeStderr();
 
     /**
      * Lets you see what your arguments are for debugging.
      */
 
-    const QValueList<QCString> &args() { return arguments; }
+    const QValueList<QCString> &args()
+    {
+        return arguments;
+    }
 
     /**
      * Controls whether the started process should drop any
      * setuid/segid privileges or whether it should keep them
      *
      * The default is @p false : drop privileges
      */
-    void setRunPrivileged(bool keepPrivileges);
+    void setRunPrivileged( bool keepPrivileges );
 
     /**
      * Returns whether the started process will drop any
      * setuid/segid privileges or whether it will keep them
      */
     bool runPrivileged() const;
 
     /**
      * Modifies the environment of the process to be started.
      * This function must be called before starting the process.
      */
-    void setEnvironment(const QString &name, const QString &value);
+    void setEnvironment( const QString &name, const QString &value );
 
     /**
      * Changes the current working directory (CWD) of the process
      * to be started.
      * This function must be called before starting the process.
      */
-    void setWorkingDirectory(const QString &dir);
+    void setWorkingDirectory( const QString &dir );
 
     /**
      * Specify whether to start the command via a shell or directly.
      * The default is to start the command directly.
      * If @p useShell is true @p shell will be used as shell, or
      * if shell is empty, the standard shell is used.
      * @p quote A flag indicating whether to quote the arguments.
      *
      * When using a shell, the caller should make sure that all filenames etc.
      * are properly quoted when passed as argument.
      * @see quote()
      */
-    void setUseShell(bool useShell, const char *shell = 0);
+    void setUseShell( bool useShell, const char *shell = 0 );
 
     /**
      * 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);
+    static QString quote( const QString &arg );
 
     /**
      * Detaches OProcess from child process. All communication is closed.
      * No exit notification is emitted any more for the child process.
      * Deleting the OProcess will no longer kill the child process.
      * Note that the current process remains the parent process of the
      * child process.
      */
     void detach();
 
-
-
 signals:
 
     /**
      * Emitted after the process has terminated when
      * the process was run in the @p NotifyOnExit  (==default option to
      * @ref start()) or the @ref Block mode.
      **/
-    void processExited(OProcess *proc);
+    void processExited( OProcess *proc );
 
 
     /**
      * Emitted, when output from the child process has
      * been received on stdout.
      *
@@ -477,13 +482,13 @@ signals:
      * @param buffer The data received.
      * @param buflen The number of bytes that are available.
      *
      * You should copy the information contained in @p buffer to your private
      * data structures before returning from this slot.
      **/
-    void receivedStdout(OProcess *proc, char *buffer, int buflen);
+    void receivedStdout( OProcess *proc, char *buffer, int buflen );
 
     /**
      * Emitted when output from the child process has
      * been received on stdout.
      *
      * To actually get these signals, the respective communications link
@@ -494,13 +499,13 @@ signals:
      * to begin processing data from the child process's stdout.  This is
      * to ensure that this signal is not emitted when no one is connected
      * to it, otherwise this signal will not be emitted.
      *
      * The data still has to be read from file descriptor @p fd.
      **/
-    void receivedStdout(int fd, int &len);
+    void receivedStdout( int fd, int &len );
 
 
     /**
      * Emitted, when output from the child process has
      * been received on stderr.
      * To actually get
@@ -510,45 +515,44 @@ signals:
      * @param buffer The data received.
      * @param buflen The number of bytes that are available.
      *
      * You should copy the information contained in @p buffer to your private
      * data structures before returning from this slot.
     */
-    void receivedStderr(OProcess *proc, char *buffer, int buflen);
+    void receivedStderr( OProcess *proc, char *buffer, int buflen );
 
     /**
      * Emitted after all the data that has been
      * specified by a prior call to @ref writeStdin() has actually been
      * written to the child process.
      **/
-    void wroteStdin(OProcess *proc);
-
+    void wroteStdin( OProcess *proc );
 
 protected slots:
 
     /**
      * This slot gets activated when data from the child's stdout arrives.
      * It usually calls "childOutput"
      */
-    void slotChildOutput(int fdno);
+    void slotChildOutput( int fdno );
 
     /**
      * This slot gets activated when data from the child's stderr arrives.
      * It usually calls "childError"
      */
-    void slotChildError(int fdno);
+    void slotChildError( int fdno );
     /*
     Slot functions for capturing stdout and stderr of the child
     */
 
     /**
      * Called when another bulk of data can be sent to the child's
      * stdin. If there is no more data to be sent to stdin currently
      * available, this function must disable the QSocketNotifier "innot".
      */
-    void slotSendData(int dummy);
+    void slotSendData( int dummy );
 
 protected:
 
     /**
      * Sets up the environment according to the data passed via
      * setEnvironment(...)
@@ -621,13 +625,13 @@ protected:
      * was successful.
      *
      * The default implementation is to create UNIX STREAM sockets for the communication,
      * but you could overload this function and establish a TCP/IP communication for
      * network communication, for example.
      */
-    virtual int setupCommunication(Communication comm);
+    virtual int setupCommunication( Communication comm );
 
     /**
      * Called right after a (successful) fork on the parent side. This function
      * will usually do some communications cleanup, like closing the reading end
      * of the "stdin" communication channel.
      *
@@ -651,27 +655,27 @@ protected:
     /**
      * Immediately called after a process has exited. This function normally
      * calls commClose to close all open communication channels to this
      * process and emits the "processExited" signal (if the process was
      * not running in the "DontCare" mode).
      */
-    virtual void processHasExited(int state);
+    virtual void processHasExited( int state );
 
     /**
      * Should clean up the communication links to the child after it has
      * exited. Should be called from "processHasExited".
      */
     virtual void commClose();
 
 
     /**
      * the socket descriptors for stdin/stdout/stderr.
      */
-    int out[2];
-    int in[2];
-    int err[2];
+    int out[ 2 ];
+    int in[ 2 ];
+    int err[ 2 ];
 
     /**
      * The socket notifiers for the above socket descriptors.
      */
     QSocketNotifier *innot;
     QSocketNotifier *outnot;
@@ -685,20 +689,20 @@ protected:
 
     /**
      * Called by "slotChildOutput" this function copies data arriving from the
      * child process's stdout to the respective buffer and emits the signal
      * "@ref receivedStderr".
      */
-    int childOutput(int fdno);
+    int childOutput( int fdno );
 
     /**
      * Called by "slotChildOutput" this function copies data arriving from the
      * child process's stdout to the respective buffer and emits the signal
      * "@ref receivedStderr"
      */
-    int childError(int fdno);
+    int childError( int fdno );
 
     // information about the data that has to be sent to the child:
 
     const char *input_data;  // the buffer holding the data
     int input_sent;    // # of bytes already transmitted
     int input_total;   // total length of input_data
@@ -706,13 +710,12 @@ protected:
     /**
      * @ref OProcessController is a friend of OProcess because it has to have
      * access to various data members.
      */
     friend class OProcessController;
 
-
 private:
     /**
      * Searches for a valid shell.
      * Here is the algorithm used for finding an executable shell:
      *
      *    @li Try the executable pointed to by the "SHELL" environment
@@ -726,22 +729,19 @@ private:
     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);
+    bool isExecutable( const QCString &filename );
 
     // Disallow assignment and copy-construction
     OProcess( const OProcess& );
     OProcess& operator= ( const OProcess& );
 
 private:
     void init ( );
-
     OProcessPrivate *d;
 };
 
-
-
 #endif