source: trunk/doc/html/qprocess.html

Last change on this file was 190, checked in by rudi, 14 years ago

reference documentation added
File size: 38.4 KB
RevLine 
[190]1<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
2<!-- /home/espenr/tmp/qt-3.3.8-espenr-2499/qt-x11-free-3.3.8/src/kernel/qprocess.cpp:52 -->
3<html>
4<head>
5<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
6<title>QProcess Class</title>
7<style type="text/css"><!--
8fn { margin-left: 1cm; text-indent: -1cm; }
9a:link { color: #004faf; text-decoration: none }
10a:visited { color: #672967; text-decoration: none }
11body { background: #ffffff; color: black; }
12--></style>
13</head>
14<body>
15
16<table border="0" cellpadding="0" cellspacing="0" width="100%">
17<tr bgcolor="#E5E5E5">
18<td valign=center>
19 <a href="index.html">
20<font color="#004faf">Home</font></a>
21 | <a href="classes.html">
22<font color="#004faf">All&nbsp;Classes</font></a>
23 | <a href="mainclasses.html">
24<font color="#004faf">Main&nbsp;Classes</font></a>
25 | <a href="annotated.html">
26<font color="#004faf">Annotated</font></a>
27 | <a href="groups.html">
28<font color="#004faf">Grouped&nbsp;Classes</font></a>
29 | <a href="functions.html">
30<font color="#004faf">Functions</font></a>
31</td>
32<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><h1 align=center>QProcess Class Reference</h1>
33
34<p>The QProcess class is used to start external programs and
35to communicate with them.
36<a href="#details">More...</a>
37<p><tt>#include &lt;<a href="qprocess-h.html">qprocess.h</a>&gt;</tt>
38<p>Inherits <a href="qobject.html">QObject</a>.
39<p><a href="qprocess-members.html">List of all member functions.</a>
40<h2>Public Members</h2>
41<ul>
42<li class=fn><a href="#QProcess"><b>QProcess</b></a> ( QObject&nbsp;*&nbsp;parent = 0, const&nbsp;char&nbsp;*&nbsp;name = 0 )</li>
43<li class=fn><a href="#QProcess-2"><b>QProcess</b></a> ( const&nbsp;QString&nbsp;&amp;&nbsp;arg0, QObject&nbsp;*&nbsp;parent = 0, const&nbsp;char&nbsp;*&nbsp;name = 0 )</li>
44<li class=fn><a href="#QProcess-3"><b>QProcess</b></a> ( const&nbsp;QStringList&nbsp;&amp;&nbsp;args, QObject&nbsp;*&nbsp;parent = 0, const&nbsp;char&nbsp;*&nbsp;name = 0 )</li>
45<li class=fn><a href="#~QProcess"><b>~QProcess</b></a> ()</li>
46<li class=fn>QStringList <a href="#arguments"><b>arguments</b></a> () const</li>
47<li class=fn>void <a href="#clearArguments"><b>clearArguments</b></a> ()</li>
48<li class=fn>virtual void <a href="#setArguments"><b>setArguments</b></a> ( const&nbsp;QStringList&nbsp;&amp;&nbsp;args )</li>
49<li class=fn>virtual void <a href="#addArgument"><b>addArgument</b></a> ( const&nbsp;QString&nbsp;&amp;&nbsp;arg )</li>
50<li class=fn>QDir <a href="#workingDirectory"><b>workingDirectory</b></a> () const</li>
51<li class=fn>virtual void <a href="#setWorkingDirectory"><b>setWorkingDirectory</b></a> ( const&nbsp;QDir&nbsp;&amp;&nbsp;dir )</li>
52<li class=fn>enum <a href="#Communication-enum"><b>Communication</b></a> { Stdin = 0x01, Stdout = 0x02, Stderr = 0x04, DupStderr = 0x08 }</li>
53<li class=fn>void <a href="#setCommunication"><b>setCommunication</b></a> ( int&nbsp;commFlags )</li>
54<li class=fn>int <a href="#communication"><b>communication</b></a> () const</li>
55<li class=fn>virtual bool <a href="#start"><b>start</b></a> ( QStringList&nbsp;*&nbsp;env = 0 )</li>
56<li class=fn>virtual bool <a href="#launch-2"><b>launch</b></a> ( const&nbsp;QString&nbsp;&amp;&nbsp;buf, QStringList&nbsp;*&nbsp;env = 0 )</li>
57<li class=fn>virtual bool <a href="#launch"><b>launch</b></a> ( const&nbsp;QByteArray&nbsp;&amp;&nbsp;buf, QStringList&nbsp;*&nbsp;env = 0 )</li>
58<li class=fn>bool <a href="#isRunning"><b>isRunning</b></a> () const</li>
59<li class=fn>bool <a href="#normalExit"><b>normalExit</b></a> () const</li>
60<li class=fn>int <a href="#exitStatus"><b>exitStatus</b></a> () const</li>
61<li class=fn>virtual QByteArray <a href="#readStdout"><b>readStdout</b></a> ()</li>
62<li class=fn>virtual QByteArray <a href="#readStderr"><b>readStderr</b></a> ()</li>
63<li class=fn>bool <a href="#canReadLineStdout"><b>canReadLineStdout</b></a> () const</li>
64<li class=fn>bool <a href="#canReadLineStderr"><b>canReadLineStderr</b></a> () const</li>
65<li class=fn>virtual QString <a href="#readLineStdout"><b>readLineStdout</b></a> ()</li>
66<li class=fn>virtual QString <a href="#readLineStderr"><b>readLineStderr</b></a> ()</li>
67<li class=fn>PID <a href="#processIdentifier"><b>processIdentifier</b></a> ()</li>
68</ul>
69<h2>Public Slots</h2>
70<ul>
71<li class=fn>void <a href="#tryTerminate"><b>tryTerminate</b></a> () const</li>
72<li class=fn>void <a href="#kill"><b>kill</b></a> () const</li>
73<li class=fn>virtual void <a href="#writeToStdin"><b>writeToStdin</b></a> ( const&nbsp;QByteArray&nbsp;&amp;&nbsp;buf )</li>
74<li class=fn>virtual void <a href="#writeToStdin-2"><b>writeToStdin</b></a> ( const&nbsp;QString&nbsp;&amp;&nbsp;buf )</li>
75<li class=fn>virtual void <a href="#closeStdin"><b>closeStdin</b></a> ()</li>
76</ul>
77<h2>Signals</h2>
78<ul>
79<li class=fn>void <a href="#readyReadStdout"><b>readyReadStdout</b></a> ()</li>
80<li class=fn>void <a href="#readyReadStderr"><b>readyReadStderr</b></a> ()</li>
81<li class=fn>void <a href="#processExited"><b>processExited</b></a> ()</li>
82<li class=fn>void <a href="#wroteToStdin"><b>wroteToStdin</b></a> ()</li>
83<li class=fn>void <a href="#launchFinished"><b>launchFinished</b></a> ()</li>
84</ul>
85<hr><a name="details"></a><h2>Detailed Description</h2>
86
87
88<p> The QProcess class is used to start external programs and
89to communicate with them.
90<p>
91
92
93<p> You can write to the started program's standard input, and can
94read the program's standard output and standard error. You can
95pass command line arguments to the program either in the
96constructor or with <a href="#setArguments">setArguments</a>() or <a href="#addArgument">addArgument</a>(). The program's
97working directory can be set with <a href="#setWorkingDirectory">setWorkingDirectory</a>(). If you
98need to set up environment variables pass them to the <a href="#start">start</a>() or
99<a href="#launch">launch</a>() functions (see below). The <a href="#processExited">processExited</a>() signal is
100emitted if the program exits. The program's exit status is
101available from <a href="#exitStatus">exitStatus</a>(), although you could simply call
102<a href="#normalExit">normalExit</a>() to see if the program terminated normally.
103<p> There are two different ways to start a process. If you just want
104to run a program, optionally passing data to its standard input at
105the beginning, use one of the launch() functions. If you want full
106control of the program's standard input (especially if you don't
107know all the data you want to send to standard input at the
108beginning), use the start() function.
109<p> If you use start() you can write to the program's standard input
110using <a href="#writeToStdin">writeToStdin</a>() and you can close the standard input with
111<a href="#closeStdin">closeStdin</a>(). The <a href="#wroteToStdin">wroteToStdin</a>() signal is emitted if the data
112sent to standard input has been written. You can read from the
113program's standard output using <a href="#readStdout">readStdout</a>() or <a href="#readLineStdout">readLineStdout</a>().
114These functions return an empty <a href="qbytearray.html">QByteArray</a> if there is no data to
115read. The <a href="#readyReadStdout">readyReadStdout</a>() signal is emitted when there is data
116available to be read from standard output. Standard error has a
117set of functions that correspond to the standard output functions,
118i.e. <a href="#readStderr">readStderr</a>(), <a href="#readLineStderr">readLineStderr</a>() and <a href="#readyReadStderr">readyReadStderr</a>().
119<p> If you use one of the <a href="#launch">launch</a>() functions the data you pass will be
120sent to the program's standard input which will be closed once all
121the data has been written. You should <em>not</em> use <a href="#writeToStdin">writeToStdin</a>() or
122<a href="#closeStdin">closeStdin</a>() if you use launch(). If you need to send data to the
123program's standard input after it has started running use <a href="#start">start</a>()
124instead of launch().
125<p> Both start() and launch() can accept a string list of strings each
126of which has the format, key=value, where the keys are the names
127of environment variables.
128<p> You can test to see if a program is running with <a href="#isRunning">isRunning</a>(). The
129program's process identifier is available from
130<a href="#processIdentifier">processIdentifier</a>(). If you want to terminate a running program
131use <a href="#tryTerminate">tryTerminate</a>(), but note that the program may ignore this. If
132you <em>really</em> want to terminate the program, without it having any
133chance to clean up, you can use <a href="#kill">kill</a>().
134<p> As an example, suppose we want to start the <tt>uic</tt> command (a Qt
135command line tool used with <em>Qt Designer</em>) and perform some
136operations on the output (the <tt>uic</tt> outputs the code it generates
137to standard output by default). Suppose further that we want to
138run the program on the file "small_dialog.ui" with the command
139line options "-tr <a href="i18n.html#i18n">i18n</a>". On the command line we would write:
140<pre>
141 uic -tr i18n small_dialog.ui
142 </pre>
143
144<p>
145
146<p> A code snippet for this with the QProcess class might look like
147this:
148<p> <pre> UicManager::UicManager()
149 {
150</pre><pre> proc = new QProcess( this );
151</pre><pre> <a name="x2122"></a> proc-&gt;<a href="#addArgument">addArgument</a>( "uic" );
152 proc-&gt;<a href="#addArgument">addArgument</a>( "-tr" );
153 proc-&gt;<a href="#addArgument">addArgument</a>( "i18n" );
154 proc-&gt;<a href="#addArgument">addArgument</a>( "small_dialog.ui" );
155
156 <a name="x2123"></a> <a href="qobject.html#connect">connect</a>( proc, SIGNAL(<a href="#readyReadStdout">readyReadStdout</a>()),
157 this, SLOT(readFromStdout()) );
158</pre><pre> <a name="x2124"></a> if ( !proc-&gt;<a href="#start">start</a>() ) {
159 // error handling
160</pre><pre> }
161 }
162</pre>
163<p> <pre> void UicManager::readFromStdout()
164 {
165 // Read and process the data.
166 // Bear in mind that the data might be output in chunks.
167</pre><pre> }
168</pre>
169<p> Although you may need quotes for a file named on the command line
170(e.g. if it contains spaces) you shouldn't use extra quotes for
171arguments passed to <a href="#addArgument">addArgument</a>() or <a href="#setArguments">setArguments</a>().
172<p> The <a href="#readyReadStdout">readyReadStdout</a>() signal is emitted when there is new data on
173standard output. This happens asynchronously: you don't know if
174more data will arrive later.
175<p> In the above example you could connect the <a href="#processExited">processExited</a>() signal
176to the slot UicManager::readFromStdout() instead. If you do so,
177you will be certain that all the data is available when the slot
178is called. On the other hand, you must wait until the process has
179finished before doing any processing.
180<p> Note that if you are expecting a lot of output from the process,
181you may hit platform-dependent limits to the pipe buffer size. The
182solution is to make sure you connect to the output, e.g. the
183readyReadStdout() and <a href="#readyReadStderr">readyReadStderr</a>() signals and read the data
184as soon as it becomes available.
185<p> Please note that QProcess does not emulate a shell. This means that
186QProcess does not do any expansion of arguments: a '*' is passed as a '*'
187to the program and is <em>not</em> replaced by all the files, a '$HOME' is also
188passed literally and is <em>not</em> replaced by the environment variable HOME
189and the special characters for IO redirection ('>', '|', etc.) are also
190passed literally and do <em>not</em> have the special meaning as they have in a
191shell.
192<p> Also note that QProcess does not emulate a terminal. This means that
193certain programs which need direct terminal control, do not work as
194expected with QProcess. Such programs include console email programs (like
195pine and mutt) but also programs which require the user to enter a password
196(like su and ssh).
197<p> <h3> Notes for Windows users
198</h3>
199<a name="1"></a><p> Some Windows commands, for example, <tt>dir</tt>, are not provided by
200separate applications, but by the command interpreter.
201If you attempt to use QProcess to execute these commands directly
202it won't work. One possible solution is to execute the command
203interpreter itself (<tt>cmd.exe</tt> on some Windows systems), and ask
204the interpreter to execute the desired command.
205<p> Under Windows there are certain problems starting 16-bit applications
206and capturing their output. Microsoft recommends using an intermediate
207application to start 16-bit applications.
208<p> <p>See also <a href="qsocket.html">QSocket</a>, <a href="io.html">Input/Output and Networking</a>, and <a href="misc.html">Miscellaneous Classes</a>.
209
210<hr><h2>Member Type Documentation</h2>
211<h3 class=fn><a name="Communication-enum"></a>QProcess::Communication</h3>
212
213<p> This enum type defines the communication channels connected to the
214process.
215<ul>
216<li><tt>QProcess::Stdin</tt> - Data can be written to the process's standard input.
217<li><tt>QProcess::Stdout</tt> - Data can be read from the process's standard
218output.
219<li><tt>QProcess::Stderr</tt> - Data can be read from the process's standard error.
220<li><tt>QProcess::DupStderr</tt> - Both the process's standard error output <em>and</em>
221its standard output are written to its standard output. (Like
222Unix's dup2().) This means that nothing is sent to the standard
223error output. This is especially useful if your application
224requires that the output on standard output and on standard error
225must be read in the same order that they are produced. This is a
226flag, so to activate it you must pass <tt>Stdout|Stderr|DupStderr</tt>,
227or <tt>Stdin|Stdout|Stderr|DupStderr</tt> if you want to provide input,
228to the <a href="#setCommunication">setCommunication</a>() call.
229</ul><p> <p>See also <a href="#setCommunication">setCommunication</a>() and <a href="#communication">communication</a>().
230
231<hr><h2>Member Function Documentation</h2>
232<h3 class=fn><a name="QProcess"></a>QProcess::QProcess ( <a href="qobject.html">QObject</a>&nbsp;*&nbsp;parent = 0, const&nbsp;char&nbsp;*&nbsp;name = 0 )
233</h3>
234Constructs a QProcess object. The <em>parent</em> and <em>name</em> parameters
235are passed to the <a href="qobject.html">QObject</a> constructor.
236<p> <p>See also <a href="#setArguments">setArguments</a>(), <a href="#addArgument">addArgument</a>(), and <a href="#start">start</a>().
237
238<h3 class=fn><a name="QProcess-2"></a>QProcess::QProcess ( const&nbsp;<a href="qstring.html">QString</a>&nbsp;&amp;&nbsp;arg0, <a href="qobject.html">QObject</a>&nbsp;*&nbsp;parent = 0, const&nbsp;char&nbsp;*&nbsp;name = 0 )
239</h3>
240Constructs a QProcess with <em>arg0</em> as the command to be executed.
241The <em>parent</em> and <em>name</em> parameters are passed to the <a href="qobject.html">QObject</a>
242constructor.
243<p> The process is not started. You must call <a href="#start">start</a>() or <a href="#launch">launch</a>() to
244start the process.
245<p> <p>See also <a href="#setArguments">setArguments</a>(), <a href="#addArgument">addArgument</a>(), and <a href="#start">start</a>().
246
247<h3 class=fn><a name="QProcess-3"></a>QProcess::QProcess ( const&nbsp;<a href="qstringlist.html">QStringList</a>&nbsp;&amp;&nbsp;args, <a href="qobject.html">QObject</a>&nbsp;*&nbsp;parent = 0, const&nbsp;char&nbsp;*&nbsp;name = 0 )
248</h3>
249Constructs a QProcess with <em>args</em> as the arguments of the
250process. The first element in the list is the command to be
251executed. The other elements in the list are the arguments to this
252command. The <em>parent</em> and <em>name</em> parameters are passed to the
253<a href="qobject.html">QObject</a> constructor.
254<p> The process is not started. You must call <a href="#start">start</a>() or <a href="#launch">launch</a>() to
255start the process.
256<p> <p>See also <a href="#setArguments">setArguments</a>(), <a href="#addArgument">addArgument</a>(), and <a href="#start">start</a>().
257
258<h3 class=fn><a name="~QProcess"></a>QProcess::~QProcess ()
259</h3>
260Destroys the instance.
261<p> If the process is running, it is <b>not</b> terminated! The
262standard input, standard output and standard error of the process
263are closed.
264<p> You can connect the <a href="qobject.html#destroyed">destroyed</a>() signal to the <a href="#kill">kill</a>() slot, if you
265want the process to be terminated automatically when the instance
266is destroyed.
267<p> <p>See also <a href="#tryTerminate">tryTerminate</a>() and <a href="#kill">kill</a>().
268
269<h3 class=fn>void <a name="addArgument"></a>QProcess::addArgument ( const&nbsp;<a href="qstring.html">QString</a>&nbsp;&amp;&nbsp;arg )<tt> [virtual]</tt>
270</h3>
271Adds <em>arg</em> to the end of the list of arguments.
272<p> The first element in the list of arguments is the command to be
273executed; the following elements are the command's arguments.
274<p> <p>See also <a href="#arguments">arguments</a>() and <a href="#setArguments">setArguments</a>().
275
276<p>Example: <a href="qprocess.html#x2122">process/process.cpp</a>.
277<h3 class=fn><a href="qstringlist.html">QStringList</a> <a name="arguments"></a>QProcess::arguments () const
278</h3>
279Returns the list of arguments that are set for the process.
280Arguments can be specified with the constructor or with the
281functions <a href="#setArguments">setArguments</a>() and <a href="#addArgument">addArgument</a>().
282<p> Note that if you want to iterate over the list, you should iterate
283over a copy, e.g.
284<pre>
285 <a href="qstringlist.html">QStringList</a> list = myProcess.arguments();
286 QStringList::Iterator it = list.<a href="qvaluelist.html#begin">begin</a>();
287 while( it != list.<a href="qvaluelist.html#end">end</a>() ) {
288 myProcessing( *it );
289 ++it;
290 }
291 </pre>
292
293<p> <p>See also <a href="#setArguments">setArguments</a>() and <a href="#addArgument">addArgument</a>().
294
295<h3 class=fn>bool <a name="canReadLineStderr"></a>QProcess::canReadLineStderr () const
296</h3>
297Returns TRUE if it's possible to read an entire line of text from
298standard error at this time; otherwise returns FALSE.
299<p> <p>See also <a href="#readLineStderr">readLineStderr</a>() and <a href="#canReadLineStdout">canReadLineStdout</a>().
300
301<h3 class=fn>bool <a name="canReadLineStdout"></a>QProcess::canReadLineStdout () const
302</h3>
303Returns TRUE if it's possible to read an entire line of text from
304standard output at this time; otherwise returns FALSE.
305<p> <p>See also <a href="#readLineStdout">readLineStdout</a>() and <a href="#canReadLineStderr">canReadLineStderr</a>().
306
307<h3 class=fn>void <a name="clearArguments"></a>QProcess::clearArguments ()
308</h3>
309Clears the list of arguments that are set for the process.
310<p> <p>See also <a href="#setArguments">setArguments</a>() and <a href="#addArgument">addArgument</a>().
311
312<h3 class=fn>void <a name="closeStdin"></a>QProcess::closeStdin ()<tt> [virtual slot]</tt>
313</h3>
314Closes the process's standard input.
315<p> This function also deletes any pending data that has not been
316written to standard input.
317<p> <p>See also <a href="#wroteToStdin">wroteToStdin</a>().
318
319<h3 class=fn>int <a name="communication"></a>QProcess::communication () const
320</h3>
321Returns the communication required with the process, i.e. some
322combination of the <a href="#Communication-enum">Communication</a> flags.
323<p> <p>See also <a href="#setCommunication">setCommunication</a>().
324
325<h3 class=fn>int <a name="exitStatus"></a>QProcess::exitStatus () const
326</h3>
327Returns the exit status of the process or 0 if the process is
328still running. This function returns immediately and does not wait
329until the process is finished.
330<p> If <a href="#normalExit">normalExit</a>() is FALSE (e.g. if the program was killed or
331crashed), this function returns 0, so you should check the return
332value of normalExit() before relying on this value.
333<p> <p>See also <a href="#normalExit">normalExit</a>() and <a href="#processExited">processExited</a>().
334
335<h3 class=fn>bool <a name="isRunning"></a>QProcess::isRunning () const
336</h3>
337Returns TRUE if the process is running; otherwise returns FALSE.
338<p> <p>See also <a href="#normalExit">normalExit</a>(), <a href="#exitStatus">exitStatus</a>(), and <a href="#processExited">processExited</a>().
339
340<h3 class=fn>void <a name="kill"></a>QProcess::kill () const<tt> [slot]</tt>
341</h3>
342Terminates the process. This is not a safe way to end a process
343since the process will not be able to do any cleanup.
344<a href="#tryTerminate">tryTerminate</a>() is safer, but processes can ignore a
345tryTerminate().
346<p> The nice way to end a process and to be sure that it is finished,
347is to do something like this:
348<pre>
349 process-&gt;tryTerminate();
350 QTimer::<a href="qtimer.html#singleShot">singleShot</a>( 5000, process, SLOT( <a href="#kill">kill</a>() ) );
351 </pre>
352
353<p> This tries to terminate the process the nice way. If the process
354is still running after 5 seconds, it terminates the process the
355hard way. The timeout should be chosen depending on the time the
356process needs to do all its cleanup: use a higher value if the
357process is likely to do a lot of computation or I/O on cleanup.
358<p> The slot returns immediately: it does not wait until the process
359has finished. When the process terminates, the <a href="#processExited">processExited</a>()
360signal is emitted.
361<p> <p>See also <a href="#tryTerminate">tryTerminate</a>() and <a href="#processExited">processExited</a>().
362
363<h3 class=fn>bool <a name="launch"></a>QProcess::launch ( const&nbsp;<a href="qbytearray.html">QByteArray</a>&nbsp;&amp;&nbsp;buf, <a href="qstringlist.html">QStringList</a>&nbsp;*&nbsp;env = 0 )<tt> [virtual]</tt>
364</h3>
365Runs the process and writes the data <em>buf</em> to the process's
366standard input. If all the data is written to standard input,
367standard input is closed. The command is searched for in the path
368for executable programs; you can also use an absolute path in the
369command itself.
370<p> If <em>env</em> is null, then the process is started with the same
371environment as the starting process. If <em>env</em> is non-null, then
372the values in the string list are interpreted as environment
373setttings of the form <tt>key=value</tt> and the process is started
374with these environment settings. For convenience, there is a small
375exception to this rule under Unix: if <em>env</em> does not contain any
376settings for the environment variable <tt>LD_LIBRARY_PATH</tt>, then
377this variable is inherited from the starting process.
378<p> Returns TRUE if the process could be started; otherwise returns
379FALSE.
380<p> Note that you should not use the slots <a href="#writeToStdin">writeToStdin</a>() and
381<a href="#closeStdin">closeStdin</a>() on processes started with <a href="#launch">launch</a>(), since the result
382is not well-defined. If you need these slots, use <a href="#start">start</a>() instead.
383<p> The process may or may not read the <em>buf</em> data sent to its
384standard input.
385<p> You can call this function even when a process that was started
386with this instance is still running. Be aware that if you do this
387the standard input of the process that was launched first will be
388closed, with any pending data being deleted, and the process will
389be left to run out of your control. Similarly, if the process
390could not be started the standard input will be closed and the
391pending data deleted. (On operating systems that have zombie
392processes, Qt will also wait() on the old process.)
393<p> The object emits the signal <a href="#launchFinished">launchFinished</a>() when this function
394call is finished. If the start was successful, this signal is
395emitted after all the data has been written to standard input. If
396the start failed, then this signal is emitted immediately.
397<p> <p>See also <a href="#start">start</a>() and <a href="#launchFinished">launchFinished</a>().
398
399<h3 class=fn>bool <a name="launch-2"></a>QProcess::launch ( const&nbsp;<a href="qstring.html">QString</a>&nbsp;&amp;&nbsp;buf, <a href="qstringlist.html">QStringList</a>&nbsp;*&nbsp;env = 0 )<tt> [virtual]</tt>
400</h3>
401This is an overloaded member function, provided for convenience. It behaves essentially like the above function.
402<p> The data <em>buf</em> is written to standard input with <a href="#writeToStdin">writeToStdin</a>()
403using the <a href="qstring.html#local8Bit">QString::local8Bit</a>() representation of the strings.
404
405<h3 class=fn>void <a name="launchFinished"></a>QProcess::launchFinished ()<tt> [signal]</tt>
406</h3>
407
408<p> This signal is emitted when the process was started with <a href="#launch">launch</a>().
409If the start was successful, this signal is emitted after all the
410data has been written to standard input. If the start failed, then
411this signal is emitted immediately.
412<p> This signal is especially useful if you want to know when you can
413safely delete the QProcess object when you are not interested in
414reading from standard output or standard error.
415<p> <p>See also <a href="#launch">launch</a>() and <a href="qobject.html#deleteLater">QObject::deleteLater</a>().
416
417<h3 class=fn>bool <a name="normalExit"></a>QProcess::normalExit () const
418</h3>
419Returns TRUE if the process has exited normally; otherwise returns
420FALSE. This implies that this function returns FALSE if the
421process is still running.
422<p> <p>See also <a href="#isRunning">isRunning</a>(), <a href="#exitStatus">exitStatus</a>(), and <a href="#processExited">processExited</a>().
423
424<h3 class=fn>void <a name="processExited"></a>QProcess::processExited ()<tt> [signal]</tt>
425</h3>
426
427<p> This signal is emitted when the process has exited.
428<p> <p>See also <a href="#isRunning">isRunning</a>(), <a href="#normalExit">normalExit</a>(), <a href="#exitStatus">exitStatus</a>(), <a href="#start">start</a>(), and <a href="#launch">launch</a>().
429
430<p>Example: <a href="process-example.html#x98">process/process.cpp</a>.
431<h3 class=fn>PID <a name="processIdentifier"></a>QProcess::processIdentifier ()
432</h3>
433Returns platform dependent information about the process. This can
434be used together with platform specific system calls.
435<p> Under Unix the return value is the PID of the process, or -1 if no
436process belongs to this object.
437<p> Under Windows it is a pointer to the <tt>PROCESS_INFORMATION</tt>
438struct, or 0 if no process is belongs to this object.
439<p> Use of this function's return value is likely to be non-portable.
440
441<h3 class=fn><a href="qstring.html">QString</a> <a name="readLineStderr"></a>QProcess::readLineStderr ()<tt> [virtual]</tt>
442</h3>
443Reads a line of text from standard error, excluding any trailing
444newline or carriage return characters and returns it. Returns
445<a href="qstring.html#QString-null">QString::null</a> if <a href="#canReadLineStderr">canReadLineStderr</a>() returns FALSE.
446<p> By default, the text is interpreted to be in Latin-1 encoding. If you need
447other codecs, you can set a different codec with
448<a href="qtextcodec.html#setCodecForCStrings">QTextCodec::setCodecForCStrings</a>().
449<p> <p>See also <a href="#canReadLineStderr">canReadLineStderr</a>(), <a href="#readyReadStderr">readyReadStderr</a>(), <a href="#readStderr">readStderr</a>(), and <a href="#readLineStdout">readLineStdout</a>().
450
451<h3 class=fn><a href="qstring.html">QString</a> <a name="readLineStdout"></a>QProcess::readLineStdout ()<tt> [virtual]</tt>
452</h3>
453Reads a line of text from standard output, excluding any trailing
454newline or carriage return characters, and returns it. Returns
455<a href="qstring.html#QString-null">QString::null</a> if <a href="#canReadLineStdout">canReadLineStdout</a>() returns FALSE.
456<p> By default, the text is interpreted to be in Latin-1 encoding. If you need
457other codecs, you can set a different codec with
458<a href="qtextcodec.html#setCodecForCStrings">QTextCodec::setCodecForCStrings</a>().
459<p> <p>See also <a href="#canReadLineStdout">canReadLineStdout</a>(), <a href="#readyReadStdout">readyReadStdout</a>(), <a href="#readStdout">readStdout</a>(), and <a href="#readLineStderr">readLineStderr</a>().
460
461<h3 class=fn><a href="qbytearray.html">QByteArray</a> <a name="readStderr"></a>QProcess::readStderr ()<tt> [virtual]</tt>
462</h3>
463Reads the data that the process has written to standard error.
464When new data is written to standard error, the class emits the
465signal <a href="#readyReadStderr">readyReadStderr</a>().
466<p> If there is no data to read, this function returns a <a href="qbytearray.html">QByteArray</a> of
467size 0: it does not wait until there is something to read.
468<p> <p>See also <a href="#readyReadStderr">readyReadStderr</a>(), <a href="#readLineStderr">readLineStderr</a>(), <a href="#readStdout">readStdout</a>(), and <a href="#writeToStdin">writeToStdin</a>().
469
470<h3 class=fn><a href="qbytearray.html">QByteArray</a> <a name="readStdout"></a>QProcess::readStdout ()<tt> [virtual]</tt>
471</h3>
472Reads the data that the process has written to standard output.
473When new data is written to standard output, the class emits the
474signal <a href="#readyReadStdout">readyReadStdout</a>().
475<p> If there is no data to read, this function returns a <a href="qbytearray.html">QByteArray</a> of
476size 0: it does not wait until there is something to read.
477<p> <p>See also <a href="#readyReadStdout">readyReadStdout</a>(), <a href="#readLineStdout">readLineStdout</a>(), <a href="#readStderr">readStderr</a>(), and <a href="#writeToStdin">writeToStdin</a>().
478
479<p>Example: <a href="process-example.html#x99">process/process.cpp</a>.
480<h3 class=fn>void <a name="readyReadStderr"></a>QProcess::readyReadStderr ()<tt> [signal]</tt>
481</h3>
482
483<p> This signal is emitted when the process has written data to
484standard error. You can read the data with <a href="#readStderr">readStderr</a>().
485<p> Note that this signal is only emitted when there is new data and
486not when there is old, but unread data. In the slot connected to
487this signal, you should always read everything that is available
488at that moment to make sure that you don't lose any data.
489<p> <p>See also <a href="#readStderr">readStderr</a>(), <a href="#readLineStderr">readLineStderr</a>(), and <a href="#readyReadStdout">readyReadStdout</a>().
490
491<h3 class=fn>void <a name="readyReadStdout"></a>QProcess::readyReadStdout ()<tt> [signal]</tt>
492</h3>
493
494<p> This signal is emitted when the process has written data to
495standard output. You can read the data with <a href="#readStdout">readStdout</a>().
496<p> Note that this signal is only emitted when there is new data and
497not when there is old, but unread data. In the slot connected to
498this signal, you should always read everything that is available
499at that moment to make sure that you don't lose any data.
500<p> <p>See also <a href="#readStdout">readStdout</a>(), <a href="#readLineStdout">readLineStdout</a>(), and <a href="#readyReadStderr">readyReadStderr</a>().
501
502<p>Example: <a href="qprocess.html#x2123">process/process.cpp</a>.
503<h3 class=fn>void <a name="setArguments"></a>QProcess::setArguments ( const&nbsp;<a href="qstringlist.html">QStringList</a>&nbsp;&amp;&nbsp;args )<tt> [virtual]</tt>
504</h3>
505Sets <em>args</em> as the arguments for the process. The first element
506in the list is the command to be executed. The other elements in
507the list are the arguments to the command. Any previous arguments
508are deleted.
509<p> QProcess does not perform argument substitutions; for example, if you
510specify "*" or "$DISPLAY", these values are passed to the process
511literally. If you want to have the same behavior as the shell
512provides, you must do the substitutions yourself; i.e. instead of
513specifying a "*" you must specify the list of all the filenames in
514the current directory, and instead of "$DISPLAY" you must specify
515the value of the environment variable <tt>DISPLAY</tt>.
516<p> Note for Windows users. The standard Windows shells, e.g. <tt>command.com</tt> and <tt>cmd.exe</tt>, do not perform file globbing, i.e.
517they do not convert a "*" on the command line into a list of files
518in the current directory. For this reason most Windows
519applications implement their own file globbing, and as a result of
520this, specifying an argument of "*" for a Windows application is
521likely to result in the application performing a file glob and
522ending up with a list of filenames.
523<p> <p>See also <a href="#arguments">arguments</a>() and <a href="#addArgument">addArgument</a>().
524
525<h3 class=fn>void <a name="setCommunication"></a>QProcess::setCommunication ( int&nbsp;commFlags )
526</h3>
527Sets <em>commFlags</em> as the communication required with the process.
528<p> <em>commFlags</em> is a bitwise OR of the flags defined by the <a href="#Communication-enum">Communication</a> enum.
529<p> The default is <tt>Stdin|Stdout|Stderr</tt>.
530<p> <p>See also <a href="#communication">communication</a>().
531
532<h3 class=fn>void <a name="setWorkingDirectory"></a>QProcess::setWorkingDirectory ( const&nbsp;<a href="qdir.html">QDir</a>&nbsp;&amp;&nbsp;dir )<tt> [virtual]</tt>
533</h3>
534Sets <em>dir</em> as the working directory for processes. This does not
535affect running processes; only processes that are started
536afterwards are affected.
537<p> Setting the working directory is especially useful for processes
538that try to access files with relative paths.
539<p> <p>See also <a href="#workingDirectory">workingDirectory</a>() and <a href="#start">start</a>().
540
541<h3 class=fn>bool <a name="start"></a>QProcess::start ( <a href="qstringlist.html">QStringList</a>&nbsp;*&nbsp;env = 0 )<tt> [virtual]</tt>
542</h3>
543Tries to run a process for the command and arguments that were
544specified with <a href="#setArguments">setArguments</a>(), <a href="#addArgument">addArgument</a>() or that were
545specified in the constructor. The command is searched for in the
546path for executable programs; you can also use an absolute path in
547the command itself.
548<p> If <em>env</em> is null, then the process is started with the same
549environment as the starting process. If <em>env</em> is non-null, then
550the values in the stringlist are interpreted as environment
551setttings of the form <tt>key=value</tt> and the process is started in
552these environment settings. For convenience, there is a small
553exception to this rule: under Unix, if <em>env</em> does not contain any
554settings for the environment variable <tt>LD_LIBRARY_PATH</tt>, then
555this variable is inherited from the starting process; under
556Windows the same applies for the environment variable <tt>PATH</tt>.
557<p> Returns TRUE if the process could be started; otherwise returns
558FALSE.
559<p> You can write data to the process's standard input with
560<a href="#writeToStdin">writeToStdin</a>(). You can close standard input with <a href="#closeStdin">closeStdin</a>() and
561you can terminate the process with <a href="#tryTerminate">tryTerminate</a>(), or with <a href="#kill">kill</a>().
562<p> You can call this function even if you've used this instance to
563create a another process which is still running. In such cases,
564QProcess closes the old process's standard input and deletes
565pending data, i.e., you lose all control over the old process, but
566the old process is not terminated. This applies also if the
567process could not be started. (On operating systems that have
568zombie processes, Qt will also wait() on the old process.)
569<p> <p>See also <a href="#launch">launch</a>() and <a href="#closeStdin">closeStdin</a>().
570
571<p>Example: <a href="qprocess.html#x2124">process/process.cpp</a>.
572<h3 class=fn>void <a name="tryTerminate"></a>QProcess::tryTerminate () const<tt> [slot]</tt>
573</h3>
574Asks the process to terminate. Processes can ignore this if they
575wish. If you want to be certain that the process really
576terminates, you can use <a href="#kill">kill</a>() instead.
577<p> The slot returns immediately: it does not wait until the process
578has finished. When the process terminates, the <a href="#processExited">processExited</a>()
579signal is emitted.
580<p> <p>See also <a href="#kill">kill</a>() and <a href="#processExited">processExited</a>().
581
582<h3 class=fn><a href="qdir.html">QDir</a> <a name="workingDirectory"></a>QProcess::workingDirectory () const
583</h3>
584Returns the working directory that was set with
585<a href="#setWorkingDirectory">setWorkingDirectory</a>(), or the current directory if none has been
586explicitly set.
587<p> <p>See also <a href="#setWorkingDirectory">setWorkingDirectory</a>() and <a href="qdir.html#current">QDir::current</a>().
588
589<h3 class=fn>void <a name="writeToStdin"></a>QProcess::writeToStdin ( const&nbsp;<a href="qbytearray.html">QByteArray</a>&nbsp;&amp;&nbsp;buf )<tt> [virtual slot]</tt>
590</h3>
591Writes the data <em>buf</em> to the process's standard input. The
592process may or may not read this data.
593<p> This function always returns immediately. The data you
594pass to <a href="#writeToStdin">writeToStdin</a>() is copied into an internal memory buffer in
595QProcess, and when control goes back to the event loop, QProcess will
596starting transferring data from this buffer to the running process.  
597Sometimes the data will be transferred in several payloads, depending on
598how much data is read at a time by the process itself. When QProcess has
599transferred all the data from its memory buffer to the running process, it
600emits <a href="#wroteToStdin">wroteToStdin</a>().
601<p> Note that some operating systems use a buffer to transfer
602the data. As a result, wroteToStdin() may be emitted before the
603running process has actually read all the data.
604<p> <p>See also <a href="#wroteToStdin">wroteToStdin</a>(), <a href="#closeStdin">closeStdin</a>(), <a href="#readStdout">readStdout</a>(), and <a href="#readStderr">readStderr</a>().
605
606<h3 class=fn>void <a name="writeToStdin-2"></a>QProcess::writeToStdin ( const&nbsp;<a href="qstring.html">QString</a>&nbsp;&amp;&nbsp;buf )<tt> [virtual slot]</tt>
607</h3>
608This is an overloaded member function, provided for convenience. It behaves essentially like the above function.
609<p> The string <em>buf</em> is handled as text using the
610<a href="qstring.html#local8Bit">QString::local8Bit</a>() representation.
611
612<h3 class=fn>void <a name="wroteToStdin"></a>QProcess::wroteToStdin ()<tt> [signal]</tt>
613</h3>
614
615<p> This signal is emitted if the data sent to standard input (via
616<a href="#writeToStdin">writeToStdin</a>()) was actually written to the process. This does not
617imply that the process really read the data, since this class only
618detects when it was able to write the data to the operating
619system. But it is now safe to close standard input without losing
620pending data.
621<p> <p>See also <a href="#writeToStdin">writeToStdin</a>() and <a href="#closeStdin">closeStdin</a>().
622
623<!-- eof -->
624<hr><p>
625This file is part of the <a href="index.html">Qt toolkit</a>.
626Copyright &copy; 1995-2007
627<a href="http://www.trolltech.com/">Trolltech</a>. All Rights Reserved.<p><address><hr><div align=center>
628<table width=100% cellspacing=0 border=0><tr>
629<td>Copyright &copy; 2007
630<a href="troll.html">Trolltech</a><td align=center><a href="trademarks.html">Trademarks</a>
631<td align=right><div align=right>Qt 3.3.8</div>
632</table></div></address></body>
633</html>
Note: See TracBrowser for help on using the repository browser.