Replace LString.h with support/std_string.h,

[features.git] / src / support / forkedcall.h

diff --git a/src/support/forkedcall.h b/src/support/forkedcall.h
index 4c24ae390fb3297d7325d6e9e981952d3244576d..8e58485d18e4c8f66c0aed5af98aaee31cce7e52 100644 (file)
--- a/src/support/forkedcall.h
+++ b/src/support/forkedcall.h
@@ -1,13 +1,15 @@
 // -*- C++ -*-
 /**
- *  \file forkedcall.h
- *  Copyright 2002 the LyX Team
- *  Read the file COPYING
+ * \file forkedcall.h
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
  *
  * \author Asger Alstrup
  *
  * Interface cleaned up by
- * \author Angus Leeming <a.leeming@ic.ac.uk>
+ * \author Angus Leeming
+ *
+ * Full author contact details are available in file CREDITS.
  *
  * An instance of Class Forkedcall represents a single child process.
  *
@@ -24,17 +26,18 @@
 #ifndef FORKEDCALL_H
 #define FORKEDCALL_H
 
-#ifdef __GNUG__
-#pragma interface
-#endif
+#include "support/std_string.h"
+
+#include <boost/shared_ptr.hpp>
+#include <boost/signals/signal2.hpp>
+#include <boost/function/function0.hpp>
 
-#include "LString.h"
 #include <sys/types.h>
-#include <boost/smart_ptr.hpp>
-#include <sigc++/signal_system.h>
 
+namespace lyx {
+namespace support {
 
-class Forkedcall {
+class ForkedProcess {
 public:
        ///
        enum Starttype {
@@ -45,25 +48,14 @@ public:
        };
 
        ///
-       Forkedcall();
-
-       /** Start the child process.
-        *
-        *  The command "what" is passed to fork() for execution.
-        *
-        *  There are two startscript commands available. They differ in that
-        *  the second receives a signal that is executed on completion of
-        *  the command. This makes sense only for a command executed
-        *  in the background, ie DontWait.
-        *
-        *  The other startscript command can be executed either blocking
-        *  or non-blocking, but no signal will be emitted on finishing.
-        */
-       int startscript(Starttype, string const & what);
+       ForkedProcess();
+       ///
+       virtual ~ForkedProcess() {}
+       ///
+       virtual ForkedProcess * clone() const = 0;
 
        /** A SignalType signal is can be emitted once the forked process
         *  has finished. It passes:
-        *  the commandline string;
         *  the PID of the child and;
         *  the return value from the child.
         *
@@ -71,7 +63,7 @@ public:
         *  we can return easily to C++ methods, rather than just globally
         *  accessible functions.
         */
-       typedef SigC::Signal3<void, string const &, pid_t, int> SignalType;
+       typedef boost::signal2<void, pid_t, int> SignalType;
 
        /** The signal is connected in the calling routine to the desired
         *  slot. We pass a shared_ptr rather than a reference to the signal
@@ -83,9 +75,6 @@ public:
         */
        typedef boost::shared_ptr<SignalType> SignalTypePtr;
 
-       ///
-       int startscript(string const & what, SignalTypePtr);
-
        /** Invoking the following methods makes sense only if the command
         *  is running asynchronously!
         */
@@ -105,6 +94,12 @@ public:
         */
        void setRetValue(int r) { retval_ = r; }
 
+       /// Returns the identifying command (for display in the GUI perhaps).
+       string const & command() const { return command_; }
+
+       /// is the process running ?
+       bool running() const;
+
        /** Kill child prematurely.
         *  First, a SIGHUP is sent to the child.
         *  If that does not end the child process within "tolerance"
@@ -112,14 +107,21 @@ public:
         *  When the child is dead, the callback is called.
         */
        void kill(int tolerance = 5);
-       ///
-       string const & command() const { return command_; }
 
-private:
+protected:
+       /** Wait for child process to finish.
+        *  Returns returncode from child.
+        */
+       int runBlocking();
+       /** Do not wait for child process to finish.
+        *  Returns returncode from child.
+        */
+       int runNonBlocking();
+
        /// Callback function
        SignalTypePtr signal_;
 
-       /// Commmand line
+       /// identifying command (for display in the GUI perhaps).
        string command_;
 
        /// Process ID of child
@@ -127,12 +129,45 @@ private:
 
        /// Return value from child
        int retval_;
-
-       ///
-       pid_t generateChild();
+private:
+       /// generate child in background
+       virtual int generateChild() = 0;
 
        /// Wait for child process to finish. Updates returncode from child.
        int waitForChild();
 };
 
+
+class Forkedcall : public ForkedProcess {
+public:
+       ///
+       virtual ForkedProcess * clone() const {
+               return new Forkedcall(*this);
+       }
+
+       /** Start the child process.
+        *
+        *  The command "what" is passed to execvp() for execution.
+        *
+        *  There are two startscript commands available. They differ in that
+        *  the second receives a signal that is executed on completion of
+        *  the command. This makes sense only for a command executed
+        *  in the background, ie DontWait.
+        *
+        *  The other startscript command can be executed either blocking
+        *  or non-blocking, but no signal will be emitted on finishing.
+        */
+       int startscript(Starttype, string const & what);
+
+       ///
+       int startscript(string const & what, SignalTypePtr);
+
+private:
+       ///
+       virtual int generateChild();
+};
+
+} // namespace support
+} // namespace lyx
+
 #endif // FORKEDCALL_H