--- /dev/null
+\chapter{Liste des commandes}
+
+Notations:
+
+<argument>: signifie que l'argument est \Mytextbf{obligatoire}.
+
+[argument]: signifie que l'argument est \Mytextbf{facultatif}.
+
+
+\section{Args}\label{cmdArgs}
+
+\begin{itemize}
+\item \util \textbf[Args()]{Args( <entier> )}.
+
+\item \desc cette fonction n'a d'effet que dans une macro, elle évalue et renvoie l'argument numéro \argu{entier} avec
+lequel la macro a été appelée. Hors de ce contexte, elle renvoie la valeur \Nil. Voir également la commande
+\Helpref{StrArgs}{cmdStrArgs}
+
+\item\exem Voir la fonction \Helpref{Nargs}{cmdNargs}.
+\end{itemize}
+
+\section{Assign}\label{cmdAssign}
+
+\begin{itemize}
+\item \util \textbf[Assign()]{Assign( <expression>, <variable>, <valeur> )}.
+
+\item \desc cette fonction évalue \argu{valeur} et l'affecte à la variable nommée \argu{variable} dans
+\argu{expression}\footnote{C'est la première occurrence de \argu{variable} dans \argu{expression} qui est assignée, car
+toutes les occurrences pointent sur la même <case mémoire>, sauf éventuellement pour les macros après l'affectation des
+paramètres.}. La fonction \textit{Assign} renvoie la valeur \Nil. Cette fonction est utile dans l'écriture de macros
+prenant une expression comme paramètre et qui doivent l'évaluer.
+
+\item \exem voici une macro \co{Bof} qui prend une fonction f(t) en paramètre et qui calcule la liste $[f(0), f(1),
+..., f(5)]$:
+\end{itemize}
+
+\centerline{\co{for \$k from 0 to 5 do Assign(\%1,t,k), \%1 od}}
+
+\%1 représente le premier paramètre de la macro (c'est à dire f(t)), la boucle: pour k allant de 0 à 5 elle exécute la
+commande [Assign(\%1, t, k), \%1], celle-ci assigne la valeur de k à la variable $t$ dans l'expression \%1, puis
+évalue
+\%1. L'exécution de \co{Bof(t\^{}2)} donne: \res{[0,1,4,9,16,25]}. L'exécution de \co{Bof(x\^{}2)} donne \Nil.
+
+\section{Attributs}\label{cmdAttributs}
+
+\begin{itemize}
+\item \util \textbf[Attributs()]{Attributs()}.
+
+\item \desc cette fonction ouvre la fenêtre permettant de modifier les attributs d'un élément graphique. Cette fonction
+renvoie la valeur 1 si l'utilisateur a choisi \textit{OK}, elle renvoie la valeur 0 s'il a choisi \textit{Cancel}. Si
+l'utilisateur a choisi \textit{OK}, alors les variables globales correspondant aux attributs sont modifiées en
+conséquence.
+\end{itemize}
+
+\section{Border}\label{cmdBorder}
+
+\begin{itemize}
+\item \util \textbf[Border()]{Border( <0/1> )}
+
+\item \desc cette fonction détermine si un cadre doit être dessiné ou non autour des marges du graphique dans les
+exportations. Lorsque la valeur de l'argument est nulle (valeur par défaut), le cadre n'est pas dessiné.
+
+Lorsque l'argument est vide, cette fonction renvoie l'état de la bordure à l'exportation (0 ou 1). Sinon, elle renvoie
+la valeur \Nil.
+\end{itemize}
+
+\section{ChangeAttr}\label{cmdChangeAttr}
+
+\begin{itemize}
+\item \util \textbf[ChangeAttr()]{ChangeAttr( <element1>, ..., <elementN> )}
+\item \desc cette fonction permet de modifier les attributs des éléments graphiques \argu{element1}, ...,
+\argu{elementN}, en leur affectant la valeur des attributs en cours. Les arguments sont interprétés comme des chaînes de
+caractères. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{Clip2D}\label{cmdClip2D}
+
+\begin{itemize}
+\item \util \textbf[Clip2D()]{Clip2D( <ligne polygonale>, <contour convexe> [, close(0/1) ] )}.
+\item \desc cette fonction clippe la \argu{ligne polygonale} qui doit être une variable contenant une liste de
+complexes, avec le \argu{contour convexe}, qui est lui aussi une liste de complexes. La fonction calcule la ligne
+polygonale qui en résulte modifie la variable \argu{ligne polygonale} en conséquence, le dernier
+agument \argu{close} ($0$ par défaut) permet de préciser si la \argu{ligne polygonale} doit être refermée ou non. La
+fonction renvoie \Nil.
+\end{itemize}
+
+\section{CloseFile}\label{cmdCloseFile}
+
+\begin{itemize}
+\item \util \textbf[CloseFile()]{CloseFile()}.
+\item \desc cette fonction permet de fermer le fichier ouvert par la commande \Helpref{OpenFile}{cmdOpenFile}.
+\end{itemize}
+
+
+\section{ComposeMatrix}\label{cmdComposeMatrix}
+
+\begin{itemize}
+\item \util \textbf[ComposeMatrix()]{ComposeMatrix( <[z1, z2, z3]> )}
+\item \desc cette fonction permet de composer la matrice courante (celle-ci affecte tous les éléments graphiques sauf
+les axes et les grilles dans la version actuelle) avec la matrice \argu{[z1, z2, z3]}. Cette matrice représente
+l'expression analytique d'une application affine du plan, c'est une liste de trois complexes: $z1$ qui est l'affixe du
+vecteur de translation, $z2$ qui est l'affixe du premier vecteur colonne de la matrice de la partie linéaire dans la
+base (1,i), et $z3$ qui est l'affixe du deuxième vecteur colonne de la matrice de la partie linéaire. Par exemple, la
+matrice de l'identité s'écrit ainsi: [0,1,i] (c'est la matrice par défaut). (Voir aussi les commandes
+\Helpref{GetMatrix}{cmdGetMatrix}, \Helpref{SetMatrix}{cmdSetMatrix}, et \Helpref{IdMatrix}{cmdIdMatrix}).
+\end{itemize}
+
+
+\section{Copy}\label{cmdCopy}
+
+\begin{itemize}
+\item \util \textbf[Copy()]{Copy( <liste>, <index depart>, <nombre> )}.
+
+\item \desc cette fonction renvoie la liste constituée par les \argu{nombre} éléments de la \argu{liste} à partir de
+l'élément numéro \argu{depart} [inclus]. Si \argu{nombre} est nul, alors la fonction renvoie tous les éléments de la
+liste à partir de l'élément numéro \argu{départ}.
+
+Si le numéro \argu{depart} est négatif, alors la liste et parcourue de droite à gauche en partant du dernier, le dernier
+élément a l'index $-1$, l'avant-dernier a l'index $-2$ $\cdots$ etc. La fonction renvoie les \argu{nombre} éléments de
+la liste (ou toute la liste si \argu{nombre} est nul) en allant vers la gauche, mais la liste renvoyée est dans le même
+sens que la \argu{liste}, et cette dernière n'est pas modifiée.
+
+\item \exem
+\begin{itemize}
+ \item \co{Copy([1,2,3,4],2,2)} renvoie \res{[2,3]}.
+ \item \co{Copy([1,2,3,4],2,5)} renvoie \res{[2,3,4]}.
+ \item \co{Copy([1,2,3,4],2,0)} renvoie \res{[2,3,4]}.
+ \item \co{Copy([1,2,3,4],-1,2)} renvoie \res{[3,4]}.
+ \item \co{Copy([1,2,3,4],-2,2)} renvoie \res{[2,3]}.
+ \item \co{Copy([1,2,3,4],-2,0)} renvoie \res{[1,2,3]}.
+\end{itemize}
+\end{itemize}
+
+\Mytextbf{NB}: pour des raisons de compatibilité avec l'ancienne version, l'index $0$ correspond aussi au dernier
+élément de la liste.
+
+\section{DefaultAttr}\label{cmdDefaultAttr}
+
+\begin{itemize}
+\item \util \textbf[DefaultAttr()]{DefaultAttr()}
+
+\item \desc cette fonction met toutes les variables correspondant aux attributs (\var{Color}, \var{Width}, ...) à leur
+valeur par défaut. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+
+\section{Del}\label{cmdDel}
+
+\begin{itemize}
+\item \util \textbf[Del()]{Del( <liste>, <depart>, <nombre> )}.
+
+\item \desc supprime de la \argu{liste} \argu{nombre} éléments à partir du numéro \argu{départ} [inclus]. Si
+\argu{nombre} est nul, alors la fonction supprime tous les éléments de la liste à partir de l'élément numéro
+\argu{départ}.
+
+
+Si le numéro \argu{depart} est négatif, alors la liste et parcourue de droite à gauche en partant du dernier. Le dernier
+élément a l'index $-1$, l'avant-dernier a l'index $-2$ $\cdots$ etc. La fonction supprime les \argu{nombre} éléments de
+la liste (ou toute la liste si \argu{nombre} est nul) en allant vers la gauche.
+
+Le paramètre \argu{liste} doit être \Mytextbf{un nom de variable}, celle-ci est modifiée et la fonction renvoie \Nil.
+
+\item \exem la commande \co{[x:=[1,2,3,4], Del(x,2,2), x]} renvoie \res{[1,4]}.
+
+La commande \co{[x:=[1,2,3,4], Del(x,-2,2), x]} renvoie \res{[1,4]}.
+
+\end{itemize}
+
+\Mytextbf{NB}: pour des raisons de compatibilité avec l'ancienne version, l'index $0$ correspond aussi au dernier
+élément de la liste.
+
+\section{Delay}\label{cmdDelay}
+
+\begin{itemize}
+\item \util \textbf[Delay()]{Delay( <nb millisecondes> )}
+
+\item \desc permet de suspendre l'exécution du programme pendant le laps de temps indiqué (en milli-secondes).
+\end{itemize}
+
+\section{DelButton}\label{cmdDelButton}
+
+\begin{itemize}
+\item \util \textbf[DelButton()]{DelButton( <texte1>, ..., <texteN> )}
+
+\item \desc Cette fonction permet de supprimer dans la colonne à gauche de la zone de dessin, les boutons portant les
+inscriptions \argu{texte1}, ..., \argu{texteN}. Si la liste est vide (\textsl{ DelButton()}), alors tous les boutons
+sont supprimés. Les arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{DelGraph}\label{cmdDelGraph}
+
+\begin{itemize}
+\item \util \textbf[DelGraph()]{DelGraph( <element1>, ..., <elementN> )}
+
+\item \desc Cette fonction permet de supprimer les éléments graphiques appelés \argu{element1}, ..., \argu{elementN}. Si
+la liste est vide (\textsl{ DelGraph()}), alors tous les éléments sont supprimés. Les arguments sont interprétés comme
+des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{DelItem}\label{cmdDelItem}
+
+\begin{itemize}
+\item \util \textbf[DelItem()]{DelItem( <nom1>, ..., <nomN> )}
+
+\item \desc Cette fonction permet de supprimer de la liste déroulante à gauche de la zone de dessin, les options
+appelées
+\argu{nom1}, ..., \argu{nomN}. Si la liste est vide (\textsl{ DelItem()}), alors toute la liste est supprimée. Les
+arguments sont interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{DelMac}\label{cmdDelMac}
+
+\begin{itemize}
+\item \util \textbf[DelMac()]{DelMac( <mac1>, ..., <macN> )}
+
+\item \desc Cette fonction permet de supprimer les macros (non prédéfinies) appelées \argu{mac1}, ..., \argu{macN}. Si
+la liste est vide (\textsl{DelMac()}), la commande est sans effet. Les arguments sont interprétés comme
+des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{DelText}\label{cmdDelText}
+
+\begin{itemize}
+\item \util \textbf[DelText()]{DelText( <texte1>, ..., <texteN> )}
+
+\item \desc Cette fonction permet de supprimer dans la colonne à gauche de la zone de dessin, les labels \argu{texte1},
+..., \argu{texteN}. Si la liste est vide (\textsl{ DelText()}), alors tous les labels sont supprimés. Les arguments sont
+interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{DelVar}\label{cmdDelVar}
+
+\begin{itemize}
+\item \util \textbf[DelVar()]{DelVar( <var1>, ..., <varN> )}
+
+\item \desc Cette fonction permet de supprimer les variables globales (non prédéfinies) appelés \argu{var1}, ...,
+\argu{varN}. Si la liste est vide (\textsl{DelVar()}), la commande est sans effet. Les arguments sont interprétés comme
+des chaînes de caractères. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+
+\section{Der}\label{cmdDer}
+
+\begin{itemize}
+\item \util \textbf[Der()]{Der( <expression>, <variable>, <liste> )}.
+
+\item \desc cette fonction calcule la dérivée de \argu{expression} par rapport à \argu{variable} et l'évalue en donnant
+à \argu{variable} les valeurs successives de la \argu{liste}. La fonction \textsl{Der} renvoie la liste des résultats.
+Mais si on a besoin de \textsl{l'expression de la dérivée}, alors on préférera la fonction \Helpref{Diff}{cmdDiff}.
+
+\item \exem
+\begin{itemize}
+\item la commande \co{Der(1/x,x,[-1,0,2] )} renvoie \res{[-1,-0.25]}.
+\item Voici le texte d'une macro appelée \co{tangente} qui prend une expression $f(x)$ en premier paramètre, une valeur
+réelle $x0$ en second paramètre et qui trace la tangente à la courbe au point d'abscisse x0:
+
+\centerline{\co{[Assign(\%1,x,\%2), \$A:=\%2+i*\%1, \$Df:=Der(\%1,x,\%2), Droite(A, A+1+i*Df)]}}
+
+On assigne la valeur $x0$ à la variable $x$ dans l'expression $f(x)$, on stocke dans une variable $A$ le point de
+coordonnées $(x0,f(x0))$ (sous forme d'affixe), on stocke dans une variable $Df$ la dérivée en $x0$ ($f'(x0)$), puis on
+trace la droite passant par $A$ et dirigée par le vecteur d'affixe $1+if'(x0)$.
+\end{itemize}
+\end{itemize}
+
+\section{Diff}\label{cmdDiff}
+
+\begin{itemize}
+\item \util \textbf[Diff()]{Diff( <nom>, <expression>, <variable> [, param1,..., paramN] )}
+
+\item \desc cette fonction permet de créer une macro appelée \argu{nom}, s'il existait déjà une macro portant ce nom,
+elle sera écrasée, sauf si c'est une macro prédéfinie auquel cas la commande est sans effet. Le corps de la macro créée
+correspond à la dérivée de \argu{expression} par rapport à \argu{variable}. Les paramètres optionnels sont des noms de
+variables, le nom de la variable \argu{param1} est remplacé dans l'expression de la dérivée par le paramètre \%1, le nom
+\argu{param2} est remplacé par \%2 ... etc. Cette fonction renvoie \Nil.
+
+\item \exem après l'exécution de la commande (dans la ligne de commande en bas de la fenêtre):
+ \co{Diff(df, sin(3*t), t)}, une macro appelée \res{df} est créée et son contenu est: \res{3*cos(3*t)}, c'est une macro
+sans paramètre qui contient une variable locale $t$, elle devra donc être utilisée en développement immédiat (c'est à
+dire
+précédée du symbole $\backslash$)\footnote{Si par exemple on veut tracer la courbe représentative de cette fonction,
+dans l'option \textit{Courbe/Paramétrée}, il faudra saisir la commande \textit{t+i*$\backslash$df} et non pas
+\textit{t+i*df(t)}.}. Par contre après la commande \co{Diff(df,sin(3*t),t,t)}, le contenu de la macro \res{df} est:
+\res{3*cos(3*\%1)} qui est une macro à un paramètre.
+\end{itemize}
+
+\section{Echange}\label{cmdEchange}
+
+\begin{itemize}
+\item \util \textbf[Echange()]{Echange( <variable1>, <variable2> )}.
+
+\item \desc cette fonction échange les deux variables, ce sont en fait les adresses qui sont échangées. Les contenus ne
+sont pas dupliqués alors qu'ils le seraient si on utilisait la commande:
+
+{\centering \co{[aux:=variable1, variable1:=variable2, variable2:=aux]}\par}
+
+ La fonction \textsl{Echange} renvoie la valeur \Nil.
+\end{itemize}
+
+\section{EpsCoord}\label{cmdEpsCoord}
+
+\begin{itemize}
+\item \util \textbf[EpsCoord()]{EpsCoord( <affixe> )}
+
+\item \desc renvoie l'affixe exportée en eps. Pour les autres, il y a les macros \Helpref{TeXCoord}{macTeXCoord} et
+\Helpref{SvgCoord}{macSvgCoord}.
+\end{itemize}
+
+\section{Eval}\label{cmdEval}
+
+\begin{itemize}
+\item \util \textbf[Eval()]{Eval( <expression> )}.
+
+\item \desc cette fonction évalue l'\argu{expression} et renvoie le résultat. L'\argu{expression} est interprétée comme
+une \Helpref{chaîne de caractères}{chaine}.
+
+\item La fonction \Helpref{{Input}}{cmdInput} renvoie la saisie sous forme d'une chaîne dans la macro appelée
+\textit{chaine()}. La fonction \textsl{Eval} évalue cette chaîne (comme n'importe quelle commande TeXgraph) et renvoie
+le résultat.
+
+\item \exem voici une commande demandant une valeur à l'utilisateur pour une variable \textit{x}:
+\end{itemize}
+
+\begin{verbatim}
+ if Input("x=", "Entrez une valeur pour x", x )
+ then x:= Eval( chaine() )
+ fi
+\end{verbatim}
+
+
+\section{Exec}\label{cmdExec}
+
+\begin{itemize}
+\item \util \textbf[Exec()]{Exec( <programme> [, argument(s), répertoire de travail, attendre] )}.
+
+\item \desc cette fonction permet d'exécuter un \argu{programme} (ou un script) en précisant éventuellement des
+\argu{arguments} et un \argu{répertoire de travail}, ces trois arguments sont interprétés comme des chaînes de
+caractères. Le dernier argument doit valoir 0 (par défaut) ou 1, il indique si le programme attend ou non la fin du
+processus fils. La fonction renvoie la valeur \Nil. Un message d'erreur s'affiche lorsque: les ressources sont
+insuffisantes, ou bien le programme est invalide, ou bien le chemin est invalide.
+
+\item La macro-chaîne prédéfinie @TmpPath contient le chemin vers un répertoire temporaire. La macro \textit{Apercu}
+exporte le graphique courant dans ce dossier au format pgf dans le fichier \textit{file.pgf}, puis elle exécute
+\textit{pdflatex} sur le fichier \textit{apercu.tex}, puis attend la fin de l'exécution avant de lancer le lecteur de
+pdf.
+
+\item \exem la macro \textsl{Apercu} contenue dans interface.mac est:
+\end{itemize}
+
+\begin{verbatim}
+ [Export(pgf,[@TmpPath,"file.pgf"] ),
+ Exec("pdflatex", ["-interaction=nonstopmode apercu.tex"],@TmpPath,1),
+ Exec(@PdfReader,"apercu.pdf",@TmpPath,0)
+ ]
+\end{verbatim}
+
+\section{Export}\label{cmdExport}
+
+\begin{itemize}
+\item \util \textbf[Export()]{Export( <mode>, <fichier> )}.
+
+\item \desc cette fonction permet d'exporter le graphique en cours, \argu{mode} est une valeur numérique qui peut être
+l'une
+des constantes suivantes: tex, pst, pgf, tkz, eps, psf, pdf, epsc, pdfc, svg, bmp, obj, geom, jvx ou teg. L'exportation
+se fait dans \argu{fichier} qui contient donc le nom du fichier, avec éventuellement le chemin.
+
+La macro prédéfinie @TmpPath contient le chemin vers un répertoire temporaire. La macro \textit{Apercu}
+exporte le graphique courant dans ce dossier au format pgf dans le fichier \textit{file.pgf}, puis elle exécute
+\textit{pdflatex} sur le fichier \textit{apercu.tex}, puis attend la fin de l'exécution avant de lancer le lecteur de
+pdf.
+
+\item \exem la macro \textsl{Apercu} contenue dans interface.mac est:
+\end{itemize}
+
+\begin{verbatim}
+ [Export(pgf,[@TmpPath,"file.pgf"] ),
+ Exec("pdflatex", ["-interaction=nonstopmode apercu.tex"],@TmpPath,1),
+ Exec(@PdfReader,"apercu.pdf",@TmpPath,0)
+ ]
+\end{verbatim}
+
+\section{ExportObject}\label{cmdExportObject}
+
+\begin{itemize}
+ \item \textbf[ExportObject()]{ExportObject( <argument> )}
+ \item \desc cette commande n'a d'effet que pendant un export. Elle permet d'exporter l'\argu{argument} dans le fichier
+de sortie, cet \argu{argumet} est soit le nom d'un élément graphique, soit une commande graphique (comme pour la
+fonction \Helpref{Get}{cmdGet}). Elle peut-être utile pour écrire des exports personnalisés, ceci est décrit dans
+\Helpref{cette section}{cmdMyExport}.
+\end{itemize}
+
+\section{Fenetre}\label{cmdFenetre}
+
+\begin{itemize}
+\item \util \textbf[Fenetre()]{Fenetre( <A>, <B> [, C] )}.
+\item \desc cette fonction modifie la fenêtre graphique, c'est l'équivalent de l'option \textit{Paramètres/Fenêtre},
+\Mytextbf{sauf que les éléments graphiques ne sont pas automatiquement recalculés}. Le paramètre \argu{A} et le
+paramètre \argu{B} sont les affixes de deux coins de la fenêtre diamétralement opposés, et le paramètre facultatif
+\argu{C} représente les deux échelles, plus précisément, la partie réelle de \argu{C} est l'échelle [en cm] sur l'axe
+des abscisses et la partie imaginaire de \argu{C} est l'échelle [en cm] sur l'axe des ordonnées, ces deux valeurs
+doivent être strictement positives. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{Free}\label{cmdFree}
+
+\begin{itemize}
+\item \util \textbf[Free()]{Free( <expression>, <variable>}.
+\item \desc cette fonction renvoie $1$ si l'\argu{expression} contient la \argu{variable}, $0$ sinon. Lorsque le
+deuxième argument n'est pas un nom de variable, la fonction renvoie \Nil.
+\end{itemize}
+
+\section{Get}\label{cmdGet}
+
+\begin{itemize}
+\item \util \textbf[Get()]{Get( <argument> [, clip(0/1)] )}.
+\item \desc lorsque le paramètre \argu{argument} est un \textit{identificateur}, la fonction cherche s'il y a un
+élément graphique dont le nom est \argu{argument}, si c'est le cas, alors la fonction renvoie la liste des points de cet
+élément graphique, sinon elle renvoie la valeur \Nil. Dans ce cas l'argument optionnel est ignoré.
+
+Lorsque \argu{argument} n'est pas un identificateur, celui-ci est considéré comme une \textit{fonction graphique}, la
+fonction \textsl{Get} renvoie la liste des points de l'élément graphique construit par cette fonction graphique mais
+sans créer l'élément en question. L'argument optionnel \argu{clip} (qui vaut $1$ par défaut) indique si l'élément doit
+être clippé par la fenêtre courante (valeur 1) ou non (valeur 0).
+
+Lorsque l'argument est vide: \textsl{Get()}, la fonction renvoie la liste des points de tous les éléments graphiques
+déjà construits, ceux qui sont cachés sont ignorés.
+
+\item \exem \co{Get(Cercle(0,1))} renvoie la liste des points du cercle de centre 0 et de rayon 1 mais sans créer ce
+cercle, la liste des points est clippée par la fenêtre graphique.
+
+\item \exem utilisation des points d'un objet graphique:
+\end{itemize}
+
+\begin{demo}{Get}{Get}
+\begin{texgraph}[name=Get,export=pgf,file]
+Cmd view(0,6.25,-1.5,2);
+ size(7.5);
+ [tMin:=0, tMax:=6.25];
+Graph axe = Axes(0,1+i);
+ C1 = [Color:=blue,Width:=8,
+ Cartesienne(1/x) ];
+ C2 = [Color:=red,Width:=8,
+ Cartesienne(sin(2*x)*1.5)];
+ inter = [DotScale:=2,DotStyle:=dotcircle,
+ Color:=forestgreen,
+ Point(Get(C1) InterL Get(C2)),
+ Color:=blue,
+ LabelDot(5.5+0.1*i,"$C_1$","N"),
+ Color:=red,
+ LabelDot(3-i,"$C_2$","E"),
+ ];
+\end{texgraph}
+\end{demo}
+
+
+\section{GetAttr}\label{cmdGetAttr}
+
+\begin{itemize}
+\item \util \textbf[GetAttr()]{GetAttr( <argument> )}
+
+\item \desc lorsque le paramètre \argu{argument} est un \textit{identificateur}, la fonction cherche s'il y a un
+élément graphique dont le nom est \argu{argument}, si c'est le cas, alors les attributs de cet élément graphique
+deviennent les attributs courants, et la fonction renvoie la valeur \Nil. Sinon, l'argument est interprété comme une
+chaîne de caractères puis la fonction
+effectue la même recherche.
+\end{itemize}
+
+\section{GetMatrix}\label{cmdGetMatrix}
+
+\begin{itemize}
+\item \util \textbf[GetMatrix()]{GetMatrix()}
+
+\item \desc cette fonction renvoie la matrice courante. (Voir aussi les commandes
+\Helpref{ComposeMatrix}{cmdComposeMatrix}, \Helpref{SetMatrix}{cmdSetMatrix}, et \Helpref{IdMatrix}{cmdIdMatrix})
+\end{itemize}
+
+\section{GetSpline}\label{cmdGetSpline}
+
+\begin{itemize}
+\item \util \textbf[GetSpline()]{GetSpline(<V0>, <A0>,..., <An>, <Vn> )}
+\item \desc renvoie la liste des points de contrôle correspondant à la spline cubique passant par les points
+\argu{A0} jusqu'à \argu{An}. \argu{V0} et \argu{Vn} désignent les vecteurs vitesses aux extrémités [contraintes], si
+l'un d'eux est nul alors l'extrémité correspondante est considérée comme libre (sans contrainte). Le résultat doit être
+dessiné avec la commande graphique \Helpref{Bezier}{cmdBezier}.
+\end{itemize}
+
+
+\section{GrayScale}\label{cmdGrayScale}
+
+\begin{itemize}
+\item \util \textbf[GrayScale()]{GrayScale(0/1)} ou \textbf[GrayScale()]{GrayScale()}.
+
+\item \desc cette fonction permet d'activer ou désactiver la conversion des couleurs en niveaux de gris. Elle équivaut à
+l'option \textsl{Paramètres/Gérer les couleurs} du menu de l'interface graphique.
+
+Lorsque l'argument est vide, la fonction renvoie l'état actuel de la conversion en niveaux de gris (0 ou 1). Sinon, elle
+renvoie \Nil.
+\end{itemize}
+
+\section{HexaColor}\label{cmdHexaColor}
+
+\begin{itemize}
+\item \util \textbf[HexaColor()]{HexaColor( <valeur héxadécimale> )}
+
+\item \desc cette fonction renvoie la couleur correspondant à la \argu{valeur héxadécimale}, cette valeur doit être
+passée sous forme d'une chaîne de caractères. Voir aussi la commande \Helpref{Rgb}{cmdRgb}.
+
+\item \exem \verb Color:=HexaColor("F5F5DC") .
+\end{itemize}
+
+\section{Hide}\label{cmdHide}
+
+\begin{itemize}
+\item \util \textbf[Hide()]{Hide( <element1>, ..., <elementN> )}
+
+\item \desc Cette fonction permet de cacher les éléments graphiques appelés \argu{element1}, ..., \argu{elementN} en
+mettant leur attribut \textsl{IsVisible} à false. Les arguments sont interprétés comme des chaînes de caractères. Cette
+fonction renvoie la valeur \Nil.
+
+Pour tout cacher on invoque la commande sans arguments: \textsl{Hide()}.
+
+Pour tout cacher sauf un ou plusieurs éléments, on invoque la commande: \textsl{Hide(except, element1, ..., elementN)}.
+Voir aussi la commande \Helpref{Show}{cmdShow}.
+\end{itemize}
+
+\section{IdMatrix}\label{cmdIdMatrix}
+
+\begin{itemize}
+\item \util \textbf[IdMatrix()]{IdMatrix()}
+\item \desc change la matrice courante en la matrice identité. (Voir aussi les commandes
+\Helpref{ComposeMatrix}{cmdComposeMatrix}, \Helpref{SetMatrix}{cmdSetMatrix}, et \Helpref{GetMatrix}{cmdGetMatrix})
+\end{itemize}
+
+
+
+\section{Input}\label{cmdInput}
+
+\begin{itemize}
+\item \util \textbf[Input()]{Input( <message> [, titre, chaîne] )}.
+\item \desc cette fonction ouvre une boite de dialogue avec \argu{titre} dans la barre de titre (par défaut le titre
+est vide), et dans laquelle le paramètre \argu{message} est affiché, le paramètre \argu{chaîne} est affiché dans la zone
+de saisie. Ces paramètres sont donc interprétés comme des \Helpref{chaînes de caractères}{chaine}, l'utilisateur est
+invité à faire une saisie. S'il valide alors la fonction \textsl{Input} renvoie la valeur $1$ et la chaîne saisie est
+\Mytextbf{mémorisée dans la macro} \textsl{chaine()}. Si l'utilisateur ne valide pas ou si la chaîne saisie est vide,
+alors la fonction \textsl{Input} renvoie la valeur $0$.
+\item \exem voir la fonction \Helpref{Eval}{cmdEval}.
+\end{itemize}
+
+\section{InputMac}\label{cmdInputMac}
+
+\begin{itemize}
+\item \util \textbf[InputMac()]{InputMac( <nom de fichier> )} ou \textbf[Load()]{Load( <nom de fichier> )}.
+\item \desc cette fonction permet de charger en mémoire un fichier de macros (\textit{*.mac}), ou un fichier modèle
+(\textit{*.mod}), ou tout fichier source texgraph (\textit{*.teg}).
+
+Dans le premier cas (fichier \textit{*.mac}), les variables globales et les macros seront considérées comme
+\Mytextbf{prédéfinies} (elles n'apparaissent pas à l'écran, elles ne seront pas
+enregistrées avec le graphique, mais elles sont effacées de la mémoire dès qu'on commence un nouveau graphique). Le
+paramètre \argu{nom de fichier} est une chaîne de caractères représentant le fichier à charger avec éventuellement son
+chemin. Cette fonction renvoie \Nil, et si ce fichier était déjà chargé, alors elle est sans effet. Si le fichier à
+charger est dans le répertoire \textit{macros} de \textit{TeXgraph}, ou dans le dossier \textit{TeXgraphMac}, alors il
+est inutile de préciser le chemin.
+\item \exem \co{InputMac("MesMacros.mac")}.
+\end{itemize}
+
+\section{Inc}\label{cmdInc}
+
+\begin{itemize}
+\item \util \textbf[Inc()]{Inc( <variable>, <expression> )}.
+\item \desc cette fonction évalue \argu{expression} et ajoute le résultat à \argu{variable}. Cette fonction est plus
+avantageuse que la commande \co{variable := variable + expression}, car dans cette commande la \argu{variable} est
+évaluée [c'est à dire dupliquée] pour calculer la somme. La fonction \textsl{Inc} renvoie la valeur \Nil.
+\end{itemize}
+
+
+\section{Insert}\label{cmdInsert}
+
+\begin{itemize}
+\item \util \textbf[Insert()]{Insert( <liste1>, <liste2> [, position] )}.
+\item \desc cette fonction insère la \argu{liste2} dans la \argu{liste1} à la position numéro \argu{position}. Lorsque
+la position vaut 0 [valeur par défaut]. La \argu{liste2} est ajoutée à la fin. La \argu{liste1} doit être une variable
+et celle-ci est modifiée. La fonction \textsl{Insert} renvoie la valeur \Nil.
+\item \exem si une variable $L$ contient la liste \co{[1,4,5]}, alors après la commande \co{Insert(L,[2,3],2)}, la
+variable $L$ contiendra la liste \res{[1,2,3,4,5]}.
+\end{itemize}
+
+\section{Int}\label{cmdInt}
+
+\begin{itemize}
+\item \util \textbf[Int()]{Int( <expression>, <variable>, <borne inf.>, <borne sup.> )}.
+\item \desc cette fonction calcule l'intégrale de \argu{expression} par rapport à \argu{variable} sur l'intervalle
+\Mytextbf{réel} défini par \argu{borne inf.} et \argu{borne sup}. Le calcul est fait à partir de la méthode de
+\textsc{Simpson} accélérée deux fois avec la méthode de \textsc{Romberg}, \argu{expression} est supposée définie et
+suffisamment régulière sur l'intervalle d'intégration.
+\item \exem \co{Int(exp(sin(u)),u,0,1)} donne \res{1.63187} (Maple donne 1.631869608).
+\end{itemize}
+
+\section{IsMac}\label{cmdIsMac}
+
+\begin{itemize}
+\item \util \textbf[IsMac()]{IsMac( <nom> )}.
+\item \desc cette fonction permet de savoir s'il y a une macro appellée \argu{nom}. Elle renvoie $1$ si c'est
+le cas, $0$ sinon.
+\end{itemize}
+
+\section{IsVar}\label{cmdIsVar}
+
+\begin{itemize}
+\item \util \textbf[IsVar()]{IsVar( <nom> )}.
+\item \desc cette fonction permet de savoir s'il y a une variable globale appellée \argu{nom}. Elle renvoie $1$ si c'est
+le cas, $0$ sinon.
+\end{itemize}
+
+\section{Liste}\label{cmdListe}
+
+\begin{itemize}
+\item \util \textbf[Liste()]{Liste( <argument1>, ..., <argumentn> )} ou bien \Mytextbf{[<argument1>, ...,
+<argumentn>]}.
+\item \desc cette fonction évalue chaque argument et renvoie la liste des résultats \Mytextbf{différents de \Nil}.
+\item \exem \co{Liste(1, Arg(1+2*i), sqrt(-1), Solve(cos(x)-x,x,0,1))} renvoie le résultat
+\res{[1,1.107149,0.739085]}.
+\end{itemize}
+
+\section{ListFiles}\label{cmdListFiles}
+
+\begin{itemize}
+\item \util \textbf[ListFiles()]{ListFiles()}.
+\item \desc cette fonction est disponible seulement dans la version GUI de TeXgraph, elle s'utilise dans la barre de
+commande en bas de la fenêtre, elle affiche alors la liste des fichiers de macros (\textit{*.mac}) chargés en mémoire.
+\end{itemize}
+
+\section{LoadImage}\label{cmdLoadImage}
+
+\begin{itemize}
+\item \util \textbf[LoadImage()]{LoadImage( <image> )}.
+\item \desc cette fonction charge le fichier \argu{image}, qui doit être une image png, jpeg ou bmp. Celle-ci est
+affichée en image de fond et fait partie du graphique, en particulier elle est exportée dans les formats tex (visible
+seulement dans la version postscript), pgf, pst et teg. Pour le format pgf c'est la version png ou jpg qui sera dans le
+document, mais pour les versions pst et tex il faut une version eps de l'image. L'argument est interprêté comme une
+chaîne de caractères, et la fonction renvoie la valeur \Nil.
+
+Lors du chargement, la taille de l'image est adaptée à la fenêtre, mais celle-ci peut être modifiée de manière à
+conserver les proportions de l'image. Dès lors la position de l'image et sa taille sont fixées. On peut ensuite élargir
+la fenêtre si on ne veut pas que l'image occupe tout l'espace. Pour modifier la position ou la taille de l'image, il
+faut recharger celle-ci.
+\end{itemize}
+
+
+\section{Loop}\label{cmdLoop}
+
+\begin{itemize}
+\item \util \textbf[Loop()]{Loop( <expression>, <condition> )}.
+\item \desc cette fonction est une \Mytextbf{boucle} qui construit une liste en évaluant \argu{expression} et
+\argu{condition} jusqu'à ce que le résultat de \argu{condition} soit égal à 1 (pour \textit{True}) ou \Nil, la fonction
+\textsl{Loop} renvoie alors la liste des résultats de \argu{expression}. Cette commande est la représentation interne de
+la boucle \Helpref{{repeat}}{cmdrepeat} dont l'utilisation est préférable pour des raisons de lisibilité.
+\item \exem les commandes (équivalentes):
+
+\centerline{\co{[n:=1, m:=1, n, Loop([ aux:=n, n:=m, m:=aux+n, n], m>100)]}}
+
+ou encore
+
+\centerline{\co{[n:=1, m:=1, n, while m<=100 do aux:=n, n:=m, m:=aux+n, n od]}}
+
+ou encore
+
+\centerline{\co{[n:=1, m:=1, n, repeat aux:=n, n:=m, m:=aux+n, n until m>100 od]}}
+
+renvoient la liste: \res{[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]} (termes d'une suite de \textsc{Fibonacci} inférieurs à
+100).
+\end{itemize}
+
+\section{Map}\label{cmdMap}
+
+\begin{itemize}
+\item \util \textbf[Map()]{Map( <expression>, <variable>, <liste> [, mode] )}.
+\item \desc cette fonction est une \Mytextbf{boucle} qui construit une liste de la manière suivante: \argu{variable}
+parcourt les éléments de \argu{liste} et pour chacun d'eux \argu{expression} est évaluée, la fonction \textsl{Map}
+renvoie la liste des résultats. Cette commande est la représentation interne de la boucle \Helpref{{for}}{cmdfor} dont
+l'utilisation est préférable pour des raisons de lisibilité.
+
+Le paramètre optionnel \argu{mode} est un complexe qui vaut \Nil par défaut, lorsque \argu{mode}$=a+ib$, alors:
+ \begin{itemize}
+ \item si $a$ est un entier et $b=0$: les éléments de la \argu{liste} sont traités de $a$ en $a$,
+ \item si $a$ est un entier et $b=1$: la \argu{liste} est traitée par composante (deux composantes sont séparées
+par la constante \jump) et les éléments de chaque composante sont traités par paquets complets de $a$ éléments, lorsque
+la constante \jump est rencontrée dans la liste, celle-ci est renvoyée dans le résultat. Un paquet non complet n'est pas
+traité.
+ \item si $a$ est un entier et $b=-1$: la \argu{liste} est traitée par composante (deux composantes sont séparées
+par la constante \jump) et les éléments de chaque composante sont traités par paquets complets de $a$ éléments, lorsque
+la constante \jump est rencontrée dans la liste, celle-ci n'est pas renvoyée dans le résultat. Un paquet non complet
+n'est pas traité.
+ \item si $a=$Re(jump): la \argu{liste} est traitée par composante (deux composantes sont séparées par la
+constante \jump), lorsque la constante \jump est rencontrée dans la liste, celle-ci est renvoyée dans le résultat si
+$b=1$ et n'est pas renvoyée si $b=-1$.
+
+ \item \exem voir la boucle \Helpref{for}{cmdfor} pour des exemples.
+ \end{itemize}
+
+
+\item \exem si $L$ est une variable contenant une liste de points, alors la commande:
+ \begin{itemize}
+ \item \co{[sum:=0, Map( Inc(sum,z), z, L), sum]} renvoie la somme des éléments de $L$.
+ \item la commande \co{Map(z*exp(i*$\pi$/3), z, L)} renvoie la liste des images des points de $L$ par la rotation
+de centre O d'angle $\pi$/3.
+ \end{itemize}
+\end{itemize}
+
+\section{Marges}\label{cmdMarges}
+
+\begin{itemize}
+\item \util \textbf[Marges()]{Marges( <gauche>, <droite>, <haut>, <bas> )}
+\item \desc cette fonction permet de fixer les marges autour du dessin (en cm). Les nouvelles valeurs sont copiées dans
+les constantes \var{margeG}, \var{margeD}, \var{margeH} et \var{margeB}.
+\end{itemize}
+
+
+\section{Merge}\label{cmdMerge}
+
+\begin{itemize}
+\item \util \textbf[Merge()]{Merge( <liste> )}.
+\item \desc cette fonction permet de recoller des morceaux de listes pour avoir des composantes de longeur maximale,
+elle renvoie la liste qui en résulte.
+\item \exem \co{Merge([1, 2, jump, 3, 5, jump, 3, 4, 2] )} renvoie \res{[1, 2, 3, 4, 5]}. Et \co{Merge( [1, 2, jump, 3,
+5, jump, 3, 4] )} renvoie \res{[1, 2, jump, 4, 3, 5]}.
+
+Attention: pour que deux extrêmités soient recollées elles doivent être égales pour la machine.
+\end{itemize}
+
+
+\section{Message}\label{cmdMessage}
+
+\begin{itemize}
+\item \util \textbf[Message()]{Message( <chaîne> )}.
+\item \desc cette fonction affiche le paramètre \argu{chaîne} [qui est donc interprété comme une \Helpref{chaîne de
+caractères}{chaine}] dans une fenêtre. Quand l'utilisateur a cliqué sur \textit{OK}, la fenêtre se referme et la
+fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{Move}\label{cmdMove}
+
+\begin{itemize}
+\item \util \textbf[Move()]{Move( <element1>, ..., <elementN> )}.
+\item \desc cette fonction ne s'applique qu'aux éléments graphiques créés en mode NotXor, ce qui correspond à la valeur
+1 de la variable \Helpref{PenMode}{cmdPenMode}. Elle redessine les éléments graphiques \argu{element1}, ...,
+\argu{elementN}, puis les recalcule, puis les redessine, et elle renvoie la valeur \Nil.
+
+Lorsqu'on redessine un élément graphique créé en mode NotXor, il s'efface en restituant le fond, on peut alors modifier
+sa position et le redessiner. Cette technique permet de faire glisser des objets sans avoir à réafficher tous les autres
+(ce qui évite d'avoir une image qui saute).
+\item\exem voir la fonction \Helpref{Stroke}{cmdStroke}.
+\end{itemize}
+
+\section{Mtransform}\label{cmdMtransform}
+
+\begin{itemize}
+\item \util \textbf[Mtransform()]{Mtransform( <liste>, <matrice> )}.
+\item \desc cette fonction applique la \argu{matrice} à la \argu{liste} et renvoie le résultat. Si la \argu{liste}
+contient la constante \jump, celle-ci est renvoyée dans le résultat sans être modifiée. La \argu{matrice} représente
+l'expression analytique d'une application affine du plan, c'est une liste de trois complexes $[z1,z2,z3]$: $z1$ est
+l'affixe du vecteur de translation, $z2$ est l'affixe du premier vecteur colonne de la matrice de la partie linéaire
+dans la base (1,i), et $z3$ est l'affixe du deuxième vecteur colonne de la matrice de la partie linéaire. Par
+exemple, la matrice de l'identité s'écrit ainsi: [0,1,i] (c'est la matrice par défaut).
+\end{itemize}
+
+\section{MyExport}
+
+\begin{itemize}
+ \item \textbf[MyExport()]{MyExport( <"nom">, <paramètre 1>, ..., <paramètre n> )} ou \textbf[draw()]{draw(
+<"nom">, <paramètre 1>, ..., <paramètre n> )}
+ \item \desc cette commande permet d'ajouter de nouveaux éléments graphiques avec un export personnalisé. Elle est
+décrite dans \Helpref{cette section}{cmdMyExport}.
+\end{itemize}
+
+\section{Nargs}\label{cmdNargs}
+
+\begin{itemize}
+\item \util \textbf[Nargs()]{Nargs()}.
+\item \desc cette fonction n'a d'effet que dans une macro, elle renvoie le nombre d'arguments avec lesquels la macro a
+été appelée. Hors de ce contexte, elle renvoie la valeur \Nil. Voir aussi la fonction \Helpref{Args}{cmdArgs}.
+\item\exem voici le corps d'une macro \textit{MyLabel(affixe1, texte1, affixe2, texte2, ...)} prenant un nombre
+indéterminé d'arguments:
+\end{itemize}
+
+\begin{verbatim}
+ for $k from 1 to Nargs()/2 do
+ Label(Args(2*k-1), Args(2*k))
+ od
+\end{verbatim}
+
+\section{NewButton}\label{cmdNewButton}
+
+\begin{itemize}
+\item \util \textbf[NewButton()]{NewButton( <Id>, <nom>, <affixe>, <taille>, <commande> [, aide] )}.
+\item \desc cette fonction crée dans la zone grisée à gauche dans la fenêtre un bouton dont le numéro d'identification
+est \Mytextbf{l'entier} \argu{Id}, le texte figurant sur le bouton est le paramètre \argu{nom} qui est donc interprété
+comme une \Helpref{chaîne de caractères}{chaine}, la position du coin supérieur gauche est donnée par le paramètre
+\argu{affixe} qui doit être de la forme X+i*Y avec X et Y \Mytextbf{entiers} car ce sont des coordonnées en
+\Mytextbf{pixels}, la taille du bouton est donnée par le paramètre \argu{taille} qui doit être de la forme
+\textit{long+i*haut} où \textit{long} désigne la longueur du bouton en pixels et \textit{haut} la hauteur (ce sont donc
+des entiers), le paramètre \argu{commande} est interprété comme une chaîne de caractères, c'est la commande associée au
+bouton, chaque clic provoquera l'exécution de cette commande. Le dernier paramètre \argu{aide} est facultatif, il
+contient le message de la bulle d'aide s'affichant lorsque la souris passe au-dessus du bouton.
+
+Si on crée un bouton dont le numéro d'identification est déjà pris, alors l'ancien bouton est détruit \Mytextbf{sauf si
+c'est un bouton prédéfini} (c'est à dire créé au démarrage). \`A chaque changement de fichier, les boutons non
+prédéfinis sont détruits. La fonction \Mytextbf{NewButton} renvoie la valeur \Nil.
+\end{itemize}
+
+\section{NewGraph}\label{cmdNewGraph}
+
+\begin{itemize}
+\item \util \textbf[NewGraph()]{NewGraph( <chaîne1>, <chaîne2> [, code] )}.
+
+\item \desc cette fonction crée un élément graphique \textsl{Utilisateur} ayant pour nom: \argu{chaîne1} et défini par
+la commande: \argu{chaîne2}. Les deux arguments sont donc interprétés comme des chaînes de caractères. Cette fonction
+renvoie la valeur \Nil. S'il existait déjà un élément graphique portant le même nom, alors celui-ci est écrasé.
+L'élément graphique est créé mais non dessiné, c'est la fonction \textsl{ReDraw()} qui permet de mettre l'affichage à
+jour.
+
+Le troisième paramètre \argu{code} est un entier positif (optionnel), un clic gauche avec la souris sur l'élément
+graphique créé dans la liste des éléments graphiques, provoquera l'exécution de la macro spéciale \textsl{ClicGraph(
+<code> )}, cette macro n'existe pas par défaut et peut-être créée par l'utilisateur, elle est utilisée en particulier
+dans le fichier modèle \textit{Mouse.mod} (dessin à la souris).
+
+\item Supposons que l'utilisateur clique sur le point d'affixe 1+i, alors une fenêtre de dialogue s'ouvre avec le
+message \textsl{Label=} et une ligne de saisie à remplir. Supposons que l'utilisateur entre la chaîne \textsl{Test} et
+valide, alors la macro va créer un élément graphique \textsl{utilisateur} portant le nom \textsl{Label1} et défini par
+la commande \co{Label(1+i,"Test")}.
+
+\item On peut aussi utiliser la macro prédéfinie \textsl{NewLabel} et définir la macro \textsl{ClicG()}
+en écrivant simplement: \co{NewLabel(\%1) }.
+
+\item \exem voici une macro \textsl{ClicG()} permettant la création "à la volée" de labels, on a créé auparavant
+ une variable globale \textsl{num} initialisée à 1:
+\end{itemize}
+
+\begin{verbatim}
+ if Input("Label=")
+ then NewGraph( ["Label",num], ["Label(", %1,",", """",chaine(),""")"] ),
+ ReDraw(), Inc(num,1)
+ fi
+\end{verbatim}
+
+\section{NewItem}\label{cmdNewItem}
+
+\begin{itemize}
+\item \util \textbf[NewItem()]{NewItem( <nom>, <commande> )}.
+\item \desc cette fonction ajoute dans la liste déroulante de la zone grisée à gauche dans la fenêtre, un item appelé
+\argu{nom}, le deuxième paramètre \argu{commande} est la commande associée à l'item, chaque sélection de l'item
+provoquera l'exécution de cette commande. Les deux arguments sont interprétés comme des chaînes de caractères. S'il
+existe déjà un item portant le même nom, alors l'ancien est détruit \Mytextbf{sauf si c'est un item prédéfini} (c'est à
+dire créé au démarrage). À chaque changement de fichier, les items non prédéfinis sont détruits. La fonction
+\textsl{NewItem} renvoie la valeur \Nil.
+\end{itemize}
+
+\section{NewMac}\label{cmdNewMac}
+
+\begin{itemize}
+\item \util \textbf[NewMac()]{NewMac( <nom>, <corps> [, param1, $\ldots$, paramN])}.
+\item \desc cette fonction crée une macro appelée \argu{nom} et dont le contenu est \argu{corps}. Les deux arguments
+sont donc interprétés comme des chaînes de caractères. Les paramètres optionnels sont des noms de variables, le nom de
+la variable \argu{param1} est remplacé dans l'expression de la macro par le paramètre \%1, le nom \argu{param2} est
+remplacé par \%2 $\ldots$ etc. Cette fonction renvoie la valeur \Nil. S'il existait déjà une macro portant le même nom,
+alors celui-ci est écrasée \Mytextbf{si elle n'est pas prédéfinie}. Si le nom n'est pas valide, ou s'il y a déjà une
+macro prédéfinie portant ce nom, ou si l'expression \argu{corps} n'est pas correcte, alors la fonction est sans effet.
+\end{itemize}
+
+\section{NewVar}\label{cmdNewVar}
+\begin{itemize}
+\item \util \textbf[NewVar()]{NewVar( <nom>, <expression> )}.
+\item \desc cette fonction crée une variable globale appelée \argu{nom} et dont la valeur est \argu{expression}. Les
+deux arguments sont donc interprétés comme des chaînes de caractères. Cette fonction renvoie la valeur \Nil. S'il
+existait déjà une variable portant le même nom, alors celle-ci est écrasée. Si le nom n'est pas valide, ou s'il y a déjà
+une constante portant ce nom, alors la fonction est sans effet. Si \argu{expression} n'est pas correcte, alors la valeur
+affectée à la variable sera \Nil.
+\end{itemize}
+
+
+\section{Nops}\label{cmdNops}
+\begin{itemize}
+\item \util \textbf[Nops()]{Nops( <liste> )}.
+\item \desc cette fonction évalue \argu{liste} et renvoie le nombre de complexes qui la composent.
+\item \exem \co{Nops([1,2,3] )} renvoie la valeur \res{3}.
+\end{itemize}
+
+\section{NotXor}\label{cmdNotXor}
+
+\begin{itemize}
+\item \util \textbf[NotXor()]{NotXor( <element1>, ..., <elementN> )}.
+\item \desc cette fonction ne s'applique qu'aux éléments graphiques créés en mode normal, ce qui correspond à la valeur
+0 de la variable \Helpref{PenMode}{cmdPenMode}. Elle change le mode des éléments graphiques \argu{element1}, ...,
+\argu{elementN} en mode NotXor puis les recalcule, et elle renvoie la valeur \Nil.
+
+Lorsqu'on redessine un élément graphique qui est en mode NotXor, il s'efface en restituant le fond, on peut alors
+modifier sa position et le redessiner. Cette technique permet de faire glisser des objets sans avoir à réafficher tous
+les autres (ce qui évite d'avoir une image qui saute).
+\item\exem voir la fonction \Helpref{Move}{cmdMove}.
+\end{itemize}
+
+\section{OpenFile}\label{cmdOpenFile}
+
+\begin{itemize}
+\item \util \textbf[OpenFile()]{OpenFile( <nom fichier> )}.
+\item \desc cette fonction permet d'ouvrir un fichier texte en écriture. ATTENTION: s'il existe un fichier du même nom,
+alors celui-ci sera écrasé.
+
+En combinaison avec les commandes \Helpref{WriteFile}{cmdWriteFile} et \Helpref{CloseFile}{cmdCloseFile}, cela permet à
+l'utilisateur de créer ses propres fichiers textes.
+\end{itemize}
+
+
+\section{OriginalCoord}\label{cmdOriginalCoord}
+
+\begin{itemize}
+\item \util \Mytextbf{OriginalCoord( <0/1> )} ou \textbf[OriginalCoord()]{OriginalCoord()}
+\item \desc cette fonction détermine si le repère à l'exportation en \textit{pstricks} et \textit{tikz/pgf} est
+identique à celui de l'écran (ce qui correspond à la valeur 1 de l'argument, valeur par défaut), ou non. Lorsque la
+valeur de l'argument est nulle, le repère à l'exportation (\textit{pstricks} et \textit{tikz/pgf}) aura son origine en
+bas à gauche et l'unité sera le cm sur les deux axes. Cela est utile lorsqu'on travaille dans des répères où certaines
+valeurs numériques ne sont plus acceptées par \TeX.
+
+Lorsque l'argument vaut 1, les coordonnées des points dans le fichier exporté sont les mêmes qu'à l'écran.
+
+Lorsque l'argument vaut 0, les coordonnées dans le fichier exporté (tex, pst, tikz/pgf) du point d'affixe z à l'écran,
+sont x=Re(TexCoord(z)) et y=Im(TeXCoord(z)) (et EpsCoord à la place de TeXCoord pour l'export eps).
+
+Lorsque l'argument est vide, la fonction renvoie l'état actuel du repère à l'exportation (0 ou 1). Sinon, elle renvoie
+la valeur \Nil.
+\end{itemize}
+
+\section{PermuteWith}\label{cmdPermuteWith}
+
+\begin{itemize}
+\item \util \textbf[PermuteWith()]{PermuteWith( <liste d'index>, <liste à permuter>, [, taille des paquets ou jump] )}
+\item \desc la \argu{liste à permuter} doit être une variable, celle-ci sera permutée selon le \argu{liste d'index} qui
+est une liste d'entiers strictement positifs. La \argu{liste à permuter} est traitée par composante si elle contient
+la constante \jump, et les éléments de chaque composante sont traités par paquets (de $1$ par défaut) ou par
+composante entière (une composante se termine par \jump), la liste est donc modifiée.
+\item \exem:
+\begin{itemize}
+\item \co{[L:=[-1,0,3,5], PermuteWith([4,3,2,1], L), L]} renvoie \res{[5,3,0,-1]}.
+\item \co{[L:=[-1,0,3,5], PermuteWith([4,3,4,1], L), L]} renvoie \res{[5,3,5,-1]}.
+\item \co{[L:=[-1,0,3,5,6,7,8], PermuteWith([4,3,2,1], L, 2), L]} renvoie \res{[6,7,3,5,-1,0]}.
+\item \co{[L:=[-1,jump,0,3,jump,5,6,7,jump,8,jump], PermuteWith( [4,3,3,1,2], L, jump), L]} renvoie
+\res{[8,jump,5,6,7,jump,5,6,7,jump,-1,jump,0,3,jump]}.
+\item \co{[L:=[-1,jump,0,3,jump,5,6,7,jump,8], PermuteWith([4,3,3,1,2], L, jump), L]} renvoie
+\res{[5,6,7,jump,5,6,7,jump,-1,jump,0,3,jump]}.
+\item \co{[L:=[-1,1,5,jump,0,3,jump,5,6,7,jump,8,9], PermuteWith( [2,1], L), L]} renvoie
+\res{[1,-1,jump,3,0,jump,6,5,jump,9,8]}.
+\end{itemize}
+\end{itemize}
+
+\section{ReadData}\label{cmdReadData}
+
+\begin{itemize}
+\item \util \textbf[ReadData()]{ReadData( <fichier> [, type de lecture, séparateur] )}.
+\item \desc cette fonction ouvre un \argu{fichier} texte en lecture, celui-ci est supposé contenir une ou plusieurs
+listes de valeurs numériques. Le premier argument est interprété comme une \Helpref{chaîne de caractères}{chaine} qui
+contient le nom du fichier (plus éventuellement son chemin). L'argument (optionnel) suivant \argu{type de lecture} est
+une valeur numérique qui peut valoir:
+\begin{itemize}
+\item \argu{type de lecture}=1: la fonction lit le fichier réel par réel et renvoie la liste ou les listes lues:
+\verb|[x1, x2, ...]|,
+\item \argu{type de lecture}=2: La fonction lit le fichier complexe par complexe, c'est à dire \Mytextbf{par paquets de
+deux réels} et renvoie la ou les listes lues sous forme d'affixes: \verb|[x1+i*x2, x3+i*x4, ...]|. C'est la valeur par
+défaut,
+\item \argu{type de lecture}=3: La fonction lit le fichier par paquet de 3 réels (points de l'espace ou point3D) et
+renvoie la ou les listes lues sous la forme: \verb|[x1+i*x2, x3, x4+i*x5, x6, ...]|.
+\end{itemize}
+
+Le troisième argument \argu{séparateur}, est interprété comme une chaîne, il est supposé contenir le caractère servant à
+indiquer la fin de liste, entre deux listes la constante \jump sera insérée, cet argument est facultatif et par défaut
+il n'y a pas de séparateur (ce qui fait donc une seule liste). Lorsque le séparateur est la fin de ligne dans le
+fichier, on utilisera la chaîne \co{"LF"} (\textit{line feed}) en troisième paramètre. Lorsqu'il y a un séparateur et
+lorsque la lecture se fait par paquet de 2 ou 3 réels, un paquet non \og complet\fg\ est ignoré.
+\item \exem supposons qu'un fichier texte \textit{test.dat} contienne exactement ceci:
+
+\begin{verbatim}
+1 2 3 4 5/ 6
+7 8 9 10 11/ 12
+13 14 15 16 17/ 18
+\end{verbatim}
+
+alors l'exécution de:
+ \begin{itemize}
+ \item \co{ReadData("test.dat")} donne: \res{[1+2*i,3+4*i,5+6*i,7+8*i,9+10*i,11+12*i,13+14*i,15+16*i,17+18*i]},
+ \item \co{ReadData("test.dat",1,"/")} donne:
+\res{[1,2,3,4,5,jump,6,7,8,9,10,11,jump,12,13,14,15,16,17,jump,18]},
+ \item \co{ReadData("test.dat",2,"/")} donne:
+\res{[1+2*i,3+4*i,jump,6+7*i,8+9*i,10+11*i,jump,12+13*i,14+15*i,16+17*i,jump]},
+ \item \co{ReadData("test.dat",3,"/")} donne:
+\res{[1+2*i,3,jump,6+7*i,8,9+10*i,11,jump,12+13*i,14,15+16*i,17,jump]},
+ \item \co{ReadData("test.dat",3,"LF")} donne:
+\res{[1+2*i,3,4+5*i,6,jump,7+8*i,9,10+11*i,12,jump,13+14*i,15,16+17*i,18,jump]}.
+ \end{itemize}
+\end{itemize}
+
+
+\section{ReadFlatPs}\label{cmdReadFlatPs}
+
+\begin{itemize}
+\item \util \textbf[ReadFlatPs()]{ReadFlatPs( <fichier> )}.
+\item \desc cette fonction ouvre un \argu{fichier} en lecture, celui-ci est censé être un fichier écrit en
+\textit{flattened postscript}. La fonction renvoie la liste des chemins contenus dans le fichier, le premier complexe de
+la liste est \textit{largeur+i*hauteur} en cm, puis le premier complexe de chaque chemin est \textit{Color+i*Width}.
+Chaque chemin se termine par un \jump dont la partie imaginaire est un enter négatif: $-1$ pour eofill, $-2$ pour fill,
+$-3$ pour stroke et $-4$ pour clip.
+
+Il est possible de transformer un fichier pdf ou un fichier postscript en \textit{flattened postscript} grâce à
+l'utilitaire \textit{pstoedit} (\url{http://www.pstoedit.net/}). La macro \Helpref{{conv2FlatPs}}{macconv2FlatPs} permet
+cette conversion en supposant que l'utilitaire est installé sur votre système.
+
+La fonction \textsl{ReadFlatPs} est surtout utilisée en interne par la macro \Helpref{{loadFlatPs}}{macloadFlatPs} qui
+en plus du chargement, adpate les coordonnées des points avant de renvoyer à son tour la liste des chemins que l'on peut
+alors dessiner avec la macro \Helpref{{drawFlatPs}}{macdrawFlatPs}.
+
+Ce système est utilisé par la macro \Helpref{{NewTeXLabel}}{macNewTeXlabel} pour récupérer les formules TeX compilées.
+\end{itemize}
+
+
+\section{ReCalc}\label{cmdReCalc}
+
+\begin{itemize}
+\item \util \Mytextbf{ReCalc( <nom1>, ..., <nomN> )} ou \textbf[ReCalc()]{ReCalc()}.
+\item \desc cette fonction force le recalcul des éléments graphiques dont les noms sont dans la liste même si ceux-ci
+ne sont pas en mode \textsl{Recalcul Automatique}. Si la liste est vide (\textsl{ReCalc()}) alors tout le graphique est
+recalculé. Après le recalcul l'affichage est mis à jour et la fonction renvoie \Nil.
+\end{itemize}
+
+\Mytextbf{Attention}: l'utilisation de \textsl{ReCalc()} dans un élément graphique entraîne une récursion infinie et
+donc un plantage du programme!
+
+\section{ReDraw}\label{cmdReDraw}
+
+\begin{itemize}
+\item \util \Mytextbf{ReDraw( <nom1>, ..., <nomN> )} ou \textbf[ReDraw()]{ReDraw()}.
+\item \desc cette fonction (re)dessine les éléments graphiques dont les noms sont dans la liste. Si la liste est vide
+(\textsl{ReDraw()}) alors tous les élments sont redessinés. Cette fonction renvoie la valeur \Nil.
+\end{itemize}
+
+\section{RenCommand}\label{cmdRenCommand}
+
+\begin{itemize}
+\item \util \textbf[RenCommand()]{RenCommand( <nom>, <nouveau> )}.
+\item \desc cette fonction renomme la commande appelée \argu{nom}. Les deux arguments sont donc interprétés comme des
+chaînes de caractères. Cette fonction renvoie la valeur \Nil. Si le \argu{nom} n'est pas valide, ou s'il n'y a pas
+de commande portant ce \argu{nom}, ou s'il a déjà une commande portant le nom \argu{nouveau}, alors la fonction est sans
+effet.
+\end{itemize}
+
+\section{RenMac}\label{cmdRenMac}
+
+\begin{itemize}
+\item \util \textbf[RenMac()]{RenMac( <nom>, <nouveau> )}.
+\item \desc cette fonction renomme la macro appelée \argu{nom}. Les deux arguments sont donc interprétés comme des
+chaînes de caractères. Cette fonction renvoie la valeur \Nil. Si le \argu{nom} n'est pas valide, ou s'il n'y a pas
+de macro portant ce \argu{nom}, ou s'il a déjà une macro portant le nom \argu{nouveau}, alors la fonction est sans
+effet.
+\end{itemize}
+
+
+\section{RestoreAttr}\label{cmdRestoreAttr}
+
+\begin{itemize}
+\item \util \textbf[RestoreAttr()]{RestoreAttr()}.
+\item \desc restaure l'ensemble des attributs sauvegardés dans une pile par la commande \Helpref{SaveAttr}{cmdSaveAttr}.
+\end{itemize}
+
+
+\section{Reverse}\label{cmdReverse}
+\begin{itemize}
+\item \util \textbf[Reverse()]{Reverse( <liste> )}.
+\item \desc renvoie la \argu{liste} inversée.
+\end{itemize}
+
+\section{Rgb}\label{cmdRgb}
+
+\begin{itemize}
+\item \util \textbf[Rgb()]{Rgb( <rouge>, <vert>, <bleu> )}.
+\item \desc cette fonction renvoie un entier représentant la couleur dont les trois composantes sont \argu{rouge},
+\argu{vert} et \argu{bleu}, ces trois valeurs doivent être des nombres \Mytextbf{compris entre 0 et 1}. Voir aussi la
+commande \Helpref{HexaColor}{cmdHexaColor}.
+\item \exem \co{Color:= Rgb(0.5,0.5,0.5))} sélectionne le gris.
+\end{itemize}
+
+\section{SaveAttr}\label{cmdSaveAttr}
+
+\begin{itemize}
+\item \util \textbf[SaveAttr()]{SaveAttr()}.
+\item \desc sauvegarde sur une pile l'ensemble des attributs courants. Voir aussi \Helpref{RestoreAttr}{cmdRestoreAttr}.
+\end{itemize}
+
+
+\section{Seq}\label{cmdSeq}
+
+\begin{itemize}
+\item \util \textbf[Seq()]{Seq( <expression>, <variable>, <départ>, <fin> [, pas] )}.
+\item \desc cette fonction est une \Mytextbf{boucle} qui construit une liste de la manière suivante: \argu{variable}
+est initialisée à \argu{départ} puis, tant que \argu{variable} est dans l'intervalle (fermé) défini par \argu{départ}
+et \argu{fin}, on évalue \argu{expression} et on incrémente \argu{variable} de la valeur de \argu{pas}. Le pas peut être
+ négatif mais il doit être non nul. Lorsqu'il n'est pas spécifié, sa valeur par défaut est 1. Lorsque \argu{variable}
+sort de l'intervalle, la boucle s'arrête et la fonction \textsl{Seq} renvoie la liste des résultats. Cette commande est
+la représentation interne de la boucle \Helpref{{for}}{cmdfor} dont l'utilisation est préférable pour des raisons de
+lisibilité.
+\item \exem \co{Seq(exp(i*k*pi/5,k,1,5)} renvoie la liste des racines cinquièmes de l'unité. La commande:
+
+\centerline{\co{Ligne( Seq( exp(2*i*k*pi/5, k, 1, 5), 1)}}
+
+renverra la valeur \Nil mais dessinera un pentagone (voir \Helpref{Ligne}{cmdLigne}) si elle est utilisée dans un
+élément graphique \textit{utilisateur}.
+\end{itemize}
+
+\section{Set}\label{cmdSet}
+
+\begin{itemize}
+\item \util \textbf[Set()]{Set( <variable>, <valeur> )}.
+\item \desc cette fonction permet d'affecter à \argu{variable}\footnote{Il n'est pas nécessaire de déclarer les
+variables, elles sont implicitement locales et initialisées à \Nil sauf si c'est le nom d'une variable globale ou d'une
+constante prédéfinie (comme i, $\pi$, e, ...).} la \argu{valeur} spécifiée. La fonction \textsl{Set} renvoie la valeur
+\Nil.
+
+Cette commande est la représentation interne de l'affectation \textsl{:=}, dont l'utilisation est préférable pour des
+raisons de lisibilité.
+\end{itemize}
+
+\section{SetAttr}\label{cmdSetAttr}
+
+\begin{itemize}
+\item \util \textbf[SetAttr()]{SetAttr()}.
+\item \desc cette fonction n'a d'effet que dans un élément graphique Utilisateur. Elle permet d'affecter aux attributs
+de l'élément la valeur des attributs actuellement en cours. La fonction \textsl{SetAttr} renvoie la valeur \Nil.
+\end{itemize}
+
+\section{SetMatrix}\label{cmdSetMatrix}
+
+\begin{itemize}
+\item \util \textbf[SetMatrix()]{SetMatrix( <[z1, z2, z3]> )}.
+\item \desc cette fonction permet de modifier la matrice courante (celle-ci affecte tous les éléments graphiques sauf
+les axes et les grilles dans la version actuelle). Cette matrice représente l'expression analytique d'une application
+affine du plan, c'est une liste de trois complexes: $z1$ qui est l'affixe du vecteur de translation, $z2$ qui est
+l'affixe du premier vecteur colonne de la matrice de la partie linéaire dans la base (1,i), et $z3$ qui est l'affixe du
+deuxième vecteur colonne de la matrice de la partie linéaire. Par exemple, la matrice de l'identité s'écrit ainsi:
+[0,1,i] (c'est la matrice par défaut). (Voir aussi les commandes \Helpref{GetMatrix}{cmdGetMatrix},
+\Helpref{ComposeMatrix}{cmdComposeMatrix}, et \Helpref{IdMatrix}{cmdIdMatrix})
+
+\item \exem si $f:z \mapsto f(z)$ est une application affine, alors sa matrice est $[f(0), f(1)-f(0), f(i)-f(0)]$, ce
+calcul peut-être fait par la macro \textit{matrix()} de TeXgraph.mac: \co{SetMatrix(matrix(i*bar(z)))} affecte la
+matrice de la symétrie orthogonale par rapport à la première bissectrice.
+\end{itemize}
+
+
+\begin{demo}{Repère non orthogonal}{SetMatrix}
+\begin{texgraph}[name=SetMatrix, export=pgf]
+view(-5,5,-3,3), size(7.5),
+SetMatrix([0,1,1+i]), axes(0,1+i),
+tMin:=-5, tMax:=5,
+Color:=red, Width:=8, Cartesienne(2*sin(x)),
+Color:=black, Arrows:=2,
+tangente(2*sin(x), pi/2, 1.5),
+Arrows:=0, LineStyle:=dotted,
+Ligne( [2*i,pi/2+2*i, pi/2], 0),
+Point(pi/2+2*i),
+LabelDot( pi/2, "$\frac{\pi}2$","S",1),
+IdMatrix()
+\end{texgraph}
+\end{demo}
+
+
+\section{Show}\label{cmdShow}
+
+\begin{itemize}
+\item \util \textbf[Show()]{Show( <element1>, ..., <elementN> )}.
+\item \desc Cette fonction permet de montrer les éléments graphiques appelés \argu{element1}, ..., \argu{elementN} en
+mettant leur attribut \textsl{IsVisible} à true. Les arguments sont interprétés comme des chaînes de caractères. Cette
+fonction renvoie la valeur \Nil. Pour tout montrer on invoque la commande sans arguments: \textsl{Show()}. Pour tout
+montrer sauf un ou plusieurs éléments, on invoque la commande: \co{Show(except, element1, ..., elementN)}. Voir aussi la
+commande \Helpref{Hide}{cmdHide}.
+\end{itemize}
+
+
+\section{Si}\label{cmdSi}
+
+\begin{itemize}
+\item \util \textbf[Si()]{Si( <condition1>, <expression1>, ..., <conditionN>, <expressionN> [, sinon] )}.
+\item \desc cette fonction évalue \argu{condition1}. Une condition est une expression dont le résultat de l'évaluation
+doit être 0 [pour \textit{False}] ou 1 [pour \textit{True}], sinon il y a un échec et la fonction renvoie la valeur
+\Nil. Si la condition donne la valeur 1 alors la fonction évalue \argu{expression1} et renvoie le résultat, si elle vaut
+0, elle évalue \argu{condition2}, si celle-ci donne la valeur 1 alors la fonction évalue \argu{expression2}, sinon
+etc... Lorsqu'aucune condition n'est remplie, la fonction évalue l'argument \argu{sinon}, s'il est présent, et renvoie
+le résultat, sinon la fonction renvoie \Nil. Cette commande est la représentation interne de l'alternative
+\Helpref{{if}}{cmdif} dont la syntaxe est préférable pour des raisons de lisibilité.
+
+\item \exem définition d'une macro \co{f(x)} représentant une fonction f d'une variable x
+définie en plusieurs morceaux:
+
+\centerline{\co{Si(\%1<-1,1-exp(pi*(\%1+1)),\%1<0,sin($\pi$*\%1),sh(pi*\%1))},}
+
+c'est à dire $f(x)=1-exp(\pi(x+1))$ si $x<-1$, $f(x)=sin(\pi x)$ si $-1\leqslant x<0$, $f(x)=$sh$(\pi x)$ sinon.
+
+\end{itemize}
+
+
+\section{Solve}\label{cmdSolve}
+
+\begin{itemize}
+\item \util \textbf[Solve()]{Solve( <expression>, <variable>, <borne inf.>, <borne sup.> [, n] )}.
+\item \desc cette fonction "résout" l'équation \argu{expression}=0 par rapport à la variable \Mytextbf{réelle}
+\argu{variable} dans l'intervalle défini par \argu{borne inf.} et \argu{borne sup.}. Cet intervalle est subdivisé en
+\argu{n} parties [par défaut n=25] et on utilise la méthode de {\sc Newton} sur chaque partie. La fonction renvoie la
+liste des résultats.
+\item \exem
+\begin{itemize}
+ \item \co{Solve(sin(x), x, -5, 5)} donne \res{[-3.141593, 0, 3.141593]}.
+
+ \item Équation: $\displaystyle \int_0^x \exp(t^2)dt=1$: \co{Solve(Int( exp(u\^{}2),u,0,x)-1, x, 0, 1)} donne
+\res{0.795172} et l'exécution de \co{Int(exp(u\^{}2), u, 0, 0.795172)} donne \res{1}.
+
+ \item \co{Solve( $x^2+x+1$, x, -1, 1)} renvoie \Nil.
+ \end{itemize}
+\end{itemize}
+
+\section{Sort}\label{cmdSort}
+
+\begin{itemize}
+\item \util \textbf[Sort()]{Sort( <liste de complexes> [, option] )}.
+\item \desc cette fonction trie la liste passée en argument dans l'ordre lexicographique, si l'argument \argu{option}
+vaut 0 (valeur par défaut), ou dans l'ordre lexicographique inverse si l'argument \argu{option} vaut 1. Cette liste doit
+être une variable, et celle-ci sera modifiée. Si la liste contient la constante \jump alors celle-ci est recopiée telle
+quelle dans le résultat, et les \og composantes connexes\fg\ de la liste sont triées indépendamment les unes des autres.
+La fonction renvoie la valeur \Nil.
+\item \exem si la variable \textsl{L} contient la liste \res{[-2,-3+i,1,1-2*i, jump, 3,5,-6]} alors après l'exécution
+de \co{Sort(L)}, la variable contiendra la liste \res{[-3+i,-2,1-2*i,1,jump,-6,3,5]}, et après l'exécution de
+\co{Sort(L,1)}, la variable contiendra la liste \res{[1,1-2*i,-2,-3+i,jump,5,3,-6]}. La méthode utilisée est le Quick
+Sort..
+\end{itemize}
+
+\section{Special}\label{cmdSpecial}
+
+\begin{itemize}
+\item \util \textbf[Special()]{Special( <chaîne> )}.
+\item \desc cette fonction n'aura d'effet que dans un élément graphique Utilisateur (comme les fonctions graphiques).
+L'argument doit être une chaîne de caractères (délimitée par " et "), si cette chaîne contient les balises \verb|\[|,
+et \verb|\]|, alors tout le texte contenu entre ces deux balises est interprété par TeXgraph et le résultat est replacé
+dans la chaîne. Puis cette chaîne sera écrite telle quelle dans le fichier d'exportation (c'est en fait un Label créé
+avec LabelStyle= special).
+\item \exem \co{Special("\bks psdot(\bks[1+\bks],\bks[2\^{}3\bks] )")}, écrira dans le fichier exporté: \res{\bks
+psdot(2,8)}.
+\end{itemize}
+
+\section{Str}\label{Str}
+
+\begin{itemize}
+\item \util \textbf[Str()]{Str( <nom de macro> )}.
+\item \desc lors d'une évaluation alphanumérique, cette fonction renvoie la définition de la macro appelée \argu{nom de
+macro} (sauf si c'est une macro prédéfinie). En dehors de ce contexte, la fonction \textsl{Str} renvoie \Nil. L'argument
+\argu{nom de macro} est lui-même interprété comme une chaîne de caractères.
+\item \exem supposons que la macro \co{f} soit définie par \co{\%1+i*sin(\%1)}, alors la commande
+\co{Label(0,["f(\%1)=",Str("f")] )} affichera à l'écran à l'affixe 0, le texte: \res{f(\%1)=\%1+i*sin(\%1)}.
+\end{itemize}
+
+\section{StrArgs}\label{cmdStrArgs}
+
+\begin{itemize}
+\item \util \textbf[StrArgs()]{StrArgs( <entier> )}.
+\item \desc cette fonction n'a d'effet que dans une macro, elle renvoie l'argument numéro \argu{entier} avec lequel la
+macro a été appelée, sous forme d'une chaîne. Hors de ce contexte, elle renvoie la valeur \Nil. Voir également la
+commande \Helpref{Args}{cmdArgs}
+\item\exem Voir la fonction \Helpref{Nargs}{cmdNargs}.
+\end{itemize}
+
+\section{StrComp}\label{cmdStrComp}
+
+\begin{itemize}
+\item \util \textbf[StrComp()]{StrComp( <chaîne1>, <chaîne2> )}.
+\item \desc les deux arguments sont interprétés comme une chaîne de caractères, et les deux chaînes sont comparées, si
+elles sont égales alors la fonction renvoie la valeur 1, sinon la valeur 0.
+\item \exem la combinaison de touches: Ctrl+Maj+<lettre> lance automatiquement l'exécution de la macro spéciale:
+\textsl{ OnKey( <lettre> )}. L'utilisateur peut définir cette macro avec par exemple la commande:
+
+\centerline{\co{if StrComp(\%1, "A") then Message("Lettre A") fi}}
+\end{itemize}
+
+\section{String}\label{cmdString}
+
+\begin{itemize}
+\item \util \textbf[String()]{String( <expression mathématique> )}.
+\item \desc lors d'une évaluation alphanumérique, cette fonction renvoie \argu{expression mathématique} sous forme d'une
+chaîne. En dehors de ce contexte, la fonction \textsl{String} renvoie \Nil.
+\end{itemize}
+
+\section{Stroke}\label{cmdStroke}
+
+\begin{itemize}
+\item \util \textbf[Stroke()]{Stroke( <element1>, ..., <elementN> )}.
+
+\item \desc cette fonction recalcule les éléments graphiques \argu{element1}, ..., \argu{elementN}, puis les redéssine
+en mode NORMAL, et renvoie la valeur \Nil.
+
+\item\exem on a créé deux variables globales: $a$ et \textit{drawing}. On va créer le cercle de centre a et de rayon 1,
+appelé \textsl{objet1}, on souhaite pouvoir déplacer cet objet à la souris. Pour cela, on crée la macro \textsl{ClicG}
+avec la commande:
+\end{itemize}
+
+\begin{verbatim}
+ [PenMode:=1, {mode NotXor}
+ NewGraph("objet1", "Cercle(a,1)"),
+ PenMode:=0, {mode normal}
+ ReDraw(), {on montre}
+ drawing:=1]
+\end{verbatim}
+
+on crée la macro \res{MouseMove} avec la commande: \co{if drawing then a:=\%1 \{on déplace le centre\}, Move(objet1)
+fi},
+
+puis la macro \res{LButtonUp} avec la commande: \co{if drawing then Stroke(objet1), drawing:=0 fi}.
+
+La macro \textsl{ClicG} crée l'objet1 en mode NotXor, rafraîchit l'affichage graphique et passe en mode "dessin". La
+macro \textsl{ MouseMove} permet de placer le centre à la position de la souris, puis de déplacer l'objet1. Lorsque le
+bouton gauche est relâché, on dessine l'objet1 en mode normal, puis on quitte le mode "dessin".
+
+
+\section{TeX2FlatPs}\label{cmdTeX2FlatPs}
+
+\begin{itemize}
+\item \util \textbf[TeX2FlatPs()]{TeX2FlatPs( <"formule"> [, dollar(0/1)] )}.
+
+\item \desc cette renvoie une \argu{formule} \TeX{} sous forme d'une liste de chemins, le résultat doit être dessiné
+avec la macro \Helpref{{drawFlatPs}}{macdrawFlatPs}. La \argu{formule} est écrite dans un fichier appelé
+\textit{formula.tex}. Ce fichier est appelé par le fichier \textit{formule.tex} qui se trouve dans le dossier de
+travail de TeXgraph, pour être compilé par \TeX{}. Si l'option \argu{dollar} vaut $1$ alors la formule sera délimitée
+par \verb|\]| et \verb|\]|, sinon elle est écrite telle quelle. Pour plus de renseignements sur la façon dont sont
+récupérés ces chemins, voir la commande \Helpref{{ReadFlatPs}}{cmdReadFlatPs}.
+\end{itemize}
+
+
+\section{Timer}\label{cmdTimer}
+
+\begin{itemize}
+\item \util \textbf[Timer()]{Timer( <milli-secondes> )}.
+
+\item \desc règle l'intervalle de temps pour le timer, celui exécute régulièrement une certaine macro (que l'on peut
+définir avec la commande TimerMac). Pour stopper le timer il suffit de régler l'intervalle de temps à 0.
+\end{itemize}
+
+\section{TimerMac}\label{cmdTimerMac}
+
+\begin{itemize}
+\item \util \textbf[TimerMac()]{TimerMac( <corps de la macro à exécuter> )}.
+
+\item \desc cette commande permet de créer une macro qui sera attachée au timer. L'argument est interprété comme une
+chaîne de caractères et doit correspondre au corps de la macro (celle-ci sera appélée TimerMac). Pour des raisons de
+performances, il est préférable d'éviter trop d'appels à d'autres macros dans celle-ci. Cette fonction renvoie la valeur
+1 si la macro est correctement définie, 0 en cas d'erreur. Attention, l'exécution de TimerMac ne déclenche pas le timer!
+Il faut utiliser la commande Timer pour cela.
+
+\item \exem soit $A$ une variable globale (un point), soit \textit{dotA} un élément graphique qui dessine le point,
+voilà une commande qui déplace $A$:
+
+\centerline{
+\co{[TimerMac("[Inc(A,0.1), if Re(A)>5 then Timer(0) else ReCalc(dotA) fi]"), A:=-5, Timer(10)]}}
+\end{itemize}
+
+\section{VisibleGraph}\label{cmdVisibleGraph}
+
+\begin{itemize}
+\item \util \Mytextbf{VisibleGraph( <0/1> )} ou \textbf[VisibleGraph()]{VisibleGraph()}.
+
+\item \desc cette fonction permet d'activer ou désactiver la zone de dessin dans l'interface graphique. Lorsque
+celle-ci est désactivée, son contenu ne change plus car il n'y a plus de mise à jour de la zone. Désactiver l'affichage
+graphique peut permettre dans certains cas un gain de temps pour enregistrer une animation par exemple.
+
+Lorsque l'argument est vide, la fonction renvoie simplement l'état actuel de l'affichage graphique (0 ou 1). Sinon, elle
+renvoie \Nil.
+\end{itemize}
+
+
+\section{WriteFile}\label{cmdWriteFile}
+
+\begin{itemize}
+\item \util \textbf[WriteFile()]{WriteFile( <argument> )}.
+
+\item \desc cette fonction permet d'écrire soit dans le fichier texte ouvert par la commande
+\Helpref{OpenFile}{cmdOpenFile}, soit dans le fichier d'exportation si l'exécution de cette commande a lieu pendant une
+exportation par l'intermédiare des macros \Helpref{Bsave}{macBsave} et/ou \Helpref{Esave}{macEsave}.
+
+\item \exem voici ce que pourrait être la macro \textsl{Bsave} pour modifier la taille des flêches en pstricks:
+\end{itemize}
+
+\begin{verbatim}
+ if ExportMode=pst then WriteFile("\psset{arrowscale=3}") fi
+\end{verbatim}
Projets / geshi.git / blobdiff
Les fichiers de Syracuse sont mis à
disposition (sauf mention contraire) selon les termes de la