// -*- 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.
*
#ifndef FORKEDCALL_H
#define FORKEDCALL_H
-#ifdef __GNUG__
-#pragma interface
-#endif
-
-#include "LString.h"
-
#include <boost/shared_ptr.hpp>
-
-#include <sigc++/signal_system.h>
+#include <boost/signal.hpp>
#include <sys/types.h>
-class Forkedcall {
+namespace lyx {
+namespace support {
+
+class ForkedProcess {
public:
///
enum Starttype {
};
///
- 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 boost::shared_ptr<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.
*
* 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::signal<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
*/
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!
*/
*/
void setRetValue(int r) { retval_ = r; }
+ /// Returns the identifying command (for display in the GUI perhaps).
+ std::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"
* When the child is dead, the callback is called.
*/
void kill(int tolerance = 5);
- ///
- string const & command() const { return command_; }
-private:
+protected:
+ /** Spawn the child process.
+ * Returns returncode from child.
+ */
+ int run(Starttype type);
+
/// Callback function
SignalTypePtr signal_;
- /// Commmand line
- string command_;
+ /// identifying command (for display in the GUI perhaps).
+ std::string command_;
/// Process ID of child
pid_t pid_;
/// 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 boost::shared_ptr<ForkedProcess> clone() const {
+ return boost::shared_ptr<ForkedProcess>(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, std::string const & what);
+
+ ///
+ int startscript(std::string const & what, SignalTypePtr);
+
+private:
+ ///
+ virtual int generateChild();
+};
+
+} // namespace support
+} // namespace lyx
+
#endif // FORKEDCALL_H