The QProcess class is used to start external programs and
to communicate with them.
You can write to the started program's standard input, and can
read the program's standard output and standard error. You can
pass command line arguments to the program either in the
constructor or with setArguments() or addArgument(). The program's
working directory can be set with setWorkingDirectory(). If you
need to set up environment variables pass them to the start() or
launch() functions (see below). The processExited() signal is
emitted if the program exits. The program's exit status is
available from exitStatus(), although you could simply call
normalExit() to see if the program terminated normally.
There are two different ways to start a process. If you just want
to run a program, optionally passing data to its standard input at
the beginning, use one of the launch() functions. If you want full
control of the program's standard input (especially if you don't
know all the data you want to send to standard input at the
beginning), use the start() function.
Both start() and launch() can accept a string list of strings each
of which has the format, key=value, where the keys are the names
of environment variables.
Although you may need quotes for a file named on the command line
(e.g. if it contains spaces) you shouldn't use extra quotes for
arguments passed to addArgument() or setArguments().
Note that if you are expecting a lot of output from the process,
you may hit platform-dependent limits to the pipe buffer size. The
solution is to make sure you connect to the output, e.g. the
readyReadStdout() and readyReadStderr() signals and read the data
as soon as it becomes available.
Some Windows commands, for example, dir, are not provided by
separate applications, but by the command interpreter.
If you attempt to use QProcess to execute these commands directly
it won't work. One possible solution is to execute the command
interpreter itself (cmd.exe on some Windows systems), and ask
the interpreter to execute the desired command.
Under Windows there are certain problems starting 16-bit applications
and capturing their output. Microsoft recommends using an intermediate
application to start 16-bit applications. See Knowledge Base article Q150956 for details on this and example code for an intermediate
application.
See also QSocket, Input/Output and Networking, and Miscellaneous Classes.
Member Type Documentation
QProcess::Communication
This enum type defines the communication channels connected to the
process.
- QProcess::Stdin - Data can be written to the process's standard input.
- QProcess::Stdout - Data can be read from the process's standard
output.
- QProcess::Stderr - Data can be read from the process's standard error.
- QProcess::DupStderr - Both the process's standard error output and
its standard output are written to its standard output. (Like
Unix's dup2().) This means that nothing is sent to the standard
error output. This is especially useful if your application
requires that the output on standard output and on standard error
must be read in the same order that they are produced. This is a
flag, so to activate it you must pass Stdout|Stderr|DupStderr,
or Stdin|Stdout|Stderr|DupStderr if you want to provide input,
to the setCommunication() call.
See also setCommunication() and communication().
Member Function Documentation
QProcess::QProcess ( QObject * parent = 0, const char * name = 0 )
Constructs a QProcess object. The parent and name parameters
are passed to the QObject constructor.
See also setArguments(), addArgument(), and start().
QProcess::QProcess ( const QString & arg0, QObject * parent = 0, const char * name = 0 )
Constructs a QProcess with arg0 as the command to be executed.
The parent and name parameters are passed to the QObject
constructor.
The process is not started. You must call start() or launch() to
start the process.
See also setArguments(), addArgument(), and start().
QProcess::QProcess ( const QStringList & args, QObject * parent = 0, const char * name = 0 )
Constructs a QProcess with args as the arguments of the
process. The first element in the list is the command to be
executed. The other elements in the list are the arguments to this
command. The parent and name parameters are passed to the
QObject constructor.
The process is not started. You must call start() or launch() to
start the process.
See also setArguments(), addArgument(), and start().
QProcess::~QProcess ()
Destroys the instance.
If the process is running, it is not terminated! The
standard input, standard output and standard error of the process
are closed.
You can connect the destroyed() signal to the kill() slot, if you
want the process to be terminated automatically when the instance
is destroyed.
See also tryTerminate() and kill().
void QProcess::addArgument ( const QString & arg ) [virtual]
Adds arg to the end of the list of arguments.
The first element in the list of arguments is the command to be
executed; the following elements are the command's arguments.
See also arguments() and setArguments().
Example: process/process.cpp.
QStringList QProcess::arguments () const
Returns the list of arguments that are set for the process.
Arguments can be specified with the constructor or with the
functions setArguments() and addArgument().
Note that if you want to iterate over the list, you should iterate
over a copy, e.g.
QStringList list = myProcess.arguments();
QStringList::Iterator it = list.begin();
while( it != list.end() ) {
myProcessing( *it );
++it;
}
See also setArguments() and addArgument().
bool QProcess::canReadLineStderr () const
Returns TRUE if it's possible to read an entire line of text from
standard error at this time; otherwise returns FALSE.
See also readLineStderr() and canReadLineStdout().
bool QProcess::canReadLineStdout () const
Returns TRUE if it's possible to read an entire line of text from
standard output at this time; otherwise returns FALSE.
See also readLineStdout() and canReadLineStderr().
void QProcess::clearArguments ()
Clears the list of arguments that are set for the process.
See also setArguments() and addArgument().
void QProcess::closeStdin () [virtual slot]
Closes the process's standard input.
This function also deletes any pending data that has not been
written to standard input.
See also wroteToStdin().
int QProcess::communication () const
Returns the communication required with the process, i.e. some
combination of the Communication flags.
See also setCommunication().
int QProcess::exitStatus () const
Returns the exit status of the process or 0 if the process is
still running. This function returns immediately and does not wait
until the process is finished.
If normalExit() is FALSE (e.g. if the program was killed or
crashed), this function returns 0, so you should check the return
value of normalExit() before relying on this value.
See also normalExit() and processExited().
bool QProcess::isRunning () const
Returns TRUE if the process is running; otherwise returns FALSE.
See also normalExit(), exitStatus(), and processExited().
void QProcess::kill () const [slot]
Terminates the process. This is not a safe way to end a process
since the process will not be able to do any cleanup.
tryTerminate() is safer, but processes can ignore a
tryTerminate().
The nice way to end a process and to be sure that it is finished,
is to do something like this:
process->tryTerminate();
QTimer::singleShot( 5000, process, SLOT( kill() ) );
This tries to terminate the process the nice way. If the process
is still running after 5 seconds, it terminates the process the
hard way. The timeout should be chosen depending on the time the
process needs to do all its cleanup: use a higher value if the
process is likely to do a lot of computation or I/O on cleanup.
The slot returns immediately: it does not wait until the process
has finished. When the process terminates, the processExited()
signal is emitted.
See also tryTerminate() and processExited().
bool QProcess::launch ( const QByteArray & buf, QStringList * env = 0 ) [virtual]
Runs the process and writes the data buf to the process's
standard input. If all the data is written to standard input,
standard input is closed. The command is searched for in the path
for executable programs; you can also use an absolute path in the
command itself.
If env is null, then the process is started with the same
environment as the starting process. If env is non-null, then
the values in the string list are interpreted as environment
setttings of the form key=value and the process is started
with these environment settings. For convenience, there is a small
exception to this rule under Unix: if env does not contain any
settings for the environment variable LD_LIBRARY_PATH, then
this variable is inherited from the starting process.
Returns TRUE if the process could be started; otherwise returns
FALSE.
Note that you should not use the slots writeToStdin() and
closeStdin() on processes started with launch(), since the result
is not well-defined. If you need these slots, use start() instead.
The process may or may not read the buf data sent to its
standard input.
You can call this function even when a process that was started
with this instance is still running. Be aware that if you do this
the standard input of the process that was launched first will be
closed, with any pending data being deleted, and the process will
be left to run out of your control. Similarly, if the process
could not be started the standard input will be closed and the
pending data deleted. (On operating systems that have zombie
processes, Qt will also wait() on the old process.)
The object emits the signal launchFinished() when this function
call is finished. If the start was successful, this signal is
emitted after all the data has been written to standard input. If
the start failed, then this signal is emitted immediately.
See also start() and launchFinished().
bool QProcess::launch ( const QString & buf, QStringList * env = 0 ) [virtual]
This is an overloaded member function, provided for convenience. It behaves essentially like the above function.
The data buf is written to standard input with writeToStdin()
using the QString::local8Bit() representation of the strings.
void QProcess::launchFinished () [signal]
This signal is emitted when the process was started with launch().
If the start was successful, this signal is emitted after all the
data has been written to standard input. If the start failed, then
this signal is emitted immediately.
This signal is especially useful if you want to know when you can
safely delete the QProcess object when you are not intrested in
reading from standard output or standard error.
See also launch() and QObject::deleteLater().
bool QProcess::normalExit () const
Returns TRUE if the process has exited normally; otherwise returns
FALSE. This implies that this function returns FALSE if the
process is still running.
See also isRunning(), exitStatus(), and processExited().
void QProcess::processExited () [signal]
This signal is emitted when the process has exited.
See also isRunning(), normalExit(), exitStatus(), start(), and launch().
Example: process/process.cpp.
PID QProcess::processIdentifier ()
Returns platform dependent information about the process. This can
be used together with platform specific system calls.
Under Unix the return value is the PID of the process, or -1 if no
process is belongs to this object.
Under Windows it is a pointer to the PROCESS_INFORMATION
struct, or 0 if no process is belongs to this object.
Use of this function's return value is likely to be non-portable.
QString QProcess::readLineStderr () [virtual]
Reads a line of text from standard error, excluding any trailing
newline or carriage return characters and returns it. Returns
QString::null if canReadLineStderr() returns FALSE.
See also canReadLineStderr(), readyReadStderr(), readStderr(), and readLineStdout().
QString QProcess::readLineStdout () [virtual]
Reads a line of text from standard output, excluding any trailing
newline or carriage return characters, and returns it. Returns
QString::null if canReadLineStdout() returns FALSE.
See also canReadLineStdout(), readyReadStdout(), readStdout(), and readLineStderr().
QByteArray QProcess::readStderr () [virtual]
Reads the data that the process has written to standard error.
When new data is written to standard error, the class emits the
signal readyReadStderr().
If there is no data to read, this function returns a QByteArray of
size 0: it does not wait until there is something to read.
See also readyReadStderr(), readLineStderr(), readStdout(), and writeToStdin().
QByteArray QProcess::readStdout () [virtual]
Reads the data that the process has written to standard output.
When new data is written to standard output, the class emits the
signal readyReadStdout().
If there is no data to read, this function returns a QByteArray of
size 0: it does not wait until there is something to read.
See also readyReadStdout(), readLineStdout(), readStderr(), and writeToStdin().
Example: process/process.cpp.
void QProcess::readyReadStderr () [signal]
This signal is emitted when the process has written data to
standard error. You can read the data with readStderr().
Note that this signal is only emitted when there is new data and
not when there is old, but unread data. In the slot connected to
this signal, you should always read everything that is available
at that moment to make sure that you don't lose any data.
See also readStderr(), readLineStderr(), and readyReadStdout().
void QProcess::readyReadStdout () [signal]
This signal is emitted when the process has written data to
standard output. You can read the data with readStdout().
Note that this signal is only emitted when there is new data and
not when there is old, but unread data. In the slot connected to
this signal, you should always read everything that is available
at that moment to make sure that you don't lose any data.
See also readStdout(), readLineStdout(), and readyReadStderr().
Example: process/process.cpp.
void QProcess::setArguments ( const QStringList & args ) [virtual]
Sets args as the arguments for the process. The first element
in the list is the command to be executed. The other elements in
the list are the arguments to the command. Any previous arguments
are deleted.
QProcess does not perform argument substitutions; for example, if you
specify "*" or "$DISPLAY", these values are passed to the process
literally. If you want to have the same behavior as the shell
provides, you must do the substitutions yourself; i.e. instead of
specifying a "*" you must specify the list of all the filenames in
the current directory, and instead of "$DISPLAY" you must specify
the value of the environment variable DISPLAY.
Note for Windows users. The standard Windows shells, e.g. command.com and cmd.exe, do not perform file globbing, i.e.
they do not convert a "*" on the command line into a list of files
in the current directory. For this reason most Windows
applications implement their own file globbing, and as a result of
this, specifying an argument of "*" for a Windows application is
likely to result in the application performing a file glob and
ending up with a list of filenames.
See also arguments() and addArgument().
void QProcess::setCommunication ( int commFlags )
Sets commFlags as the communication required with the process.
commFlags is a bitwise OR of the flags defined by the Communication enum.
The default is Stdin|Stdout|Stderr.
See also communication().
void QProcess::setWorkingDirectory ( const QDir & dir ) [virtual]
Sets dir as the working directory for processes. This does not
affect running processes; only processes that are started
afterwards are affected.
Setting the working directory is especially useful for processes
that try to access files with relative paths.
See also workingDirectory() and start().
bool QProcess::start ( QStringList * env = 0 ) [virtual]
Tries to run a process for the command and arguments that were
specified with setArguments(), addArgument() or that were
specified in the constructor. The command is searched for in the
path for executable programs; you can also use an absolute path in
the command itself.
If env is null, then the process is started with the same
environment as the starting process. If env is non-null, then
the values in the stringlist are interpreted as environment
setttings of the form key=value and the process is started in
these environment settings. For convenience, there is a small
exception to this rule: under Unix, if env does not contain any
settings for the environment variable LD_LIBRARY_PATH, then
this variable is inherited from the starting process; under
Windows the same applies for the environment variable PATH.
Returns TRUE if the process could be started; otherwise returns
FALSE.
You can write data to the process's standard input with
writeToStdin(). You can close standard input with closeStdin() and
you can terminate the process with tryTerminate(), or with kill().
You can call this function even if you've used this instance to
create a another process which is still running. In such cases,
QProcess closes the old process's standard input and deletes
pending data, i.e., you lose all control over the old process, but
the old process is not terminated. This applies also if the
process could not be started. (On operating systems that have
zombie processes, Qt will also wait() on the old process.)
See also launch() and closeStdin().
Example: process/process.cpp.
void QProcess::tryTerminate () const [slot]
Asks the process to terminate. Processes can ignore this if they
wish. If you want to be certain that the process really
terminates, you can use kill() instead.
The slot returns immediately: it does not wait until the process
has finished. When the process terminates, the processExited()
signal is emitted.
See also kill() and processExited().
QDir QProcess::workingDirectory () const
Returns the working directory that was set with
setWorkingDirectory(), or the current directory if none has been
explicitly set.
See also setWorkingDirectory() and QDir::current().
void QProcess::writeToStdin ( const QByteArray & buf ) [virtual slot]
Writes the data buf to the process's standard input. The
process may or may not read this data.
This function returns immediately; the QProcess class might write
the data at a later point (you must enter the event loop for this
to occur). When all the data is written to the process, the signal
wroteToStdin() is emitted. This does not mean that the process
actually read the data, since this class only detects when it was
able to write the data to the operating system.
See also wroteToStdin(), closeStdin(), readStdout(), and readStderr().
void QProcess::writeToStdin ( const QString & buf ) [virtual slot]
This is an overloaded member function, provided for convenience. It behaves essentially like the above function.
The string buf is handled as text using the
QString::local8Bit() representation.
void QProcess::wroteToStdin () [signal]
This signal is emitted if the data sent to standard input (via
writeToStdin()) was actually written to the process. This does not
imply that the process really read the data, since this class only
detects when it was able to write the data to the operating
system. But it is now safe to close standard input without losing
pending data.
See also writeToStdin() and closeStdin().
This file is part of the Qt toolkit.
Copyright © 1995-2003
Trolltech. All Rights Reserved.
