===== QProcess =====
La classe QProcess est utilisée pour lancer des programmes externes et communiquer avec eux. [[#Description détaillée|Plus d'informations...]]
==== Héritage ====
Hérite de [[QIODevice]].
==== Description détaillée ====
La classe QProcess est utilisée pour lancer des programmes externes et communiquer avec eux.
=== Exécuter un processus ===
Pour lancer un processus, donnez le nom de l'exécutable et la liste des arguments du programme que vous voulez démarrer dans les arguments de la fonction [[#start()]]. Les arguments sont fournis sous forme de chaînes de caractères individuelles dans une [[QStringList]].
Par exemple, l'extrait de code suivant exécute l'exemple analog clock dans le style Motif sur plateformes X11 en passant des chaînes de caractères contenant "-style" et "motif" comme deux éléments dans la liste des arguments :
QObject *parent;
...
QString program = "./path/du/dossier/examples/Qt/widgets/analogclock";
QStringList arguments;
arguments << "-style" << "motif";
QProcess *myProcess = new QProcess(parent);
myProcess->start(program, arguments);
QProcess entre alors dans l'état [[#ProcessState-enum|Starting]] et, quand le programme a démarré, QProcess entre dans l'état [[#ProcessState-enum|Running]] et émet le signal [[#started()]].
QProcess vous permet de traiter un processus comme un périphérique d'entrée/sortie séquentiel. Vous pouvez écrire et lire dans le processus comme vous le feriez pour accéder à une connexion réseau en utilisant [[QTcpSocket]]. Vous pouvez alors écrire sur l'entrée standard du processus en utilisant la fonction [[qiodevice#write()]], et lire sur la sortie standard en utilisant la fonction [[qiodevice#read()]], [[qiodevice#readLine()]] et [[qiodevice#getChar()]]. Comme la classe hérite de [[QIODevice]], QProcess peut aussi être utilisé comme une source d'entrée pour [[QXmlReader]], ou pour générer des données à envoyer en utilisant [[QFtp]].
**Note :** sur Windows CE et Symbian, la lecture et l'écriture dans un processus ne sont pas supportées.
Quand le processus se termine, QProcess retourne à l'état [[#ProcessState-enum|NotRunning]] (situation initiale) et émet le signal [[#finished()]].
Le signal [[#finished()]] fournit dans ses arguments le code et le statut de sortie du processus. Vous pouvez aussi appeler [[#exitCode()]] pour obtenir le code de sortie du dernier processus terminé et [[#exitStatus()]] pour obtenir son statut de sortie. Dès qu'une erreur se produit, QProcess émettra le signal [[#error()]]. Vous pouvez aussi appeler [[#error()]] pour avoir le dernier type d'erreur qui s'est produit et [[#state()]] pour obtenir le dernier état du processus.
=== Les canaux de communications ===
Les processus ont deux sorties prédéfinies. La sortie standard (''stdout''), qui est la sortie régulière de la console et la sortie d'erreur (''stderr''), qui fournit généralement les messages d'erreurs du processus. Ces canaux représentent deux flux de données séparés. Vous pouvez jongler entre ces deux canaux en utilisant [[#setReadChannel()]]. QProcess émet le signal [[qiodevice#readyRead()]] quand de nouvelles données sont disponibles sur le canal en cours lecture. Il émet aussi le signal [[#readyReadStandardOutput()]] quand de nouvelles données sont disponibles sur la sortie standard. Quand de nouvelles données sont disponibles sur la sortie d'erreur standard, le signal [[#readyReadStandardError()]] est émis. Au lieu d'appeler [[qiodevice#read()]], [[qiodevice#readLine()]] ou [[qiodevice#getChar()]], vous pouvez lire toutes les données de l'un ou de l'autre des deux canaux en appelant [[#readAllStandardOutput()]] ou [[#readAllStandardError()]].
La terminologie utilisée pour les canaux peut être trompeuse. Soyez conscients que la sortie standard du processus correspond au canal ''read'' de QProcess, quant à l'entrée standard, elle correspond au canal ''write''. C'est parce que nous lisons (''read'') sur la sortie du processus et que nous écrivons (''write'') sur son entrée.
QProcess peut fusionner les deux canaux de sortie, de sorte que la sortie standard et la sortie d'erreur standard utilisent toutes les deux la sortie standard du processus. Utilisez [[#setProcessChannelMode()]] avec [[#ProcessChannelMode-enum|MergedChannels]] avant de lancer le processus pour qu'il prenne en compte le changement. Vous avez aussi l'option de faire suivre la sortie du processus en cours à l'appelant, le processus principal, en passant [[#ProcessChannelMode-enum|ForwardedChannels]] comme argument.
Certains processus ont besoin d'avoir des paramètres d'environnement spéciaux afin de les exploiter. Vous pouvez fixer les variables d'environnement pour votre processus en appelant [[#setEnvironment()]]. Pour définir un répertoire de travail, utilisez la fonction [[#setWorkingDirectory()]]. Par défaut, les processus fonctionnent dans le répertoire courant où l'application a été exécuté.
**Note :** sur Symbian, les paramètres d'environnement et le répertoire de travail ne sont pas supportés. Le répertoire de travail sera toujours le répertoire privé du processus exécuté.
=== API de processus synchrone ===
QProcess fournit un ensemble de fonctions qui lui permet d'être utilisé sans boucle événementielle, en suspendant le thread appelant jusqu'à ce que certains signaux soient émis :
* [[#waitForStarted()]] attend jusqu'à ce que le processus ait commencé ;
* [[#waitForReadyRead()]] attend jusqu'à ce que de nouvelles données soient disponibles pour la lecture sur le canal de lecture ;
* [[#waitForBytesWritten()]] attend jusqu'à ce qu'un champ de données ait été écrit dans le processus ;
* [[#waitForFinished()]] attend jusqu'à ce que le processus soit fini.
Appeler ces fonctions depuis le thread principal (le thread qui appelle [[qapplication#exec|QApplication::exec()]]) peut faire geler votre interface.
L'exemple suivant lance ''gzip'' pour compresser la chaîne de caractères "Qt rocks!" sans utiliser la boucle événementielle :
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();
===Note pour les utilisateurs de Windows===
Certaines commandes Windows (par exemple, ''dir'') ne sont pas fournies par des applications distinctes, mais par l'interpréteur de commande lui-même. Si vous tentez d'utiliser QProcess pour exécuter ces commandes directement, cela ne marchera pas. La solution possible est d'exécuter l'interpréteur de commandes lui-même (''cmd.exe'' sur les systèmes Windows) et de demander à l'interpréteur d'exécuter la commande voulue.
Voir aussi [[QBuffer]], [[QFile]] et [[QTcpSocket]].
==== Types ====
=== ExitStatus-enum ===
''enum QProcess::ExitStatus''
Cette énumération décrit les différents statuts de sortie de [[QProcess]].
^ Constante ^ Valeur ^ Description ^
| ''QProcess::NormalExit'' | 0 | Le processus a quitté normalement. |
| ''QProcess::CrashExit'' | 1 | Le processus a planté. |
Voir aussi [[#exitStatus()]].
=== ProcessChannel-enum ===
''enum QProcess::ProcessChannel''
Cette énumération décrit les canaux de processus utilisés par le processus en fonctionnement. Mettez une de ces valeurs à [[#setReadChannel()]] pour définir le canal de lecture courant de [[QProcess]]
^ Constante ^ Valeur ^ Description ^
| ''QProcess::StandardOutput'' | 0 | Sortie standard (''stdout'') du processus en cours. |
| ''QProcess::StandardError'' | 1 | Sortie d'erreur standard (''stderr'') du processus en cours. |
Voir aussi [[#setReadChannel()]].
=== ProcessChannelMode-enum ===
''enum QProcess::ProcessChannelMode''
Cette énumération décrit les modes de canaux d'un [[QProcess]]. Passez une des ces valeurs à [[#setProcessChannelMode()]] pour définir le mode du canal de lecture courant.
^ Constante ^ Valeur ^ Description ^
| ''QProcess::SeparateChannels'' | 0 | [[QProcess]] gère la sortie du processus en cours, gardant les données de la sortie standard et de la sortie d'erreur standard dans des buffers internes séparés. Vous pouvez sélectionner l'actuel canal de lecture de [[QProcess]] en appelant [[#setReadChannel()]]. Il s'agit du mode de canal par défaut de [[QProcess]]. |
| ''QProcess::MergedChannels'' | 1 | [[QProcess]] fusionne la sortie du processus en cours dans le canal de sortie standard (''stdout''). La sortie d'erreur standard (''stderr'') ne recevra plus aucune donnée. La sortie standard et d'erreur standard du processus en cours sont entrelacées. |
| ''QProcess::ForwardedChannels'' | 2 | [[QProcess]] fait suivre la sortie du processus en cours au processus principal. Tout ce que le processus enfant écrit sur sa sortie standard et sur sa sortie d'erreur standard sera écrit sur la sortie standard et sur la sortie d'erreur standard du processus principal. |
Voir aussi [[#setProcessChannelMode()]].
=== ProcessError-enum ===
''enum QProcess::ProcessError''
Cette énumération décrit les différents types d'erreurs qui sont signalés par [[QProcess]].
^ Constante ^ Valeur ^ Description ^
| ''QProcess::FailedToStart'' | 0 | Le processus n'a pas pu démarrer. Soit le programme invoqué n'existe pas, ou vos droits sont insuffisants. |
| ''QProcess::Crashed'' | 1 | Le processus a planté peu de temps après que le démarrage ait réussi. |
| ''QProcess::Timedout'' | 2 | La dernière fonction waitFor...() a fait un timed out. L'état de [[QProcess]] est inchangé ; vous pouvez essayer d'appeler waitFor...() de nouveau. |
| ''QProcess::WriteError'' | 4 | Une erreur s'est produite lors de la tentative d'écriture sur le processus. Par exemple, le processus peut ne pas être en cours d'exécution, ou son canal d'entrée peut être fermé. |
| ''QProcess::ReadError'' | 3 | Une erreur s'est produite lors de la tentative de lecture sur le processus. Par exemple, le processus peut ne pas être en cours d'exécution. |
| ''QProcess::UnknownError'' | 5 | Une erreur inconnue s'est produite. Il s'agit de la valeur de retour par défaut de [[#error()]]. |
Voir aussi [[#error()]].
=== ProcessState-enum ===
''enum QProcess::ProcessState''
Cette énumération décrit les différents états de [[QProcess]].
^ Constante ^ Valeur ^ Description ^
| 'QProcess::NotRunning' | 0 | Le processus n'est pas lancé. |
| 'QProcess::Starting' | 1 | Le processus est en cours de démarrage. |
| 'QProcess::Running' | 2 | Le processus est lancé et est prêt pour la lecture et l'écriture. |
Voir aussi [[#state()]].
==== Fonctions membres ====
=== QProcess() ===
''QProcess::QProcess ( [[QObject]] * parent = 0 )''
Construit un objet [[QProcess]] avec comme argument ''parent''.
=== ~QProcess() ===
''QProcess::~QProcess () [virtual]''
Détruit l'objet [[QProcess]], c'est-à-dire tue le processus.
Notez que cette fonction ne fera pas de retour jusqu'à ce que le processus soit terminé.
=== atEnd() ===
''bool QProcess::atEnd () const [virtual]''
Réimplémentation de [[qiodevice#atEnd|QIODevice::atEnd()]].
Retourne ''true'' si le processus n'est pas en cours d'exécution et aucune nouvelle donnée n'est disponible en lecture ; sinon retourn ''false''.
=== bytesAvailable() ===
''[[qtglobal#qint64-typedef|qint64]] QProcess::bytesAvailable () const [virtual]''
Réimplémentation de [[qiodevice#bytesAvailable|QIODevice::bytesAvailable()]].
=== bytesToWrite() ===
''qint64 QProcess::bytesToWrite () const [virtual]''
Réimplémentation de [[qiodevice#bytesToWrite|QIODevice::bytesToWrite()]].
=== canReadLine() ===
''bool QProcess::canReadLine () const [virtual]''
Réimplémentation de [[qiodevice#canReadLine|QIODevice::canReadLine()]].
Cette fonction agit sur le canal de lecture courant.
Voir aussi [[#readChannel()]] et [[#setReadChannel()]].
=== close() ===
''void QProcess::close () [virtual]''
Réimplémentation de [[qiodevice#close|QIODevice::close()]].
Ferme toutes les communications avec le processus et le tue. Après l'appel de cette fonction, [[QProcess]] ne pourra plus émettre le signal [[qiodevice#readyRead|readyRead()]] et les données ne pourront plus être lues ni écrites.
=== closeReadChannel() ===
''void QProcess::closeReadChannel ( [[#ProcessChannel-enum|ProcessChannel]] channel )''
Ferme le canal de lecture ''channel''. Après l'appel de cette fonction, [[QProcess]] ne recevra plus de données sur ce canal. Les données déjà reçues sont toujours disponibles en lecture.
Utilisez cette fonction pour économiser de la mémoire, si vous n'êtes pas intéressé par la sortie du processus.
Voir aussi [[#closeWriteChannel()]] et [[#setReadChannel()]].
=== closeWriteChannel() ===
''void QProcess::closeWriteChannel ()''
Planifie la fermeture du canal d'écriture de [[QProcess]]. Le canal sera fermé une fois que toutes les données auront été écrites dans le processus. Après avoir appelé cette fonction, toute tentative d'écriture sur le processus échouera.
La fermeture du canal d'écriture est nécessaire pour les programmes qui lisent les données d'entrée jusqu'à ce que le canal ait été fermé. Par exemple, le programme "more" est utilisé pour afficher du texte dans une console sur Unix ou Windows. Mais il n'affichera pas le texte tant que le canal d'écriture de QProcess ne sera pas fermé. Exemple :
QProcess more;
more.start("more");
more.write("Text to display");
more.closeWriteChannel();
// QProcess émettra le signal readyRead() une fois que "more" commencera l'impression
Le canal d'écriture est implicitement ouvert quand [[#start()]] est appelé.
Voir aussi [[#closeReadChannel()]].
=== environment() ===
''[[QStringList]] QProcess::environment () const''
Cette fonction est dépréciée.
Retourne l'environnement qui sera utilisé par [[QProcess]] lors du démarrage du processus ou une [[QStringList]] vide si l'environnement n'a pas été défini avec [[#setEnvironment()]]. Si aucun environnement n'a été défini, celui du processus appelant sera utilisé.
**Note** : les paramètres d'environnement sont ignorés sous Windows CE et Symbian car il n'y a pas de notion d'environnement.
Voir aussi [[#processEnvironment()]], [[#setEnvironment()]] et [[#systemEnvironment()]].
=== error() ===
''[[#ProcessError-enum|QProcess::ProcessError]] QProcess::error () const''
Retourne le dernier type d'erreur qui s'est produit.
Voir aussi [[#state()]].
=== error() ===
''void QProcess::error ( [[#ProcessError-enum|QProcess::ProcessError]] error ) [signal]''
Ce signal est émis quand une erreur se produit sur le processus. L'erreur spécifiée dans ''error'' décrit le type d'erreur qui s'est produit.
=== execute() ===
''int QProcess::execute ( const [[QString]] & program, const [[QStringList]] & arguments ) [static]''
Lance le programme ''program'' avec les arguments ''arguments'' dans un nouveau processus, attend la fin de l'exécution de celui-ci et retourne le code de sortie du processus. Toutes les données écrites sur la console du nouveau processus sont transmises au processus appelant.
L'environnement et le répertoire de travail sont hérités par le processus appelant.
Sous Windows, les arguments qui contiennent des espaces sont enveloppés par des guillemets.
=== execute() ===
''int QProcess::execute ( const [[QString]] & program ) [static]''
Il s'agit d'une fonction membre surchargée.
Lance le programme ''program'' dans un nouveau processus. ''program'' est une simple chaîne de caractères contenant à la fois le nom du programme et ses arguments. Les arguments sont séparés par un ou plusieurs espaces.
=== exitCode() ===
''int QProcess::exitCode () const''
Retourne le code de sortie du dernier processus terminé.
=== exitStatus() ===
''[[#ExitStatus-enum|QProcess::ExitStatus]] QProcess::exitStatus () const''
Retourne le statut de sortie du dernier processus terminé.
Sous Windows, si le processus a pris fin avec TerminateProcess() depuis une autre application, cette fonction retournera [[#ExitStatus-enum|NormalExit]] à moins que le code de sortie soit inférieur à 0.
Cette fonction a été introduite à partir de Qt 4.1.
=== finished() ===
''void QProcess::finished ( int exitCode, [[#ExitStatus-enum|QProcess::ExitStatus]] exitStatus ) [signal]''
Le signal est émis quand le processus s'est terminé. ''exitCode'' est le code de sortie du processus et ''exitStatus'' est le statut de sortie. Après que le processus soit fini, les buffers dans [[QProcess]] sont encore intacts. Vous pouvez donc toujours lire les données que le processus a écrites avant de se terminer.
Voir aussi [[#exitStatus()]].
=== isSequential() ===
bool QProcess::isSequential () const [virtual]
Réimplémentation de [[qiodevice#isSequential|QIODevice::isSequential()]].
=== kill() ===
''void QProcess::kill () [slot]''
Tue le processus en cours, causant sa fermeture immédiate.
Sur Windows, la fonction kill() utilise TerminateProcess et, sur Unix et Mac OS X, le signal SIGKILL est envoyé au processus.
Voir aussi [[#terminate()]].
=== pid() ===
''[[#Q_PID-typedef|Q_PID]] QProcess::pid () const''
Retourne l'identifiant natif du processus en cours, s'il est disponible. Si aucun processus n'est en cours d'exécution, 0 est retourné.
=== processChannelMode() ===
''[[#ProcessChannelMode-enum|ProcessChannelMode]] QProcess::processChannelMode () const''
Retourne le mode du canal de la sortie standard et de la sortie d'erreur standard de [[QProcess]].
Cette fonction a été introduite à partir de Qt 4.2.
Voir aussi [[#setProcessChannelMode()]], [[#ProcessChannelMode-enum|ProcessChannelMode]] et [[#setReadChannel()]].
=== processEnvironment() ===
''QProcessEnvironment QProcess::processEnvironment () const''
Retourne l'environnement que [[QProcess]] utilisera lors du démarrage d'un processus ou un objet vide si aucun environnement n'a été défini à l'aide des fonctions [[#setEnvironment()]] ou [[#setProcessEnvironment()]] et dans ce dernier cas, l'environnement du processus appelant sera utilisé.
**Note** : les paramètres d'environnement sont ignorés sous Windows CE et Symbian car il n'y a pas de notion d'environnement.
Cette fonction a été introduite à partir de Qt 4.6.
Voir aussi [[#setProcessEnvironment()]], [[#setEnvironment()]] et [[qprocessenvironment#isEmpty|QProcessEnvironment::isEmpty()]].
=== readAllStandardError() ===
''[[QByteArray]] QProcess::readAllStandardError ()''
Indépendamment de l'actuel canal de lecture, cette fonction retourne toutes les données disponibles sur la sortie d'erreur standard dans un [[QByteArray]].
Voir aussi [[#readyReadStandardError()]], [[#readAllStandardOutput()]], [[#readChannel()]] et [[#setReadChannel()]].
=== readAllStandardOutput() ===
''QByteArray QProcess::readAllStandardOutput ()''
Indépendamment de l'actuel canal de lecture, cette fonction retourne toutes les données disponibles sur la sortie standard du processus dans un [[QByteArray]].
Voir aussi [[#readyReadStandardOutput()]], [[#readAllStandardError()]], [[#readChannel()]] et [[#setReadChannel()]].
=== readChannel() ===
''[[#ProcessChannel-enum|ProcessChannel]] QProcess::readChannel () const''
Retourne le canal de lecture de [[QProcess]].
Voir aussi [[#setReadChannel()]].
=== readData() ===
''[[qtglobal#qint64-typedef|qint64]] QProcess::readData ( char * data, [[qtglobal#qint64-typedef|qint64]] maxlen ) [virtual protected]''
Réimplémentation de [[qiodevice#readData|QIODevice::readData()]].
=== readyReadStandardError() ===
''void QProcess::readyReadStandardError () [signal]''
Ce signal est émis lorsque le processus a de nouvelles données disponibles sur son canal de sortie d'erreur standard (''stderr''). Il est émis, quel que soit le [[#readChannel|canal de lecture]] en cours.
Voir aussi [[#readAllStandardError()]] et [[#readChannel()]].
=== readyReadStandardOutput() ===
''void QProcess::readyReadStandardOutput () [signal]''
Ce signal est émis lorsque le processus a de nouvelles données disponibles sur son canal de sortie standard (''stdout''). Il est émis, quel que soit le [[#readChannel|canal de lecture]] en cours.
Voir aussi [[#readAllStandardOutput()]] et [[#readChannel()]].
=== setEnvironment() ===
''void QProcess::setEnvironment ( const [[QStringList]] & environment )''
Cette fonction est dépréciée.
Définit l'environnement que [[QProcess]] utilisera quand il lancera le processus. La variable ''environment'' se défini en une liste de paires clé=valeur.
Par exemple, le code suivant ajoute le répertoire ''C:\\BIN'' à la liste des chemins exécutables (''PATHS'') sur Windows :
QProcess process;
QStringList env = QProcess::systemEnvironment();
env << "TMPDIR=C:\\MyApp\\temp"; // Ajouter une variable d'environnement
env.replaceInStrings(QRegExp("^PATH=(.*)", Qt::CaseInsensitive), "PATH=\\1;C:\\Bin");
process.setEnvironment(env);
process.start("myapp");
**Note :** Cette fonction est moins efficace que [[#setProcessEnvironment()]].
Voir aussi [[#environment()]], [[#setProcessEnvironment()]] et [[#systemEnvironment()]].
=== setProcessChannelMode() ===
''void QProcess::setProcessChannelMode ( [[#ProcessChannelMode-enum|ProcessChannelMode]] mode )''
Définit le mode du canal de la sortie standard et de la sortie d'erreur standard du [[QProcess]] par le ''mode'' spécifié. Ce mode sera utilisé la prochaine fois que [[#start()]] sera appelé. Par exemple :
QProcess builder;
builder.setProcessChannelMode(QProcess::MergedChannels);
builder.start("make", QStringList() << "-j2");
if (!builder.waitForFinished())
qDebug() << "Echec du Make :" << builder.errorString();
else
qDebug() << "Sortie du Make :" << builder.readAll();
Cette fonction a été introduite à partir de Qt 4.2.
Voir aussi [[#processChannelMode()]], [[#readChannelMode()]], [[#ProcessChannelMode-enum|ProcessChannelMode]] et [[#setReadChannel()]].
=== setProcessEnvironment() ===
''void QProcess::setProcessEnvironment ( const [[QProcessEnvironment]] & environment )''
Définit l'environnement que [[QProcess]] utilisera quand il démarrera un processus à l'objet ''environnement''.
Par exemple, le code suivant ajoute le repertoire ''C:\\BIN'' à la liste des chemins exécutables (''PATHS'') sur Windows et défini ''TMPDIR'' :
QProcess process;
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
env.insert("TMPDIR", "C:\\MyApp\\temp"); // Ajouter une variable d'environnement
env.insert("PATH", env.value("Path") + ";C:\\Bin");
process.setProcessEnvironment(env);
process.start("myapp");
Noter que sur Windows, les noms des variables d'environnement sont insensibles à la casse.
Cette fonction a été introduite à partir de Qt 4.6.
Voir aussi [[#processEnvironment()]], [[qprocessenvironment#systemEnvironment|QProcessEnvironment::systemEnvironment()]] et [[#setEnvironment()]].
=== setProcessState() ===
''void QProcess::setProcessState ( [[#ProcessState-enum|ProcessState]] state ) [protected]''
Définit l'état de [[QProcess]] avec l'argument ''state''.
Voir aussi [[#state()]].
=== setReadChannel() ===
''void QProcess::setReadChannel ( [[#ProcessChannel-enum|ProcessChannel]] channel )''
Définit le canal de lecture actuel de [[QProcess]] avec l'argument ''channel''. Le canal d'entrée actuel est utilisé par les fonctions [[qiodevice#read|read()]], [[qiodevice#readAll|readAll()]], [[qiodevice#readLine|readLine()]] et [[qiodevice#getChar|getChar()]]. Elle détermine également quel canal déclenche [[QProcess]] pour émettre [[qiodevice#readyRead|readyRead()]].
Voir aussi [[#readChannel()]].
=== setStandardErrorFile() ===
''void QProcess::setStandardErrorFile ( const [[QString]] & fileName, [[qiodevice#OpenModeFlag-enum|OpenMode]] mode = Truncate )''
Redirige la sortie d'erreur standard du processus dans le fichier ''filename''. Quand la redirection est en place, le canal de la sortie d'erreur standard est fermé essayer de le lire en utilisant [[qiodevice#read|read()]] ou [[#readAllStandardError()]] échouera dans tous les cas. Le fichier sera ouvert en mode ajouté des données en fin de fichier si le ''mode'' est Append, sinon celui ci sera tronqué.
Voir [[#setStandardOutputFile()]] pour plus d'information sur l'ouverture du fichier.
Note : si [[#setProcessChannelMode()]] a été appelé avec un argument de [[#ProcessChannelMode-enum|QProcess::MergedChannels]], cette fonction n'aura pas d'effet.
Cette fonction a été introduite à partir de Qt 4.2.
Voir aussi [[#setStandardInputFile()]], [[#setStandardOutputFile()]] et [[#setStandardOutputProcess()]].
=== setStandardInputFile() ===
''void QProcess::setStandardInputFile ( const [[QString]] & fileName )''
Redirige l'entrée standard du processus dans le fichier indiqué par ''filename''. Quand la redirection de l'entrée est en place, l'objet [[QProcess]] sera en mode lecture seule (appeler [[qiodevice#write()]] produira une erreur).
Si le fichier ''filename'' n'existe pas lorsque vous appelez la fonction [[#start()]] ou qu'il est illisible, le processus échouera lors de son lancement.
Appeler setStandardInputFile() après que le processus ait été lancé n'aura aucun effet.
Cette fonction a été introduite à partir de Qt 4.2.
Voir aussi [[#setStandardOutputFile()]], [[#setStandardErrorFile()]] et [[#setStandardOutputProcess()]].
=== setStandardOutputFile() ===
''void QProcess::setStandardOutputFile ( const [[QString]] & fileName, [[qiodevice#OpenModeFlag-enum|OpenMode]] mode = Truncate )''
Redirige la sortie standard du processus dans le fichier ''filename''. Quand la redirection est en place, le canal de la sortie standard est fermé essayer de le lire en utilisant [[qiodevice#read()]] ou [[#readAllStandardOutput()]] échouera dans tous les cas.
Si le fichier ''filename'' n'existe pas lorsque vous appelez la fonction [[#start()]], il sera créé. S'il ne peut pas être créé, le lancement du processus échouera.
Si le fichier existe et que ''mode'' est [[qiodevice#OpenModeFlag-enum|QIODevice::Truncate]], le fichier sera tronqué sinon (si le ''mode'' est [[qiodevice#OpenModeFlag-enum|QIODevice::Append]]) les données seront écrite à la suite de la fin du fichier.
Appeler setStandardOutputFile() après que le processus ait été lancé n'aura aucun effet.
Cette fonction a été introduite à partir de Qt 4.2.
Voir aussi [[#setStandardInputFile()]], [[#setStandardErrorFile()]] et [[#setStandardOutputProcess()]].
=== setStandardOutputProcess() ===
''void QProcess::setStandardOutputProcess ( QProcess * destination )''
Pipes la sortie standard du processus sur l'entrée standard du processus ''destination''.
La commande shell suivante :
command1 | command2
Peut être réalisée avec QProcess en utilisant le code suivant :
QProcess process1;
QProcess process2;
process1.setStandardOutputProcess(&process2);
process1.start("command1");
process2.start("command2");
Cette fonction a été introduite à partir de Qt 4.2.
=== setWorkingDirectory() ===
''void QProcess::setWorkingDirectory ( const [[QString]] & dir )''
Définit le répertoire de travail avec comme path ''dir''. [[QProcess]] démarrera le processus dans ce répertoire. Par défaut le répertoire est celui du processus appelant.
**Note :** le répertoire de travail défini est ignoré sur Symbian ; le répertoire privé du processus est considéré comme le répertoire de travail.
Voir aussi [[#workingDirectory()]] et [[#start()]].
=== setupChildProcess() ===
''void QProcess::setupChildProcess () [virtual protected]''
Cette fonction est appelée dans un processus enfant juste avant que le programme soit exécuté, sur Unix ou Mac OS X (c'est-à-dire, après fork(), mais avant execve()). Réimplémentez cette fonction pour faire l'initialisation de dernière minute du processus enfant. Exemple :
class SandboxProcess : public QProcess
{
...
protected:
void setupChildProcess();
...
};
void SandboxProcess::setupChildProcess()
{
// Retire tous les privilèges du processus enfant et met
// un "chroot jail".
#if defined Q_OS_UNIX
::setgroups(0, 0);
::chroot("/etc/safe");
::chdir("/");
::setgid(safeGid);num
::setuid(safeUid);
::umask(0);
#endif
}
Vous ne pouvez pas fermer le processus (en appelant exit(), pour cette instance) depuis cette fonction. Si vous avez besoin d'arrêter le programme avant que son exécution commence, vous devrez émettre le signal [[#finished()]] et ensuite appeler exit().
**Attention :** cette fonction est appelée par [[QProcess]] seulement sur Unix et Mac OS X. Sur Windows, elle n'est pas appelée.
=== start() ===
''void QProcess::start ( const [[QString]] & program, const [[QStringList]] & arguments, [[qiodevice#OpenModeFlag-enum|OpenMode]] mode = ReadWrite )''
Lance le programme ''program'' dans un nouveau processus, s'il n'est pas déjà en cours d'exécution, en lui passant ''arguments'' aux arguments de la ligne de commande. L'[[qiodevice#OpenModeFlag-enum|OpenMode]] est défini à ''mode''.
L'objet [[QProcess]] sera immédiatement mis dans l'état Starting. Si le processus réussit son lancement, [[QProcess]] émettra le signal [[#started()]] sinon il émettra le signal [[#error()]]. Si l'objet QProcess est déjà en cours d'exécution, un avertissement sera peut être écrit dans la console et le processus existant continuera son exécution.
**Note :** les arguments contenant des espaces sont passés au processus en tant qu'un seul argument.
**Note** : les processus sont lancés de manière asynchrone, ce qui signifie que les signaux [[#started()]] et [[#error()]] peuvent être retardés. Appelez [[#waitForStarted()]] pour s'assurer que le processus est lancé (ou a échoué à son lancement) et que les signaux ont été émis.
**Windows** : les arguments contenant des espaces sont mis entre guillemets.
Voir aussi [[#pid()]], [[#started()]] et [[#waitForStarted()]].
=== start()===
''void QProcess::start ( const [[QString]] & program, [[qiodevice#OpenModeFlag-enum|OpenMode]] mode = ReadWrite )''
Il s'agit d'une fonction membre surchargée.
Lance le programme ''program'' dans un nouveau processus, s'il n'est pas déjà en cours d'exécution. ''program'' est une simple chaîne de caractères ayant le nom du programme et ses arguments. Les arguments sont séparés par un ou plusieurs espaces. Par exemple :
QProcess process;
process.start("del /s *.txt");
// ce qui revient à process.start("del", QStringList() << "/s" << "*.txt");
...
La chaîne de caractères ''program'' peut aussi contenir des guillemets, ce qui permet aux arguments contenant des espaces d'être correctement fournis au nouveau processus. Par exemple :
QProcess process;
process.start("dir \"My Documents\"");
Si l'objet [[QProcess]] est déjà en cours d'exécution, un avertissement sera peut être écrit dans la consol, et le processus existant continuera son lancement.
Notez que sur Windows, les guillemets ont besoin d'être à la fois échappés et entre guillemets. Par exemple, le code suivant permet de s'assurer que ''"Mes Documents"'' est utilisé en argument pour l'exécutable ''dir''.
QProcess process;
process.start("dir \"\"\"Mes Documents\"\"\"");
L'[[qiodevice#OpenModeFlag-enum|OpenMode]] est défini à ''mode''.
=== startDetached() ===
''bool QProcess::startDetached ( const [[QString]] & program, const [[QStringList]] & arguments, const [[QString]] & workingDirectory, [[qtglobal#qint64-typedef|qint64]] * pid = 0 ) [static]''
Lance le programme ''program'' avec les arguments ''arguments'' dans un nouveau processus et le détache de celui-ci. Retourne ''true'' si l'exécution a réussi sinon retourne ''false''. Si le processus appelant se termine, le processus détaché sera quant à lui toujours en vie.
**Note :** les arguments contenant des espaces sont passés au processus en tant qu'un seul argument.
**Unix :** le processus sera lancé dans sa propre session et agira comme un démon.
**Windows :** les arguments contenant des espaces sont mis entre guillemets. Le lancement du processus sera considéré comme un processus autonome et le processus sera lancé dans le répertoire ''workingDirectory''.
Si l'exécution a réussi alors ''*pid'' aura l'identifiant du processus.
=== startDetached() ===
''bool QProcess::startDetached ( const [[QString]] & program, const [[QStringList]] & arguments ) [static]''
Lance le programme ''program'' avec les arguments ''arguments'' dans un nouveau processus et le détache de celui-ci. Retourne ''true'', si l'exécution a réussi sinon retourne ''false''. Si le processus appelant se termine, le processus détaché sera quant à lui toujours en vie.
**Note :** les arguments contenant des espaces sont passés au processus en tant qu'un seul argument.
**Unix :** le processus sera lancé dans sa propre session et agira comme un démon.
**Windows :** les arguments contenant des espaces sont mis entre guillemets. Le lancement du processus sera considéré comme un processus autonome.
=== startDetached() ===
''bool QProcess::startDetached ( const [[QString]] & program ) [static]''
Il s'agit d'une fonction membre surchargée.
Lance le programme ''program'' en tant que nouveau processus. ''program'' est une simple chaîne de caractères contenant le nom du programme et ses arguments. Les arguments sont séparés par un ou plusieurs espaces.
La chaîne de caractères ''program'' peut aussi contenir des guillemets, ce qui permet aux arguments contenant des espaces d'être correctement fournis au nouveau processus.
=== started() ===
''void QProcess::started () [signal]''
Le signal est émis par [[QProcess]] quand le processus a été lancé et [[#state()]] retourne [[#ProcessState-enum|Running]].
=== state() ===
''[[#ProcessState-enum|QProcess::ProcessState]] QProcess::state () const''
Retourne l'état actuel du processus.
Voir aussi [[#stateChanged()]] et [[#error()]].
=== stateChanged() ===
''void QProcess::stateChanged ( [[#ProcessState-enum|QProcess::ProcessState]] newState ) [signal]''
Le signal est émis lorsque l'état de [[QProcess]] change. L'argument ''newState'' est le nouvel état de [[QProcess]].
=== systemEnvironment() ===
''[[QStringList]] QProcess::systemEnvironment () [static]''
Retourne l'environnement du processus appelant en une liste de paires de clé=valeur. Exemple :
QStringList environment = QProcess::systemEnvironment();
// environment = {"PATH=/usr/bin:/usr/local/bin",
// "USER=greg", "HOME=/home/greg"}
Cette fonction ne met pas en cache l'environnement du système. Par conséquent, il est possible d'obtenir une version mise à jour de l'environnement si des fonctions bas niveau de la bibliothèque C comme ''setenv'' ou ''putenv'' ont été appelées.
Toutefois, notez que les appels répétés à cette fonction vont recréer la liste des variables d'environnement, qui est une opération non triviale.
**Note :** pour du nouveau code, il est recommandé d'utiliser QProcessEvironment::systemEnvironment()
Cette fonction a été introduite à partir de Qt 4.1.
Voir aussi [[qprocessenvironment#systemEnvironment|QProcessEnvironment::systemEnvironment()]], [[#environment()]] et [[#setEnvironment()]].
=== terminate() ===
''void QProcess::terminate () [slot]''
Tente de mettre fin au processus.
Le processus peut ne pas être fermé avec l'appel de cette fonction (elle permet d'avoir une chance que l'utilisateur puisse sauvegarder ses fichiers).
Sur Windows, terminate() poste un message WM_CLOSE à toutes les fenêtres de premier plan du processus et ensuite au thread principal du processus lui-même. Sur Unix et Mac OS X le signal SIGTERM est envoyé.
Les applications consoles sur Windows qui ne tournent pas dans une boucle évènementielle ou dont celle-ci ne gère pas le message WM_CLOSE, peuvent seulement être terminées par la fonction [[#kill()]].
**Note :** terminer un processus en cours d'exécution à partir d'autres processus causera généralement une panique sur Symbian à cause de la sécurité de la plateforme.
Voir aussi [[#kill()]].
=== waitForBytesWritten() ===
''bool QProcess::waitForBytesWritten ( int msecs = 30000 ) [virtual]''
Réimplémentation de [[qiodevice#waitForBytesWritten|QIODevice::waitForBytesWritten()]].
=== waitForFinished() ===
''bool QProcess::waitForFinished ( int msecs = 30000 )''
Attend que le processus soit terminé et que le signal [[#finished()]] ait été émis, ou que ''msecs'' millisecondes soient passées.
Retourne ''true'' si le processus est terminé, sinon retourne ''false'' (si une erreur est survenue, si msecs millisecondes sont passées ou si [[QProcess]] est déjà terminé).
Cette fonction peut opérer sans boucle évènementielle. Elle est utile lorsque vous écrivez une application consoles et quand vous effectuez des opérations d'entrée/sortie dans un thread non graphique.
**Attention :** appeler cette fonction depuis le thread principal (GUI) peut faire geler votre interface.
Si msecs est -1, la fonction n'aura pas de temps limite.
Voir aussi [[#finished()]], [[#waitForReadyRead()]], [[#waitForBytesWritten()]] et [[#waitForFinished()]].
=== waitForReadyRead() ===
''bool QProcess::waitForReadyRead ( int msecs = 30000 ) [virtual]''
Réimplémentation de [[qiodevice#waitForReadyRead|QIODevice::waitForReadyRead()]].
=== waitForStarted() ===
''bool QProcess::waitForStarted ( int msecs = 30000 )''
Attend que le processus ait démarré et que le signal [[#started()]] ait été émis, ou que ''msecs'' millisecondes soient passées.
Retourne ''true'' si le processus a été lancé avec succès, sinon retourne ''false'' (si une erreur est survenue ou que msecs millisecondes sont passées).
Cette fonction peut opérer sans boucle évènementielle. Elle est utile lorsque vous écrivez une application consoles et quand vous effectuez des opérations d'entrée/sortie dans un thread non graphiques.
**Attention :** appeler cette fonction depuis le thread principal (GUI) peut faire geler votre interface.
Si msecs est -1, la fonction n'aura pas de temps limite.
Voir aussi [[#started()]], [[#waitForReadyRead()]], [[#waitForBytesWritten()]] et [[#waitForFinished()]].
=== workingDirectory() ===
''[[QString]] QProcess::workingDirectory () const''
Si un répertoire de travail a été assigné à [[QProcess]], cette fonction retournera le répertoire de travail avant que le programme ait été lancé. Sinon (c'est-à-dire qu'aucun répertoire n'a été assigné) une chaîne de caractères vide sera retournée et [[QProcess]] utilisera le répertoire de travail actuel de l'application.
Voir aussi [[#setWorkingDirectory|setWorkingDirectory()]].
=== writeData() ===
''qint64 QProcess::writeData ( const char * data, qint64 len ) [virtual protected]''
Réimplémentation de [[qiodevice#writeData|QIODevice::writeData()]].
==== En relation mais non membres de la classe ====
=== Q_PID-typedef ===
''typedef Q_PID''
Définition de type pour les identifiants utilisés pour représenter les processus de la plateforme sous-jacente. Sur Unix et Symbian, cela représente un [[qtglobal#qint64-typedef|qint64]], sur Windows, il correspond à un ''_PROCESS_INFORMATION*''.
Voir aussi [[#pid|QProcess::pid()]].
==== Remerciements ====
Merci à pour la traduction et à , ainsi qu'à pour leur relecture !