Overview | Package | Class | Tree | Deprecated | Index | Help
Qt Jambi Home |
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.trolltech.qt.core
Class QProcess

    java.lang.Object
      com.trolltech.qt.QSignalEmitter
          com.trolltech.qt.QtJambiObject
              com.trolltech.qt.core.QObject
                  com.trolltech.qt.core.QIODevice
                      com.trolltech.qt.core.QProcess

All Implemented Interfaces:
  QtJambiInterface

    public class QProcess

extends QIODevice

The `QProcess` class is used to start external programs and to communicate with them.

To start a process, pass the name and command line arguments of the program you want to run as arguments to `start`. For example:

            QObject *parent;
            ...
            QString program = "./path/to/Qt/examples/widgets/analogclock";
            QStringList arguments;
            arguments << "-style" << "motif";

            QProcess *myProcess = new QProcess(parent);
            myProcess->start(program, arguments);

`QProcess` then enters the Starting state, and when the program has started, `QProcess` enters the Running state and emits `started`.

`QProcess` allows you to treat a process as a sequential I/O device. You can write to and read from the process just as you would access a network connection using `QTcpSocket`. You can then write to the process's standard input by calling `write`, and read the standard output by calling `read`, `readLine`, and getChar(). Because it inherits `QIODevice`, `QProcess` can also be used as an input source for `QXmlReader`, or for generating data to be uploaded using `QFtp`.

When the process exits, `QProcess` reenters the `NotRunning` state (the initial state), and emits `finished`.

The `finished` signal provides the exit code and exit status of the process as arguments, and you can also call `exitCode` to obtain the exit code of the last process that finished, and `exitStatus` to obtain its exit status. If an error occurs at any point in time, `QProcess` will emit the `error` signal. You can also call `error` to find the type of error that occurred last, and `state` to find the current process state.

Processes have two predefined output channels: The standard output channel (`stdout`) supplies regular console output, and the standard error channel (`stderr`) usually supplies the errors that are printed by the process. These channels represent two separate streams of data. You can toggle between them by calling `setReadChannel`. `QProcess` emits `readyRead` when data is available on the current read channel. It also emits `readyReadStandardOutput` when new standard output data is available, and when new standard error data is available, `readyReadStandardError` is emitted. Instead of calling `read`, `readLine`, or getChar(), you can explicitly read all data from either of the two channels by calling `readAllStandardOutput` or `readAllStandardError`.

The terminology for the channels can be misleading. Be aware that the process's output channels correspond to `QProcess`'s read channels, whereas the process's input channels correspond to `QProcess`'s write channels. This is because what we read using `QProcess` is the process's output, and what we write becomes the process's input.

`QProcess` can merge the two output channels, so that standard output and standard error data from the running process both use the standard output channel. Call `setProcessChannelMode` with `MergedChannels` before starting the process to activative this feature. You also have the option of forwarding the output of the running process to the calling, main process, by passing `ForwardedChannels` as the argument.

Certain processes need special environment settings in order to operate. You can set environment variables for your process by calling `setEnvironment`. To set a working directory, call `setWorkingDirectory`. By default, processes are run in the current working directory of the calling process.

`QProcess` provides a set of functions which allow it to be used without an event loop, by suspending the calling thread until certain signals are emitted:

- `waitForStarted` blocks until the process has started.
- `waitForReadyRead` blocks until new data is available for reading on the current read channel.
- `waitForBytesWritten` blocks until one payload of data has been written to the process.
- `waitForFinished` blocks until the process has finished.

Calling these functions from the main thread (the thread that calls QApplication::exec()) may cause your user interface to freeze.

The following example runs `gzip` to compress the string "Qt rocks!", without an event loop:

            QProcess gzip;
            gzip.start("gzip", QStringList() << "-c");
            if (!gzip.waitForStarted())
                return false;

            gzip.write("Qt rocks!");
            gzip.closeWriteChannel();

            if (!gzip.waitForFinished())
                return false;

            QByteArray result = gzip.readAll();

See Also:
  `QBuffer`, `QFile`, `QTcpSocket`

Nested Class Summary
`static class` | `QProcess.DetachedProcessInfo`
`static class` | `QProcess.ExitStatus` This enum describes the different exit statuses of `QProcess`.
`static class` | `QProcess.ProcessChannel` This enum describes the process channels used by the running process.
`static class` | `QProcess.ProcessChannelMode` This enum describes the process channel modes of `QProcess`.
`static class` | `QProcess.ProcessError` This enum describes the different types of errors that are reported by `QProcess`.
`static class` | `QProcess.ProcessState` This enum describes the different states of `QProcess`.

Nested classes/interfaces inherited from class com.trolltech.qt.core.QIODevice
`QIODevice.OpenMode, QIODevice.OpenModeFlag`

Nested classes/interfaces inherited from class com.trolltech.qt.QSignalEmitter
`QSignalEmitter.AbstractSignal, QSignalEmitter.Signal0, QSignalEmitter.Signal1<A>, QSignalEmitter.Signal2<A,B>, QSignalEmitter.Signal3<A,B,C>, QSignalEmitter.Signal4<A,B,C,D>, QSignalEmitter.Signal5<A,B,C,D,E>, QSignalEmitter.Signal6<A,B,C,D,E,F>, QSignalEmitter.Signal7<A,B,C,D,E,F,G>, QSignalEmitter.Signal8<A,B,C,D,E,F,G,H>, QSignalEmitter.Signal9<A,B,C,D,E,F,G,H,I>`

Field Summary
`QSignalEmitter.Signal1<QProcess.ProcessError>` | `error` This signal is emitted when an error occurs with the process.
`QSignalEmitter.Signal1<java.lang.Integer>` | `finished` This signal is obsolete.
`QSignalEmitter.Signal2<java.lang.Integer,QProcess.ExitStatus>` | `finishedWithStatusCode` This signal is emitted when the process finishes.
`QSignalEmitter.Signal0` | `readyReadStandardError` This signal is emitted when the process has made new data available through its standard error channel (`stderr`).
`QSignalEmitter.Signal0` | `readyReadStandardOutput` This signal is emitted when the process has made new data available through its standard output channel (`stdout`).
`QSignalEmitter.Signal0` | `started` This signal is emitted by `QProcess` when the process has started, and `state` returns Running.
`QSignalEmitter.Signal1<QProcess.ProcessState>` | `stateChanged` This signal is emitted whenever the state of `QProcess` changes.

Fields inherited from class com.trolltech.qt.core.QIODevice
`aboutToClose, bytesWritten, readyRead`

Constructor Summary
`QProcess()` Equivalent to `QProcess`(0).
`QProcess(QObject parent)` Constructs a `QProcess` object with the given `parent`.

Method Summary
`boolean` | `atEnd()` This function is reimplemented for internal reasons.
`long` | `bytesAvailable()` This function is reimplemented for internal reasons.
`long` | `bytesToWrite()` This function is reimplemented for internal reasons.
`boolean` | `canReadLine()` This function is reimplemented for internal reasons.
`void` | `close()` Closes all communication with the process.
`void` | `closeReadChannel(QProcess.ProcessChannel channel)` Closes the read channel `channel`.
`void` | `closeWriteChannel()` Schedules the write channel of `QProcess` to be closed.
`java.util.List<java.lang.String>` | `environment()` Returns the environment that `QProcess` will use when starting a process, or an empty `QStringList` if no environment has been set using `setEnvironment`.
`QProcess.ProcessError` | `error()` Returns the type of error that occurred last.
`static int` | `execute(java.lang.String program)` Starts the program `program` in a new process.
`static int` | `execute(java.lang.String program, java.util.List<java.lang.String> arguments)` Starts the program `program` with the arguments `arguments` in a new process, waits for it to finish, and then returns the exit code of the process.
`int` | `exitCode()` Returns the exit code of the last process that finished.
`QProcess.ExitStatus` | `exitStatus()` Returns the exit status of the last process that finished.
`static QProcess` | `fromNativePointer(QNativePointer nativePointer)` This function returns the QProcess instance pointed to by nativePointer
`boolean` | `isSequential()` This function is reimplemented for internal reasons.
`void` | `kill()` Kills the current process, causing it to exit immediately.
`QProcess.ProcessChannelMode` | `processChannelMode()` Returns the channel mode of the `QProcess` standard output and standard error channels.
`QByteArray` | `readAllStandardError()` Regardless of the current read channel, this function returns all data available from the standard error of the process as a `QByteArray`.
`QByteArray` | `readAllStandardOutput()` Regardless of the current read channel, this function returns all data available from the standard output of the process as a `QByteArray`.
`QProcess.ProcessChannel` | `readChannel()` Returns the current read channel of the `QProcess`.
`protected int` | `readData(byte[] data)` Equivalent to `readData`(`data`, ).
`void` | `setEnvironment(java.util.List<java.lang.String> environment)` Sets the environment that `QProcess` will use when starting a process to the `environment` specified which consists of a list of key=value pairs.
`void` | `setProcessChannelMode(QProcess.ProcessChannelMode mode)` Sets the channel mode of the `QProcess` standard output and standard error channels to the `mode` specified.
`protected void` | `setProcessState(QProcess.ProcessState state)` Sets the current state of the `QProcess` to the `state` specified.
`void` | `setReadChannel(QProcess.ProcessChannel channel)` Sets the current read channel of the `QProcess` to the given `channel`.
`void` | `setStandardErrorFile(java.lang.String fileName)` Equivalent to `setStandardErrorFile`(`fileName`, Truncate).
`void` | `setStandardErrorFile(java.lang.String fileName, QIODevice.OpenMode mode)` Redirects the process' standard error to the file `fileName`.
`void` | `setStandardErrorFile(java.lang.String fileName, QIODevice.OpenModeFlag... mode)` Redirects the process' standard error to the file `fileName`.
`void` | `setStandardInputFile(java.lang.String fileName)` Redirects the process' standard input to the file indicated by `fileName`.
`void` | `setStandardOutputFile(java.lang.String fileName)` Equivalent to `setStandardOutputFile`(`fileName`, Truncate).
`void` | `setStandardOutputFile(java.lang.String fileName, QIODevice.OpenMode mode)` Redirects the process' standard output to the file `fileName`.
`void` | `setStandardOutputFile(java.lang.String fileName, QIODevice.OpenModeFlag... mode)` Redirects the process' standard output to the file `fileName`.
`void` | `setStandardOutputProcess(QProcess destination)` Pipes the standard output stream of this process to the `destination` process' standard input.
`protected void` | `setupChildProcess()` This function is called in the child process context just before the program is executed on Unix or Mac OS X (i.e., after fork(), but before execve()).
`void` | `setWorkingDirectory(java.lang.String dir)` Sets the working directory to `dir`.
`void` | `start(java.lang.String program)` Equivalent to start(`program`, ReadWrite).
`void` | `start(java.lang.String program, java.util.List<java.lang.String> arguments)` Starts the program `program` in a new process, passing the command line arguments in `arguments`.
`void` | `start(java.lang.String program, java.util.List<java.lang.String> arguments, QIODevice.OpenMode mode)` Starts the program `program` in a new process, passing the command line arguments in `arguments`.
`void` | `start(java.lang.String program, java.util.List<java.lang.String> arguments, QIODevice.OpenModeFlag... mode)` Starts the program `program` in a new process, passing the command line arguments in `arguments`.
`void` | `start(java.lang.String program, QIODevice.OpenMode mode)` Starts the program `program` in a new process.
`void` | `start(java.lang.String program, QIODevice.OpenModeFlag... mode)` Starts the program `program` in a new process.
`static boolean` | `startDetached(java.lang.String program)` Starts the program `program` in a new process.
`static boolean` | `startDetached(java.lang.String program, java.util.List<java.lang.String> arguments)` Starts the program `program` with the arguments `arguments` in a new process, and detaches from it.
`static QProcess.DetachedProcessInfo` | `startDetached(java.lang.String program, java.util.List<java.lang.String> arguments, java.lang.String workingDirectory)` Starts the program `program` with the arguments `arguments` in a new process, and detaches from it.
`QProcess.ProcessState` | `state()` Returns the current state of the process.
`static java.util.List<java.lang.String>` | `systemEnvironment()` Returns the environment of the calling process as a list of key=value pairs.
`void` | `terminate()` Attempts to terminate the process.
`boolean` | `waitForBytesWritten(int msecs)` This function is reimplemented for internal reasons.
`boolean` | `waitForFinished()` Equivalent to `waitForFinished`(30000).
`boolean` | `waitForFinished(int msecs)` Blocks until the process has finished and the `finished` signal has been emitted, or until `msecs` milliseconds have passed.
`boolean` | `waitForReadyRead(int msecs)` This function is reimplemented for internal reasons.
`boolean` | `waitForStarted()` Equivalent to `waitForStarted`(30000).
`boolean` | `waitForStarted(int msecs)` Blocks until the process has started and the `started` signal has been emitted, or until `msecs` milliseconds have passed.
`java.lang.String` | `workingDirectory()` Returns the working directory that the `QProcess` will enter before the program has started.
`protected int` | `writeData(byte[] data)` Equivalent to `writeData`(`data`, ).

Methods inherited from class com.trolltech.qt.core.QIODevice
`errorString, getByte, isOpen, isReadable, isTextModeEnabled, isWritable, open, open, openMode, peek, peek, pos, putByte, read, read, readAll, readLine, readLine, readLine, readLineData, reset, seek, setErrorString, setOpenMode, setOpenMode, setTextModeEnabled, size, ungetByte, write, write`

Methods inherited from class com.trolltech.qt.core.QObject
`blockSignals, childEvent, children, connectSlotsByName, customEvent, disposeLater, dumpObjectInfo, dumpObjectTree, dynamicPropertyNames, event, eventFilter, findChild, findChild, findChild, findChildren, findChildren, findChildren, findChildren, installEventFilter, isWidgetType, killTimer, moveToThread, objectName, parent, property, removeEventFilter, setObjectName, setParent, setProperty, signalsBlocked, startTimer, thread, timerEvent`

Methods inherited from class com.trolltech.qt.QtJambiObject
`dispose, disposed, finalize, reassignNativeResources, tr, tr, tr`

Methods inherited from class com.trolltech.qt.QSignalEmitter
`disconnect, disconnect, signalSender`

Methods inherited from class java.lang.Object
`clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface com.trolltech.qt.QtJambiInterface
`disableGarbageCollection, nativeId, nativePointer, reenableGarbageCollection, setJavaOwnership`

Field Detail

### error

    public final QSignalEmitter.Signal1<QProcess.ProcessError> error

  This signal is emitted when an error occurs with the process. The specified `error` describes the type of error that occurred.

  Compatible Slot Signatures:
    `void mySlot(com.trolltech.qt.core.QProcess.ProcessError error)`
    `void mySlot()`

### finished

    public final QSignalEmitter.Signal1<java.lang.Integer> finished

  This signal is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code.

  Use finished(int `exitCode`, QProcess::ExitStatus status) instead.

  Compatible Slot Signatures:
    `void mySlot(int exitCode)`
    `void mySlot()`

### finishedWithStatusCode

    public final QSignalEmitter.Signal2<java.lang.Integer,QProcess.ExitStatus> finishedWithStatusCode

  This signal is emitted when the process finishes. `exitCode` is the exit code of the process, and `exitStatus` is the exit status. After the process has finished, the buffers in `QProcess` are still intact. You can still read any data that the process may have written before it finished.

  Compatible Slot Signatures:
    `void mySlot(int exitCode, com.trolltech.qt.core.QProcess.ExitStatus exitStatus)`
    `void mySlot(int exitCode)`
    `void mySlot()`
  See Also:
    `exitStatus`

### readyReadStandardError

    public final QSignalEmitter.Signal0 readyReadStandardError

  This signal is emitted when the process has made new data available through its standard error channel (`stderr`). It is emitted regardless of the current read channel.

  Compatible Slot Signature:
    `void mySlot()`
  See Also:
    `readAllStandardError`, `readChannel`

### readyReadStandardOutput

    public final QSignalEmitter.Signal0 readyReadStandardOutput

  This signal is emitted when the process has made new data available through its standard output channel (`stdout`). It is emitted regardless of the current read channel.

  Compatible Slot Signature:
    `void mySlot()`
  See Also:
    `readAllStandardOutput`, `readChannel`

### started

    public final QSignalEmitter.Signal0 started

  This signal is emitted by `QProcess` when the process has started, and `state` returns Running.

  Compatible Slot Signature:
    `void mySlot()`

### stateChanged

    public final QSignalEmitter.Signal1<QProcess.ProcessState> stateChanged

  This signal is emitted whenever the state of `QProcess` changes. The `state` argument is the state `QProcess` changed to.

  Compatible Slot Signatures:
    `void mySlot(com.trolltech.qt.core.QProcess.ProcessState state)`
    `void mySlot()`

Constructor Detail

### QProcess

    public QProcess()

  Equivalent to `QProcess`(0).

### QProcess

    public QProcess(QObject parent)

  Constructs a `QProcess` object with the given `parent`.

Method Detail

### closeReadChannel

    public final void closeReadChannel(QProcess.ProcessChannel channel)

  Closes the read channel `channel`. After calling this function, `QProcess` will no longer receive data on the channel. Any data that has already been received is still available for reading.

  Call this function to save memory, if you are not interested in the output of the process.

  See Also:
    `closeWriteChannel`, `setReadChannel`

### closeWriteChannel

    public final void closeWriteChannel()

  Schedules the write channel of `QProcess` to be closed. The channel will close once all data has been written to the process. After calling this function, any attempts to write to the process will fail.

  Closing the write channel is necessary for programs that read input data until the channel has been closed. For example, the program "more" is used to display text data in a console on both Unix and Windows. But it will not display the text data until `QProcess`'s write channel has been closed. Example:

          QProcess more;
          more.start("more");
          more.write("Text to display");
          more.closeWriteChannel();
          // QProcess will emit readyRead() once "more" starts printing

  The write channel is implicitly opened when `start` is called.

  See Also:
    `closeReadChannel`

### environment

    public final java.util.List<java.lang.String> environment()

  Returns the environment that `QProcess` will use when starting a process, or an empty `QStringList` if no environment has been set using `setEnvironment`. If no environment has been set, the environment of the calling process will be used.

  See Also:
    `setEnvironment`, `systemEnvironment`

### error

    public final QProcess.ProcessError error()

  Returns the type of error that occurred last.

  See Also:
    `state`

### exitCode

    public final int exitCode()

  Returns the exit code of the last process that finished.

### exitStatus

    public final QProcess.ExitStatus exitStatus()

  Returns the exit status of the last process that finished.

  On Windows, if the process was terminated with TerminateProcess() from another application this function will still return `NormalExit` unless the exit code is less than 0.

### kill

    public final void kill()

  Kills the current process, causing it to exit immediately.

  On Windows, `kill` uses TerminateProcess, and on Unix and Mac OS X, the SIGKILL signal is sent to the process.

  See Also:
    `terminate`

### processChannelMode

    public final QProcess.ProcessChannelMode processChannelMode()

  Returns the channel mode of the `QProcess` standard output and standard error channels.

  See Also:
    `setProcessChannelMode`, `setReadChannelMode`, `ProcessChannelMode`, `setReadChannel`

### readAllStandardError

    public final QByteArray readAllStandardError()

  Regardless of the current read channel, this function returns all data available from the standard error of the process as a `QByteArray`.

  See Also:
    `readyReadStandardError`, `readAllStandardOutput`, `readChannel`, `setReadChannel`

### readAllStandardOutput

    public final QByteArray readAllStandardOutput()

  Regardless of the current read channel, this function returns all data available from the standard output of the process as a `QByteArray`.

  See Also:
    `readyReadStandardOutput`, `readAllStandardError`, `readChannel`, `setReadChannel`

### readChannel

    public final QProcess.ProcessChannel readChannel()

  Returns the current read channel of the `QProcess`.

  See Also:
    `setReadChannel`

### setEnvironment

    public final void setEnvironment(java.util.List<java.lang.String> environment)

  Sets the environment that `QProcess` will use when starting a process to the `environment` specified which consists of a list of key=value pairs.

  For example, the following code adds the `C:\\BIN` directory to the list of executable paths (`PATHS`) on Windows:

          QProcess process;
          QStringList env = QProcess::systemEnvironment();
          env << "TMPDIR=C:\\MyApp\\temp"; // Add an environment variable
          env.replaceInStrings(QRegExp("^PATH=(.*)", Qt::CaseInsensitive), "PATH=\\1;C:\\Bin");
          process.setEnvironment(env);
          process.start("myapp");

  See Also:
    `environment`, `systemEnvironment`

### setProcessChannelMode

    public final void setProcessChannelMode(QProcess.ProcessChannelMode mode)

  Sets the channel mode of the `QProcess` standard output and standard error channels to the `mode` specified. This mode will be used the next time `start` is called. For example:

          QProcess builder;
          builder.setProcessChannelMode(QProcess::MergedChannels);
          builder.start("make", QStringList() << "-j2");

          if (!builder.waitForFinished())
              qDebug() << "Make failed:" << builder.errorString();
          else
              qDebug() << "Make output:" << builder.readAll();

  See Also:
    `processChannelMode`, `readChannelMode`, `ProcessChannelMode`, `setReadChannel`

### setProcessState

    protected final void setProcessState(QProcess.ProcessState state)

  Sets the current state of the `QProcess` to the `state` specified.

  See Also:
    `state`

### setReadChannel

    public final void setReadChannel(QProcess.ProcessChannel channel)

  Sets the current read channel of the `QProcess` to the given `channel`. The current input channel is used by the functions `read`, `readAll`, `readLine`, and getChar(). It also determines which channel triggers `QProcess` to emit `readyRead`.

  See Also:
    `readChannel`

### setStandardErrorFile

    public final void setStandardErrorFile(java.lang.String fileName,
                                           QIODevice.OpenModeFlag... mode)

  Redirects the process' standard error to the file `fileName`. When the redirection is in place, the standard error read channel is closed: reading from it using `read` will always fail, as will `readAllStandardError`. The file will be appended to if `mode` is Append, otherwise, it will be truncated.

  See `setStandardOutputFile` for more information on how the file is opened.

  Note: if `setProcessChannelMode` was called with an argument of QProcess::MergedChannels, this function has no effect.

  See Also:
    `setStandardInputFile`, `setStandardOutputFile`, `setStandardOutputProcess`

### setStandardErrorFile

    public final void setStandardErrorFile(java.lang.String fileName)

  Equivalent to `setStandardErrorFile`(`fileName`, Truncate).

### setStandardErrorFile

    public final void setStandardErrorFile(java.lang.String fileName,
                                           QIODevice.OpenMode mode)

  Redirects the process' standard error to the file `fileName`. When the redirection is in place, the standard error read channel is closed: reading from it using `read` will always fail, as will `readAllStandardError`. The file will be appended to if `mode` is Append, otherwise, it will be truncated.

  See `setStandardOutputFile` for more information on how the file is opened.

  Note: if `setProcessChannelMode` was called with an argument of QProcess::MergedChannels, this function has no effect.

  See Also:
    `setStandardInputFile`, `setStandardOutputFile`, `setStandardOutputProcess`

### setStandardInputFile

    public final void setStandardInputFile(java.lang.String fileName)

  Redirects the process' standard input to the file indicated by `fileName`. When an input redirection is in place, the `QProcess` object will be in read-only mode (calling `write` will result in error).

  If the file `fileName` does not exist at the moment `start` is called or is not readable, starting the process will fail.

  Calling `setStandardInputFile` after the process has started has no effect.

  See Also:
    `setStandardOutputFile`, `setStandardErrorFile`, `setStandardOutputProcess`

### setStandardOutputFile

    public final void setStandardOutputFile(java.lang.String fileName,
                                            QIODevice.OpenModeFlag... mode)

  Redirects the process' standard output to the file `fileName`. When the redirection is in place, the standard output read channel is closed: reading from it using `read` will always fail, as will `readAllStandardOutput`.

  If the file `fileName` doesn't exist at the moment `start` is called, it will be created. If it cannot be created, the starting will fail.

  If the file exists and `mode` is QIODevice::Truncate, the file will be truncated. Otherwise (if `mode` is QIODevice::Append), the file will be appended to.

  Calling `setStandardOutputFile` after the process has started has no effect.

  See Also:
    `setStandardInputFile`, `setStandardErrorFile`, `setStandardOutputProcess`

### setStandardOutputFile

    public final void setStandardOutputFile(java.lang.String fileName)

  Equivalent to `setStandardOutputFile`(`fileName`, Truncate).

### setStandardOutputFile

    public final void setStandardOutputFile(java.lang.String fileName,
                                            QIODevice.OpenMode mode)

  Redirects the process' standard output to the file `fileName`. When the redirection is in place, the standard output read channel is closed: reading from it using `read` will always fail, as will `readAllStandardOutput`.

  If the file `fileName` doesn't exist at the moment `start` is called, it will be created. If it cannot be created, the starting will fail.

  If the file exists and `mode` is QIODevice::Truncate, the file will be truncated. Otherwise (if `mode` is QIODevice::Append), the file will be appended to.

  Calling `setStandardOutputFile` after the process has started has no effect.

  See Also:
    `setStandardInputFile`, `setStandardErrorFile`, `setStandardOutputProcess`

### setStandardOutputProcess

    public final void setStandardOutputProcess(QProcess destination)

  Pipes the standard output stream of this process to the `destination` process' standard input.

  The following shell command:

          command1 | command2

  Can be accomplished with QProcesses with the following code:

          QProcess process1;
          QProcess process2;

          process1.setStandardOutputProcess(process2);

          process1.start("command1");
          process2.start("command2");

### setWorkingDirectory

    public final void setWorkingDirectory(java.lang.String dir)

  Sets the working directory to `dir`. `QProcess` will start the process in this directory. The default behavior is to start the process in the working directory of the calling process.

  See Also:
    `workingDirectory`, `start`

### start

    public final void start(java.lang.String program,
                            java.util.List<java.lang.String> arguments,
                            QIODevice.OpenModeFlag... mode)

  Starts the program `program` in a new process, passing the command line arguments in `arguments`. The OpenMode is set to `mode`. `QProcess` will immediately enter the Starting state. If the process starts successfully, `QProcess` will emit `started`; otherwise, `error` will be emitted.

  On Windows, arguments that contain spaces are wrapped in quotes.

  Note: processes are started asynchronously, which means the `started` and `error` signals may be delayed. Call `waitForStarted` to make sure the process has started (or has failed to start) and those signals have been emitted.

  See Also:
    `pid`, `started`, `waitForStarted`

### start

    public final void start(java.lang.String program,
                            java.util.List<java.lang.String> arguments)

  Starts the program `program` in a new process, passing the command line arguments in `arguments`. QProcess will immediately enter the Starting state. If the process starts successfully, QProcess will emit started(); otherwise, error() will be emitted.

  On Windows, arguments that contain spaces are wrapped in quotes.

  Note: processes are started asynchronously, which means the started() and error() signals may be delayed. Call waitForStarted() to make sure the process has started (or has failed to start) and those signals have been emitted.

### start

    public final void start(java.lang.String program,
                            java.util.List<java.lang.String> arguments,
                            QIODevice.OpenMode mode)

  Starts the program `program` in a new process, passing the command line arguments in `arguments`. The OpenMode is set to `mode`. `QProcess` will immediately enter the Starting state. If the process starts successfully, `QProcess` will emit `started`; otherwise, `error` will be emitted.

  On Windows, arguments that contain spaces are wrapped in quotes.

  Note: processes are started asynchronously, which means the `started` and `error` signals may be delayed. Call `waitForStarted` to make sure the process has started (or has failed to start) and those signals have been emitted.

  See Also:
    `pid`, `started`, `waitForStarted`

### start

    public final void start(java.lang.String program,
                            QIODevice.OpenModeFlag... mode)

  Starts the program `program` in a new process. `program` is a single string of text containing both the program name and its arguments. The arguments are separated by one or more spaces. For example:

          QProcess process;
          process.start("del /s *.txt");
          // same as process.start("del", QStringList() << "/s" << "*.txt");
          ...

  The `program` string can also contain quotes, to ensure that arguments containing spaces are correctly supplied to the new process. For example:

          QProcess process;
          process.start("dir \"My Documents\"");

  Note that, on Windows, quotes need to be both escaped and quoted. For example, the above code would be specified in the following way to ensure that `"My Documents"` is used as the argument to the `dir` executable:

          QProcess process;
          process.start("dir \"\"\"My Documents\"\"\"");

  The OpenMode is set to `mode`.

### start

    public final void start(java.lang.String program)

  Equivalent to start(`program`, ReadWrite).

### start

    public final void start(java.lang.String program,
                            QIODevice.OpenMode mode)

  Starts the program `program` in a new process. `program` is a single string of text containing both the program name and its arguments. The arguments are separated by one or more spaces. For example:

          QProcess process;
          process.start("del /s *.txt");
          // same as process.start("del", QStringList() << "/s" << "*.txt");
          ...

  The `program` string can also contain quotes, to ensure that arguments containing spaces are correctly supplied to the new process. For example:

          QProcess process;
          process.start("dir \"My Documents\"");

  Note that, on Windows, quotes need to be both escaped and quoted. For example, the above code would be specified in the following way to ensure that `"My Documents"` is used as the argument to the `dir` executable:

          QProcess process;
          process.start("dir \"\"\"My Documents\"\"\"");

  The OpenMode is set to `mode`.

### state

    public final QProcess.ProcessState state()

  Returns the current state of the process.

  See Also:
    `stateChanged`, `error`

### terminate

    public final void terminate()

  Attempts to terminate the process.

  The process may not exit as a result of calling this function (it is given the chance to prompt the user for any unsaved files, etc).

  On Windows, `terminate` posts a WM_CLOSE message to all toplevel windows of the process and then to the main thread of the process itself. On Unix and Mac OS X the SIGTERM signal is sent.

  Console applications on Windows that do not run an event loop, or whose event loop does not handle the WM_CLOSE message, can only be terminated by calling `kill`.

  See Also:
    `kill`

### waitForFinished

    public final boolean waitForFinished()

  Equivalent to `waitForFinished`(30000).

### waitForFinished

    public final boolean waitForFinished(int msecs)

  Blocks until the process has finished and the `finished` signal has been emitted, or until `msecs` milliseconds have passed.

  Returns true if the process finished; otherwise returns false (if the operation timed out or if an error occurred).

  This function can operate without an event loop. It is useful when writing non-GUI applications and when performing I/O operations in a non-GUI thread.

  Warning: Calling this function from the main (GUI) thread might cause your user interface to freeze.

  If msecs is -1, this function will not time out.

  See Also:
    `finished`, `waitForStarted`, `waitForReadyRead`, `waitForBytesWritten`

### waitForStarted

    public final boolean waitForStarted()

  Equivalent to `waitForStarted`(30000).

### waitForStarted

    public final boolean waitForStarted(int msecs)

  Blocks until the process has started and the `started` signal has been emitted, or until `msecs` milliseconds have passed.

  Returns true if the process was started successfully; otherwise returns false (if the operation timed out or if an error occurred).

  This function can operate without an event loop. It is useful when writing non-GUI applications and when performing I/O operations in a non-GUI thread.

  Warning: Calling this function from the main (GUI) thread might cause your user interface to freeze.

  If msecs is -1, this function will not time out.

  See Also:
    `started`, `waitForReadyRead`, `waitForBytesWritten`, `waitForFinished`

### workingDirectory

    public final java.lang.String workingDirectory()

  Returns the working directory that the `QProcess` will enter before the program has started.

  See Also:
    `setWorkingDirectory`

### atEnd

    public boolean atEnd()

  This function is reimplemented for internal reasons.

  Overrides:
    `atEnd` in class `QIODevice`
  See Also:
    `bytesAvailable`, `read`, `isSequential`

### bytesAvailable

    public long bytesAvailable()

  This function is reimplemented for internal reasons.

  Overrides:
    `bytesAvailable` in class `QIODevice`
  See Also:
    `bytesToWrite`, `readyRead`, `isSequential`

### bytesToWrite

    public long bytesToWrite()

  This function is reimplemented for internal reasons.

  Overrides:
    `bytesToWrite` in class `QIODevice`
  See Also:
    `bytesAvailable`, `bytesWritten`, `isSequential`

### canReadLine

    public boolean canReadLine()

  This function is reimplemented for internal reasons.

  Overrides:
    `canReadLine` in class `QIODevice`
  See Also:
    `readChannel`, `setReadChannel`

### close

    public void close()

  Closes all communication with the process. After calling this function, `QProcess` will no longer emit `readyRead`, and data can no longer be read or written.

  Overrides:
    `close` in class `QIODevice`
  See Also:
    `setOpenMode`, `OpenMode`

### isSequential

    public boolean isSequential()

  This function is reimplemented for internal reasons.

  Overrides:
    `isSequential` in class `QIODevice`
  See Also:
    `bytesAvailable`

### readData

    protected int readData(byte[] data)

  Equivalent to `readData`(`data`, ).

  Specified by:
    `readData` in class `QIODevice`

### setupChildProcess

    protected void setupChildProcess()

  This function is called in the child process context just before the program is executed on Unix or Mac OS X (i.e., after fork(), but before execve()). Reimplement this function to do last minute initialization of the child process. Example:

          class SandboxProcess : public QProcess
          {
              ...
           protected:
               void setupChildProcess();
              ...
          };

          void SandboxProcess::setupChildProcess()
          {
              // Drop all privileges in the child process, and enter
              // a chroot jail.
          #if defined Q_OS_UNIX
              ::setgroups(0, 0);
              ::chroot("/etc/safe");
              ::chdir("/");
              ::setgid(safeGid);
              ::setuid(safeUid);
              ::umask(0);
          #endif
          }

  Warning: This function is called by `QProcess` on Unix and Mac OS X only. On Windows, it is not called.

### waitForBytesWritten

    public boolean waitForBytesWritten(int msecs)

  This function is reimplemented for internal reasons.

  Overrides:
    `waitForBytesWritten` in class `QIODevice`
  See Also:
    `waitForReadyRead`

### waitForReadyRead

    public boolean waitForReadyRead(int msecs)

  This function is reimplemented for internal reasons.

  Overrides:
    `waitForReadyRead` in class `QIODevice`
  See Also:
    `waitForBytesWritten`

### writeData

    protected int writeData(byte[] data)

  Equivalent to `writeData`(`data`, ).

  Specified by:
    `writeData` in class `QIODevice`

### execute

    public static int execute(java.lang.String program,
                              java.util.List<java.lang.String> arguments)

  Starts the program `program` with the arguments `arguments` in a new process, waits for it to finish, and then returns the exit code of the process. Any data the new process writes to the console is forwarded to the calling process.

  The environment and working directory are inherited by the calling process.

  On Windows, arguments that contain spaces are wrapped in quotes.

### execute

    public static int execute(java.lang.String program)

  Starts the program `program` in a new process. `program` is a single string of text containing both the program name and its arguments. The arguments are separated by one or more spaces.

### startDetached

    public static boolean startDetached(java.lang.String program,
                                        java.util.List<java.lang.String> arguments)

  Starts the program `program` with the arguments `arguments` in a new process, and detaches from it. Returns true on success; otherwise returns false. If the calling process exits, the detached process will continue to live.

  On Unix, the started process will run in its own session and act like a daemon. On Windows, it will run as a regular standalone process.

  On Windows, arguments that contain spaces are wrapped in quotes.

### startDetached

    public static boolean startDetached(java.lang.String program)

  Starts the program `program` in a new process. `program` is a single string of text containing both the program name and its arguments. The arguments are separated by one or more spaces.

  The `program` string can also contain quotes, to ensure that arguments containing spaces are correctly supplied to the new process.

### systemEnvironment

    public static java.util.List<java.lang.String> systemEnvironment()

  Returns the environment of the calling process as a list of key=value pairs. Example:

          QStringList environment = QProcess::systemEnvironment();
          // environment = {"PATH=/usr/bin:/usr/local/bin",
                            "USER=greg", "HOME=/home/greg"}

  See Also:
    `environment`, `setEnvironment`

### fromNativePointer

    public static QProcess fromNativePointer(QNativePointer nativePointer)

  This function returns the QProcess instance pointed to by nativePointer

  Parameters:
    `nativePointer` - the QNativePointer of which object should be returned.

### startDetached

    public static QProcess.DetachedProcessInfo startDetached(java.lang.String program,
                                                             java.util.List<java.lang.String> arguments,
                                                             java.lang.String workingDirectory)

  Starts the program `program` with the arguments `arguments` in a new process, and detaches from it. Returns true on success; otherwise, returns false. If the calling process exits, the detached process will continue to live.

  On Unix, the started process will run in its own session and act like a daemon. On Windows, it will run as a regular standalone process.

  On Windows, arguments that contain spaces are wrapped in quotes.

  The process will be started in the directory `workingDirectory`.

Overview | Package | Class | Tree | Deprecated | Index | Help
Qt Jambi Home |
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD