QProcess

La classe QProcess est utilisée pour lancer des programmes externes et communiquer avec eux. Plus d'informations...

#include <QProcess>

Voir la position dans l'arbre des classes.

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 Starting et, quand le programme a démarré, QProcess entre dans l'état 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 write(), et lire sur la sortie standard en utilisant la fonction read(), readLine() et 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 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 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 read(), readLine() ou 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 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 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()) 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

enum QProcess::ExitStatus

Cette énumération décrit les différents statuts de sortie de QProcess.

Voir aussi exitStatus().

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 

Voir aussi setReadChannel().

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.

Voir aussi setProcessChannelMode().

enum QProcess::ProcessError

Cette énumération décrit les différents types d'erreurs qui sont signalés par QProcess.

Voir aussi error().

enum QProcess::ProcessState

Cette énumération décrit les différents états de QProcess.

Voir aussi state().

Fonctions membres

QProcess::QProcess ( QObject * parent = 0 )

Construit un objet QProcess avec comme argument parent.

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é.

bool QProcess::atEnd () const [virtual]

Réimplémentation de 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.

qint64 QProcess::bytesAvailable () const [virtual]

Réimplémentation de QIODevice::bytesAvailable().

qint64 QProcess::bytesToWrite () const [virtual]

Réimplémentation de QIODevice::bytesToWrite().

bool QProcess::canReadLine () const [virtual]

Réimplémentation de QIODevice::canReadLine().

Cette fonction agit sur le canal de lecture courant.

Voir aussi readChannel() et setReadChannel().

void QProcess::close () [virtual]

Réimplémentation de 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 readyRead() et les données ne pourront plus être lues ni écrites.

void QProcess::closeReadChannel ( 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().

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().

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().

QProcess::ProcessError QProcess::error () const

Retourne le dernier type d'erreur qui s'est produit.

Voir aussi state().

void QProcess::error ( 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.

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.

Si le processus ne peut pas être démarré, -2 est retourné. Si le processus plante, -1 est retourné. Sinon le code de sortie du processus est retourné.

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.

int QProcess::exitCode () const

Retourne le code de sortie du dernier processus terminé.

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 NormalExit à moins que le code de sortie soit inférieur à 0.

Cette fonction a été introduite à partir de Qt 4.1.

void QProcess::finished ( int exitCode, 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().

bool QProcess::isSequential () const [virtual]

Réimplémentation de QIODevice::isSequential().

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 les exigences de sécurité de la plateforme Symbian et terminate().

QString QProcess::nativeArguments () const

Retourne l'argument additionnel natif de la ligne de commande du programme.

Note : cette fonction est disponible uniquement sous les plateformes Windows et Symbian.

Cette fonction a été introduite dans Qt 4.7.

Voir aussi setNativeArguments().

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 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 et setReadChannel().

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().

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().

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().

ProcessChannel QProcess::readChannel () const

Retourne le canal de lecture de QProcess.

Voir aussi setReadChannel().

qint64 QProcess::readData ( char * data, qint64 maxlen ) [virtual protected]

Réimplémentation de QIODevice::readData().

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 canal de lecture en cours.

Voir aussi readAllStandardError() et readChannel().

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 canal de lecture en cours.

Voir aussi readAllStandardOutput() et readChannel().

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().

void QProcess::setNativeArguments ( const QString & arguments )

Il s'agit d'une fonction membre surchargée.

Définit l'arguments additionnel natif de la ligne de commande du programme.

Sous les systèmes d'exploitation où l'API système doit utiliser une seule chaîne de caractères pour passer l'arguments de la ligne de commande à un sous processus natif, on doit prendre en compte les lignes de commandes qui ne peuvent pas être passé par les API portables à base de liste de QProcess. Dans ces cas précis, cete fonction doit être utilisé pour définir une chaîne de caractères qui sera ajoutée à la chaîne de caractères composée de la liste des arguments avec un espace comme délimitation.

Note : cette fonction est disponible uniquement sous les plateformes Windows et Symbian.

Cette fonction a été introduite dans Qt 4.7.

Voir aussi nativeArguments().

void QProcess::setProcessChannelMode ( 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 et setReadChannel().

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() et setEnvironment().

void QProcess::setProcessState ( ProcessState state ) [protected]

Définit l'état de QProcess avec l'argument state.

Voir aussi state().

void QProcess::setReadChannel ( 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 read(), readAll(), readLine() et getChar(). Elle détermine également quel canal déclenche QProcess pour émettre readyRead().

Voir aussi readChannel().

void QProcess::setStandardErrorFile ( const QString & fileName, 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 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 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().

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 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().

void QProcess::setStandardOutputFile ( const QString & fileName, 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 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::Truncate, le fichier sera tronqué sinon (si le mode est 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().

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.

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().

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.

void QProcess::start ( const QString & program, const QStringList & arguments, OpenMode mode = ReadWrite )

Lance le programme program donné dans un nouveau processus, si aucun n'est déjà en cours d'exécution, en lui passant arguments aux arguments de la ligne de commande. L'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 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.

Note : aucune division des arguments est effectuée.

Windows : les arguments contenant des espaces sont mis entre guillemets.

Voir aussi pid(), started() et waitForStarted().

void QProcess::start ( const QString & program, 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'OpenMode est défini à mode.

bool QProcess::startDetached ( const QString & program, const QStringList & arguments, const QString & workingDirectory, 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.

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.

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.

void QProcess::started () [signal]

Le signal est émis par QProcess quand le processus a été lancé et state() retourne Running.

QProcess::ProcessState QProcess::state () const

Retourne l'état actuel du processus.

Voir aussi stateChanged() et error().

void QProcess::stateChanged ( QProcess::ProcessState newState ) [signal]

Le signal est émis lorsque l'état de QProcess change. L'argument newState est le nouvel état de QProcess.

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(), environment() et setEnvironment().

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 les exigences de sécurité de la plateforme Symbian et kill().

bool QProcess::waitForBytesWritten ( int msecs = 30000 ) [virtual]

Réimplémentation de QIODevice::waitForBytesWritten().

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().

bool QProcess::waitForReadyRead ( int msecs = 30000 ) [virtual]

Réimplémentation de QIODevice::waitForReadyRead().

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().

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().

qint64 QProcess::writeData ( const char * data, qint64 len ) [virtual protected]

Réimplémentation de QIODevice::writeData().

En relation mais non membres de la classe

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 qint64, sur Windows, il correspond à un _PROCESS_INFORMATION*.

Voir aussi QProcess::pid().

Remerciements

Merci à Mikael Sans pour la traduction et à Jonathan Courtois, Thibaut Cuvelier ainsi qu'à Jacques Thery pour leur relecture !