====== Process [En cours de Traduction Wismerheal][WSL] ======
Cet objet vous permet de lancer et manager un processus. (programme)

===== Fonctions =====

==== Process ====
Fonction de construction.

=== Syntaxe ===
<code javascript>
var myObject = new Process();
</code>
<code javascript>
var myObject = new Process(parameters);
</code>

=== Arguments ===
  - parameters - (object) les paramètres
    * workingDirectory - (string) le dossier de travail
    * processChannelMode - ([[#processchannelmode|ProcessChannelMode]]) le mode du "channel" du processus
    * readChannel - ([[#processchannel|ProcessChannel]]) le "channel" du processus à lire
    * onError - ([[#onError|onError]]) appelé quand une erreur survient
    * onFinished - ([[#onFinished|onFinished]]) appelé quand le processus est terminé
    * onReadyReadStandardError - ([[#onReadyReadStandardError|onReadyReadStandardError]]) appelé quand le processus dispose de données sur le "channel" d'erreur standard
    * onReadyReadStandardOutput - ([[#onReadyReadStandardOutput|onReadyReadStandardOutput]]) appelé quand le processus dispose de données sur le "channel" standard de sortie
    * onStarted - ([[#onStarted|onStarted]]) appellé quand le processus a commencé
    * onStateChanged - ([[#onStateChanged|onStateChanged]]) appelé quand l'état du processus a changé

=== Example ===
<code javascript>
var myObject = new Process();
</code>
<code javascript>
var myObject = new Process({
	workingDirectory: "/home/user",
	onStarted: function()
	{
		Console.print("Started!");
	},
	onFinished: function()
	{
		Console.print("Finished!");
	}
});
</code>

==== list ====
Renvoie un tableau de [[en:code:core:processhandle|ProcessHandle]] lié à tous les processus en cours d’exécution.

=== Syntaxe ===
<code javascript>
Process.list();
</code>

=== Renvoie ===
  * (array) un tableau de [[en:code:core:processhandle|ProcessHandle]] lié à tous les processus en cours d’exécution

==== thisProcess ====
Renvoi un [[en:code:core:processhandle|ProcessHandle]] lié au processus d'Actionaz.

=== Syntaxe ===
<code javascript>
Process.thisProcess();
</code>

=== Renvoie ===
  * (array) un [[en:code:core:processhandle|ProcessHandle]] lié au processus d'Actionaz

==== startDetached ====
Lance le processus en mode détaché et renvoie un [[en:code:core:processhandle|ProcessHandle]] qui lui est lié.
Vous aurez moins de contrôle sur le processus qu'en mode attaché, cependant il sera indépendant de l'actuelle exécution.

=== Syntaxe ===
<code javascript>
Process.startDetached(filename);
</code>
<code javascript>
Process.startDetached(filename, parameters);
</code>
<code javascript>
Process.startDetached(filename, parameters, workingDirectory);
</code>

=== Arguments ===
  - filename - (string) le nom de fichier/commande du processus à lancer
  - parameters - (array) un tableau de paramètres
  - workingDirectory - (string) le dossier de travail

=== Renvoie ===
  * (array) un [[en:code:core:processhandle|ProcessHandle]] lié au processus lancé

=== Exceptions ===
  * (FilenameError) nom de fichier non valide
  * (StartProcessError) ne parvient pas à lancer le processus

===== Méthodes =====

==== handle ====
Renvoie un [[en:code:core:processhandle|ProcessHandle]] lié au processus lancé.

=== Syntaxe ===
<code javascript>
myObject.handle();
</code>

=== Renvoie ===
  * ([[en:code:core:processhandle|ProcessHandle]]) un [[en:code:core:processhandle|ProcessHandle]] lié au processus lancé

==== id ====
Renvoie l'identifiant (id) du processus lancé.

=== Syntaxe ===
<code javascript>
myObject.id();
</code>

=== REnvoie ===
  * (integer) l'identifiant (id) du processus lancé

==== start ====
Lance le processus.

=== Syntaxe ===
<code javascript>
myObject.start(filename);
</code>
<code javascript>
myObject.start(filename, parameters);
</code>
<code javascript>
myObject.start(filename, parameters, openMode);
</code>

=== Arguments ===
  - filename - (string) le nom de fichier/commande du processus à lancer
  - parameters - (array) un tableau de paramètres
  - openMode - ([[#openmode|OpenMode]]) le mode d'ouverture à utiliser (défaut: lecture & écriture)

=== Renvoie ===
  * (Process) ce Processus

=== Exceptions ===
  * (FilenameError) nom de fichier non valide

==== state ====
Renvoie l'état du processus lancé.

=== Syntaxe ===
<code javascript>
myObject.state();
</code>

=== Renvoie===
  * ([[#processstate|ProcessState]]) l'état du processus lancé

==== error ====
Renvoie l'état de l'erreur du processus lancé.

=== Syntaxe ===
<code javascript>
myObject.error();
</code>

=== Renvoie ===
  * ([[#processerror|ProcessError]]) l'état de l'erreur du processus lancé

==== exitCode ====
Renvoie le code de sortie du processus.

=== Syntaxe ===
<code javascript>
myObject.exitCode();
</code>

=== Renvoie ===
  * (integer) le code de sortie du processus

==== exitStatus ====
Renvoie le statut du processus de sortie.

=== Syntaxe ===
<code javascript>
myObject.exitStatus();
</code>

=== Renvoie ===
  * ([[#exitstatus|ExitStatus]]) le statut du processus de sortie

==== readError ====
Renvoie le contenu de l’erreur de sortie standard en un [[en:code:core:rawdata|RawData]] .

=== Syntaxe ===
<code javascript>
myObject.readError();
</code>

=== Renvoie ===
  * ([[en:code:core:rawdata|RawData]]) le contenu de l’erreur de sortie standard en un [[en:code:core:rawdata|RawData]]

==== read ====
Renvoie le contenu de la sortie standard en un [[en:code:core:rawdata|RawData]] .

=== Syntaxe ===
<code javascript>
myObject.read();
</code>

=== Renvoie ===
  * ([[en:code:core:rawdata|RawData]]) le contenu de la sortie standard en un [[en:code:core:rawdata|RawData]]

==== readErrorText ====
Renvoie le contenu d'erreur  de sotie standard sous forme de texte.

=== Syntaxe ===
<code javascript>
myObject.readErrorText();
</code>
<code javascript>
myObject.readErrorText(encoding);
</code>

=== Arguments ===
  - encoding - ([[en:code:core:global#encoding|Encoding]]) l'encodage à utiliser

=== Renvoie ===
  * (string) le contenu d'erreur  de sotie standard sous forme de texte

==== readText ====
Renvoie le contenu standard de sortie sous forme de texte.

=== Syntaxe ===
<code javascript>
myObject.readText();
</code>
<code javascript>
myObject.readText(encoding);
</code>

=== Arguments ===
  - encoding - ([[en:code:core:global#encoding|Encoding]]) l'encodage à utiliser

=== Renvoie ===
  * (string) le contenu de sortie standard sous forme de texte

==== atEnd ====
Renvoie vrai si le processus n'est pas en cours d'exécution et si aucune donnée ne peut être lue.

=== Syntaxe ===
<code javascript>
myObject.atEnd();
</code>

=== Returns ===
  * (boolean) vrai si le processus n'est pas en cours d'exécution et si aucune donnée ne peut être lue

==== bytesAvailable ====
Renvoi le nombre de bytes qui peuvent être lus.

=== Syntaxe ===
<code javascript>
myObject.bytesAvailable();
</code>

=== Renvoie ===
  * (integer) le nombre de bytes qui peuvent être lus

==== bytesToWrite ====
Renvoie le nombre de bytes qui doivent toujours être écrit.

=== Syntaxe ===
<code javascript>
myObject.bytesToWrite();
</code>

=== Renvoie ===
  * (integer) le nombre de bytes qui doivent toujours être écrit

==== canReadLine ====
Renvoie vrai si une ligne peut être lue.

=== Syntaxe ===
<code javascript>
myObject.canReadLine();
</code>

=== Renvoie ===
  * (boolean) vrai si une ligne peut être lue

==== write ====
Écrit des données sur le processus.

=== Syntaxe ===
<code javascript>
myObject.write(data);
</code>

=== Arguments ===
  - data - (mixed) les données à écrire

=== Renvoie ===
  * (Process) ce Processus

==== writeText ====
Écrit du texte sur le processus.

=== Syntaxe ===
<code javascript>
myObject.writeText(text, encoding);
</code>

=== Arguments ===
  - text - (string) le texte à écrire
  - encoding - ([[en:code:core:global#encoding|Encoding]]) l'encodage à utiliser

=== Renvoie ===
  * (Process) ce Processus

==== setWorkingDirectory ====
Définit le dossier de travail. Cela ne fonctionne que sur les processus qui ne sont pas encore lancés.

=== Syntaxe ===
<code javascript>
myObject.setWorkingDirectory(workingDirectory);
</code>

=== Arguments ===
  - workingDirectory - (string) le texte à écrire

=== Renvoie ===
  * (Process) ce Processus

==== setProcessChannelMode ====
Définit le mode du "channel" du processus. Cela ne fonctionne que sur les processus qui ne sont pas encore lancés.

=== Syntaxe ===
<code javascript>
myObject.setProcessChannelMode(channelMode);
</code>

=== Arguments ===
  - channelMode - ([[#processchannelmode|ProcessChannelMode]]) le mode du "channel" du processus

=== Renvoie ===
  * (Process) ce Processus

==== setEnvironment ====
Définit les variables d'environnement du processus. Cela ne fonctionne que sur les processus qui ne sont pas encore lancés.

=== Syntaxe ===
<code javascript>
myObject.setEnvironment(environment);
</code>

=== Arguments ===
  - environment - (object) les variables d'environnement du processus

=== Renvoie ===
  * (Process) ce Processus

=== Example ===
<code javascript>
myObject.setEnvironment({
	PATH: "c:\\;c:\\path",
	MYVAR: "hello"
});
</code>

==== updateEnvironment ====
Met à jour les variables d'environnement du processus. Cela ne fonctionne que sur les processus qui ne sont pas encore lancés.

=== Syntaxe ===
<code javascript>
myObject.updateEnvironment(environment);
</code>

=== Arguments ===
  - environment - (object) les variables d'environnement du processus

=== Returns ===
  * (Process) ce Processus

=== Example ===
<code javascript>
myObject.updateEnvironment({
	PATH: "c:\\;c:\\path",
	MYVAR: "hello"
});
</code>

==== setReadChannel ====
Définit le "channel" du processus à lire. 

=== Syntaxe ===
<code javascript>
myObject.setReadChannel(channel);
</code>

=== Arguments ===
  - channel - ([[#processchannel|ProcessChannel]]) le "channel" du processus à lire

=== Renvoie ===
  * (Process) ce Processus

==== setStandardErrorFile ====
Définit le fichier d'erreur standard.

=== Syntaxe ===
<code javascript>
myObject.setStandardErrorFile(fileName);
</code>
<code javascript>
myObject.setStandardErrorFile(fileName, openMode);
</code>

=== Arguments ===
  - fileName - (string) le nom du fichier
  - channel - ([[#openmode|OpenMode]]) le mode d'ouverture du fichier (défaut: tronqué)

=== Renvoie ===
  * (Process) ce Processus

==== setStandardInputFile ====
Définit le fichier d'entrée standard.

=== Syntaxe ===
<code javascript>
myObject.setStandardInputFile(fileName);
</code>

=== Arguments ===
  - fileName - (string) le nom du fichier

=== Renvoie ===
  * (Process) ce Processus

==== setStandardOutputFile ====
Définit le fichier de sortie standard.

=== Syntaxe ===
<code javascript>
myObject.setStandardOutputFile(fileName);
</code>
<code javascript>
myObject.setStandardOutputFile(fileName, openMode);
</code>

=== Arguments ===
  - fileName - (string) le nom du fichier
  - channel - ([[#openmode|OpenMode]]) le mode d'ouverture du fichier (défaut: tronqué)

=== Renvoie ===
  * (Process) ce Processus

==== setStandardOutputProcess ====
Définit la sortie standard du processus.

=== Syntaxe ===
<code javascript>
myObject.setStandardOutputFile(process);
</code>

=== Arguments ===
  - process - (Process) la sortie du processus

=== Renvoie ===
  * (Process) ce Processus

=== Exceptions ===
  * (InvalidProcessError) processus non valide

==== waitForFinished ====
Gèle l'exécution jusqu'à ce que le processus soit terminé.

=== Syntaxe ===
<code javascript>
myObject.waitForFinished(waitTime);
</code>
<code javascript>
myObject.waitForFinished();
</code>

=== Arguments ===
  - waitTime - (integer) le temps d'attente (en millisecondes, défaut: 30000)

=== Renvoie ===
  * (Process) ce Processus

=== Exceptions ===
  * (WaitForFinishedError) l'attente de la fin d'exécution à échouée

==== waitForStarted ====
Gèle l'exécution jusqu'à ce que le processus soit lancé.

=== Syntaxe ===
<code javascript>
myObject.waitForStarted(waitTime);
</code>
<code javascript>
myObject.waitForStarted();
</code>

=== Arguments ===
  - waitTime - (integer) le temps d'attente (en millisecondes, défaut: 30000)

=== Renvoie ===
  * (Process) ce Processus

=== Exceptions ===
  * (WaitForStartedError) l'attente du lancement de l'exécution à échouée

==== waitForBytesWritten ====
Gèle l'exécution jusqu'à ce que les données soient écrites.

=== Syntaxe ===
<code javascript>
myObject.waitForBytesWritten(waitTime);
</code>
<code javascript>
myObject.waitForBytesWritten();
</code>

=== Arguments ===
  - waitTime - (integer) le temps d'attente (en millisecondes, défaut: 30000)

=== Renvoie ===
  * (Process) ce Processus

=== Exceptions ===
  * (WaitForBytesWrittenError) l'attente de l'écriture des bytes a échoué

==== waitForReadyRead ====
Gèle l'exécution jusqu'à ce que les données soient disponibles.

=== Syntaxe ===
<code javascript>
myObject.waitForReadyRead(waitTime);
</code>
<code javascript>
myObject.waitForReadyRead();
</code>

=== Arguments ===
  - waitTime - (integer) le temps d'attente (en millisecondes, défaut: 30000)

=== Renvoie ===
  * (Process) ce Processus

=== Exceptions ===
  * (WaitForReadyReadError) l'attente pour le "prêt" en lecture a échoué

==== close ====
Tente de fermer le processus de manière élégante.

=== Syntaxe ===
<code javascript>
myObject.close();
</code>

=== Renvoie ===
  * (Process) ce Processus

==== kill ====
Kill (me baby!) le processus.

=== Syntaxe ===
<code javascript>
myObject.kill();
</code>

=== Renvoie ===
  * (Process) ce Processus

==== terminate ====
Met fin au processus.

=== Syntaxe ===
<code javascript>
myObject.terminate();
</code>

=== Renvoie ===
  * (Process) ce Processus







===== Évènements =====

==== onError ====
Appelé quand une erreur survient.

=== Syntaxe ===
<code javascript>
myObject.onError = function(processError) {};
</code>

=== Arguments ===
  - processError - ([[#processerror|ProcessError]]) le processus a rencontré une erreur

=== Example ===
<code javascript>
myObject.onError = function(processError)
{
	//Event action
};
</code>

==== onFinished ====
Appelé quand le processus s'est terminé.

=== Syntaxe ===
<code javascript>
myObject.onFinished = function(exitCode, exitStatus) {};
</code>

=== Arguments ===
  - exitCode - (integer) le code de sortie du processus
  - exitStatus - ([[#exitstatus|ExitStatus]]) le statut de sortie du processus

=== Example ===
<code javascript>
myObject.onFinished = function(exitCode, exitStatus)
{
	//Event action
};
</code>

==== onReadyReadStandardError ==== (au scrabble ça fait un carton :) )
Appelé quand il n'y a pas de données disponibles sur l'erreur de sortie standard.

=== Syntaxe ===
<code javascript>
myObject.onReadyReadStandardError = function() {};
</code>

=== Example ===
<code javascript>
myObject.onReadyReadStandardError = function()
{
	//Event action
};
</code>

==== onReadyReadStandardOutput ====
Appelé quand il n'y a pas de données disponible sur la sortie standard.

=== Syntaxe ===
<code javascript>
myObject.onReadyReadStandardOutput = function() {};
</code>

=== Example ===
<code javascript>
myObject.onReadyReadStandardOutput = function()
{
	//Event action
};
</code>

==== onStarted ====
Appelé quand le processus a commencé sont exécution.

=== Syntaxe ===
<code javascript>
myObject.onStarted = function() {};
</code>

=== Example ===
<code javascript>
myObject.onStarted = function()
{
	//Event action
};
</code>

==== onStateChanged ====
Appelé quans le statut du processus a changé.

=== Syntaxe ===
<code javascript>
myObject.onStateChanged = function(newState) {};
</code>

=== Arguments ===
  - newState - ([[#processstate|ProcessState]]) le ratio du processus

=== Example ===
<code javascript>
myObject.onStateChanged = function(newState)
{
	//Event action
};
</code>

===== Enumerations =====

==== ProcessError ====
Une erreur de processus.

=== Valeurs ===
  - FailedToStart: le fichier ne peut pas être trouvé ou vous ne disposez pas des autorisations suffisantes
  - Crashed: le processus a crashé après un lancement effectué avec succès (Ariane, quand tu nous tient...)
  - Timedout: la dernière attente pour la méthode ... a échoué
  - WriteError: le processus n'est pas en cours d’exécution ou a possiblement fermé son "channel" d'entrée
  - ReadError: le processus n'est pas en cours d'exécution
  - UnknownError: une erreur inconnue est apparue

==== ExitStatus ====
Le statut de sortie.

=== Valeurs ===
  - NormalExit: le processus s'est terminé normalement
  - CrashExit: le processus a crashé

==== ProcessState ====
Le statut du processus.

=== Valeurs ===
  - NotRunning: le processus n'est pas en cours d'exécution
  - Starting: le processus est en cours de lancement
  - Running: le processus est en cours d'exécution

==== ProcessChannel ====
Un "channel" de processus.


=== Valeurss ===
  - StandardOutput: le "channel" de sortie standard
  - StandardError: le channel d'erreur de sortie standard

==== ProcessChannelMode ====
Un mode de "channel" de processus.

=== Valeurs ===
  - SeparateChannels: l'erreur standard et les "channels" de sortie sont séparés
  - MergedChannels: le "channel" d'erreur standard est redirigé vers le "channel" de sortie standard
  - ForwardedChannels: la sortie de l'ensemble des "channels" est redirigée vers le processus parent

==== OpenMode ====
Un mode d'ouverture de "channel" de processus.

=== Valeurs ===
  - ReadOnly: "channel" de processus ouvert en lecture seule
  - WriteOnly: "channel" de processus ouvert en écriture seule
  - ReadWrite: "channel" de processus ouvert en lecture et écriture
  - Truncate: "channel" de processus ouvert pour écrire, et effacer tout précédent contenu
  - Text: "channel" de processus ouvert en mode texte
  - Unbuffered: "channel" de processus ouvert en mode sans-tampon