\documentclass[a4paper]{book}
\usepackage[T1]{fontenc}
\usepackage[frenchb]{babel}
\title{Manuel de Réference DTML}
\author{Michel Pelletier, Amos Latteier\\Traduction de Benoît Rouits}
\date{}
\begin{document}
\maketitle
\tableofcontents
\noindent Ce document est une traduction de l'appendice A du Zope-Book, accessible à~: http://www.zope.org/Members/michel/ZB/

\chapter{Référence DTML}
DTML signifie "Document Template Markup Language", 
c'est un langage de présentation et de modélisation
fournit par Zope. Ce document est une référence à 
toutes les balises ("tags") de DTML et explique 
brièvement comment elles fonctionnent.

\section{call : appelle une méthode}
la balise \texttt{call} vous permet d'appeler une méthode 
sans insérer son résultat dans la sortie DTML.

\subsection*{Syntaxe:}
\noindent{\tt<dtml-call Variable-expr="Expression">}\\
Si la balise call utilise une variable, les 
arguments des méthodes sont passés automatiquement 
par DTML comme pour la balise var. Si la méthode est 
spécifiée dans une expression, alors vous devez 
passer les arguments vous-même.

\subsection*{Exemples:}
\noindent {\tt<dtml-call UpdateInfo>}\\
appelle l'objet UpdateInfo en lui passant 
automatiquement ses arguments.

\noindent{\tt<dtml-call expr="RESPONSE.setHeader('content-type', 'text/plain')">}\\
appelle l'expression contenue entre les guillemets. 

\subsection*{Voir aussi:}
\noindent balise {\texttt{var}}

\section{comment : balise de commentaire}
Les balises de commentaire vous permettent de 
documenter votre DTML sans que cela soit montré.
Vous pouvez aussi les utiliser pour annuler 
temporairement d'autres balises DTML.
\subsection*{Syntaxe:}
\noindent\texttt{<dtml-comment>}\\
commentaire...\\
\texttt{</dtml-comment>}

\subsection*{Exemples:}
\noindent\texttt{<dtml-comment>}\\
La balise suivante est ignorée : \\
<dtml-call uneMéthode>\\
\texttt{</dtml-comment>}

\section{Fonctions DTML}
(appel par \texttt{expr="\_.fonction()})

\subsection*{abs(nombre)}
	retourne la valeur absolue du nombre passé en 
	argument. Il peut être un nombre entier, réel ou 
	complexe ; dans le cas d'un nombre complexe, son 
	module est retourné.
\subsection*{chr(integer)}
	retourne une cha\^\i ne d'un caractère dont le code  ASCII est integer. En conséquence,
	integer doit  être compris entre $0$ et $255$, sinon, l'exception  ValueError sera
	déclenchée.
\subsection*{DateTime()}
	retourne un objet Zope DateTime. Voir l'API de 
	DateTime pour plus d'informations sur ses 
	arguments.
\subsection*{divmod(a,b)}
	prends deux nombres comme arguments et retourne une
	paire de nombres correspondant à leur  quotient et leur
	reste par application d'une  division. Pour des opérandes de
	type différent,  les lois de l'arithmétique binaire s'applique.
	 Pour les nombres entiers, le résultat est  $(a/b,a\%b)$. Pour
	les nombres réels, le résultat  est $(q,a\%b)$ où $q$ est
	$math.floor(a/b)$.$q*b+a\%b$ est très proche de $a$, si
	$a\%b$ est différent de $0$ alors  cela a le même signe que
	$b$, et $0\leq abs(a\%b)<abs(b)$.
\subsection*{float(n)}
	 convertit une cha\^\i ne ou un entier en réel. Si $n$  est une cha\^\i ne,
	 elle doit contenir un nombre  décimal entouré d'espaces ; le
	 comportement est identique à \emph{string.atof(n)}. Autrement,
	 l'argument  peut être un entier ou un réel, il sera retourné un
	 nombre réel de la même valeur. 
\subsection*{getattr(objet,cha\^\i ne)}
 	retourne la valeur de l'attribut de l'objet  spécifié par la cha\^\i ne. 
	Par exemple:
 	\emph{getattr(x,'truc')} est équivalent à \emph{x.truc}. Si l' attribut 
	n'existe pas, l'exception \emph{AttributeError} est levée. 
\subsection*{getitem(variable, render=0)}
	 retourne la valeur d'une variable DTML.
	si render est à vrai, la variable est rendue. 
\subsection*{hasatr(objet, cha\^\i ne)} 
	le résultat est $1$ si la cha\^\i ne est le nom de l'un  des
	attributs de l'objet, $0$ sinon. 
\subsection*{hash(objet)}
	 retourne la valeur de hashage de l'objet (s'il en  a une). Les
	 valeurs de hachage sont des entiers.  Elles sont utiliseées
	 pour comparer rapidement des clés de dictionnaires. Les
	 valeurs numériques  égales ont la même clé même si leur
	 type diffère (exemple : $1$ et $1.0$).
\subsection*{has\_key(variable)}
	 retourne vrai si l'espace des noms de DTML  contient la
	 variable. 
\subsection*{hex(entier)} 
	convertit un entier en une cha\^\i ne
	 hexadécimale. Le résultat est une expression Python valide.
\subsection*{int(nombre)}
	 convertit une cha\^\i ne ou un nombre en un nombre  entier.
	 S'il s'agit d'une cha\^\i ne, elle doit  contenir un nombre
	 décimal ébentuellement signé, comme un entier sous Python,
	 entouré d'espaces. Le comportment est équivalent à
	 \texttt{string.atoi(x[,radix])}. Le paramètre $radix$ donne 
	 la base pour la  conversion et doit être compris entre $2$ et $36$.
	 Si le $radix$ est spécifié et que $x$ n'est pa une  cha\^\i ne,
	 l'exception \emph{TypeError} est levée. Sinon, l' argument doit être
	 un entier ou en réel. La  conversion de réel vers entier est
	 définie par la sémantique du C ; normallement, la
	 conversion  tronque le réel.
\subsection*{len(objet)}
	 retourne le nombre d'items d'un objet ou sa longueur. L'argument doit être une
	 séquence de  type cha\^\i ne, tuple, liste ou un dictionnaire.
\subsection*{max(s)}
	 si $s$ est une séquence, alors $max(s)$ retourne l' item le
	 plus grand de la séquence. si $s$ est un ensemble de plusieurs
	 arguments, alors le plus  grand argument est retourné.
\subsection*{min(s)}
	 voir $max(s)$ sauf que $min(s)$ retourne le plus petit élément de $s$.
\subsection*{namespace([name=value]...)}
	 retourne un nouvel espace de noms DTML. Les mots-clés $name=value$
	 sont mis dans le nouvel espace de  noms. 
\subsection*{oct(entier)}
	 convertit un entier en une cha\^\i ne octale. Le résultat est une expression valide Python.
\subsection*{ord(char)} retourne le code ASCII de $char$. Par exemple : $ord( 'a')$ retourne
	 l'entier $97$. C'est la fonction inverse de $chr()$.
\subsection*{pow(x,y[,z])} 
	retourne x à la puissance y. Si z est présent, 
	alors cela retourne l'équivalent de $pow(x,y)\%z$.
	Les arguments doivent être numériques. S'ils sont 
	de types numériques différents, les lois des 
	opérateurs arithmétiques binaires s'appliquent. 
	Le type du résultat est celui de l'opérande 
	effective et si le résultat ne peux s'exprimer 
	dans ce type, alors une exception est levée. Par 
	exemple, $pow(2,-1)$ est interdit car le résultat 
	doit être entier dans ce cas (en revanche, $pow(2.0,-1)$ fonctionne).
\subsection*{range([debut,]fin[,pas])}
	retourne une liste d'entiers triés. Les arguments 
	doivent être des nombres entiers. Si le pas est 
	ommis, il est mis à 1. Si le début est ommis, il 
	est mis à 0. Le pas peut être négatif.
\subsection*{round(x[,n])}
	retourne la valeur réelle $x$ arrondie à $n$ chiffres 
	après la virgule. Si $n$ est ommis, il est mis à 0.
	Le résultat est un réel. Exemple : $round(0.5)=1$ 
	mais $round(-0.5)=-1$.
\subsection*{render(objet)}
	"imprime" l'objet. Pour des objets DTML, cela 
	équivaut à \texttt{call}, pour les autres objets, cela 
	revient à \texttt{str(objet)}.
\subsection*{reorder(s[,with][,without])}
	réordonne les items de $s$ avec l'ordre de $with$ et  en retirant les items de
	$without$. Les items de $s$ non présents dans $with$ sont retirés. $s$, $with$ et 
	 $without$ sont soit des sequences de cha\^\i nes soit des sequences de tuples $cle-
	valeur$ avec l'ordre fait sur les clés. Cette fonction est utile pour construire  des 
	   listes ordonnées.
\subsection*{str(objet)}
	retourne une cha\^\i ne contenant une représentation imprimable de l'objet.  Pour 
	 une cha\^\i ne, elle est retournée sans altération.
\subsection*{test(condition, resultat[,condition, resultat]...[, defaut])}
	prend une ou plusieurs paires de $condition, resultat$ et retourne le resultat  de 
	 la première condition vraie. Un seul résultat est retourné même si plus d'une
	condition est vraie. Si aucune condition n'est vraie alors le résultat $defaut$ est 
	 retourné s'il existe, sinon, $None$ est retourné.
\subsection*{None}
	l'objet \texttt{None} est équivalent à l'objet \texttt{None} de Python. Il est
	utilisé pour représenter une valeur nulle ou fausse.

\section{if : test de conditions}
La balise \texttt{if} vous permet de tester des conditions et de faire des actions
différentes en fonction de ces conditions.
\subsection*{Syntaxe:}
\noindent\texttt{<dtml-if condition|expr="expression">}\\
\texttt{[<dtml-elif ... >]}\\
\texttt{\dots}\\
\texttt{[<dtml-else>]}\\
\texttt{[\dots]}\\
\texttt{</dtml-if>}\\
Si la condition est vraie, alors le bloc contenu entre \texttt{<dtml-if>} et 
\texttt{<dtml-elif>} est exécuté. Sinon, c'est le bloc d'un \texttt{elif} ou du
\texttt{else} qui est exécuté. Un seul bloc sera exécuté.
\subsection*{Exemples:}
\noindent\texttt{<dtml-if expr="num > 5">}\\
num est plus grand que 5\\
\texttt{<dtml-elif expr="num < 5">}\\
num est plus petit que 5\\
\texttt{<dtml-else>}\\
num = 5\\
\texttt{</dtml-if>}
\subsection*{Voir aussi:}
\noindent Tutorial Python : structure if
\section{in : traverse une séquence}
La balise \texttt{in} vous permet de traverser une séquence et de 
traîter chacun  de  ses éléments.
\subsection*{Syntaxe:}
\noindent\texttt{<dtml-in Sequence|expr="ExpressionSequence">}\\
\texttt{[<dtml-else>]}\\
\texttt{</dtml-in>}\\
Le bloc \texttt{in} est répété pour chaque item de la séquence.
 L'item courant  est mis dans l'espace des noms DTML pour
chaque execution du bloc. S'il n'y a pas d'item dans la séquence,
 alors le bloc \texttt{else} est exécuté s'il existe.
\subsection*{Attributs:}
\begin{itemize}
	\item mapping\\  itère sur des objets pointeurs plutôt que sur des
	instances. Cela permet aux valeurs des objets pointeurs  d'être
	accédées comme des variables DTML.
	\item reverse\\ inverse la séquence.
	\item sort=\emph{cha\^\i ne}\\trie la sequence par l'attribut 
	donné.
	\item start=\emph{int}\\indique le numéro premier 
	élément à être montré (à parir de 1).  
	\item end=\emph{int}\\indique le numéro du dernier 
	élément à être montré (à partir de 1).
	\item size=\emph{int}\\la taille du traitement \footnote{NdT : traitement de lot}
	\item skip unauthorized\\ne lève pas d'exception si un item 
	non-autorisé est rencontré.
	\item orphan=\emph{int}\\la taille minimale du batch.
	\item overlap=\emph{int}\\le nombre d'items à superposer 
	entre les batches, par défaut $3$.
	\item previous\\itère une fois si il y a un batch précédent.
	Positionne les variables du batch pour la séquence précédente.
	\item next\\itère une fois si il y a un batch suivant. 
	Positionne les variables du batch pour la prochaine séquence.
\end{itemize}
\subsection*{Variables de balise:}
\subsubsection*{variables de l'item courant}
Ces variables sont utilisées pour décrire l'item en cours dans un
processus \emph{in} sur une séquence d'objets.
\begin{itemize}
	\item	sequence-item\\l'item courant
	\item	sequence-key\\la clé courante. Lorsqu'on travaille 
	sur des tuples de la forme $(cle,valeur)$, le processus\emph{in}
	les interprète comme $(sequence-key, sequence-item)$.
	\item 	sequence-index\\l'indice de l'item courant, partant de $0$.
	\item 	sequence-number\\l'indice de l'item courant, partant de $1$.
	\item 	sequence-roman\\l'indice de l'item courant en chiffres romains minuscules.
	\item 	sequence-Roman\\l'indice de l'item courant en chiffrres romains majuscules.
	\item 	sequence-letter\\l'indice de l'item courant en lettres minuscules.
	\item 	sequence-Letter\\l'indice de l'item courant en lettres majuscules.
	\item 	sequence-start\\VRAI si l'item courant est le premier.
	\item 	sequence-end\\VRAI si l'item courant est le dernier.
	\item 	sequence-even\\VRAI si l'item courant est pair.
	\item 	sequence-odd\\VRAI si l'item courant est impair.
	\item 	sequence-length\\la longueur de la séquence.
	\item 	sequence-var-\emph{variable}\\une \emph{variable} dans l'item courant.
	Par exemple, \texttt{sequence-var-title} est la variable
	\texttt{title} de l'item courant.
	\item 	sequence-index-\emph{variable}\\l'indice d'une variable de l'item courant.
\end{itemize}
\subsubsection*{variables de somme}
Ces variables récaputulent l'information à propos des items
numériques. Pour utiliser ces variables, vous dever travailler sur des
objets qui ont des variables numériques.
\begin{itemize}
	\item	total-\emph{variable}\\le total de toutes les occurences d'une variable item.
	\item	count-\emph{variable}\\le nombre d'occurences d'une variable item.
	\item 	min-\emph{variable}\\la valeur minimale d'une variable item.
	\item 	max-\emph{variable}\\la valeur maximale d'une variable item.
	\item 	mean-\emph{variable}\\la valeur moyenne d'une variable item.
	\item 	variance-\emph{variable}\\la variance d'une variable item avec $count - 1$ degrés de liberté.
	\item 	variance-n-\emph{variable}\\la variance d'une variable item avec $count$ degrés de liberté.
	\item 	standard-deviation-\emph{variable}\\la déviation standard d'une variable item avec $count - 1$ degrés de liberté.
	\item 	standard-deviation-n-\emph{variable}\\la déviation d'une variable item avec $count$ degrés de liberté.
\end{itemize}
\subsubsection*{variables de groupe}
Ces variables vous permettent d'observer les changements dans les
variables item courantes.
\begin{itemize}
	\item	first-\emph{variable}\\VRAI si l'item courant est le premier avec une valeur particulière pour une variable.
	\item	last-\emph{variable}\\VRAI si l'item courant est le dernier avec une valeur particulière pour une variable.
\end{itemize}
\subsubsection*{variables de traitement de lot (batch)}
\begin{itemize}
	\item	sequence-query\\la cha\^\i ne de la requète avec la variable \texttt{start} retirée.
			Vous pouvez utiliser cette variable pour construire des liens vers les traiements 
			précédant et futurs.
	\item	sequence-step-size\\la taille du traitement.
	\item 	previous-sequence\\VRAI si le traitement courant n'est pas le premier.
	\item 	previous-sequence-start-index\\l'index de départ du traitement précédant.
	\item 	previous-sequence-start-number\\égal à \texttt{previous-sequence-start-index + 1}.
	\item 	previous-sequence-end-index\\l'index de fin du dernier traitement.
	\item 	previous-sequence-end-number\\égal à \texttt{previous-sequence-end-index + 1}.
	\item 	previous-sequence-size\\la taille du dernier traitement.
	\item 	previous-batches\\une sequence d'objets avec l'information des batches précédants.
			chaque objet a les clés \texttt{batch-start-index}, \texttt{batch-end-index},
			et \texttt{batch-size}.
	\item 	next-sequence\\VRAI si le traitement courant n'est pas le dernier.
	\item 	next-sequence-start-index\\l'index de départ de la prochaine séquence.
	\item 	next-sequence-start-number\\égal à \texttt{next-sequence-start-index + 1}.
	\item 	next-sequence-end-index\\l'index de fin de la prochaine séquence.
	\item 	next-sequence-end-number\\égal à \texttt{next-sequence-end-index + 1}.
	\item 	next-sequence-size\\la taille de la prochaine séquence.
	\item 	next-batches\\une séquence d'objets pointeurs avec l'information sur tous 
			les traitements suivants. Chaque objet pointeur a les clés :
			\texttt{batch-start-index, batch-end-index} et \texttt{batch-size}
\end{itemize}
\subsection*{Exemples:}
\noindent Traverser une séquence d'objets~:
\begin{verbatim}
<dtml-in objectValues> title :
  <dtml-var title><br>
</dtml-in>
\end{verbatim}
Créer une table colorée par alternance~:
\begin{verbatim}
<table>
<dtml-in objectValues>
<tr <dtml-if sequence-odd>bgcolor="#EEEEEE" <dtml-else>bgcolor="FFFFFF"</dtml-if>>
 <td><dtml-var title></td>
</tr>
</dtml-in>
</table>
\end{verbatim}
Traitement par lot basique~:
\begin{verbatim}
<p>
<dtml-in largeSequence size=10 start=start previous>
  <a href="<dtml-var absolute_url><dtml-var sequence-query>start=<dtml-var previous-sequence-start-number>">Previous</a>
</dtml-in>
<dtml-in largeSequence size=10 start=start next>
  <a href="<dtml-var absolute_url><dtml-var sequence-query>start=<dtml-var next-sequence-start-number>">Next</a>
</dtml-in>
</p>
<p>
<dtml-in largeSequence size=10 start=start>
  <dtml-var sequence-item>
</dtml-in>
</p>
\end{verbatim}
Ceci crée des liens \emph{Previous} et \emph{Next} pour naviguer sur les lots.
\section{let : définit des variables DTML}
La balise \texttt{let} définit des objets dans l'espace des noms DTML.
\subsection*{Syntaxe:}
\noindent\texttt{<dtml-let [nom=variable][nom="expression"]\dots>}\\
\texttt{</dtml-let>}

Les variables sont définies par les arguments de \texttt{let}. Les variables définies sont
mises dans l'espace de nommage DTML lorsque le bloc \texttt{let} est éxécuté. On peut
définir plusieurs variables dans la même balise \texttt{let}. Si les arguments sont entourées
de \texttt{"\dots"} alors ils sont considérés comme expressions. Les attributs sont lis de
gauche à droite donc on peut faire référence à un attribut défini plus tôt.
\subsection*{Exemples:}
\noindent Utilisation basique~:
\begin{verbatim}
<dtml-let nom="'bob'" ids=objectIds>
Nom : <dtml-var nom>
Ids : <dtml-var ids>
</dtml-let>
\end{verbatim}
Combiner \texttt{let} et \texttt{in}~:
\begin{verbatim}
<dtml-in expr="(1,2,3,4)">
 <dtml-let num=sequence-item index=sequence-index result="num*index">
 <dtml-var num> * <dtml-var index> = <dtml-var result>
 </dtml-let>
</dtml-in>
\end{verbatim}
donne~:
\begin{verbatim}
1 * 0 = 0
2 * 1 = 2
3 * 2 = 6
4 * 3 = 12
\end{verbatim}
\subsection*{Voir aussi:}
\noindent balise \texttt{with}
\section{Fonctions mathématiques DTML}
Le module \texttt{math} offre un ensemble de fonctions mathématiques.
Il s'agit du module mathématique standard de Python.
\subsection*{acos(x)}
retourne l'arc-cosinus de x.
\subsection*{asin(x)}
retourne l'arc-sinus de x.
\subsection*{atan(x)}
retourne l'arc-tangente de x.
\subsection*{atan2(x,y)}
retourne \emph{atan(y/x)}
\subsection*{ceil(x)}
retourne ???
\subsection*{cos(x)}
retourne le cosinus de x.
\subsection*{cosh(x)}
retourne le cosinus hyperbolique de x.
\subsection*{exp(x)}
retourne $e^x$
\subsection*{fabs(x)}
retourne la valeur absolue d'un réel x.
\subsection*{floor(x)}
retourne ??? la partie entière de x.
\subsection*{fmod(x,y)}
retourne fmod(x,y) selon la définition de la librairie C.
\subsection*{fexp(x)}
retourne la mantisse et l'exposant de x en une paire (m,e) où m est réel et e est entiertel
que~: $x = m \times 2^e$. Si $x = 0$ retourne alors $(0.0 , 0)$, sinon $0.5 \leq abs(m) \leq 1$.
\subsection*{hypot(x,y)}
retourne la distance euclidienne, $\sqrt{x^2 + y^2}$
\subsection*{ldexp(x,y)}
retourne $x \times (2^i)$.
\subsection*{log(x)}
retourne le logarithme naturel de x.
\subsection*{log10(x)}
retourne le logarithme base 10 de x.
\subsection*{modf(x)}
retourne ??? la partie décimale et la partie entière de x, les deux parties ayant le même signe
que x. La partie entière est retournée en nombre réel.
\subsection*{pow(x,y)}
retourne x à la puissance y.
\subsection*{sin(x)}
retourne le sinus de x.
\subsection*{sinh(x)}
retourne le sinus hyperbolique de x.
\subsection*{sqrt(x)}
retourne la racine carrée de x.
\subsection*{tan(x)}
retourne la tangente de x.
\subsection*{tanh(x)}
retourne la tangente hyperbolique de x.
\subsection*{e}
la constante mathématique $e$.
\subsection*{pi}
la constante mathématique $\pi$.
\section{mime : formate des données avec MIME}
La balise \texttt{mime} vous permet de créer des données encodées au format MIME. Cela
est surtout utilisé pour envoyer des e-mail avec la balise \texttt{sendmail}.
\subsection*{Syntaxe:}
\begin{verbatim}
<dtml-mime>
[<dtml-boudry>]
...
</dtml-mime>
\end{verbatim}
Le block \texttt{mime} peut  être divisé en plusieurs \texttt{boundry} qui créent alors un
message \textsc{mime} multi-parties.
\subsection*{Attributs:}
\noindent les balises \texttt{mime} et \texttt{boundry} ont les attributs suivants~:
\begin{itemize}
	\item	encode=cha\^\i ne\\le header \emph{Content-Transfert-Encoding} \textsc{mime}, 
			par défaut \texttt{base64}. Les options d'encodage valides sont~:
			\texttt{base64},\texttt{quoted-printable}, \texttt{uuencode}, \texttt{x-uuencode},
			\texttt{uue}, \texttt{x-uue} et \texttt{7bit}. Si l'option est \texttt{7bit} alors aucun 
			encodage n'est fait.
	\item	type=cha\^\i ne\\header \emph{Content-Type}
	\item 	type\_expr=cha\^\i ne\\header \emph{Content-Type} en tant qu'expression. 
			Ne pas utiliser en même temps que \texttt{type}.
	\item 	name=cha\^\i ne\\le nom du header \emph{Content-Type} \textsc{mime}.
	\item 	name\_expr=cha\^\i ne\\le nom du header \emph{Content-Type} \textsc{mime} 
			en tant qu'expression. Ne pas utiliser en même temps que \texttt{name}.
	\item 	disposition=cha\^\i ne\\header \textsc{mime} \emph{Content-Disposition}.
	\item 	disposition\_expr=cha\^\i ne\\header \textsc{mime} \emph{Content-Disposition} 
			en tant qu'expresion. Ne pas utiliser en même temps que \texttt{disposition}.
	\item 	filename=cha\^\i ne\\fichier header \textsc{mime} \emph{Content-Disposition}.
	\item 	filename\_exrp=cha\^\i ne\\fichier header \textsc{mime} \emph{Content-Disposition}
			en tant qu'expression. Ne pas utiliser en même temps que \texttt{filename}.
	\item 	skip\_expr=cha\^\i ne\\une expression qui, si VRAIE alors passe le block. Vous pouvez 
			l'utiliser pour inclure séléctivement des blocks \textsc{mime}.
\end{itemize}
\subsection*{Exemples:}
\noindent Envoyer un fichier attaché~:
\begin{verbatim}
<dtml-sendmail>
To:<dtml-recipient>
Subject:Rapport
<dtml-mime type="text/plain" encode="7bit">

Salut, veuillez regarder mon rapport.

<dtml-boudary type="application/octet-stream" disposition="attachment"
encode="base64" filename_expr="resume_file.getId()">
<dtml-var expr="resume_file.read()">
</dtml-mime>
</dtml-sendmail>
\end{verbatim}
\subsection*{Voir aussi:}
\noindent Librairie \texttt{mimetools} Python.
\section{raise : Lève une exception}
La balise \texttt{raise} lève une exception comme en Python.
\subsection*{Syntaxe:}
\begin{verbatim}
<dtml-raise NomException | ExpressionException>
</dtml-raise>
\end{verbatim}
Les exceptions peuvent  être une cha\^\i ne ou une expression. .e contenu de la balise est passé
comme valeur d'erreur.
\subsection*{Exemples:}
lever une KeyError~:
\begin{verbatim}
<dtml-raise KeyError></dtml-raise>
\end{verbatim}
lever une erreur \textsc{http} 404~:
\begin{verbatim}
<dtml-raise NotFound>Page non trouvée</dtml-raise>
\end{verbatim}
\subsection*{Voir aussi:}
balise \texttt{try}\\ Tutoriel Python : Erreurs et Exceptions
\section{return : retourne des données}
La balise \texttt{return} stoppe l'exécution DTML et retourne des données. Elle agit comme
le \texttt{return} de Python.
\subsection*{Syntaxe:}
\begin{verbatim}
<dtml-return Variable | expr="expression">
\end{verbatim}
stoppe l'execution DTML et retourne la variable ou l'expression. la sortie DTML n'est pas
retournée. Habituellement, on retourne une expression. Les scripts Python rendent obsolete
l'utilisation de cette balise.
\subsection*{Exemples:}
retourner une variable~:
\begin{verbatim}
<dtml-return result>
\end{verbatim}
retourner un dictionnaire Python~:
\begin{verbatim}
<dtml-return expr="{'hi':200, 'lo':5}">
\end{verbatim}
\section{sendmail : envoit d'e-mail via SMTP}
\subsection*{Syntaxe:}
\begin{verbatim}
<dtml-sendmail>
</dtml-sendmail>
\end{verbatim}
\texttt{sendmail} demande un \texttt{mailhost} 
ou un \texttt{smtphost} en argument mais pas les deux. le block est envoyé comme un e-mail.
Le début de block décrit les entètes de l'e-mail. Les entètes sont séparées du corps par une ligne
vide.
\subsection*{Attributs:}
\begin{itemize}
	\item	mailhost\\le nom d'un objet MailHost Zope à utiliser pour envoyer un e-mail.
	\item	smtphost\\le nom d'un server \textsc{smtp} à utiliser pour envoyer un e-mail. 
			On ne doit pas spécifier \emph{smtphost} et \emph{mailhost} en même temps.
	\item 	port\\si on utilise l'attribut \emph{smtphost} alors l'attribut \emph{port} sert à spécifier 
			le port \textsc{tcp} poour se connecter, par défaut : port 25.
	\item 	mailto\\adresse destinataire. On peut en spécifier plusieurs séparées par des virgules.
			Cela est équivalent à spécifier l'entrée \texttt{To} dans le header.
	\item 	mailfrom\\l'adresse de l'expéditeur. Cela est équivalent à spécifier l'entrée \texttt{From}
			dans le header.
	\item 	subject\\le titre de l'e-mail. Cela est équivalent à spécifier l'entrée \texttt{Subject} dans
			le header.
\end{itemize}

\subsection*{Exemples:}
\begin{verbatim}
<dtml-sendmail mailhost="mailhost">
To: <dtml-var destinataire>
From: <dtml-var expediteur>
Subject: <dtml-var titre>

Cher <dtml-var destinataire>,

blablabla...
</dtml-sendmail>
\end{verbatim}
\subsection*{Voir aussi:}
\noindent RFC 821 (protocole smtp), balise mime.
\section{sqlgroup : Expressions SQL complexes}
La balise \texttt{sqlgroup} permet de produire des requetes SQL complexes. Vous pouvez
l'utiliser avec la balise \texttt{sqltest}.
\subsection*{Syntaxe:}
\begin{verbatim}
<dtml-sqlgroup>
[<dtml-or>]
[<dtml-and>]
...
</dtml-group>
\end{verbatim}
\subsection*{Attributs:}
\begin{itemize}
	\item	required=booléen\\indiquen si le groupe est requis. 
			Sinon et s'il ne contient rien, il est exclut de la sortie DTML.
	\item	where=booléen\\si \texttt{true} alors inclus la cha\^\i ne "where".
\end{itemize}
\subsection*{Exemples:}
\begin{verbatim}
select * from employes
<dtml-sqlgroup where>
  <dtml-sqltest salaire op=gt type=float optional>
<dtml-and>
  <dtml-sqltest prenom op=eq type=string multiple optional>
<dtml-and>
  <dtml-sqltest nom op=eq type=string multiple optional>
</dtml-sqlgroup>
\end{verbatim}
Si \texttt{prenom}=Bob et \texttt{nom}=Smith, McDonald, cela donne~:
\begin{verbatim}
select * from employes
where (first='Bob'
       and
       last in ('Smith', 'McDonald')
      )
\end{verbatim}
Si \texttt{salaire}=50000 et \texttt{nom}=Smith, cela donne~:
\begin{verbatim}
select * from employes
where (salaire > 50000.0
       and
       nom='Smith'
      )
\end{verbatim}
Balises \texttt{sqlgroup} emboitées~:
\begin{verbatim}
select * from employes
<dtml-sqlgroup where>
  <dtml-sqlgroup>
    <dtml-sqltest prenom op=like type=string>
  <dtml-and>
    <dtml-sqltest nom op=like type=string>
  <dtml-sqlgroup>
  <dtml-or>
    <dtml-sqltest salaire op=gt type=float>
  </dtml-sqlgroup>
\end{verbatim}
Avec des arguments, cela peut donner~:
\begin{verbatim}
select * from employes
where(
       (
        prenom like 'A*'
        and
        nom like 'Smith'
       )
      or
      salaire > 20000.0
     )
\end{verbatim}
\subsection*{Voir aussi:}
\noindent Balise sqltest.
\section{sqltest : tests de conditions SQL}
La balise \texttt{sqltest} insère un test de condition dans du code
SQL. Cela teste une colonne avec une variable. Cette balise est utilisée
dans les mèthodes SQL.
\subsection*{Syntaxe:}
\begin{verbatim}
<dtml-sqltest Variable|expr="Expression">
\end{verbatim}
\subsection*{Attributs:}
\begin{itemize}
	\item	type=cha\^\i ne\\Le type de la variable. Les types valides sont~: 
			\texttt{string}, \texttt{int}, \texttt{float} et \texttt{nb}.
			\texttt{nb} signifie ``cha\^\i ne non vide''. L'attribut type est requis 
			et utilisé pour échaper les variables insérées.
	\item	column=cha\^\i ne\\Le nom de la colonne SQL à tester. Cet attribut 
			est par défaut le nom de la variable.
	\item 	multiple=booléen\\Si \textsc{vrai}, la variable peut-être une séquence
			de valeurs à tester avec la colonne.
	\item 	optional=booléen\\Si \textsc{vrai}, alors le test est optionnel et ne sera 
			pas exécuté si la variable est vide ou non-existante.
	\item 	op=cha\^\i ne\\L'opérateur de comparaison. Les opérateurs valides sont~:
			\begin{itemize}
				\item	eq\\égal à
				\item 	gt\\plus grand que
				\item 	lt\\plus petit que
				\item 	ne\\différent de
				\item 	ge\\plus grand ou égal à
				\item 	le\\plus petit ou égal à
			\end{itemize}
			Par défaut, l'opérateur de comparaison est \emph{eq}.
			Aussi, on peut utiliser l'opérateur SQL \texttt{like}.
\end{itemize}
\subsection*{Exemples:}
\noindent Utilisation basique~:
\begin{verbatim}
select * from employes 
	where <dtml-sqltest name type="string">
\end{verbatim}
Si \texttt{name} est \emph{bob} alors cela donne~:
\begin{verbatim}
select * from employes 
	where name = 'bob'
\end{verbatim}
Valeurs multiples~:
\begin{verbatim}
select * from employes 
	where <dtml-sqltest empid type=int multiple>
\end{verbatim}
Si \texttt{empid} est égal à (12,14,17) alors cela donne~:
\begin{verbatim}
select * from employes
	where empid in (12,14,17)
\end{verbatim}
\subsection*{Voir aussi:}
\noindent balise \texttt{sqlgroup} ; balise \texttt{sqlvar}
\section{sqlvar : insère des variables dans une requète SQL}
\subsection*{Syntaxe:}
\begin{verbatim}
<dtml-sqlvar Variable | expr="Expression">
\end{verbatim}
La balise \texttt{sqlvar} ressemble à la balise \texttt{var} mais elle
est faite pour les requètes SQL.
\subsection*{Attributs:}
\begin{itemize}
	\item	type=cha\^\i ne\\Le type de la variable. Les types valides sont~:
			\texttt{string}, \texttt{int}, \texttt{float}, et \texttt{nb}.
			\texttt{nb} signifie ``cha\^\i ne non vide''. L'attribut type est requis
			et utilisé pour échapper correctement la variable
			insérée.
	\item	optional=booléen\\Si \textsc{vrai} et que la variable est null 
			ou non existante, alors rien n'est inséré.
\end{itemize}
\subsection*{Exemples:}
\noindent Utilisation basique~:
\begin{verbatim}
select * from employes  
	where nom=<dtml-sqlvar le_nom type="string">
\end{verbatim}
\subsection*{Voir aussi:}
\noindent balise \texttt{sqltest}
\section{string : Fonctions DTML sur les cha\^\i nes}
Le module \texttt{string} fournit des fonctions de manipulation de
cha\^\i ne, de conversion, et de recherche. C'est un module standard de Python.
\subsection*{atof(s)}
Convertit une cha\^\i ne \emph{s} en un nombre réel. La cha\^\i ne doit avoir
la syntaxe standard d'un nombre réel en Python, précédé
éventuellement d'un signe ( + ou - ).
\subsection*{atoi(s [, base])}
Convertit une cha\^\i ne \emph{s} en un entier dans la base donnée. La
cha\^\i ne doit consister en un ou plusieurs chiffres éventuellement
précédés d'un signe ( + ou - ). La base est par défaut 10. Si la base est 0
alors la base choisie dépend des premiers caractères de la cha\^\i ne
après le signe~: ``0x'' ou ``0X'' signifie 16, ``0'' signifie 8, tout le reste
signifie 10. Si la base est 16, les caractères ``0x'' ou ``0X'' sont acceptés
mais non obligatoires.
\subsection*{atol(s [,base])}
Convertit une cha\^\i ne \emph{s} en un entier long dans la base donnée.
La cha\^\i ne doit consister en un ou plusieurs chiffres éventuellement
précédés d'un signe ( + ou - ). l'argument \emph{base} a la même
signification que pour la fonction \emph{atoi()}. un ``l'' ou ``L'' final n'est
pas autorisé dans la cha\^\i ne \emph{s} sauf si la base est 0.
\subsection*{capitalize(mot)}
Met la première lettre du mot en majuscule.
\subsection*{capwords(cha\^\i ne)}
Sectionne la cha\^\i ne en mots (avec split), met en majuscule la première
lettre de chaque mot, et enfin rejoint les mots (avec join). Notez que
cela ne met qu'un caractère d'espace entre les mots et supprime tout
espace après le dernier mot.
\subsection*{find(cha\^\i ne, sub [,start [,end]])}
Retourne le plus petit indice dans la cha\^\i ne où la sous-cha\^\i ne
\emph{sub} est trouvée et telle que \emph{sub} est entre l'indice \emph{start}
et l'indice \emph{end}. Retourne -1 si pas de sous-cha\^\i ne trouvée.
\subsection*{rfind(s, sub [,start [,end]])}
Fait comme \emph{find} mais retourne le dernier indice où la
sous-cha\^\i ne est trouvée.
\subsection*{index(cha\^\i ne, sub [,start [,end]])}
Fait comme \emph{find} mais lève l'exception \texttt{ValueError} si
la sous-cha\^\i ne n'est pas trouvée.
\subsection*{rindex(cha\^\i ne, sub [,start [,end]])}
Fait comme \emph{rfind} mais lève l'exception \texttt{ValueError} si
la sous-cha\^\i ne n'est pas trouvée.
\subsection*{count(cha\^\i ne, sub [,start [,end]])}
Retourne le nombre d'occurences de la sous-cha\^\i ne \emph{sub} dans la
cha\^\i ne à partir de l'indice \emph{start}jusqu'à l'indice \emph{end}.
\subsection*{lower(cha\^\i ne)}
Retourne une copie de la cha\^\i ne en caractères minuscules.
\subsection*{makestrans(from, to)}
Retourne une table de translation passable à la fonction
\emph{translate()}. Cette table fait correspondre à chaque caractère de
la cha\^\i ne \emph{from} le caractère de la cha\^\i ne \emph{to} à la même
position. \emph{from} et \emph{to} doivent avoir la même taille.
\subsection*{split(cha\^\i ne, [,sep [,maxsplit]])}
Retourne une liste de mots séparés par \emph{sep} (espace, tabs et
retour charriot par défaut). Il y a au plus \emph{maxsplit} (0 par
défaut) occurences de split donc la liste fera au plus 
\emph{maxsplit+1} éléments.
\subsection*{join(mots [,sep])}
Concatene une liste ou un n-uplet de mots en ajoutant un séparateur
spécifié par \emph{sep} (un espace par défaut).
\subsection*{lstrip(cha\^\i ne)}
Retourne une copie de la cha\^\i ne sans les espaces éventuels de départ.
\subsection*{rstrip(cha\^\i ne)}
Retourne une copie de la cha\^\i ne sans les espaces éventuels de fin.
\subsection*{strip(cha\^\i ne)}
Retourne une copie de la cha\^\i ne sans les espaces éventuels de début
ni de fin.
\subsection*{wapcase(cha\^\i ne)}
Retourne une copie de la cha\^\i ne mais avec les minuscules transformés
en majuscules et vice versa.
\subsection*{translate(cha\^\i ne, table [,deletechars])}
Efface tous les caractères de la cha\^\i ne qui sont dans
\emph{deletechars} (si présent) puis convertit les caractères en utilisant 
la table qui doit être une cha\^\i ne de 256 caractères donnant la
correspondance pour chaque valeur de caractère, indexé par son ordinal.
\subsection*{upper(cha\^\i ne)}
Retourne une copie de la cha\^\i ne mais avec toutes les minuscules
converties en majuscules.
\subsection*{ljust(cha\^\i ne, largeur)}
Justifie à gauche la cha\^\i ne sur la largeur.
\subsection*{rjust(cha\^\i ne, largeur)}
Justifie à droite la cha\^\i ne sur la largeur.
\subsection*{center(cha\^\i ne, largeur)}
Centre la cha\^\i ne sur la largeur.
\subsection*{zfill(cha\^\i ne, largeur)}
Remplit de zéros la cha\^\i ne pour atteindre la largeur, tout en gardant
le signe à gauche.
\subsection*{replace(cha\^\i ne, old, new [, maxsplit])}
Retourne une copie de la cha\^\i ne avec toutes les occurences de
\emph{old} remplacées par \emph{new}. Si \emph{maxsplit} est donné, 
les premières occurences jusqu'à maxsplit sont remplacées.
\subsection*{Attributs:}
\begin{itemize}
	\item	digits\\la cha\^\i ne \texttt{0123456789}
	\item	hexdigits\\la cha\^\i ne \texttt{0123456789abcdefABCDEF}
	\item 	letters\\la concaténation de \emph{lowercase} 
			et de \emph{uppercase}
	\item 	lowercase\\la cha\^\i ne \texttt{abcdefghijklmnopqrstuvwxyz}
			généralement.
	\item 	octdigits\\la cha\^\i ne \texttt{01234567}
	\item 	uppercase\\ la cha\^\i ne \texttt{ABCDEFGHIJKLMNOPQRSTUVWXYZ}
			généralement.
	\item 	whitespace\\ tous les caractères considérés comme blancs, généralement~:
			l'espace, la tabulation, le linefeed, le return, le formfeed
			et la tabulation verticale.
\end{itemize}
\subsection*{Voir aussi:}
Le module \texttt{string} de Python
\section{tree : insère un arbre}
La balise \texttt{tree} affiche dynamiquement un arbre en invoquant
des objets Zope.
\subsection*{Syntaxe:}
\begin{verbatim}
<dtml-tree [Variable | expr="Expression"]>
</dtml-tree>
\end{verbatim}
La racine de l'arbre qui s'affichera est donné par la variable ou
l'expression ou l'objet courant par défaut. Le noeud courant est mis
dans l'espace des noms DTML. L'état de l'arbre est mis dans un
\emph{cookie}, donc, pour que cela fonctionne, les
\emph{cookies} doivent être en fonction.
\subsection*{Attributs:}
\begin{itemize}
	\item	branches=cha\^\i ne\\trouve les branches de l'arbre en 
			appelant la méthode nommée. La méthode par défaut est
			\texttt{tpValues} qui est supporté par la plupart des objets Zope.
	\item	branches\_expr=cha\^\i ne\\trouve les branches de l'arbre en évaluant 
			l'expression.
	\item 	id=cha\^\i ne\\le nom d'une méthode ou d'un identifiant pour déterminer
			l'état de l'arbre, par défaut \texttt{tpId} supporté par
			la plupart des objets Zope. (pour un usage avancé)
	\item 	url=cha\^\i ne\\le nom d'une méthode ou d'un attribut pour 
			déterminer les URLs des items de l'arbre, par défaut
			\texttt{tpURL} qui est supporté par la plupart des objets Zope.
			(utilisation avancée)
	\item 	leaves=cha\^\i ne\\le nom d'un document DTML ou d'une méthode pour afficher
			les noeuds qui n'ont pas de fils. Note~: ce document doit
			commencer avec \texttt{<dtml-var
			standard\_html\_header>} et finir avec
			\texttt{<standard\_html\_footer>} pour assurer un bon affichage de l'arbre.
	\item 	header=cha\^\i ne\\le nom d'un document DTML ou d'une méthode
			affichée avant les noeuds ouverts. Si le header n'est pas
			trouvé, il est sauté.
	\item 	footer=cha\^\i ne\\le nom d'un document DTML ou d'une méthode affichée
			après les noeuds ouverts. Si le footer n'est pas trouvé, il
			est sauté.
	\item 	nowrap=booléen\\si \textsc{vrai}, alors au lieu d'être enroulés, les noeuds
			seront tronqués pour remplir l'espace disponible.
	\item 	sort=cha\^\i ne\\trie les branches par l'attribut donné.
	\item 	reverse\\inverse l'ordre des branches.
	\item 	assume\_children=booléen\\suppose que les noeuds ont des fils. Ceci est utile
			si atteindre et appeler les noeuds fils est un process
			long. Cela résulte en l'affichage de signe + à tous les noeuds.
	\item 	single=booléen\\permet de n'ouvrir qu'une branche à la fois.
	\item 	skip\_unauthorized\\saute les noeuds que l'utilisateur n'est pas authorisé à voir,
			plutôt que de lever une exception.
	\item 	urlparam=cha\^\i ne\\une cha\^\i ne requète qui est incluse dans les liens d'ouverture et 
			de fermeture. (utilisation avancée)
\end{itemize}
\subsection*{Variables de balise:}
\begin{itemize}
	\item	tree-item-expanded\\\textsc{vrai} si le noeud courant est ouvert.
	\item	tree-item-url\\l'URL du noeud courant.
	\item 	tree-root-url\\l'URL du noeud racine.
	\item 	tree-level\\la profondeur du noeud courant. un noeud racine a une profondeur de 0.
	\item 	tree-colspan\\Le nombre de niveaux sur lequel est affiché l'arbre. Cette variable peut être
			utilisée avec la variable \texttt{treelevel} pour calculer les colones d'un
			tableau lorsqu'on insère des colonnes dans le tableau de l'arbre.
	\item 	tree-state\\l'état de l'arbre exprimé en liste et sous-lisetes d'identifiants. (utilisation avancée)
\end{itemize}
\subsection*{Variables de contrôle:}
\begin{itemize}
	\item	expand\_all\\si cette variable est \textsc{vrai}, alors l'arbre est entièrement ouvert.
	\item	collapse\_all\\si cette variable est \textsc{vrai}, alors l'arbre est entièrement fermé.
\end{itemize}
\subsection*{Exemples:}
\noindent Afficher l'arbre dont la racine est lobjet courant~:
\begin{verbatim}
<dtml-tree>
  <dtml-var title_or_id>
</dtml-tree>
\end{verbatim}
Afficher l'arbre dont la racine est un objet différent de l'objet courant, avec des branches particulières.
\begin{verbatim}
<dtml-tree expr="folder.object" branches="objectValues">
  Node id : <dtml-var getId>
</dtml-tree>
\end{verbatim}
\section{try : gère les exceptions}
La balise \texttt{try} vous permet de gérer les exceptions en DTML tout comme les
exceptions de Python \texttt{try/except} et \texttt{try/finally}.
\subsection*{Syntaxe:}
\begin{verbatim}
<dtml-try>  
<dtml-except [NomException] [NomException]...> ...
[<dtml-else>]
</dtml-try>
\end{verbatim}
La balise \texttt{try} forme un bloc dans lequel on peut attraper des exceptions en
donnant leur nom dans la balise \texttt{except}. Si la balise \texttt{except} est vide,
alors toutes les exceptions sont retenues. Lorsqu'une exception est levée, elle est
rattrapée par la balise \texttt{except}. Si cette balise ne contient pas l'exception
levée, alors cette dernière est propagée. Si aucune exception n'est propagée, alors c'est
le bloc \texttt{else} qui est éxécuté.
\begin{verbatim}
<dtml-try>
...
<dtml-finally>
...
</dtml-try>
\end{verbatim}
Le bloc \texttt{finally} est de toute façons exécuté, qu'il y ait ou non d'exception
levée. la balise \texttt{finally} ne peut pas être utilisé dans le même bloc \texttt{try}
que \texttt{except} ou \texttt{else}.
\subsection*{Attributs:}
\begin{itemize}
	\item	except\\+ noms d'exceptions. Si aucun nom n'est donné alors la balise gèrera toute exception levée.
\end{itemize}
\subsection*{Variables de balise:}
\noindent Dans un bloc \texttt{except}, ces variables sont définies~:
\begin{itemize}
	\item	error\_type\\le type d'exception.
	\item	error\_value\\la valeur de l'exception.
	\item 	error\_tb\\la pile d'erreur (traceback)
\end{itemize}
\subsection*{Exemples:}
\noindent Gérer une erreur mathématique~:
\begin{verbatim}
<dtml-try> 
<dtml-var expr="1/0">
<dtml-except ZeroDivisionError>
  Vous essayez de diviser par zéro.
</dtml-try>
\end{verbatim}
retourner une information sur l'exception retenue~:
\begin{verbatim}
<dtml-try>
<dtml-call Method_probleme>
<dtml-except>
Il y a eu une erreur !
Type de l'erreur: <dtml-var error_type>
Valeur: <dtml-var error_value>
</dtml-try>
\end{verbatim}
Utiliser la balise \texttt{finally} pour assurer une action, qu'il y ait exception ou non~:
\begin{verbatim}
<dtml-call prendLock>
<dtml-try>
  <dtml-call uneMethode> 
<dtml-finally>
  <dtml-call relacherLock>
</dtml-try>
\end{verbatim}
\subsection*{Voir aussi:}
\noindent balise \texttt{raise} ;
Tutorial Python : Erreurs et Exceptions\footnote{http://www.python.org/doc/current/tut/node10.html}
\section{unless : teste une condition}
\begin{verbatim}
<dtml-unless VariableCondition|expr="ExpressionCondition">
...
</dtml-unless>
\end{verbatim}
Si la condition est fausse alors le block contenu est exécuté. Une variable absente est
considérée comme fausse.
\subsection*{Exemples:}
\begin{verbatim}
<dtml-unless Test>
  <dtml-call Operation>
</dtml-unless>
\end{verbatim}
Ce bloc s'éxecutera si \texttt{Test} est faux ou n'existe pas.
\subsection*{Voir aussi:}
\noindent balise \texttt{if}
\section{var : insère une variable}
\subsection*{Syntaxe:}
\begin{verbatim}
<dtml-var Variable|expr="Expression">
\end{verbatim}
La balise \texttt{var} trouve une variable en la recherchant dans l'espace de noms
DTML qui consiste habituellement en l'objet courant, son conteneur, et enfin la
requète web. Si la variable est trouvée, elle est insérée à l'affichage du DTML, sinon
Zope lève une exception. On peut  appeler une variable DTML par le racourci suivant~:
\begin{verbatim}
&dtml-NomVariable
\end{verbatim}
On peut rechercher une variable dans un chemin d'attributs~:
\begin{verbatim}
&dtml.attribut1[.attribut2]...-NomVariable
\end{verbatim}
La spécification d'attribut désactive l'automatisation de la mise en forme HTML. On
peut donc interdire la mise en forme HTML d'une variable en l'appelant de la manière suivante~:
\begin{verbatim}
&dtml.-NomVariable
\end{verbatim}
\subsection*{Attributs:}
\begin{itemize}
	\item	html\_quote\\convertit les caractères qui ont un sens HTML en entités HTML.
	\item	missing=cha\^\i ne\\spécifie une valeur par défaut si Zope ne trouve pas la variable.
	\item 	fmt=cha\^\i ne\\formate une variable. Zope offre quelques format de variable y compris
			les cha\^\i nes de format en sytle C. Pour plus d'information, voir le manuel de
			référence
			Python\footnote{http://www.python.org/doc/current/lib/typesseq-strings.html}.
			Si la cha\^\i ne ne correspond pas à un format alors elle est prise comme étant une
			méthode de l'objet et est alors appelée. les formats intégrés sont~:
			\begin{itemize}
				\item	whole-dollars\\formate la variable en dollars.
				\item	dollars-and-cents\\formate en dollars et cents.
				\item 	collection-length\\la longueur d'une variable séquence.
				\item 	structured-text\\formate la variable en texte 
						structuré\footnote{http://www.zope.org/Members/millejoh/structuredText}
			\end{itemize}
	\item 	null=cha\^\i ne\\une valeur par défaut si la variable est None.
	\item 	lower\\convertit les majuscules en minuscules.
	\item 	upper\\convertit les minuscules en majuscules.
	\item 	capitalize\\met en majuscule la première lettre de chaque mot.
	\item 	spacify\\convertit les "\_" en espaces.
	\item 	thousands\_commas\\insère des virgules tous les trois chiffres à partir des unités. par exemple~:
			12000 devient 12,000.
	\item 	url\\insère l'URL de l'objet en appelant sa méthode \texttt{absolute\_url}.
	\item 	url\_quote\\convertit les caractères spéciaux des URLs en entités HTML.
	\item 	url\_quote\_plus\\apllique \texttt{url\_quote} et convertit les espaces en signes "+".
	\item 	sql\_quote\\convertit les guillements simlpes en paires de guillemets simples.
			Ceci est requis pour inclure des valeurs dans des cha\^\i nes SQL.
	\item 	newline\_to\_br\\convertit le caractère LF ou CR/LF en balise HTML \texttt{<BR>}.
	\item 	size=arg\\tronque la variable à la longueur spécifiée.
	\item 	etc=arg\\spécifie une cha\^\i ne à ajouter à la fin d'une cha\^\i ne tronquée, par défaut \dots
\end{itemize}
\subsection*{Exemples}
\noindent Insérer une simple variable dans un document DTML~:
\begin{verbatim}
<dtml-var standard_html_header>
\end{verbatim}
Troncature~:
\begin{verbatim}
<dtml-var couleurs size=10 etc=", etc.">
\end{verbatim}
Si couleurs est la cha\^\i ne ``rouge vert bleu'' alors le résultat sera~:
\begin{verbatim}
rouge vert, etc.
\end{verbatim}
Formatage en style C~:
\begin{verbatim}
<dtml-var expr="23432.2323" fmt="%.2f">
\end{verbatim}
deviendra~:
\begin{verbatim}
23432.23
\end{verbatim}
Insérer une variable \emph{link} dans une balise HTML~:
\begin{verbatim}
<A href="&dtml-link;">Lien</A>
\end{verbatim}
Insérer un lien vers un document \emph{doc}~:
\begin{verbatim}
<A href="&dtml.url-doc;"><dtml-var doc fmt="title_or_id"></A>
\end{verbatim}
Cet exemple appele la méthode \texttt{absolute\_url} de l'objet pour son URL (attribut url)
et son \texttt{title\_or\_id} pour son titre.
\section{with : regarder une variable DTML}
la balise \texttt{with} met un objet dans l'espace des noms DTML.
\subsection*{Syntaxe:}
\begin{verbatim}
<dtml-with Variable|expr="Expression">
...
</dtml-with>
\end{verbatim}
La variable est mise dans l'espace de noms DTML le temps de l'exécution du bloc \texttt{with}.
\subsection*{Attributs:}
\begin{itemize}
	\item	only\\limite l'espace de noms DTML à l'objet cité.
	\item	mapping\\indique que la variable est un pointeur.
\end{itemize}
\subsection*{Exemples:}
Regarder une variable dans l'objet REQUEST~:
\begin{verbatim}
<dtml-with REQUEST only>
  <dtml-if id>
    <dtml-var id>
  <dtml-else>
    'id' n'est pas dans la requete.
  </dtml-in>
</dtml-with>
\end{verbatim}
Mettre le premier fils dans le'espace de noms DTML~:
\begin{verbatim}
<dtml-with expr="objectValues()[0]">
Premier fils : <dtml-var id>
</dtml-with>
\end{verbatim}
\subsection*{Voir aussi:}
balise \texttt{let}.
\end{document}
