From cf21e1270ef7cd45a69ad9e25642e6aa7f9eecfc Mon Sep 17 00:00:00 2001 From: mohrt Date: Wed, 30 Apr 2003 18:48:44 +0000 Subject: [PATCH] add frech docs to cvs repository --- docs/fr/appendixes.sgml | 408 +++ docs/fr/common.dsl | 46 + docs/fr/designers.sgml | 5790 ++++++++++++++++++++++++++++++++++ docs/fr/getting-started.sgml | 427 +++ docs/fr/html-common.dsl | 382 +++ docs/fr/html.dsl | 21 + docs/fr/manual.sgml | 44 + docs/fr/php.dsl | 21 + docs/fr/preface.sgml | 77 + docs/fr/programmers.sgml | 3090 ++++++++++++++++++ 10 files changed, 10306 insertions(+) create mode 100644 docs/fr/appendixes.sgml create mode 100644 docs/fr/common.dsl create mode 100644 docs/fr/designers.sgml create mode 100644 docs/fr/getting-started.sgml create mode 100644 docs/fr/html-common.dsl create mode 100644 docs/fr/html.dsl create mode 100644 docs/fr/manual.sgml create mode 100644 docs/fr/php.dsl create mode 100644 docs/fr/preface.sgml create mode 100644 docs/fr/programmers.sgml diff --git a/docs/fr/appendixes.sgml b/docs/fr/appendixes.sgml new file mode 100644 index 00000000..791c5d9b --- /dev/null +++ b/docs/fr/appendixes.sgml @@ -0,0 +1,408 @@ + + Appendices + + Diagnostic des erreurs + + + Erreurs Smarty/PHP + + Smarty peut identifier de nombreuses erreurs comme des attributs de + balises manquants ou de noms de variables malformés. Dans ce cas-là, + vous verrez apparaître une erreur semblable à : + + +erreurs Smarty + +Warning: Smarty: [in index.tpl line 4]: syntax error: unknown tag - '%blah' + in /path/to/smarty/Smarty.class.php on line 1041 + +Fatal error: Smarty: [in index.tpl line 28]: syntax error: missing section name + in /path/to/smarty/Smarty.class.php on line 1041 + + + + Smarty vous indique le nom du template, le numéro de la ligne et l'erreur. + Après cela, vous pouvez connaître le numéro de ligne où il y a eu erreur dans + la définition de la classe Smarty. + + + + Il y a certaines erreurs que Smarty ne peut pas détecter, comme les + balises fermantes manquantes. Ce type d'erreurs est la plupart du temps + repéré dans la phase de compilation PHP du template compilé. + + + +erreur d'analyse PHP + +Parse error: parse error in /path/to/smarty/templates_c/index.tpl.php on line 75 + + + + Quand vous rencontrez une erreur d'analyse PHP, le numéro de la ligne + indiqué est celui du fichier PHP compilé et non du template. Vous pouvez alors + regarder le template et détecter l'erreur. Voici quelques erreurs fréquentes : + balises fermantes pour {if}{/if} ou {section}{/section} manquantes, ou + syntaxe logique incorrecte dans une instruction {if}. Si vous ne trouvez pas l'erreur, + vous devrez alors ouvrir le fichier PHP compilé et aller à la ligne correspondante pour + trouver d'où vient l'erreur. + + + + + Trucs et astuces + + + + Gestion des variables non-assignées + + Peut-être voudrez-vous des fois afficher une valeur par défaut pour + une variable qui n'a pas été assignée, comme pour afficher "&nbsp;" + afin que les couleurs de fond des tableaux fonctionnent. Beaucoup utiliseraient + une instruction {if} pour gérer cela, mais il existe un moyen plus facile dans + Smarty, l'utilisation du modificateur de variable default. + + +afficher &nbsp; quand une variable est vide + + +{* la méthode pas adaptée *} + +{if $title eq ""} + &nbsp; +{else} + {$title} +{/if} + + +{* la bonne méthode *} + +{$title|default:"&nbsp;"} + + + + + Gestion des variables par défaut + + Si une variable est utilisée fréquemment dans vos templates, + lui appliquer le modificateur par défaut peut être un peu fastidieux. + Vous pouvez remédier à cela en lui assignant une valeur par défaut + avec la fonction assign. + + +assigner une valeur par défaut à une variable de template + +{* faites cela qq part en haut de votre template *} +{assign var="title" value=$title|default:"no title"} + +{* si $title est vide, il contiendra alors no "no title" *} +{$title} + + + + Passage du titre à un template d'en-tête + + Quand la majorité de vos templates utilisent les mêmes en-tête et pied-de-page, + il est d'usage de les mettre dans leurs propres templates et de les inclure. + Mais comment faire si l'en-tête doit avoir un titre différent, selon la page + d'où on vient ? Vous pouvez passer le titre à l'en-tête quand il est inclus. + + +passer le titre au template d'en-tête + + +mainpage.tpl +------------ + +{include file="header.tpl" title="Main Page"} +{* le corps du template va ici *} +{include file="footer.tpl"} + + +archives.tpl +------------ + +{config_load file="archive_page.conf"} +{include file="header.tpl" title=#archivePageTitle#} +{* le corps du template va ici *} +{include file="footer.tpl"} + + +header.tpl +---------- +<HTML> +<HEAD> +<TITLE>{$title|default:"BC News"}</TITLE> +</HEAD> +<BODY> + + +footer.tpl +---------- +</BODY> +</HTML> + + + Quand la page principale est conçue, le titre "Main page" est passé à header.tpl + et sera donc utilisé pour le titre. Quand la page d'archive est conçue, + le titre sera "Archives". Notez que dans l'exemple des archives, on utilise + le fichier archives_page.conf plutôt que des variables codées en dur. + Remarquez aussi que "BC News" est affichée si la variable $title + n'est pas définie, grâce au modificateur de variable default. + + + + Dates + + De façon générale, essayez de toujours passer les dates à Smarty + sous forme de timestamp. Cela permet aux designers de templates d'utiliser + date_format + pour avoir un contrôle total sur le formatage des dates et de comparer + facilement les dates entre elles. + + + NOTE : à partir Smarty 1.4.0, vous pouvez passer les dates à Smarty + sous la forme de timestamps Unix ou MySQL, ou tout autre format de dates + que comprend strtotime(). + + +utilisation de date_format + +{$startDate|date_format} + +OUTPUT: + +Jan 4, 2001 + + +{$startDate|date_format:"%Y/%m/%d"} + +OUTPUT: + +2001/01/04 + + +{if $date1 < $date2} + ... +{/if} + + + En utilisant la fonction {html_select_date} dans un template, le programmeur + veut en général convertir le résultat d'un formulaire en un timestamp. + Voici une fonction qui devrait vous être utile. + + +conversion des éléments date d'un formulaire en timestamp + +// cela suppose que vos éléments de formulaire soient nommés +// startDate_Day, startDate_Month, startDate_Year + +$startDate = makeTimeStamp($startDate_Year,$startDate_Month,$startDate_Day); + +function makeTimeStamp($year="",$month="",$day="") +{ + if(empty($year)) + $year = strftime("%Y"); + if(empty($month)) + $month = strftime("%m"); + if(empty($day)) + $day = strftime("%d"); + + return mktime(0,0,0,$month,$day,$year); +} + + + + WAP/WML + + Les templates WAP/WML nécessitent un en-tête "Content-Type" qui doit être + passé avec le template. Le moyen le plus facile de faire cela est d'écrire + une fonction utilisateur qui écrit l'en-tête. Si vous utilisez le cache, + cela ne fonctionnera pas. Nous utiliserons donc une balise d'insertion + (rappelez-vous que les balises d'insertion ne sont pas mises en cache !). + Assurez-vous qu'aucune sortie + rien n'est transmise au navigateur avant l'appel du template, sans quoi + la modification de l'en-tête échouera. + + +utilisation d'insert pour écrire un en-tête Content-Type WML + +// assurez-vous que Apache est configuré pour les extensions .wml ! +// mettez cette fonction qq part dans votre applications +// ou dans Smarty.addons.php +function insert_header() { + // cette fonction attend un argument $content + extract(func_get_arg(0)); + if(empty($content)) + return; + header($content); + return; +} + +// votre template Smarty DOIT commencer avec la balise d'insertion + +<?xml version="1.0"?> +<!DOCTYPE wml PUBLIC "-//WAPFORUM//DTD WML 1.1//EN" "http://www.wapforum.org/DTD/wml_1.1.xml"> + +<!-- begin new wml deck --> +<wml> +<!-- begin first card --> +<card> +<do type="accept"> +<go href="#two"/> +</do> +<p> +Welcome to WAP with Smarty! +Press OK to continue... +</p> +</card> +<!-- begin second card --> +<card id="two"> +<p> +Pretty easy isn't it? +</p> +</card> +</wml> + + + + Templates composants + + Cette astuce tient plus du hack qu'autre chose mais n'en demeure pas + moins une idée plutôt chouette. Utilisez-la à vos propres risques. ;-) + + + Traditionnellemnt, la programmation avec des templates dans les applications + se déroule de la façon suivante : d'abord vous récupérez vos variables + dans l'application PHP (peut-être avec des requêtes en base de données), puis + vous instanciez votre objet Smarty, assignez les variables et affichez le + template. Disons par exemple que nous avons un téléscripteur dans + notre template. Nous récupérerions les données dans notre application, + puis les assignerions ensuite pour les afficher. Mais ne serait-ce pas + mieux de pouvoir ajouter ce téléscripteur à n'importe quelle application + en incluant directement le template sans avoir à se soucier de la récupération + des données. + + + Vous pouvez intégrer du PHP dans vos templates avec les balises + {php}{/php}. Avec cette méthode, vous pouvez inclure des templates complets, + dans la mesure où ils récupèrent leurs propres données pour les assigner + à leurs propres variables. Avec le traitement intégré + de cette façon, vous pouvez garder le template et le traitement ensemble. + Ainsi, on ne se soucie plus d'où vient le contenu du template, + tout vient comme un seul et unique composant. + + +template composant + +{* Smarty *} + +{php} + + // notre fonction pour récupérer les données + function fetch_ticker($symbol,&$ticker_name,&$ticker_price) { + // du traitement qui récupère $ticker_name + // $ticker_price + } + + // appelle la fonction + fetch_ticker("YHOO",$ticker_name,$ticker_price); + + // assigne les variables + $this->assign("ticker_name",$ticker_name); + $this->assign("ticker_price",$ticker_price); + +{/php} + +Stock Name: {$ticker_name} Stock Price: {$ticker_price} + + + A partir de Smarty 1.5.0, il y a même un moyen plus propre. Vous + pouvez inclure du PHP dans votre template avec la balise {include_php ...}. + De cette façon, vous pouvez garder séparée la logique applicative + de la logique de présentation. Reportez-vous à la fonction include_php pour plus + d'informations. + + +template composant avec include_php + +load_ticker.php +--------------- + +<?php + // notre fonction pour récupérer les données + function fetch_ticker($symbol,&$ticker_name,&$ticker_price) { + // put logic here that fetches $ticker_name + // and $ticker_price from some resource + } + + // appelle la fonction + fetch_ticker("YHOO",$ticker_name,$ticker_price); + + // assigne les variables + $this->assign("ticker_name",$ticker_name); + $this->assign("ticker_price",$ticker_price); +?> + + +index.tpl +--------- + +{* Smarty *} + +{include_php file="load_ticker.php"} + +Stock Name: {$ticker_name} Stock Price: {$ticker_price} + + + + Dissimuler les adresses email + + Vous-êtes vous déjà demandé pourquoi vos adresses emails sont sur autant + de mailing listes de spam ? Une façon pour les spammers de récupérer les + adresses est de parcourir les pages Web. Voici une façon de remédier + à ce problème : mettre votre adresse email dans du Javascript brouillé + au milieu de votre source HTML, sans que cela ne gêne l'affichage sur le + navigateur Web. Cela est fait grâce au plugin mailto. + + +exemple de dissimulation d'une adresse email + + +index.tpl +--------- + +Send inquiries to +{mailto address=$EmailAddress encode="javascript" subject="Hello"} + + + + + Note technique + + Cette méthode n'est pas infaillible. Un spammer peut programmer son + collecteur d'email pour passer outre cette astuce, mais c'est cependant + peu probable. + + + + + + Ressources + + La page Web de Smarty se trouve à l'adresse suivante : http://smarty.php.net/. + Vous pouvez souscrire à la mailing liste en envoyant un email à + smarty-general-subscribe@lists.php.net. + Les archives de la mailing list se trouvent à l'adresse suivante : + http://marc.theaimsgroup.com/?l=smarty&r=1&w=2 + + + + BUGS + + Vérifiez le fichier de BUGS fourni avec la dernière version de Smarty ou + consultez le site Web. + + + diff --git a/docs/fr/common.dsl b/docs/fr/common.dsl new file mode 100644 index 00000000..ad47f956 --- /dev/null +++ b/docs/fr/common.dsl @@ -0,0 +1,46 @@ +;; -*- Scheme -*- +;; +;; $Id$ +;; +;; This file contains stylesheet customization common to the HTML +;; and print versions. +;; + +;; Stylesheets Localization +(define %default-language% "en") + +(define %use-id-as-filename% #t) +(define %gentext-nav-tblwidth% "100%") +(define %refentry-function% #t) +(define %refentry-generate-name% #f) +(define %funcsynopsis-style% 'ansi) +(define ($legalnotice-link-file$ legalnotice) + (string-append "copyright" %html-ext%)) +(define %generate-legalnotice-link% #t) +(define %footnotes-at-end% #t) +(define %force-chapter-toc% #t) +(define newline "\U-000D") +(define %number-programlisting-lines% #f) +(define %linenumber-mod% 1) +(define %shade-verbatim% #t) + +(define ($generate-book-lot-list$) + ;; REFENTRY generate-book-lot-list + ;; PURP Which Lists of Titles should be produced for Books? + ;; DESC + ;; This parameter should be a list (possibly empty) of the elements + ;; for which Lists of Titles should be produced for each 'Book'. + ;; + ;; It is meaningless to put elements that do not have titles in this + ;; list. If elements with optional titles are placed in this list, only + ;; the instances of those elements that do have titles will appear in + ;; the LOT. + ;; + ;; /DESC + ;; AUTHOR N/A + ;; /REFENTRY + (list (normalize "table"))) + +(define (php-code code) + (make processing-instruction + data: (string-append "php " code "?"))) diff --git a/docs/fr/designers.sgml b/docs/fr/designers.sgml new file mode 100644 index 00000000..2c0802c4 --- /dev/null +++ b/docs/fr/designers.sgml @@ -0,0 +1,5790 @@ + + Smarty pour les graphistes + + + Bases syntaxiques + + Toutes les balises Smarty sont entourées de délimiteurs. Par défaut, + ces délimiteurs sont { et + }, mais ils peuvent être modifiés. + + + Pour ces exemples, nous supposons que vous utiliserez leur valeur par défaut. + Dans Smarty, le contenu qui est situé en dehors des délimiteurs + est affiché comme contenu statique, inchangé. Lorsque Smarty rencontre + des balises de template, il tente de les comprendre et en affiche la sortie + appropriée, en lieu et place. + + + + Commentaires + + Les commentaires dans Smarty sont entourés d'asterisques, de cette + façon : {* voici un commentaire *} + Les commentaires Smarty ne sont pas affichés dans la sortie finale du + template. + Ils sont utilisés pour des notes internes, dans le template, pour aider + les développeurs à en comprendre le fonctionnement. + + + Commentaires + +{* Smarty *} + +{* Inclusion de l'en tête *} +{include file="header.tpl"} + +{include file=$includeFile} + +{include file=#includeFile#} + +{* affiche des listes déroulantes *} +<SELECT name=company> +{html_options values=$vals selected=$selected output=$output} +</SELECT> + + + + + Fonctions + + Les balises Smarty affichent une variable + ou invoquent une fonction. Les fonctions sont appelées + lorsqu'elles sont entourées, ainsi que leurs paramètres, des délimiteurs Smarty. + Par exemple : {nomfonction par1="val" par2="val"}. + + + syntaxe des fonctions + +{config_load file="colors.conf"} + +{include file="header.tpl"} + +{if $name eq "Fred"} + Vous êtes admis dans cette zone +{else} + Bienvenue, <font color="{#fontColor#}">{$name}!</font> +{/if} + +{include file="footer.tpl"} + + + Les fonctions natives et les fonctions utilisateurs ont toutes deux la même + syntaxe, dans les templates. Les fonctions natives sont relatives + au traitement interne de Smarty, comme par exemple if, + section et strip. Elles ne peuvent + être modifiées. Les fonctions utilisateurs sont des fonctions additionnelles, + implémentées par l'intermédiaire de plugins. + Elles peuvent être modifiées pour correspondre à vos besoins, et vous + pouvez en créer de nouvelles. html_options et + html_select_date sont deux exemples de fonctions + utilisateurs. + + + + + Paramètres + + La plupart des fonctions attendent des paramètres qui régissent leur + comportement. Les paramètres des fonctions Smarty sont très proches des + attributs des balises HTML. Les valeurs numériques n'ont pas besoin d'être + entourées par des guillemets, par contre, ces guillemets sont recommandées lors + de l'utilisation de chaînes de caractères. Des variables peuvent aussi être + utilisées en tant que paramètres, et ne doivent pas être entourées de guillemets. + + + Certains paramètres requièrent des valeurs booléennes (true / false). + Elles peuvent être spécifiées par l'une des valeures suivantes, sans + guillemet: true, on, et yes, + ou false, off, et no. + + + Paramètres de fonction, syntaxe + +{include file="header.tpl"} + +{include file=$includeFile} + +{include file=#includeFile#} + +{html_select_date display_days=yes} + +<SELECT name=company> +{html_options values=$vals selected=$selected output=$output} +</SELECT> + + + + Variables insérées dans des chaînes de caractères + + Smarty est capable d'interpréter les variables insérées à l'intérieur de + chaînes entre guillemets, du moment que leur nom est exclusivement composé + de chiffres, lettres, underscores et crochets. Si le nom de la variable + contient tout autre caractère (point, référence à un objet, etc.) + la variable doit être entourée d'apostrophes inverses (`). + + + Syntaxe d'insertion de variables dans des chaînes + +EXEMPLE DE SYNTAXE: +{func var="test $foo test"} <-- comprends $foo +{func var="test $foo_bar test"} <-- comprends $foo_bar +{func var="test $foo[0] test"} <-- comprends $foo[0] +{func var="test $foo[bar] test"} <-- comprends $foo[bar] +{func var="test $foo.bar test"} <-- comprends $foo (not $foo.bar) +{func var="test `$foo.bar` test"} <-- comprends $foo.bar + +EXEMPLE PRATIQUE: +{include file="subdir/$tpl_name.tpl"} <-- remplace $tpl_name avec la valeur +{cycle values="one,two,`$smarty.config.myval`"} <-- doit comporter les +apostrophes inverses + + + + + + + Variables + + Smarty possède différents types de variables. Le type de ces variables dépend + du symbole qui les préfixe, ou des symboles qui les entourent. + + + + Les variables de Smarty peuvent être soit affichées directement, soit utilisées + comme arguments pour les fonctions et modificateurs, à l'intérieur d'expressions + conditionnelles, etc. + Pour afficher une variable, il suffit de l'entourer par des délimiteurs de + telle sorte qu'elle soit la seule chose qu'ils contiennent. Exemple : + +{$Nom} + +{$Contacts[enreg].Telephone} + +<body bgcolor="{#bgcolor#}"> + + + + Variables assignées depuis PHP + + Pour utiliser une variables assignées depuis PHP, il faut la préfixer par le + symbole dollar $. Les variables asignées depuis un + template grâce à la fonction assign + sont manipulées de la même façon. + + + + Variables assignées + +Bienvenue {$prenom}, heureux de voir que tu es arrivé ici. +<p> +La dernière connexion remonte au {$dateConnexionPrecedente}. + +SORTIE: + +Bienvenue Doug, heureux de voir que tu est arrivé ici. +<p> +La dernière connexion remonte au 11 janvier 2001. + + + + Tableaux associatifs + + Vous pouvez également utiliser des variables sous forme de tableaux + associatifs assignées depuis PHP en en spécifiant la clef, + après le symbole '.' (point). + + +accéder aux variables de tableaux associatifs + +index.php: + +$smarty = new Smarty; +$smarty->assign('Contacts', + array('fax' => '555-222-9876', + 'email' => 'zaphod@slartibartfast.com', + 'phone' => array('home' => '555-444-3333', + 'cell' => '555-111-1234'))); +$smarty->display('index.tpl'); + +index.tpl: + +{$Contacts.fax}<br> +{$Contacts.email}<br> +{* you can print arrays of arrays as well *} +{$Contacts.phone.home}<br> +{$Contacts.phone.cell}<br> + +SORTIE: + +555-222-9876<br> +zaphod@slartibartfast.com<br> +555-444-3333<br> +555-111-1234<br> + + + + Tableaux indexés + + Vous pouvez utiliser des tableaux indexés de la même façon que vous le + faites en PHP. + + +Accès aux tableaux grâce à l'index + +index.php: + +$smarty = new Smarty; +$smarty->assign('Contacts', + array('555-222-9876', + 'zaphod@slartibartfast.com', + array('555-444-3333', + '555-111-1234'))); +$smarty->display('index.tpl'); + +index.tpl: + +{$Contacts[0]}<br> +{$Contacts[1]}<br> +{* you can print arrays of arrays as well *} +{$Contacts[2][0]}<br> +{$Contacts[2][1]}<br> + +SORTIE: + +555-222-9876<br> +zaphod@slartibartfast.com<br> +555-444-3333<br> +555-111-1234<br> + + + + Objets + + Les attributs des objets assignés depuis PHP peuvent être utilisées en + en spécifiant le nom après le symbole '->'. + + +accéder aux attributs des objets + +nom: {$person->name}<br> +email: {$person->email}<br> + +SORTIE: + +nom: Zaphod Beeblebrox<br> +email: zaphod@slartibartfast.com<br> + + + + + + Variables chargées depuis des fichiers de configuration + + Les variables récupérées depuis un fichier de configuration sont utilisées + entourées du symbole dièse (#), ou via la variable spéciale smarty + $smarty.config. + + + +variables de fichiers de configuration + +foo.conf: + +pageTitle = "C'est le mien" +bodyBgColor = "#eeeeee" +tableBorderSize = "3" +tableBgColor = "#bbbbbb" +rowBgColor = "#cccccc" + +index.tpl: + +{config_load file="foo.conf"} +<html> +<title>{#pageTitle#}</title> +<body bgcolor="{#bodyBgColor#}"> +<table border="{#tableBorderSize#}" bgcolor="{#tableBgColor#}"> +<tr bgcolor="{#rowBgColor#}"> + <td>First</td> + <td>Last</td> + <td>Address</td> +</tr> +</table> +</body> +</html> + +index.tpl: (alternate syntax) + +{config_load file="foo.conf"} +<html> +<title>{$smarty.config.pageTitle}</title> +<body bgcolor="{$smarty.config.bodyBgColor}"> +<table border="{$smarty.config.tableBorderSize}" bgcolor="{$smarty.config.tableBgColor}"> +<tr bgcolor="{$smarty.config.rowBgColor}"> + <td>First</td> + <td>Last</td> + <td>Address</td> +</tr> +</table> +</body> +</html> + + +SORTIE: (same for both examples) + +<html> +<title>C'est le mien</title> +<body bgcolor="#eeeeee"> +<table border="3" bgcolor="#bbbbbb"> +<tr bgcolor="#cccccc"> + <td>First</td> + <td>Last</td> + <td>Address</td> +</tr> +</table> +</body> +</html> + + + Les variables de fichier de configuration ne peuvent être utilisés tant + qu'elles n'ont pas été chargées. Cette procédure est expliquée + plus loin dans le document, voir config_load. + + + + + Variable réservée {$smarty} + + La variable réservée {$smarty} peut être utilisée pour accéder à plusieurs + variables spéciales du template. En voici la liste complète. + + + + Variables de requête + + Les variables de requête comme GET, POST, COOKIES, SERVER, ENVIRONNEMENT + et SESSION peuvent être utilisées comme dans l'exemple suivant: + + + + Afficher des variables de requête + +{* Affiche la valeur de page dans l'url (GET) http://www.domain.com/index.php?page=foo *} +{$smarty.get.page} + +{* affiche la variable "page" récupérée depuis un formulaire (POST) *} +{$smarty.post.page} + +{* affiche la valeur du cookie "utilisateur" *} +{$smarty.cookies.utilisateur} + +{* affiche la variable serveur "SERVER_NAME" *} +{$smarty.server.SERVER_NAME} + +{* affiche la variable d'environnement "PATH" *} +{$smarty.env.PATH} + +{* affiche la variable de session PHP "id" *} +{$smarty.session.id} + +{* affiche la variable "utilisateur" du regroupement de get/post/cookies/server/env *} +{$smarty.request.utilisateur} + + + + + {$smarty.now} + + Le timestamp courant peut être récupéré grâce à {$smarty.now}. + Le nombre obtenu correspond au nombre de secondes écoulées depuis + Epoch (1 Janvier 1970) et peut être passé directement au modificateur + de variable date à des fins d'affichage. + + + +utilisation de {$smarty.now} + +{* utilise le modificateur de variable date_format pour afficher la date et heure *} +{$smarty.now|date_format:"%d-%m-%Y %H:%M:%S"} + + + + {$smarty.const} + + Vous pouvez directement accéder aux constantes PHP. + + + +Utiliser {$smarty.const} + +{$smarty.const._MA_CONSTANTE_} + + + + + {$smarty.capture} + + La capture réalisée via {capture}..{/capture} peut être récupérée + par l'intermédiaire de la variable {$smarty}. Voir la section + sur capture pour un + exemple à ce sujet. + + + + + {$smarty.config} + + La variable {$smarty} peut être utilisée pour désigner une variable + d'un fichier de configuration. {$smarty.config.foo} est un synonyme de + {#foo#}. Voir la section config_load + pour un exemple à ce sujet. + + + + + {$smarty.section}, {$smarty.foreach} + + La variable {$smarty} peut être utilisée pour accéder aux propriétés + des boucles 'section' et 'foreach'. Voir la documentation de + section et + foreach. + + + + + {$smarty.template} + + Cette variable contient le nom du template en cours de traitement. + + + + + + + + Modificateurs de variables + + Les modificateurs de variables peuvent être appliqués aux variables, + fonctions utilisateurs ou chaînes de caractères. Pour appliquer un modificateur + de variable, tappez une valeure suivie de | + (pipe) et du nom du modificateur. Un modificateur de variable + est succeptible d'accepter des paramètres additionnels, qui en affectent + le comportement. Ces paramètres suivent le nom du modificateur et + sont séparés par un : (deux points). + + + Exemple de modificateur + +{* Met le titre en majuscule *} +<h2>{$title|upper}</h2> + +{* Tronque le sujet à 40 caractères, place des "..." à la fin *} +Sujet: {$sujet|truncate:40:"..."} + +{* formatage en chaîne *} +{"now"|date_format:"%Y/%m/%d"} + +{* application d'un modificateur à une fonction utilisateur *} +{mailto|upper address="me@domain.dom"} + + + Si vous appliquez un modificateur de variable à un tableau plutôt qu'à une + variable simple, le modificateur sera appliqué à chaque valeur du tableau. + Si vous souhaitez que le modificateur travaille réellement avec le tableau + en tant que tel, vous devez préfixer le nom du modificateur avec un symbole + @ comme ceci: {$titreArticle|@count} + (Affiche le nombre d'élements du tableau $titreArticle.) + + + + capitalize + + Met la première lettre de chaque mot d'une variable en majuscule. + + + capitalize + +index.php: + +$smarty = new Smarty; +$smarty->assign('titreArticle', 'La police commence une campagne de sensibilisation contre la violence routière.'); +$smarty->display('index.tpl'); + +index.tpl: + +{$titreArticle} +{$titreArticle|capitalize} + +SORTIE: + +La police commence une campagne de sensibilisation contre la violence routière. +La Police Commence Une Campagne De Sensibilisation Contre La Violence Routière. + + + + count_characters + + Compte le nombre de caractères dans une variable. + + +count_characters + +index.php: + +$smarty = new Smarty; +$smarty->assign('titreArticle', 'Vagues de froid liées à la température.'); +$smarty->display('index.tpl'); + +index.tpl: + +{$titreArticle} +{$titreArticle|count_characters} + +SORTIE: + +Vagues de froid liées à la température. +39 + + + + + cat + + + + + + + + + + Position du paramètre + Type + Requis + cat + Description + + + + + 1 + chaîne de caractères + Non + empty + Valeur à concaténer à la variable donnée. + + + + + + Cette valeur est concaténée à la variable donnée. + + +cat + +index.php: + +$smarty = new Smarty; +$smarty->assign('TitreArticle', 'Les devins ont prévus que le monde existera toujours '); +$smarty->display('index.tpl'); + +index.tpl: + +{$TitreArticle|cat:" demain."} + +SORTIE: + +Les devins ont prévus que le monde existera toujours demain. + + + + count_paragraphs + + Compte le nombre de paragraphes dans une variable. + + +count_paragraphs + +index.php: + +$smarty = new Smarty; +$smarty->assign('TitreArticle', 'La guerre apporte la paix, au prix de la vie de certains innocents.'); +$smarty->display('index.tpl'); + +index.tpl: + +{$TitreArticle} +{$TitreArticle|count_paragraphs} + +SORTIE: + +La guerre apporte la paix, au prix de la vie des innocents. +1 + + + + count_sentences + + Compte le nombre de phrases dans une variable. + + +count_sentences + +index.php: + +$smarty = new Smarty; +$smarty->assign('TitreArticle', 'Deux navires rentrent en +collision - Un des deux coule. Des vaches enragées blessent un fermier à +coups de haches.'); +$smarty->display('index.tpl'); + +index.tpl: + +{$TitreArticle} +{$TitreArticle|count_sentences} + +SORTIE: +Deux navires rentrent en collision +- Un des deux coule. Des vaches enragées blessent un fermier +à coups de haches. + +2 + + + + count_words + + Compte le nombre de mots dans une variable. + + +count_words + +index.php: + +$smarty = new Smarty; +$smarty->assign('TitreArticle', 'Un anneau pour les gouverner tous.'); +$smarty->display('index.tpl'); + +index.tpl: + +{$titreArticle} +{$titreArticle|count_words} + +SORTIE: + +Un anneau pour les gouverner tous. +6 + + + + date_format + + + + + + + + + + Position du paramètre + Type + Requis + Defaut + Description + + + + + 1 + chaîne de caractères + Non + %b %e, %Y + Format de sortie de la date. + + + 2 + chaîne de caractères + Non + n/a + Date par défaut si aucune n'est spécifiée en entrée. + + + + + + Formate une date / heure au format strftime donné. Les dates peuvent + être passées à smarty en tant que timestamp unix, timestamp mysql ou + comme chaîne quelconque contenant mois jour année (interprétable par + strtotime). Les concepteurs de templates peuvent utiliser date_format + pour contrôler parfaitement le format de sortie de la date. + Si la date passée à date_format est vide, et qu'un second paramètre + est donné, ce dernier sera utilisé comme étant la date à formater. + + +date_format + +index.php: + +$smarty = new Smarty; +$smarty->assign('hier', strtotime('-1 day')); +$smarty->display('index.tpl'); + +index.tpl: + + +{$smarty.now|date_format} +{$smarty.now|date_format:"%A, %B %e, %Y"} +{$smarty.now|date_format:"%H:%M:%S"} +{$hier|date_format} +{$hier|date_format:"%A, %B %e, %Y"} +{$hier|date_format:"%H:%M:%S"} + +SORTIE: + +Feb 6, 2001 +Tuesday, February 6, 2001 +14:33:00 +Feb 5, 2001 +Monday, February 5, 2001 +14:33:00 + + +date_format indicateurs de convertion + +%a - Abréviation du jour de la semaine, selon les paramètres locaux. + +%A - Nom du jour de la semaine, selon les paramètres locaux. + +%b - Abréviation du nom du jour, selon les paramètres locaux. + +%B - Nom complet du mois, selon les paramètres locaux. + +%c - Préférences d'affichage selon les paramètres locaux. + +%C - Siècle, (L'année divisée par 100 et tronquée comme un entier, de 00 à 99) + +%d - Jour du mois, en tant que nombre décimal (de 00 à 31) + +%D - même chose que %m/%d/%y + +%e - Jour du mois en tant que nombre décimal. Un chiffre unique est précédé par +un espace (de 1 à 31) + +%g - Position de la semaine dans le siècle [00,99] + +%G - Position de la semaine, incluant le siècle [0000,9999] + +%h - identique à %b + +%H - L'heure en tant que décimale, en utilisant une horloge sur 24 (de 00 à 23) + +%I - L'heure en tant que décimale en utilisant une horloge sur 12 (de 01 to 12) + +%j - jour de l'année (de 001 à 366) + +%k - Heure (horloge sur 24). Les numéros à un chiffre sont précédés d'un espace. (de 0 à 23) + +%l - Heure (horloge sur 12). Les numéros à un chiffre sont précédés d'un espace. (de 1 à 12) + +%m - Mois en tant que nombre décimal (de 01 à 12) + +%M - Minute en tant que nombre décimal + +%n - Retour chariot (nouvelle ligne). + +%p - soit am soit pm selon l'heure donnée, ou alors leurs correspondances locales. + +%r - heure en notation a.m. et p.m. + +%R - Heure au format 24 heures + +%S - Secondes en tant que nombre décimal. + +%t - Caractère tabulation. + +%T - Heure courante, équivalent à %H:%M:%S + +%u - Jour de la semaine en tant que nombre décimal [1,7], ou 1 représente le lundi. + +%U - Le numéro de la semaine en nombre décimal, utilisant le premier dimanche +en tant que premier jour de la première semaine. + +%V - Le numéro de la semaine de l'année courante selon la norme ISO 8601:1988, + de 01 à 53, ou la semaine 1 est la première semaine qui dispose au minimum + de 4 jours dans l'année courante et ou Lundi est le premier jour + de cette semaine. + +%w - Jour de la semaine en tant que nombre décimal, dimanche étant 0 + +%W - Le numéro de la semaine de l'année courante en tant que nombre décimal, + ou Lundi est le premier jour de la première semaine. + +%x - Représentation préférée de la date selon les paramètres locaux. + +%X - Représentation préférée de l'heure selon les paramètres locaux, sans la + date. + +%y - L'année en tant que nombre décimal, sans le siècle. (de 00 à 99) + +%Y - L'année en tant que nombre décimal, avec le siècle. + +%Z - Zone horraire, nom ou abréviation + +%% - Un caractère litéral `%' + +NOTE AUX DEVELOPPEURS: date_format est un alias de la fonction +PHP strftime(). Il est probable que vous disposiez de plus ou moins d'options +disponibles selon le système sur lequel PHP a été compilé (strftime ()). +Reportez vous à l'aide de votre système pour une liste complète des +paramètres disponibles. + + + + + default + + + + + + + + + + Position du paramètre + Type + Requis + Defaut + Description + + + + + 1 + chaîne de caractères + Non + empty + La valeur par défaut de la sortie si la variable + d'entrée est vide. + + + + + + Utilisé pour définir une valeur par défaut à une variable. + Si la variable est vide ou indéfinie, la valeur donnée est affichée + en lieu et place. Default attends un seul argument. + + +default + +index.php: + +$smarty = new Smarty; +$smarty->assign('TitreArticle', 'Les portes de la moria restent fermées.'); +$smarty->display('index.tpl'); + +index.tpl: + +{$TitreArticle|default:"pas de titre"} +{$monTitre|default:"pas de titre"} + +SORTIE: + +Les portes de la moria restent fermées. +pas de titre + + + + escape + + + + + + + + + + + Position du paramètre + Type + Requis + Valeurs possibles + Defaut + Description + + + + + 1 + chaîne de caractère + Non + html, htmlall, url, quotes, hex, hexentity, + javascript + html + Format d'échappement à utiliser. + + + + + + "Echappe" les caractères spéciaux html, d'url, pour + les quotes d'une chaîne, les valeurs + hexadécimales, les entités hexadécimales ou javascript. + Par défaut, ce paramètre est html. + + +escape + +index.php: + +$smarty = new Smarty; +$smarty->assign('TitreArticle', "'Stiff Opposition Expected to Casketless Funeral Plan'"); +$smarty->display('index.tpl'); + +index.tpl: + +{$titreArticle} +{$titreArticle|escape} +{$titreArticle|escape:"html"} {* escapes & " ' < > *} +{$titreArticle|escape:"htmlall"} {* escapes ALL html entities *} +{$titreArticle|escape:"url"} +{$titreArticle|escape:"quotes"} +<a +href="mailto:{$EmailAddress|escape:"hex"}">{$EmailAddress|escape:"hexentity"}</a> + +SORTIE: + +'Stiff Opposition Expected to Casketless Funeral Plan' +'Stiff%20Opposition%20Expected%20to%20Casketless%20Funeral%20Plan' +'Stiff%20Opposition%20Expected%20to%20Casketless%20Funeral%20Plan' +'Stiff%20Opposition%20Expected%20to%20Casketless%20Funeral%20Plan' +'Stiff+Opposition+Expected+to+Casketless+Funeral+Plan' +\'Stiff Opposition Expected to Casketless Funeral Plan\' +<a +href="mailto:%62%6f%62%40%6d%65%2e%6e%65%74">&#x62;&#x6f;&#x62;&#x40;&#x6d;&#x65;&#x2e;&#x6e;&#x65;&#x74;</a> + + + + indent + + + + + + + + + + Position du paramètre + Type + Requis + Defaut + Description + + + + + 1 + entier + Non + 4 + De combien de caractères l'indentation doit être effectuée. + + + 2 + chaîne de caractère + Non + (espace) + Caractère à utiliser pour l'indentation. + + + + + + Indente chacune des lignes d'une chaîne. Comme paramètre optionnel, + vous pouvez spécifier le nombre de caractères à utiliser pour l'indentation (4 par défaut). + Comme second paramètre optionnel, vous + pouvez spécifier le caractère à utiliser pour l'indentation (utilisez + "\t" pour les tabulations). + + +indent + +index.php: + +$smarty = new Smarty; +$smarty->assign('TitreArticle', 'Il fera noir cette nuit.'); +$smarty->display('index.tpl'); + +index.tpl: + +{$TitreArticle} + +{$TitreArticle|indent} + +{$TitreArticle|indent:10} + +{$TitreArticle|indent:1:"\t"} + +SORTIE: + +Il fera noir cette nuit. + + Il fera noir cette nuit. + + Il fera noir cette nuit. + + Il fera noir cette nuit. + + + + + lower + + Met une variable en minuscules. + + +lower + +index.php: + +$smarty = new Smarty; +$smarty->assign('TitreArticle', 'Deux Suspects Se Sont Sauvés.'); +$smarty->display('index.tpl'); + +index.tpl: + +{$TitreArticle} +{$TitreArticle|lower} + +SORTIE: + +Deux Suspects Se Sont Sauvés. +deux suspects se sont sauvés. + + + + nl2br + + Transforme toutes les fins de lignes en balises <br />. + Equivalent à la fonction PHP nl2br(). + + +nl2br + +index.php: + +$smarty = new Smarty; +$smarty->assign('TitreArticle', "Pluie ou soleil attendu\naujourd'hui, nuit noire"); +$smarty->display('index.tpl'); + +index.tpl: + +{$TitreArticle|nl2br} + +SORTIE: + +Pluie ou soleil attendu<br />aujourd'hui, nuit noire + + + + regex_replace + + + + + + + + + + Position du paramètre + Type + Requis + Defaut + Description + + + + + 1 + chaîne de caractère + Oui + n/a + Expression régulière à remplacer. + + + 2 + chaîne de caractère + Oui + n/a + La chaîne de remplacement. + + + + + + Un rechercher / remplacer avec une expression régulière. Utilise la même + syntaxe que la fonction PHP preg_replace. + + +regex_replace + +index.php: + +$smarty = new Smarty; +$smarty->assign('TitreArticle', "L'infertilité est un maux grandissant\n, disent les experts."); +$smarty->display('index.tpl'); + +index.tpl: + +{* Remplace tous les retours chariot et les tabulation par une nouvelle ligne avec un espace *} + +{$TitreArticle} +{$TitreArticle|regex_replace:"/[\r\t\n]/":" "} + +SORTIE: + +L'infertilité est un maux grandissant +, disent les experts. +L'infertilité est un maux grandissant, disent les experts. + + + + replace + + + + + + + + + + Position du paramètre + Type + Requis + Defaut + Description + + + + + 1 + chaîne de caractères + Oui + n/a + chaîne à remplacer. + + + 2 + chaîne de caractères + Oui + n/a + chaîne de remplacement. + + + + + + Un simple remplacement de chaîne de caractères. + + +replace + +index.php: + +$smarty = new Smarty; +$smarty->assign('titreArticle', "Child's Stool Great for Use in Garden."); +$smarty->display('index.tpl'); + +index.tpl: + +{$titreArticle} +{$titreArticle|replace:"Garden":"Vineyard"} +{$titreArticle|replace:" ":" "} + +SORTIE: + +Child's Stool Great for Use in Garden. +Child's Stool Great for Use in Vineyard. +Child's Stool Great for Use in Garden. + + + + spacify + + + + + + + + + + Position du paramètre + Type + Requis + Defaut + Description + + + + + 1 + chaîne de caractère + Non + espace + Ce qui est inséré entre chaque caractère de la variable. + + + + + + spacify est un moyen pour insérer un espace entre tous les caractères + d'une variable. Optionnellement, vous pouvez lui passer un caractère + (ou une chaîne) différent de espace à insérer. + + +spacify + +index.php: + +$smarty = new Smarty; +$smarty->assign('titreArticle', 'Quelque chose s'est mal passé et à provoqué +cet accident, disent les experts'); +$smarty->display('index.tpl'); + +index.tpl: + +{$titreArticle} +{$titreArticle|spacify} +{$titreArticle|spacify:"^^"} + +SORTIE: + +Quelquechose s'est mal passé et à provoqué cet accident, disent les experts. +Q u e l q u e c h o s e s ' e s t m a l p a s s é e t à p r o v o q u é c e t a c c i d e n t , d i s e n t l e s e x p e r t s . +Q^^u^^e^^l^^q^^u^^e^^c^^h^^o^^s^^e^^ ^^s^^'^^e^^s^^t^^ ^^m^^a^^l^^ ^^p^^a^^s^^s^^é^^ ^^e^^t^^ ^^à^^ ^^p^^r^^o^^v^^o^^q^^u^^é^^ ^^c^^e^^t^^ ^^a^^c^^c^^i^^d^^e^^n^^t^^,^^ ^^d^^i^^s^^e^^n^^t^^ ^^l^^e^^s^^ ^^e^^x^^p^^e^^r^^t^^s^^. + + + + string_format + + + + + + + + + + Position du paramètre + Type + Requis + Defaut + Description + + + + + 1 + chaîne de caractères + Oui + n/a + Le format à utiliser (sprintf) + + + + + + Un moyen pour formater les chaînes de caractères, comme par exemple les + nombres décimaux. Utilise la syntaxe de sprintf pour formater les éléments. + + +string_format + +index.php: + +$smarty = new Smarty; +$smarty->assign('nombre', 23.5787446); +$smarty->display('index.tpl'); + +index.tpl: + +{$nombre} +{$nombre|string_format:"%.2f"} +{$nombre|string_format:"%d"} + +SORTIE: + +23.5787446 +23.58 +24 + + + + strip + + Remplace les espaces multiples, les nouvelles lignes et les tabulations + par un espace simple, ou une chaîne donnée. + + + Note + + Si vous voulez réaliser cette action sur un bloc complet du template, + utilisez la fonction strip. + + + +strip + +index.php: + +$smarty = new Smarty; +$smarty->assign('titreArticle', "Une réunion autour\n d'un feu de cheminée\t +est toujours agréable."); +$smarty->display('index.tpl'); + +index.tpl: + +{$titreArticle} +{$titreArticle|strip} +{$titreArticle|strip:"&nbsp;"} + +SORTIE: + +Une réunion autour + d'un feu de cheminée est toujours agréable. +Une réunion autour d'un feu de cheminée est toujours agréable. +Une&nbsp;réunion&nbsp;autour&nbsp;d'un&nbsp;feu&nbsp;de&nbsp;cheminée&nbsp;est&nbsp;toujours +&nbsp;agréable. + + + + strip_tags + + Supprime toutes les balises, et plus généralement tout ce qui se trouve + entre < et >. + + +strip_tags + +index.php: + +$smarty = new Smarty; +$smarty->assign('titreArticle', "Une femme aveugle obtient un nouveau <font face=\"helvetica\"> +rein</font> d'un père qu'elle n'a pas vu depuis<b> des années</b>."); +$smarty->display('index.tpl'); + +index.tpl: + +{$titreArticle} +{$titreArticle|strip_tags} + +SORTIE: + +Une femme aveugle obtient un nouveau <font face=\"helvetica\"> +rein</font> d'un père qu'elle n'a pas vu depuis<b> des années</b>. +Une femme aveugle obtient un nouveau rein d'un père +qu'elle n'a pas vu depuis des années. + + + + truncate + + + + + + + + + + Position du paramètre + Type + Requis + Defaut + Description + + + + + 1 + entier + Non + 80 + Le nombre de caractères maximums au-delà duquel + on effectue le troncage + + + 2 + chaîne de caractère + Non + ... + Le texte à rajouter lorsque l'on effectue un + troncage. + + + 3 + booléen + Non + false + Détermine si le troncage est effectué sur + le dernier mot (false), ou au caractère exact (true). + + + + + + + Tronque une variable à une certaine longueur, par défaut 80. + Un second paramètre optionnel permet de spécifier une chaîne à afficher + à la fin de la variable une fois tronquée. Les caractères de fin sont + inclus dans la longueur de la chaîne à tronquer. Par défaut, + truncate tentera de couper la chaîne à la fin d'un mot. Si vous voulez + tronquer la chaîne au caractère exact, donnez la valeur true au + dernier paramètre optionnel. + + +truncate + +index.php: + +$smarty = new Smarty; +$smarty->assign('titreArticle', 'Deux soeurs réunies après 18 ans de séparation.'); +$smarty->display('index.tpl'); + +index.tpl: + +{$titreArticle} +{$titreArticle|truncate} +{$titreArticle|truncate:30} +{$titreArticle|truncate:30:""} +{$titreArticle|truncate:30:"---"} +{$titreArticle|truncate:30:"":true} +{$titreArticle|truncate:30:"...":true} + +SORTIE: + +Deux soeurs réunies après 18 ans de séparation. +Deux soeurs réunies après... +Deux soeurs réunies après +Deux soeurs réunies après--- +Deux soeurs réunies après 18 a +Deux soeurs réunies après 1... + + + + + upper + + Met une variable en majuscules. + + +upper + +index.php: + +$smarty = new Smarty; +$smarty->assign('titreArticle', "Si l'attaque n'est pas mise en place +rapidement, cela risque de durer longtemps."); +$smarty->display('index.tpl'); + +index.tpl: + +{$titreArticle} +{$titreArticle|upper} + +SORTIE: + +Si l'attaque n'est pas mise en place rapidement, cela risque de durer longtemps. +SI L'ATTAQUE N'EST PAS MISE EN PLACE RAPIDEMENT, CELA RISQUE DE DURER LONGTEMPS. + + + + wordwrap + + + + + + + + + + Position du paramètre + Type + Requis + Defaut + Description + + + + + 1 + entier + Non + 80 + La nombre de colonnes sur lequel ajuster l'affichage. + + + 2 + chaîne de caractères + Non + \n + chaîne de caractères utilisée pour l'ajustement. + + + 3 + booléen + Non + false + Détermine si l'ajustement se fait en fin de mot + (false) ou au caractère exact (true). + + + + + + Ajuste une chaîne de caractères à une taille de colonne, par défaut 80. + Un second paramètre optionnel vous permet de spécifier la chaîne à utiliser + pour l'ajustement à la nouvelle ligne (retour chariot \n par défaut). + Par défaut, wordwrap tente un ajustement à la fin d'un mot. Si vous voulez + autoriser le découpage des mots pour un ajustement au caractère près, + passez true au troisième paramètre optionnel. + + +wordwrap + +index.php: + +$smarty = new Smarty; +$smarty->assign('titreArticle', "Une femme aveugle obtient un nouveau rein +d'un père qu'elle n'a pas vu depuis des années."); +$smarty->display('index.tpl'); + +index.tpl: + +{$titreArticle} + +{$titreArticle|wordwrap:30} + +{$titreArticle|wordwrap:20} + +{$titreArticle|wordwrap:30:"<br>\n"} + +{$titreArticle|wordwrap:30:"\n":true} + +SORTIE: + +Une femme aveugle obtient un nouveau rein d'un père qu'elle n'a pas vu depuis des années. + +Une femme aveugle obtient un +nouveau rein d'un père +qu'elle n'a pas vu depuis +des années. + +Une femme aveugle +obtient un nouveau +rein d'un père +qu'elle n'a pas vu +depuis des années. + +Une femme aveugle obtient un<br> +nouveau rein d'un père<br> +qu'elle n'a pas vu depuis<br> +des années. + +Une femme aveugle obtient un n +ouveau rein d'un père qu'elle +n'a pas vu depuis des années. + + + + + + + + Combiner des modificateurs de variable. + + Vous pouvez appliquer un nombre quelquonque de modificateurs à une variable. + Ils seront invoqués dans l'ordre d'apparition, de la gauche vers la droite. + Ils doivent être séparés par un | (pipe). + + + Combiner des modificateurs + +index.php: + +$smarty = new Smarty; +$smarty->assign('titreArticle', 'Les fumeurs sont productifs, mais la mort +tue l'efficacitée.'); +$smarty->display('index.tpl'); + +index.tpl: + +{$titreArticle} +{$titreArticle|upper|spacify} +{$titreArticle|lower|spacify|truncate} +{$titreArticle|lower|truncate:30|spacify} +{$titreArticle|lower|spacify|truncate:30:". . ."} + + +SORTIE: + +Les fumeurs sont productifs, mais la mort tue l'efficacitée. +L E S F U M E U R S S O N T P R O D U C T I F S , M A I S L A M O R T T U E L ' E F F I C A C I T É E . +L E S F U M E U R S S O N T P R O D U C T I F S , M A I S L A M... +L E S F U M E U R S S O N T P R O D U C T I F S , M A I S L A M... +L e s f u m e u r s s o n t p r o d u c t i f s , . . . +L e s f u m e u r s s. . . + + + + + + Fonctions natives + + Smarty est fourni en standard avec plusieurs fonctions natives. + Les fonctions natives sont partie intégrante du language de template. + Vous ne pouvez pas créer de fonctions utilisateurs qui portent le même nom + qu'une fonction native. Vous ne pouvez pas non plus en modifier le + comportement. + + + capture + + Capture est utilisé pour récupérer la sortie d'éléments dans une variable + au lieu de les afficher. Tout contenu situé entre {capture + name="foo"} et {/capture} est intercepté dans une variable dont le nom est + spécifié dans l'attribut name. Le contenu capturé peut être utilisé dans + le template par l'intermédiaire de la variable spéciale $smarty.capture.foo + ou foo est la valeur de l'attribut name. Si vous ne donnez pas de valeur + à l'attribut name, alors "default" est utilisé. Toutes les commandes + {capture} doivent être utilisées de paire avec {/capture}. Vous pouvez + imbriquer les demandes de captures. + + + Note technique + + Smarty 1.4.0 - 1.4.4 plaçait les contenus capturés dans une variable + appelée $return. Depuis Smarty 1.4.5, ce comportement à été modifié et + Smarty utilise maintenant l'attribut name en lieu et place. + Veuillez donc mettre vos templates à jour selon cette règle. + + + + + Faites attention lorsque vous interceptez la sortie de commandes + insert. Si vous avez configuré le cache pour que ce + dernier soit actif, et que vous avez des commandes insert + supposées s'exécuter dans un contenu en cache, ne tentez pas de capturer + ce contenu. + + + + + Capturer le contenu d'un template. + +{* nous ne voulons afficher une ligne que si cette dernière est activé. *} +{capture name=banner} +{include file="get_banner.tpl"} +{/capture} +{if $smarty.capture.banner ne ""} + <tr> + <td> + {$smarty.capture.banner} + </td> + </tr> +{/if} + + + + + config_load + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + file + chaîne de caractère + Oui + n/a + Le nom du fichier de configuration à inclure + + + section + chaîne de caractère + Non + n/a + Le nom de la section à charger + + + scope + chaîne de caractère + non + local + + La façon dont la portée des variables est définie, soit + local, parent ou global. local signifie que la variable est + chargée dans le contexte du template. parent indique que + la variable est disponible tant dans le template qui + l'a inclus que dans le template parent, ayant réalisé + l'inclusion du sous template. global signifie que la variable + est diponible dans tous les templates. + + + + global + booléen + Non + No + + Si oui ou non les variables sont disponibles pour les + templates parents, identique à scope=parent. + Note: Cet attribut est obsolète depuis l'apparition + de l'attribut scope, il est toutefois toujours supporté. + Si scope est défini, global est ignoré. + + + + + + + Cette fonction est utiliseé pour charger des variables de fichier + de configuration dans un template. Voir + Fichiers de configuration pour de plus amples informations. + + +fonction config_load + + +{config_load file="colors.conf"} + +<html> +<title>{#pageTitle#}</title> +<body bgcolor="{#bodyBgColor#}"> +<table border="{#tableBorderSize#}" bgcolor="{#tableBgColor#}"> + <tr bgcolor="{#rowBgColor#}"> + <td>First</td> + <td>Last</td> + <td>Address</td> + </tr> +</table> +</body> +</html> + + + Les fichiers de configuration peuvent contenir des sections. + Vous pouvez charger des variables d'une section donnée avec le + nouvel attribut section. + + + NOTE: Les sections des fichiers de configuration + et la fonction native section n'ont rien en + commun, il s'avère simplement qu'elles portent le même nom. + + +fonction config_load et section + +{config_load file="colors.conf" section="client"} + +<html> +<title>{#pageTitle#}</title> +<body bgcolor="{#bodyBgColor#}"> +<table border="{#tableBorderSize#}" bgcolor="{#tableBgColor#}"> + <tr bgcolor="{#rowBgColor#}"> + <td>First</td> + <td>Last</td> + <td>Address</td> + </tr> +</table> +</body> +</html> + + + + foreach,foreachelse + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + from + chaîne de caractère + oui + n/a + Le nom du tableau à parcourir + + + item + chaîne de caractère + Oui + n/a + Le nom de la variable "élément courant" + + + key + chaîne de caractère + Non + n/a + Le nom de la variable représentant la clef courante. + + + name + chaîne de caractère + Non + n/a + Le nom de la boucle foreach, qui nous permettra + d'accéder à ses propriétés. + + + + + + Les boucles foreach sont une alternative aux boucles + section. Les boucles foreach + sont utilisées pour parcourir des tableaux associatifs simples. + La syntaxe des boucles foreach est bien plus simple + que celle des boucles section, mais en contrepartie, + elles ne peuvent être utilisées que pour des tableaux associatifs simples. + La balise foreach doit toujours être accompagnée + de la balise /foreach. Les paramètres requis sont + from et item. Le nom des boucles + foreach doit être composés exclusivement de lettres, + chiffres et underscores, selon vos préférences. Les boucles + foreach peuvent être imbriquées. + La variable from (généralement le tableau à + parcourir) détermine le nombre de fois que foreach + sera exécuté. foreachelse est exécuté si aucune + valeur n'est présente dans la variable donnée à l'attribut + from. + + +foreach + + +{* Cet exemple affiche toutes les valeurs du tableau $custid *} +{foreach from=$custid item=curr_id} + id: {$curr_id}<br> +{/foreach} + +SORTIE: + +id: 1000<br> +id: 1001<br> +id: 1002<br> + + + +foreach key + +{* key contient la clef de chaque élément parcouru + +l'attribution des élément est de la forme: + +$smarty->assign("contacts", array(array("tel" => "1", "fax" => "2", "portable" => "3"), + array("tel" => "555-4444", "fax" => "555-3333", "portable" => "760-1234"))); + +*} + +{foreach name=outer item=contact from=$contacts} + {foreach key=key item=item from=$contact} + {$key}: {$item}<br> + {/foreach} +{/foreach} + +SORTIE: + +tel: 1<br> +fax: 2<br> +portable: 3<br> +tel: 555-4444<br> +fax: 555-3333<br> +portable: 760-1234<br> + + + + include + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + file + chaîne de caractères + Oui + n/a + Le nom du template à inclure + + + assign + chaîne de caractères + Non + n/a + Le nom de la variable dans laquelle sera assignée + la sortie de include + + + [var ...] + [type de variable] + Non + n/a + Variables à passer au template + + + + + + Les balises "include" sont utilisées pour inclure des templates à + l'intérieur d'autres templates. Toutes les variables disponibles + dans le template réalisant l'inclusion sont disponibles dans le + template inclus. La balise include doit disposer de l'attribut + "file", qui contient le chemin de la ressource template. + + + Vous pouvez spécifier un attribut optionnel assign + qui définit une variable de template dans laquelle la sortie de + include sera stockée plutôt qu'affichée. + + +fonction include + +{include file="header.tpl"} + +{* Le corp du template va ici *} + +{include file="footer.tpl"} + + + Vous pouvez également passer des variables au template inclus + sous forme d'attributs. Les variables passées au template par ce moyen + ne sont accessibles que dans la portée de ce dernier. Les variables + passées en tant qu'attribut remplacent les variables déjà définies, + qui auraient le même nom. + + +fonction include, passage de variables + +{include file="header.tpl" title="Menu principal" table_bgcolor="#c0c0c0"} + +{* Le corps du template vient ici *} + +{include file="footer.tpl" logo="http://mon.domaine.com/logo.gif"} + + + Utilisez la syntaxe ressource template pour inclure + des fichiers situés en dehors du répertoire $template_dir. + + +fonction include, exemple de ressource template + +{* chemin absolu *} +{include file="/usr/local/include/templates/header.tpl"} + +{* chemin absolu (même chose) *} +{include file="file:/usr/local/include/templates/header.tpl"} + +{* chemin absolu windows (DOIT utiliser le préfixe "file:") *} +{include file="file:C:/www/pub/templates/header.tpl"} + +{* inclusion d'une ressource template "db" *} +{include file="db:header.tpl"} + + + + include_php + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + file + chaîne de caractère + oui + n/a + Le nom du fichier PHP à inclure + + + once + boléen + Non + true + Inclure plusieurs fois ou non le fichier PHP si + plusieurs demandes d'inclusions sont faites. + + + assign + chaîne de caractère + Non + n/a + le nom de la variable PHP dans laquelle la sortie + sera assignée plutôt que directement affichée. + + + + + + les balises include_php sont utilisées pour inclure directement + un script PHP dans vos templates. Si "security" est activé, alors le script + à exécuter doit être placé dans le chemin $trusted_dir. La balise + include_php attends l'attribut "file", qui contient le chemin du + fichier PHP à inclure, relatif à $trusted_dir, ou absolu. + + + include_php est un moyen agréable pour gérer des "composants templates", + tout en conservant le code PHP en dehors du template lui même. + Supposons que vous ayez un template reprenant la navigation de votre + site, elle même récupérée depuis une base de données. Vous pouvez + conserver la logique du code PHP récupérant le contenu de la base dans + un emplacement séparé, et l'inclure depuis votre template. Maintenant, + vous pouvez utiliser ce template n'importe ou, sans vous inquiéter de + savoir si les informations nécessaires ont bien étés assignées + par l'application, avant la demande d'affichage. + + + Par défaut, les fichiers PHP ne sont inclus qu'une seule fois, même si + la demande d'inclusion survient plusieurs fois dans le template. + Vous pouvez demander à ce que ce fichier soit inclus à chaque demande + grâce à l'attribut once. Mettre l'attribut once à + false aura pour effet d'inclure le script PHP à chaque fois que demandé + dans le template. + + + Vous pouvez donner une valeur à l'attribut optionnel + assign, pour demander à la fonction + include_php d'assigner la sortie du script PHP + à la variable spécifiée plutôt que d'en afficher directement le résultat. + + + L'objet Smarty est disponible en tant que $this dans le script PHP inclus. + + +fonction include_php + +load_nav.php +------------- + +<?php + + // charge des variables depuis une base de données mysql et les assigne au template. + require_once("MySQL.class.php"); + $sql = new MySQL; + $sql->query("select * from site_nav_sections order by name",SQL_ALL); + $this->assign('sections',$sql->record); + +?> + + +index.tpl +--------- + +{* chemin absolu, ou relatif à $trusted_dir *} +{include_php file="/path/to/load_nav.php"} + +{foreach item="curr_section" from=$sections} + <a href="{$curr_section.url}">{$curr_section.name}</a><br> +{/foreach} + + + + insert + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + name + chaîne de caractères + Oui + n/a + le nom de la fonction insert (insert_name) + + + assign + chaîne de caractère + Non + n/a + Le nom de la variable qui recevra la sortie + + + script + chaîne de caractères + Non + n/a + Le nom du script PHP inclus avant que la fonction + insert ne soit appelée. + + + [var ...] + [var type] + Non + n/a + Variable à passer à la fonction insert + + + + + + Les balises insert fonctionnent à peu près comme les balises include, + à l'exception que leur sortie n'est pas placée en cache lorsque + le cache [caching] est activé. + Les balises insert seront exécutées à chaque appel du template. + + + Supposons que vous avez un template avec un emplacement + pour un bandeau publicitaire en haut de page. + Ce bandeau publicitaire peut contenir toutes sortes de contenus + HTML, images, flash, etc. Nous ne pouvons pas placer du contenu + statique à cet endroit. Nous ne voulons pas non plus que ce + contenu fasse partie du cache. Arrive alors la balise insert. + Le template connais #emplacement_bandeau# et #id_site# (récupérés + depuis un fichier de configuration), et à besoin d'un appel de + fonction pour récupérer le contenu du bandeau. + + +function insert + +{* exemple de récupération d'un bandeau publicitaire *} +{insert name="getBanner" lid=#emplacement_bandeau# sid=#id_site#} + + + Dans cet exemple, nous utilisons le nom getBanner et lui passons les + paramètres #emplacement_bandeau# et #id_site#. Smarty va rechercher une + fonction appelée insert_getBanner () dans votre application PHP, et lui + passer les valeurs #banner_location_id# et #site_id# comme premier + paramètre, dans un tableau associatif. Tous les noms des fonctions insert + de votre application doivent être prefixées de "insert_" pour remédier + à d'éventuels conflits de nommage. Votre fonction insert_getBanner () + est supposée traiter les valeurs passées et retourner + un résultat. Ces résultats sont affichés dans le template en lieu et + place de la balise. Dans cet exemple, Smarty appellera cette fonction + insert_getBanner(array("lid" => "12345","sid" => "67890")); et affichera + le résultat retourné à la place de la balise insert. + + + Si vous donnez une valeur à l'attribut "assign", la sortie de la balise + insert sera assigné à une variable de template de ce nom au lieu d'être + affichée directement. NOTE: assigner la sortie à une variable n'est pas + très utile lorsque le cache est activé. + + + Si vous donnez une valeur à l'attribut "script", ce script PHP sera + inclus (une seule fois) avant l'exécution de la fonction insert. + Le cas peut survenir lorsque la fonction insert n'existe pas encore, + et que le script PHP chargé de sa définission doit être inclus. Le + chemin doit être absolu ou relatif à $trusted_dir. + Lorsque "security" est actif, le script doit être situé + dans $trusted_dir. + + + L'objet Smarty est passé comme second argument. De cette façon, vous + pouvez utiliser ou modifier des informations sur l'objet Smarty, + directement depuis votre fonction d'insertion. + + + Note technique + + Il est possible d'avoir des portions de template qui ne soient pas + gérables par le cache. Même si vous avez activé l'option + caching, les balises insert + ne feront pas partie du cache. Elles retourneront un contenu dynamique + à chaque invocation de la page. Cette méthode est très pratique pour + des éléments tels que les bandeaux publicitaires, les enquêtes, + la météo, les résultats de recherche, retours utilisateurs, etc. + + + + + if,elseif,else + + l'instruction if dans Smarty dispose de la même flexibilité que l'instruction + PHP du même nom, avec quelques fonctionnalités supplémentaires pour le + moteur de template. Tous les if doivent être + utilisés de pair avec un /if. + else et elseif sont également + des balises autorisées. "eq", "ne","neq", "gt", "lt", "lte", "le", + "gte" "ge","is even","is odd", "is not even","is not odd","not","mod", + "div by","even by","odd by","==","!=",">", "<","<=",">=" sont tous + des opérateurs conditionnels valides, et doivent obligatoirement être + séparés des autres éléments par des espaces. + + +Instruction if + +{if $name eq "Fred"} + Bienvenue, Monsieur. +{elseif $name eq "Wilma"} + Bienvenue m'dame. +{else} + Bienvenue, qui que vous soyez. +{/if} + +{* Un exemple avec l'opérateur or *} +{if $name eq "Fred" or $name eq "Wilma"} + ... +{/if} + +{* même chose que ci-dessus *} +{if $name == "Fred" || $name == "Wilma"} + ... +{/if} + +{* l'exemple suivant NE fonctionne PAS, les opérateurs + doivent être entourés d'espaces. *} +{if $name=="Fred" || $name=="Wilma"} + ... +{/if} + + +{* les parenthèses sont autorisées *} +{if ( $amount < 0 or $amount > 1000 ) and $volume >= #minVolAmt#} + ... +{/if} + +{* vous pouvez également faire appel aux fonctions PHP *} +{if count($var) gt 0} + ... +{/if} + +{* teste si les valeurs sont paires(even) ou impaires(odd) *} +{if $var is even} + ... +{/if} +{if $var is odd} + ... +{/if} +{if $var is not odd} + ... +{/if} + +{* teste si la variable est divisble par 4 *} +{if $var is div by 4} + ... +{/if} + +{* teste si la variable est paire, par groupe de deux i.e., +0=paire, 1=paire, 2=impaire, 3=impaire, 4=paire, 5=paire, etc. *} +{if $var is even by 2} + ... +{/if} + +{* 0=paire, 1=paire, 2=paire, 3=impaire, 4=impaire, 5=impaire, etc. *} +{if $var is even by 3} + ... +{/if} + + + + ldelim,rdelim + + ldelim et rdelim sont utilisés pour afficher les délimiteurs en tant + que tels, dans notre cas "{" ou "}". Le moteur de template tentera + toujours d'interpréter le contenu entre les délimiteurs, c'est donc + une façon d'afficher ces derniers sans interférer avec Smarty. + + +ldelim, rdelim + +{* Affiche les délimiteurs de template *} + +{ldelim}nomFonction{rdelim} est la façon dont sont appelées les fonctions dans Smarty ! + + +SORTIE: + +{nomFonction} est la façon dont sont appelées les fonctions dans Smarty ! + + + + literal + + Les balises "literal" permettent à un bloc de données d'être pris tel + quel, sans qu'il ne soit interprété par Smarty. Très pratique lors + de l'emplois d'éléments tels que javascript, acolades et autres + qui peuvent confondre le moteur de template. Tout le contenu situé + entre les balises {literal}{/literal} ne sera pas interprété, et + affiché comme du contenu statique. + + +balises literal + +{literal} + <script language=javascript> + + <!-- + function isblank(field) { + if (field.value == '') + { return false; } + else + { + document.loginform.submit(); + return true; + } + } + // --> + + </script> +{/literal} + + + + php + + Les balises PHP permettent de rajouter du code PHP directement dans le + template. Ils ne seront pas ignorés, quelle que soit la valeur de $php_handling. Pour les + utilisateurs avancés seulement, son utilisation n'est normalement pas + nécessaire. + + +balises php + +{php} + // inclusion directe d'un script PHP + // depuis le template. + include("/path/to/display_weather.php"); +{/php} + + + + section,sectionelse + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + name + chaîne de caractère + Oui + n/a + Le nom de la section + + + loop + [$nom_variable] + Oui + n/a + le nom de la variable qui détermine le nombre de + fois que la boucle sera exécutée. + + + + start + entier + Non + 0 + La position de l'index ou la section commencera son + parcours. Si la valeur donnée est négative, la position de + départ est calculée depuis la fin du tableau. Par exemple, + s'il existe 7 valeurs dans le tableau à parcourir et que start + est à -2, l'index de départ sera 5. Les valeurs incorrectes + (en dehors de la portée du tableau) sont automatiquements + tronquées à la valeur correcte la plus proche. + + + step + entier + Non + 1 + La valeur du pas qui sera utilisé pour parcourir le + tableau.Par exemple, step=2 parcourera les indices + 0,2,4, etc. Si step est négatif, le tableau sera parcouru en sens + inverse. + + + max + entier + Non + 1 + Définit le nombre maximum de fois que le tableau sera + parcouru. + + + show + booléen + Non + true + Détermine s'il est nécessaire d'afficher la + section ou non. + + + + + + Les balises section sont utilisées pour + parcourir un tableau de données. Toutes les balises + section doivent être utilisées de paire avec + les balises /section. Les paramètres requis + sont name et loop. + Le nom de la section est, selon votre choix, composé de lettres, + chiffres et underscores. Les sections peuvent être imbriquées, + mais leurs noms doivent être uniques. La variable de parcours + (généralement un tableau de données) détermine le nombre de fois + que la section sera parcourue. Lorsque l'on affiche une variable + dans une section, le nom de la section doit précéder + la variable entre crochets. sectionelse + est exécuté lorsqu'aucune valeur n'est trouvée dans la variable à + parcourir. + + +section + + +{* Cet exemple va afficher toutes les valeurs du tableau $custid *} +{section name=client loop=$custid} + id: {$custid[client]}<br> +{/section} + +SORTIE: + +id: 1000<br> +id: 1001<br> +id: 1002<br> + + + +section, variable de parcours + +{* La variable de parcours détermine uniquement le nombre de fois que nous allons + rentrer dans la boucle. Vous pouvez accéder à toutes les variables du template + lorsque vous êtes dans une section. Cet exemple part du principe que + $idClient, $noms et $adresses sont tous des tableaux qui contiennent + autant de valeurs les uns que les autres.*} +{section name=client loop=$custid} + id: {$idClient[client]}<br> + nom: {$noms[client]}<br> + addresse: {$addresses[client]}<br> + <p> +{/section} + + +SORTIE: + +id: 1000<br> +nom: John Smith<br> +addresse: 253 N 45th<br> +<p> +id: 1001<br> +nom: Jack Jones<br> +addresse: 417 Mulberry ln<br> +<p> +id: 1002<br> +nom: Jane Munson<br> +addresse: 5605 apple st<br> +<p> + + + +nom de section + +{* Le nom de la section peut être ce que vous voulez, + et est utilisé pour référencer les données depuis la section. *} +{section name=monTableau loop=$idClient} + id: {$idCLient[monTableau]}<br> + name: {$noms[monTableau]}<br> + address: {$addresses[monTableau]}<br> + <p> +{/section} + + + +sections imbriquées + +{* Les sections peuvent être imbriquées à un nombre de niveaux illimité. + Grâce aux sections imbriquées, vous pouvez accéder à des structures de données + complexes, comme des tableaux multi-dimentionnels. Dans cet exemple, + $type_contact[client] est un tableau de type de contact pour le client + courant. *} +{section name=client loop=$custid} + id: {$idClient[client]}<br> + nom: {$nom[client]}<br> + addresse: {$addresse[client]}<br> + {section name=contact loop=$type_contact[client]} + {$type_contact[client][contact]}: {$info_contact[client][contact]}<br> + {/section} + <p> +{/section} + + +SORTIE: + +id: 1000<br> +nom: John Smith<br> +addresse: 253 N 45th<br> +telephone: 555-555-5555<br> +telephone portable: 555-555-5555<br> +e-mail: john@mydomain.com<br> +<p> +id: 1001<br> +nom: Jack Jones<br> +addresse: 417 Mulberry ln<br> +telephone: 555-555-5555<br> +telephone portable: 555-555-5555<br> +e-mail: jack@mydomain.com<br> +<p> +id: 1002<br> +nom: Jane Munson<br> +addresse: 5605 apple st<br> +telephone: 555-555-5555<br> +telephone portable: 555-555-5555<br> +e-mail: jane@mydomain.com<br> +<p> + + + +Sections et tableaux associatifs + +{* Exemple d'affichage d'un tableau associatif dans une section *} +{section name=client loop=$contacts} + nom: {$contacts[client].name}<br> + telephone: {$contacts[client].home}<br> + portable: {$contacts[client].cell}<br> + e-mail: {$contacts[client].email}<p> +{/section} + + +SORTIE: + +nom: John Smith<br> +telephone: 555-555-5555<br> +portable: 555-555-5555<br> +e-mail: john@mydomain.com<p> +nom: Jack Jones<br> +telephone: 555-555-5555<br> +portable: 555-555-5555<br> +e-mail: jack@mydomain.com<p> +nom: Jane Munson<br> +telephone: 555-555-5555<br> +portable: 555-555-5555<br> +e-mail: jane@mydomain.com<p> + + + + + +sectionelse + +{* sectionelse est exécuté s'il n'existe aucune valeur dans idClient *} +{section name=client loop=$idClient} + id: {$idClient[client]}<br> +{sectionelse} + Aucune valeur dans $idClient. +{/section} + + + Les sections ont leur propre variable de gestion des propriétés. + Elles sont de la forme: {$smarty.section.nomSection.nomVariable} + + + NOTE: Depuis Smarty 1.5.0, la syntaxe pour les propiétés des sections + a été changée de {%sectionname.varname%} à + {$smarty.section.nomSection.nomVariable}. L'ancienne syntaxe est toujours + supportée, mais vous ne verrez que des exemples avec la nouvelle syntaxe + dans le manuel. + + + index + + Index est utilisé pour afficher l'index de parcours courant, commence par + 0 (ou l'attribut start), et s'incrémente de 1 (ou de la valeur + de l'attribut step). + + + Note technique + + Si les attributs step et start ne sont pas modifiés, alors index + fonctionne de la même façon que iteration, à l'exception qu'il commence + par 0 plutôt que par 1. + + + + propriété de section index + + {section name=client loop=$idClient} + {$smarty.section.client.index} id: {$idClient[client]}<br> + {/section} + + + SORTIE: + + 0 id: 1000<br> + 1 id: 1001<br> + 2 id: 1002<br> + + + + + index_prev + + index_prev est utilisé pour afficher l'index de parcours + précédent de la boucle. Au premier passage, il vaut -1. + + + propriété de section index_prev + + {section name=client loop=$custid} + {$smarty.section.client.index} id: {$idClient[client]}<br> + {* Pour votre information, $idClient[client.index] and $idClient[client] sont identiques *} + {if $idClient[client.index_prev] ne $idClient[client.index]} + L'id du client à été modifié<br> + {/if} + {/section} + + + SORTIE: + + 0 id: 1000<br> + L'id du client à été modifié<br> + 1 id: 1001<br> + L'id du client à été modifié<br> + 2 id: 1002<br> + L'id du client à été modifié<br> + + + + + index_next + + index_next est utilisé pour afficher la valeur théorique suivante de + index. Dans la dernière boucle, cela reste la valeur incrémentée, + qui respecte l'attribut step si donné. + + + propriété de section index_next + + {section name=client loop=$idClient} + {$smarty.section.client.index} id: {$idClient[client]}<br> + {* Pour votre information, $idClient[client.index] and $idClient[client] sont identiques *} + {if $idClient[client.index_next] ne $idClient[client.index]} + L'id du client va changer<br> + {/if} + {/section} + + + SORTIE: + + 0 id: 1000<br> + L'id du client va changer<br> + 1 id: 1001<br> + L'id du client va changer<br> + 2 id: 1002<br> + L'id du client va changer<br> + + + + + iteration + + iteration est utilisé pour afficher la valeur courante de l'iteration. + + + NOTE: Cette valeur n'est pas affectée par les attributs start, step et + max, à l'inverse de la propriété index. L'itération commence par + 1 et non par 0 (comme le fait index). rownum est un alias de iteration, + ils fonctionnent de la même façon. + + + propriété iteration de section + + {section name=client loop=$idClient start=5 step=2} + Iteration courante: {$smarty.section.client.iteration}<br> + {$smarty.section.client.index} id: {$idClient[client]}<br> + {* Pour votre information, $idClient[client.index] and $idClient[client] sont identiques *} + {if $idCLient[client.index_next] ne $idClient[client.index]} + L'id du client va changer<br> + {/if} + {/section} + + + SORTIE: + + Iteration courante: 1 + 5 id: 1000<br> + L'id du client va changer<br> + Iteration courante: 2 + 7 id: 1001<br> + L'id du client va changer<br> + Iteration courante: 3 + 9 id: 1002<br> + L'id du client va changer<br> + + + + + first + + first est à true lorsque la section est parcouru pour la première fois. + + + propriété first de la section + + {section name=client loop=$idClient} + {if $smarty.section.client.first} + <table> + {/if} + + <tr><td>{$smarty.section.client.index} id: + {$idClient[client]}</td></tr> + + {if $smarty.section.client.last} + </table> + {/if} + {/section} + + + SORTIE: + + <table> + <tr><td>0 id: 1000</td></tr> + <tr><td>1 id: 1001</td></tr> + <tr><td>2 id: 1002</td></tr> + </table> + + + + + last + + last est à true lorsque la section est parcourue pour la dernière fois. + + + Propriété last de section + + {section name=client loop=$idClient} + {if $smarty.section.client.first} + <table> + {/if} + + <tr><td>{$smarty.section.client.index} id: + {$idClient[client]}</td></tr> + + {if $smarty.section.client.last} + </table> + {/if} + {/section} + + + SORTIE: + + <table> + <tr><td>0 id: 1000</td></tr> + <tr><td>1 id: 1001</td></tr> + <tr><td>2 id: 1002</td></tr> + </table> + + + + + rownum + + rownum, utilisé pour afficher la valeur courante de l'itération, + commence par 1. C'est un alias de iteration, ils fonctionnent de façon + identique. + + + propriété rownum de section + + {section name=client loop=$idClient} + {$smarty.section.client.rownum} id: {$idClient[client]}<br> + {/section} + + + SORTIE: + + 1 id: 1000<br> + 2 id: 1001<br> + 3 id: 1002<br> + + + + + loop + + loop est utilisé pour afficher la dernière valeur de index que cette + section a utilisé. Peut être utilisé dans ou en dehors de la section. + + + Propriété de section index + + {section name=client loop=$idClient} + {$smarty.section.client.index} id: {$idClient[client]}<br> + {/section} + + Il y eu {$smarty.section.client.loop} clients d'affichés. + + SORTIE: + + 0 id: 1000<br> + 1 id: 1001<br> + 2 id: 1002<br> + + il y eu 3 clients d'affichés. + + + + + show + + show est utilisé comme paramètre de section. + show est une valeur booléenne, true ou false. + Si show est à "false", la section ne sera pas affichée. Si un + sectionelse est présent, elle sera affiché. + + + section, attribut show + + {* $show_client_info a pu être passé par le script PHP, + pour déterminer si oui ou non on souhaite afficher la section *} + {section name=client loop=$idClient show=$show_client_info} + {$smarty.section.client.rownum} id: {$idClient[client]}<br> + {/section} + + {if $smarty.section.client.show} + la section à été affichée. + {else} + la section n'a pas été affichée. + {/if} + + + SORTIE: + + 1 id: 1000<br> + 2 id: 1001<br> + 3 id: 1002<br> + + la section à été affichée. + + + + + total + + total est utilisé pour afficher le nombre d'itération que la section + va exécuter. Peut être utilisé dans ou en dehors de la section. + + + section, propriété total + + {section name=client loop=$idClient step=2} + {$smarty.section.client.index} id: {$idClient[client]}<br> + {/section} + + Il y eu {$smarty.section.client.total} clients affichés. + + SORTIE: + + 0 id: 1000<br> + 2 id: 1001<br> + 4 id: 1002<br> + + Il y eu 3 clients affichés. + + + + + + strip + + Il est fréquent que les designers web rencontrent des problèmes + dus aux espaces et retours chariots, qui affectent le rendu HTML + ("fonctionnalités" des navigateurs), les obligeant à coller les + balises les unes aux autres. Cette solution rend généralement le + code illisible et impossible à maintenir. + + + Tout contenu situé entre les balises {strip}{/strip} se verra + allégé des espaces superflus et des retours chariots en début ou en fin + de ligne, avant qu'il ne soit affichés. De la sorte, vous pouvez + conserver vos templates lisibles, sans vous soucier des effets + indésirables que peuvent apporter les espaces superflus. + + + Note technique + + {strip}{/strip} n'affecte en aucun cas le contenu des variables de + template. Voir le modificateur + strip pour un rendu identique pour les variables. + + + +balises strip + +{* la suite sera affichée sur une seule ligne *} +{strip} +<table border=0> + <tr> + <td> + <A HREF="{$url}"> + <font color="red">Un test</font> + </A> + </td> + </tr> +</table> +{/strip} + + +SORTIE: + +<table border=0><tr><td><A HREF="http://mon.domaine.com"><font color="red">Un test</font></A></td></tr></table> + + + Notez que dans l'exemple ci-dessus, toutes les lignes commencent et + se terminent par des balises HTML. Sachez que si vous avez du texte + en début ou en fin de ligne dans des balises strip, ce dernier sera collé + au suivant/précédent et risque de ne pas être affiché selon + l'effet désiré. + + + + + + Fonctions utilisateur + + Smarty est livré avec plusieurs fonctions utilisateurs que vous pouvez + appeler dans vos templates. + + + assign + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + var + chaîne de caractère + Oui + n/a + Le nom de la variable assignée + + + value + chaîne de caractère + Oui + n/a + La valeur assignée + + + + + + Assign est utilisé pour déclarer ou modifier des variables de template. + + +assign + +{assign var="name" value="Bob"} + +La valeur de $name est {$name}. + +SORTIE: + +La valeur de $name est Bob. + + + + counter + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + name + chaîne de caractère + Non + default + Le nom du compteur + + + start + numérique + Non + 1 + La valeur initiale du compteur + + + skip + numérique + Non + 1 + L'intervale du compteur + + + direction + chaîne de caractères + Non + up + la direction du compteur (up/down) [compte / décompte] + + + print + booléen + Non + true + S'il faut afficher cette valeur ou non + + + assign + chaîne de caractères + Non + n/a + La variable dans laquelle la valeur du compteur + sera assignée. + + + + + + counter affiche un compteur. counter retient la valeur + du compte à chaque itération. Vous pouvez adapter le nombre, l'intervale + et la direction du compteur, ainsi que décider d'afficher ou non + les valeurs. Vous pouvez lancer plusieurs compteurs simultanément en + leur donnant des noms uniques. Si vous ne donnez pas de nom à un + compteur, 'default' sera utilisé. + + + Si vous donnez une valeur à l'attribut "assign", alors la sortie de la + fonction counter sera assignée à la variable de template donnée plutôt + que d'être directement affichée. + + +counter + +{* initialisation du compteur *} +{counter start=0 skip=2 print=false} + +{counter}<br> +{counter}<br> +{counter}<br> +{counter}<br> + +SORTIE: + +2<br> +4<br> +6<br> +8<br> + + + + cycle + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + name + chaîne de caractères + Non + default + Le nom du cycle + + + values + divers + Oui + N/A + Les valeurs sur lesquelles boucler, soit une liste + séparée par des virgules, (voir l'attribut delimiter), + soit un tableau de valeurs. + + + print + booléen + Non + true + S'il faut afficher ou non cette valeur + + + advance + booléen + Non + true + Oui ou non aller à la prochaîne valeur + + + delimiter + chaîne de caractères + Non + , + Le délimiteur à utiliser dans la liste. + + + assign + chaîne de caractères + Non + n/a + La variable de template dans laquelle la sortie + sera assignée + + + + + + cycle est utilisé pour boucler sur un ensemble de valeurs. Très pratique + pour alterner entre deux ou plusieurs couleurs dans un tableau, + ou plus généralement pour boucler sur les valeurs d'un tableau. + + + Vous pouvez définir plusieurs "cycle" dans votre template, en leur + donnant des noms uniques (attribut name). + + + Vous pouvez empêcher la valeur courante de s'afficher en définissant + l'attribut print à false. Ce procédé peut être utile pour discrètement + passer outre une valeur de la liste. + + + L'attribut advance est utilisé pour répéter une valeur. Lorsque + définit à false, le prochain appel de cycle ramènera la même valeur. + + + Si vous définissez l'attribut spécial "assign", la sortie de la fonction + cycle y sera assignée plutôt que d'être directement affichée. + + +cycle + +{section name=rows loop=$data} +<tr bgcolor="{cycle values="#eeeeee,#d0d0d0"}"> + <td>{$data[rows]}</td> +</tr> +{/section} + +SORTIE: + +<tr bgcolor="#eeeeee"> + <td>1</td> +</tr> +<tr bgcolor="#d0d0d0"> + <td>2</td> +</tr> +<tr bgcolor="#eeeeee"> + <td>3</td> +</tr> + + + + + debug + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + output + chaîne de caractères + Non + html + Type de sortie, html ou javascript + + + + + + {debug} amène la console de débogage sur la page. Fonctionne + quelle que soit la valeur du paramètre debug de Smarty. + Comme ce dernier est appelé lors de l'exécution, il n'est capable + d'afficher que les variables assignées au template, et non + les templates en cours d'utilisation. Toutefois, vous voyez toutes + les variables disponibles pour le template courant. + + + + eval + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + var + mixed + Oui + n/a + variable (ou chaîne de caractères) à évaluer + + + assign + chaîne de caractères + Non + n/a + Le nom de la variable PHP dans laquelle la sortie + sera assignée + + + + + + eval évalue une variable comme si cette dernière était un template. + Peut être utile pour embarquer des balises de templates ou des variables + de template dans des variables ou des balises/variables dans des + variables de fichiers de configuration. + + + Si vous définissez l'attribut "assign", la sortie sera assignée à la + variable de template désignée plutôt que d'être affichée dans le + template. + + + Note technique + + Les variables évaluées sont traitées de la même façon que les templates. + Elles suivent les mêmes règles de traitement et de sécurité, comme si + elles étaient réellement des templates. + + + + Note technique + + Les variables évaluées sont compilées à chaque invocation, et la version + compilée n'est pas sauvegardée ! Toutefois, si le cache est activé, + la sortie sera placée en cache avec le reste du template. + + + +eval + +setup.conf +---------- + +emphstart = <b> +emphend = </b> +titre = Bienvenue sur la homepage de {$company} ! +ErrorVille = Vous devez spécifier un nom de {#emphstart#}ville{#emphend#}. +ErrorDept = Vous devez spécifier un {#emphstart#}département{#emphend#}. + + +index.tpl +--------- + +{config_load file="setup.conf"} + +{eval var=$foo} +{eval var=#titre#} +{eval var=#ErrorVille#} +{eval var=#ErrorDept# assign="state_error"} +{$state_error} + +SORTIE: + +Ceci est le contenu de foo. +Bienvenue sur la homepage de FictifLand. +Vous devez spécifier un nom de <b>ville</b>. +Vous devez spécifier un <b>département</b>. + + + + + + fetch + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + file + chaîne de caractères + Oui + n/a + le fichier, site http ou ftp à récupérer + + + assign + chaîne de caractères + Non + n/a + le nom de la variable PHP dans laquelle la sortie + sera assignée plutôt que d'être directement affichée. + + + + + + + fetch est utilisé pour récupérer des fichiers depuis le système de + fichier local, depuis un serveur http ou ftp, et en afficher le contenu. + Si le nom du fichier commence par "http://", la page internet sera + récupérée, puis affichée. Si le nom du fichier commence par "ftp://", + le fichier sera récupéré depuis le serveur ftp, et affiché. + Pour les fichiers du système local, le chemin doit être absolu ou + relatif au chemin d'exécution du script PHP. + + + Vous pouvez spécifier l'attribut optionnel assign + qui défini une variable de template dans laquelle la sortie + sera stockée plutôt qude d'être affichée (nouveau dans Smarty 1.5.0). + + + Note technique + Ne supporte pas les redirections http. Assurez vous d'inclure les + slash de fin sur votre page web si nécessaire. + + + + Note technique + + Si la sécurité est activée, vous ne pourez récupérer les + fichiers du système local que s'ils sont situés dans l'un des + répertoires sécurisé ($secure_dir). + + + +fetch + +{* Inclus du javascript dans votre template *} +{fetch file="/export/httpd/www.domain.com/docs/navbar.js"} + +{* récupère les informations météo d'un autre site sur votre page *} +{fetch file="http://www.myweather.com/68502/"} + +{* récupère les titres depuis un fichier ftp *} +{fetch file="ftp://user:password@ftp.domain.com/path/to/currentheadlines.txt"} + +{* assigne le contenu récupéré à une variable de template *} +{fetch file="http://www.myweather.com/68502/" assign="weather"} +{if $weather ne ""} + <b>{$weather}</b> +{/if} + + + + html_checkboxes + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + name + chaîne de caractères + Non + checkbox + Nom de la liste de cases à cocher + + + values + array + Oui, à moins que vous n'utilisiez l'attribut + option + n/a + Un tableau de valeurs pour les cases à + cocher + + + output + array + Oui, à moins que vous n'utilisiez l'attribut + option + n/a + Un tableau de sortie pour les cases à cocher + + + checked + chaîne de caractères + Non + empty + Les éléments cochés de la liste + + + options + associative array + Oui, à moins que vous n'utilisiez values et + output + n/a + Un tableau associatif de valeurs et + sorties + + + separator + chaîne de caractères + Non + empty + chaîne de caractère pour séparer chaque case + à cocher + + + + + + html_checkboxes est une fonction utilisateur qui crée un groupe de + cases à cocher avec les données fournies. Elle prend en compte la liste + des éléments sélectionnés par défaut. Les attributs requis sont + values et output, à moins que vous n'utilisiez options à la place. + La sortie générée est compatible XHTML. + + + Tous les paramètres qui ne sont pas listés ci-dessus sont affichés + en tant que paires nom/valeur dans chaque balise <input> crée. + +html_checkboxes + +index.php: + +require('Smarty.php.class'); +$smarty = new Smarty; +$smarty->assign('id_client', array(1000,1001,1002,1003)); +$smarty->assign('cust_names', array('Joe Schmoe','Jack Smith','Jane +Johnson','Charlie Brown')); +$smarty->assign('client_id', 1001); +$smarty->display('index.tpl'); + + +index.tpl: + +{html_checkboxes values=$id_client checked=$client_id output=$nom_client separator="<br />"} + + +index.php: + +require('Smarty.php.class'); +$smarty = new Smarty; +$smarty->assign('cust_checkboxes', array( + 1001 => 'Joe Schmoe', + 1002 => 'Jack Smith', + 1003 => 'Jane Johnson','Charlie Brown')); +$smarty->assign('client_id', 1001); +$smarty->display('index.tpl'); + +index.tpl: + +{html_checkboxes name="id" checkboxes=$cust_checkboxes checked=$client_id separator="<br />"} + + +SORTIE: (pour les deux exemples) + +<input type="checkbox" name="id[]" value="1000">Joe Schmoe<br /> +<input type="checkbox" name="id[]" value="1001" checked="checked"><br /> +<input type="checkbox" name="id[]" value="1002">Jane Johnson<br /> +<input type="checkbox" name="id[]" value="1003">Charlie Brown<br /> + + + + html_image + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + file + chaîne de caractères + Oui + n/a + nom/chemin des images + + + border + chaîne de caractères + Non + 0 + Bordure de l'image + + + height + chaîne de caractères + Non + Hauteur de l'image actuelle + Hauteur de l'image à afficher + + + width + chaîne de caractères + Non + Longueur de l'image actuelle + Longueur de l'image à afficher + + + basedir + chaîne de caractères + non + racine du serveur web + répertoire depuis lequel baser le calcul des + chemins relatifs + + + link + chaîne de caractères + non + n/a + lien sur lequel l'image pointe + + + + + + html_image est une fonction utilisateur qui génère la balise + HTML pour une image. La hauteur et la longueur de l'image sont calculés + automatiquement depuis le fichier image si aucune n'est spécifiée. + + + basedir est le répertoire de base depuis lequel seront calculés les + chemins relatifs. Si non spécifié, la racine du serveur web est utilisé + (variable d'environnement DOCUMENT_ROOT). Si la sécurité est activée, + l'image doit se situer dans un répertoire sécurisé. + + + link est la valeur href à laquelle lier l'image. Si link est défini, + une balise <a href="VALEURLINK"><a> est placée autour de + l'image. + + + Note technique + + html_image requiert un accès au disque dur pour lire l'image et + calculer ses dimensions. Si vous n'utilisez pas un cache, il + est généralement préférable d'éviter d'utiliser html_image + et de laisser les balises images statiques pour de meilleures + performances. + + + +html_image + +index.php: + +require('Smarty.php.class'); +$smarty = new Smarty; +$smarty->display('index.tpl'); + +index.tpl: + +{image file="pumpkin.jpg"} +{image file="/path/from/docroot/pumpkin.jpg"} +{image file="../path/relative/to/currdir/pumpkin.jpg"} + +SORTIE: (possible) + +<img src="pumpkin.jpg" border="0" width="44" height="68"> +<img src="/path/under/docroot/pumpkin.jpg" border="0" width="44" height="68"> +<img src="../path/relative/to/currdir/pumpkin.jpg" border="0" width="44" height="68"> + + + + html_options + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + values + array + Oui, à moins que vous n'utilisiez + l'attribut options + n/a + un tableau de valeurs pour les listes + déroulantes + + + output + array + Oui, à moins que vous n'utilisiez + l'attribut options + n/a + Un tableau de libellés pour la liste + déroulante + + + selected + chaîne de caractères/tableau + Non + empty + Les éléments sélectionnés + + + options + Tableau associatif + Oui, à moins que vous n'utilisiez option + et values + n/a + Un tableau associatif valeur / libellé + + + name + chaîne de caractères + Non + empty + Nom du goupe d'options + + + + + + html_options est une fonction utilisateur qui crée un groupe d'options + avec les données fournies. Elle prend en charge les éléments + sélectionnés par défaut. Les attributs requis sont values et output, + à moins que vous n'utilisiez options à la place. + + + Si la valeur donnée est un tableau, elle sera traitée comme un + OPTGROUP html, et affichée. La récursivité est supportée avec + OPTGROUP. La sortie est compatible XHTML. + + + Si l'attribut optionnel name est donné, les + balises <select name="groupname"></select> entoureront la + liste d'options. + + + Tous les paramètres qui ne sont pas dans la liste ci-dessus sont + affichés en tant que paires nom / valeur. Ils sont ignorés si + le paramètre optionnel name n'est pas donné. + +html_options + +index.php: + +require('Smarty.php.class'); +$smarty = new Smarty; +$smarty->assign('id_client', array(1000,1001,1002,1003)); +$smarty->assign('nom_client', array('Joe Schmoe','Jack Smith','Jane +Johnson','Charlie Brown')); +$smarty->assign('client_id', 1001); +$smarty->display('index.tpl'); + +index.tpl: + +<select name=client_id> + {html_options values=$id_client selected=$client_id output=$nom_client} +</select> + + +index.php: + +require('Smarty.php.class'); +$smarty = new Smarty; +$smarty->assign('cust_options', array( + 1001 => 'Joe Schmoe', + 1002 => 'Jack Smith', + 1003 => 'Jane Johnson', + 1004 => 'Charlie Brown')); +$smarty->assign('client_id', 1001); +$smarty->display('index.tpl'); + +index.tpl: + +<select name=client_id> + {html_options options=$cust_options selected=$client_id} +</select> + + +SORTIE: (valable pour les deux exemples) + +<select name=client_id> + <option value="1000">Joe Schmoe</option> + <option value="1001" selected="selected">Jack Smith</option> + <option value="1002">Jane Johnson</option> + <option value="1003">Charlie Brown</option> +</select> + + + + html_radios + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + name + chaîne de caractères + Non + radio + nom de la liste boutons radio + + + values + tableau + Oui, à moins que vous n'utilisiez l'attribut + options + n/a + Le tableau des valeurs des boutons radio + + + output + tableau + Oui, à moins que vous n'utilisiez l'attribut + options + n/a + Un tableau de libellés pour les boutons radio + + + checked + chaîne de caractères + Non + empty + Les boutons radios sélectionnés + + + options + tableau associatif + Oui, à moins que vous n'utilisiez values + et outputs + n/a + un tableau associatif valeurs / libellés + + + separator + chaîne de caractères + Non + empty + chaîne de séparation à placer entre les + boutons radio + + + + + + html_radio est une fonction utilisateur qui crée des boutons radio + html à partir des données fournies. Elle prend en charge les éléments + sélectionnés par défaut. Les attributs requis sont values et output, + à moins que vous n'utilisiez options à la place. La sortie générée est + compatible XHTML. + + + Tous les paramètres qui ne sont pas dans la liste ci dessus sont + affichés en tant que paires nom / valeur dans chaque balise <input> + créée. + +html_radios + +index.php: + +require('Smarty.php.class'); +$smarty = new Smarty; +$smarty->assign('id_client', array(1000,1001,1002,1003)); +$smarty->assign('nom_client', array('Joe Schmoe','Jack Smith','Jane +Johnson','Charlie Brown')); +$smarty->assign('client_id', 1001); +$smarty->display('index.tpl'); + + +index.tpl: + +{html_radios values=$id_client checked=$client_id output=$nom_client separator="<br />"} + + +index.php: + +require('Smarty.php.class'); +$smarty = new Smarty; +$smarty->assign('cust_radios', array( + 1001 => 'Joe Schmoe', + 1002 => 'Jack Smith', + 1003 => 'Jane Johnson', + 1004 => 'Charlie Brown')); +$smarty->assign('client_id', 1001); +$smarty->display('index.tpl'); + + +index.tpl: + +{html_radios name="id" radios=$cust_radios checked=$client_id separator="<br />"} + + +SORTIE: (both examples) + +<input type="radio" name="id[]" value="1000">Joe Schmoe<br /> +<input type="radio" name="id[]" value="1001" checked="checked"><br /> +<input type="radio" name="id[]" value="1002">Jane Johnson<br /> +<input type="radio" name="id[]" value="1003">Charlie Brown<br /> + + + + html_select_date + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + prefix + chaîne de caractères + Non + Date_ + Avec quoi préfixer le nom de variable + + + time + timestamp/YYYY-MM-DD + Non + la date courante au format unix YYYY-MM-DD + format + la date / heure à utiliser + + + start_year + chaîne de caractères + Non + current year + La première année dans la liste déroulante, soit + le numéro de l'année, soit un nombre relatif à l'année + courante (+/- N). + + + end_year + chaîne de caractères + Non + même chose que start_year + La dernière année dans la liste déroulante, soit + le numéro de l'année, soit un nombre relatif à l'année + courante (+/- N). + + + display_days + boolean + Non + true + Si l'on souhaite afficher les jours ou pas. + + + display_months + boolean + Non + true + Si l'on souhaite afficher les mois ou pas. + + + display_years + boolean + Non + true + Si l'on souhaite afficher les années ou pas. + + + month_format + chaîne de caractères + Non + %B + le format du mois (strftime) + + + day_format + chaîne de caractères + Non + %02d + Le format du jour (sprintf) + + + day_value_format + chaîne de caractères + Non + %d + le format de la valeur du jour (sprintf) + + + year_as_text + boolean + Non + false + S'il faut afficher l'année au format texte + + + reverse_years + boolean + Non + false + Affiche les années dans l'ordre inverse + + + field_array + chaîne de caractères + Non + null + + Si un nom est donné, la liste déroulante sera affichée + de telle façon que les résultats seront retournés à PHP + sous la forme nom[Day] (jour), nom[Year] (année), + nom[Month] (Mois). + + + + day_size + chaîne de caractères + Non + null + Ajoute un attribut size à la liste + déroulante des jours. + + + month_size + chaîne de caractères + Non + null + Ajoute un attribut size à la liste + déroulante des mois. + + + year_size + chaîne de caractères + Non + null + Ajoute un attribut size à la liste + déroulante des années. + + + all_extra + chaîne de caractères + Non + null + Ajoute des attributs supplémentaires à + toutes les balises select/input. + + + day_extra + chaîne de caractères + Non + null + Ajoute des attributs supplémentaires aux balises + select/input du jour. + + + month_extra + chaîne de caractères + Non + null + Ajoute des attributs supplémentaires aux balises + select/input du mois. + + + year_extra + chaîne de caractères + Non + null + Ajoute des attributs supplémentaires aux balises + select/input de l'année. + + + field_order + chaîne de caractères + Non + MDY + L'ordre dans lequel afficher les + listes déroulantes. + + + field_separator + chaîne de caractères + Non + \n + la chaîne de caractères affichée entre les + différents champs. + + + month_value_format + chaîne de caractères + Non + %m + Le format strftime de la valeur des mois, par défaut %m + pour les numéros. + + + + + + html_select_date est une fonction utilisateur qui crée des listes + déroulantes pour saisir la date. Elle peut afficher n'importe quel + jour, mois et année. + + +html_select_date + +{html_select_date} + + +SORTIE: + +<select name="Date_Month"> +<option value="1">January</option> +<option value="2">February</option> +<option value="3">March</option> +<option value="4">April</option> +<option value="5">May</option> +<option value="6">June</option> +<option value="7">July</option> +<option value="8">August</option> +<option value="9">September</option> +<option value="10">October</option> +<option value="11">November</option> +<option value="12" selected>December</option> +</select> +<select name="Date_Day"> +<option value="1">01</option> +<option value="2">02</option> +<option value="3">03</option> +<option value="4">04</option> +<option value="5">05</option> +<option value="6">06</option> +<option value="7">07</option> +<option value="8">08</option> +<option value="9">09</option> +<option value="10">10</option> +<option value="11">11</option> +<option value="12">12</option> +<option value="13" selected>13</option> +<option value="14">14</option> +<option value="15">15</option> +<option value="16">16</option> +<option value="17">17</option> +<option value="18">18</option> +<option value="19">19</option> +<option value="20">20</option> +<option value="21">21</option> +<option value="22">22</option> +<option value="23">23</option> +<option value="24">24</option> +<option value="25">25</option> +<option value="26">26</option> +<option value="27">27</option> +<option value="28">28</option> +<option value="29">29</option> +<option value="30">30</option> +<option value="31">31</option> +</select> +<select name="Date_Year"> +<option value="2001" selected>2001</option> +</select> + + + + +html_select_date + + +{* le démarage et la fin de l'année peuvent être relatif à l'année courante *} +{html_select_date prefix="StartDate" time=$time start_year="-5" end_year="+1" display_days=false} + +SORTIE: (current year is 2000) + +<select name="StartDateMonth"> +<option value="1">January</option> +<option value="2">February</option> +<option value="3">March</option> +<option value="4">April</option> +<option value="5">May</option> +<option value="6">June</option> +<option value="7">July</option> +<option value="8">August</option> +<option value="9">September</option> +<option value="10">October</option> +<option value="11">November</option> +<option value="12" selected>December</option> +</select> +<select name="StartDateYear"> +<option value="1999">1995</option> +<option value="1999">1996</option> +<option value="1999">1997</option> +<option value="1999">1998</option> +<option value="1999">1999</option> +<option value="2000" selected>2000</option> +<option value="2001">2001</option> +</select> + + + + html_select_time + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + prefix + chaîne de caractères + Non + Time_ + Par quoi préfixer la variable. + + + time + timestamp + Non + current time + Quel jour / heure utiliser. + + + display_hours + boolean + Non + true + S'il faut afficher l'heure. + + + display_minutes + boolean + Non + true + S'il faut afficher les minutes. + + + display_seconds + boolean + Non + true + S'il faut afficher les secondes. + + + display_meridian + boolean + Non + true + S'il faut afficher le méridian (am/pm) + + + use_24_hours + boolean + Non + true + S'il faut utiliser l'horloge 24 heure. + + + minute_interval + integer + Non + 1 + Intervalle des minutes dans la liste + déroulante + + + second_interval + integer + Non + 1 + Intervalle des secondes dans la liste + déroulante + + + field_array + chaîne de caractères + Non + n/a + Nom du tableau dans lequel les valeures + seront stockées. + + + all_extra + chaîne de caractères + Non + null + Ajoute des attributs supplémentaires aux balises + select / input. + + + hour_extra + chaîne de caractères + Non + null + Ajoute des attributs supplémentaires aux balises + select / input de l'heure. + + + minute_extra + chaîne de caractères + Non + null + Ajoute des attributs supplémentaires aux balises + select / input des minutes. + + + second_extra + chaîne de caractères + Non + null + Ajoute des attributs supplémentaires aux balises + select / input des secondes. + + + meridian_extra + chaîne de caractères + Non + null + Ajoute des attributs supplémentaires aux balises + select / input du méridian. + + + + + + html_select_time est une fonction utilisateur qui crée des listes + déroulantes pour saisir une heure. Elle prends en charge l'heure, + les minutes, les secondes et le méridian. + + +html_select_time + +{html_select_time use_24_hours=true} + + +SORTIE: + +<select name="Time_Hour"> +<option value="00">00</option> +<option value="01">01</option> +<option value="02">02</option> +<option value="03">03</option> +<option value="04">04</option> +<option value="05">05</option> +<option value="06">06</option> +<option value="07">07</option> +<option value="08">08</option> +<option value="09" selected>09</option> +<option value="10">10</option> +<option value="11">11</option> +<option value="12">12</option> +<option value="13">13</option> +<option value="14">14</option> +<option value="15">15</option> +<option value="16">16</option> +<option value="17">17</option> +<option value="18">18</option> +<option value="19">19</option> +<option value="20">20</option> +<option value="21">21</option> +<option value="22">22</option> +<option value="23">23</option> +</select> +<select name="Time_Minute"> +<option value="00">00</option> +<option value="01">01</option> +<option value="02">02</option> +<option value="03">03</option> +<option value="04">04</option> +<option value="05">05</option> +<option value="06">06</option> +<option value="07">07</option> +<option value="08">08</option> +<option value="09">09</option> +<option value="10">10</option> +<option value="11">11</option> +<option value="12">12</option> +<option value="13">13</option> +<option value="14">14</option> +<option value="15">15</option> +<option value="16">16</option> +<option value="17">17</option> +<option value="18">18</option> +<option value="19">19</option> +<option value="20" selected>20</option> +<option value="21">21</option> +<option value="22">22</option> +<option value="23">23</option> +<option value="24">24</option> +<option value="25">25</option> +<option value="26">26</option> +<option value="27">27</option> +<option value="28">28</option> +<option value="29">29</option> +<option value="30">30</option> +<option value="31">31</option> +<option value="32">32</option> +<option value="33">33</option> +<option value="34">34</option> +<option value="35">35</option> +<option value="36">36</option> +<option value="37">37</option> +<option value="38">38</option> +<option value="39">39</option> +<option value="40">40</option> +<option value="41">41</option> +<option value="42">42</option> +<option value="43">43</option> +<option value="44">44</option> +<option value="45">45</option> +<option value="46">46</option> +<option value="47">47</option> +<option value="48">48</option> +<option value="49">49</option> +<option value="50">50</option> +<option value="51">51</option> +<option value="52">52</option> +<option value="53">53</option> +<option value="54">54</option> +<option value="55">55</option> +<option value="56">56</option> +<option value="57">57</option> +<option value="58">58</option> +<option value="59">59</option> +</select> +<select name="Time_Second"> +<option value="00">00</option> +<option value="01">01</option> +<option value="02">02</option> +<option value="03">03</option> +<option value="04">04</option> +<option value="05">05</option> +<option value="06">06</option> +<option value="07">07</option> +<option value="08">08</option> +<option value="09">09</option> +<option value="10">10</option> +<option value="11">11</option> +<option value="12">12</option> +<option value="13">13</option> +<option value="14">14</option> +<option value="15">15</option> +<option value="16">16</option> +<option value="17">17</option> +<option value="18">18</option> +<option value="19">19</option> +<option value="20">20</option> +<option value="21">21</option> +<option value="22">22</option> +<option value="23" selected>23</option> +<option value="24">24</option> +<option value="25">25</option> +<option value="26">26</option> +<option value="27">27</option> +<option value="28">28</option> +<option value="29">29</option> +<option value="30">30</option> +<option value="31">31</option> +<option value="32">32</option> +<option value="33">33</option> +<option value="34">34</option> +<option value="35">35</option> +<option value="36">36</option> +<option value="37">37</option> +<option value="38">38</option> +<option value="39">39</option> +<option value="40">40</option> +<option value="41">41</option> +<option value="42">42</option> +<option value="43">43</option> +<option value="44">44</option> +<option value="45">45</option> +<option value="46">46</option> +<option value="47">47</option> +<option value="48">48</option> +<option value="49">49</option> +<option value="50">50</option> +<option value="51">51</option> +<option value="52">52</option> +<option value="53">53</option> +<option value="54">54</option> +<option value="55">55</option> +<option value="56">56</option> +<option value="57">57</option> +<option value="58">58</option> +<option value="59">59</option> +</select> +<select name="Time_Meridian"> +<option value="am" selected>AM</option> +<option value="pm">PM</option> +</select> + + + + html_table + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + loop + array + Oui + n/a + Tableau de données à parcourir + + + cols + integer + Non + 3 + Nombre de colonnes du tableau + + + table_attr + chaîne de caractères + Non + border="1" + attributs pour la balise table + + + tr_attr + chaîne de caractères + Non + empty + attributs pour les balises tr (les tableaux sont + parcourus) + + + td_attr + chaîne de caractères + Non + empty + attributs pour les balises td (les tableaux sont + parcourus) + + + trailpad + chaîne de caractères + Non + &nbsp; + valeur avec laquelle remplir les cellules + restantes de la dernière ligne (si il y en a) + + + + + + html_table est une fonction utilisateur + qui transforme un tableau de données dans un tabeau HTML. L'attribut + cols détermine le nombre de colonne du tableau. + Les attributs table_attr, tr_attr + et td_attr déterminent les attributs donnés aux + balises table, tr et td. Si tr_attr ou + td_attr sont des tableaux, ils seront parcourus. + trailpad est la valeur avec laquelle remplir + les cellules restantes de la dernière ligne, s'il y en a une. + + +html_table + +index.php: + +require('Smarty.php.class'); +$smarty = new Smarty; +$smarty->assign('data',array(1,2,3,4,5,6,7,8,9)); +$smarty->assign('tr',array('bgcolor="#eeeeee"','bgcolor="#dddddd"')); +$smarty->display('index.tpl'); + +index.tpl: + +{html_table loop=$data} +{html_table loop=$data cols=4 table_attrs='border="0"'} +{html_table loop=$data cols=4 tr_attrs=$tr} + +SORTIE: + +<table border="1"> +<tr><td>1</td><td>2</td><td>3</td></tr> +<tr><td>4</td><td>5</td><td>6</td></tr> +<tr><td>7</td><td>8</td><td>9</td></tr> +</table> +<table border="0"> +<tr><td>1</td><td>2</td><td>3</td><td>4</td></tr> +<tr><td>5</td><td>6</td><td>7</td><td>8</td></tr> +<tr><td>9</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td></tr> +</table> +<table border="1"> +<tr bgcolor="#eeeeee"><td>1</td><td>2</td><td>3</td><td>4</td></tr> +<tr bgcolor="#dddddd"><td>5</td><td>6</td><td>7</td><td>8</td></tr> +<tr bgcolor="#eeeeee"><td>9</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td></tr> +</table> + + + + math + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + equation + chaîne de caractères + Oui + n/a + L'opération à éxécuter + + + format + chaîne de caractères + Non + n/a + Le format du résultat (sprintf) + + + var + numeric + Oui + n/a + Les variables de l'opération + + + assign + chaîne de caractères + Non + n/a + Variable de template dans laquelle la sortie + sera assignée + + + [var ...] + numeric + Oui + n/a + Valeurs des variables de l'opération + + + + + + math autorise les designers de templates à effectuer des opérations + dans le template. Toute valeur numérique peut être utilisée dans une + opération, et le résultat sera affiché à la place des balises + "equation". Les variables utilisées dans l'opération sont passées en + tant que paramètre, et peuvent être des variables de templates ou des + valeurs statiques. +, -, /, *, abs, ceil, cos, + exp, floor, log, log10, max, min, pi, pow, rand, round, sin, sqrt, + srans et tan sont tous des opérateurs valides. Voir la + documentation PHP pour plus d'informations sur ces fonctions + mathématiques. + + + Si vous spécifiez l'attribut assign, la sortie sera assignée à la variable + donnée plutôt que d'être directement affichée. + + + Note technique + + math est une fonction coûteuse en terme de performances, du fait + qu'elle utilise la fonction PHP eval (). Effectuer les calculs + dans votre code PHP est beaucoup plus efficient, donc, chaque fois + que possible, effectuez vos calculs directement dans PHP et assignez + le résultat au template. Evitez coût que coût les appels + répétitifs à la fonction math, comme on pourait le faire une + une boucle section. + + + +math + +{* $height=4, $width=5 *} + +{math equation="x + y" x=$height y=$width} + +SORTIE: + +9 + + +{* $row_height = 10, $row_width = 20, #col_div# = 2, assigned in template *} + +{math equation="height * width / division" + height=$row_height + width=$row_width + division=#col_div#} + +SORTIE: + +100 + + +{* vous pouvez utiliser des parenthèses *} + +{math equation="(( x + y ) / z )" x=2 y=10 z=2} + +SORTIE: + +6 + + +{* vous pouvez définir un format sprintf pour l'affichage *} + +{math equation="x + y" x=4.4444 y=5.0000 format="%.2f"} + +SORTIE: + +9.44 + + + + mailto + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + address + chaîne de caractères + Oui + n/a + l'adresse email + + + text + chaîne de caractères + Non + n/a + le texte à afficher, par défaut l'adresse email + + + encode + chaîne de caractères + Non + none + Comment encoder l'adresse email. + none, hex et javascript sont des valeurs correctes. + + + cc + chaîne de caractères + Non + n/a + Les adresses email en copie (Cc). + Séparez les entrées par une virgule. + + + bcc + chaîne de caractères + Non + n/a + Les adresses email en copie cachées (Bcc). + Séparez les entrées par une virgule. + + + subject + chaîne de caractères + Non + n/a + Sujet de l'email. + + + newsgroups + chaîne de caractères + Non + n/a + newsgroup ou poster le message. + Séparez les entrées par une virgule. + + + followupto + chaîne de caractères + Non + n/a + Adresses ou transmettre le message. + Séparez les entrées par une virgule. + + + + extra + chaîne de caractères + Non + n/a + Toute information que vous souhaitez passer au lien, + comme par exemple une classe css. + + + + + + mailto crée un lien mailto automatiquement encodé (optionnel). + L'encodage rend la tâche de récupération des e-mails sur votre + site plus difficiles aux "web spiders". + + + Note technique + + javascript n'est certainement pas la forme d'encodage la plus robuste. + Vous pouvez également utiliser un encodage hexadécimal. + + + +mailto + +{mailto address="me@domain.com"} +{mailto address="moi@domaine.com" text="send me some mail"} +{mailto address="moi@domaine.com" encode="javascript"} +{mailto address="moi@domaine.com" encode="hex"} +{mailto address="moi@domaine.com" subject="Hello to you!"} +{mailto address="moi@domaine.com" cc="you@domain.com,they@domain.com"} +{mailto address="moi@domaine.com" extra='class="email"'} + +SORTIE: + +<a href="mailto:moi@domaine.com" >moi@domaine.com</a> +<a href="mailto:moi@domaine.com" >send me some mail</a> +<SCRIPT language="javascript">eval(unescape('%64%6f%63%75%6d%65%6e%74%2e%77%72%6 +9%74%65%28%27%3c%61%20%68%72%65%66%3d%22%6d%61%69%6c%74%6f%3a%6d%65%40%64%6f%6d% +61%69%6e%2e%63%6f%6d%22%20%3e%6d%65%40%64%6f%6d%61%69%6e%2e%63%6f%6d%3c%2f%61%3e +%27%29%3b'))</SCRIPT> +<a href="mailto:%6d%65@%64%6f%6d%61%69%6e.%63%6f%6d" >&#x6d;&#x65;&#x40;&#x64;& +#x6f;&#x6d;&#x61;&#x69;&#x6e;&#x2e;&#x63;&#x6f;&#x6d;</a> +<a href="mailto:moi@domaine.com?subject=Hello%20to%20you%21" >moi@domaine.com</a> +<a href="mailto:moi@domaine.com?cc=you@domain.com%2Cthey@domain.com" >moi@domaine.com</a> +<a href="mailto:moi@domaine.com" class="email">moi@domaine.com</a> + + + + popup_init + + popup est une intégration de overLib, une librairie capable de réaliser + des fenêtres surgissantes. (nous parlerons de "popup"). + Ce type de fenêtre est utilisé pour apporter des informations + contextuelles, comme des infobulles d'aides ou astuces. + popup_init doit être appelé une fois, en début de page si vous comptez + utiliser la fonction popup. + overLib à été écrit par Erik Bosrup. Le site d'overlib est situé à + l'adresse http://www.bosrup.com/web/overlib/. + + + Comme dans Smarty 2.1.2, overLib n'est PAS fournie dans la distribution. + Téléchargez overLib, déposez overlib.js dans votre arborescence web et + indiquez le chemin relatif à ce fichier dans l'attribut src de + popup_init. + + +popup_init + +{* popup_init doit être appelé une fois en début de page. *} +{popup_init src="/javascripts/overlib.js"} + + + + popup + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + text + chaîne de caractères + Oui + n/a + le texte/code html à afficher dans la popup + + + trigger + chaîne de caractères + Non + onMouseOver + L'évènement utilisé pour rendre la popup active, + onMouseOver ou onClick. + + + sticky + boolean + Non + false + Rends la popup active jusqu'a ce qu'elle soit + explicitement fermée. + + + caption + chaîne de caractères + Non + n/a + Défini le libellé du titre + + + fgcolor + chaîne de caractères + Non + n/a + couleur interne de la popup + + + bgcolor + chaîne de caractères + Non + n/a + couleur de la bordure de la popup + + + textcolor + chaîne de caractères + Non + n/a + couleur du texte à l'intérieur de la + popup + + + capcolor + chaîne de caractères + Non + n/a + couleur du libellé de la popup + + + closecolor + chaîne de caractères + Non + n/a + couleur du texte de fermeture + + + textfont + chaîne de caractères + Non + n/a + la police à utiliser dans le texte principal + + + captionfont + chaîne de caractères + Non + n/a + la police à utiliser dans le libellé + + + closefont + chaîne de caractères + Non + n/a + la police pour le texte de fermeture + + + textsize + chaîne de caractères + Non + n/a + taille de la police texte prinicpal + + + captionsize + chaîne de caractères + Non + n/a + taille de la police du libellé + + + closesize + chaîne de caractères + Non + n/a + taille de la police du bouton "fermer" + + + width + integer + Non + n/a + Longeur de la popup + + + height + integer + Non + n/a + Hauteur de la popup + + + left + boolean + Non + false + la popup va à gauche de la souris + + + right + boolean + Non + false + la popup va à droite de la souris + + + center + boolean + Non + false + la popup est centrée par rapport à la + position de la souris + + + above + boolean + Non + false + la popup est au dessus de la souris. NOTE: + possible uniquement si la hauteur est définie + + + below + boolean + Non + false + la popup apparait en dessous de la souris + + + border + integer + Non + n/a + rends la bordure de la popup plus épaisse ou plus + fine + + + offsetx + integer + Non + n/a + A quelle distance du curseur la popup apparaitra + , horizontalement. + + + offsety + integer + Non + n/a + A quelle distance du curseur la popup apparaitra + , verticalement. + + + fgbackground + url to image + Non + n/a + Une image à utiliser à la place de la couleur de + fonds dans la popup + + + bgbackground + url to image + Non + n/a + Image à utiliser à la place de la bordure de la + popup. NOTE: vous veillerez à définir bgcolor à "" ou la + couleur apparaitra de même. NOTE: Lorsque vous avez un + lien de fermeture, Netscape effectuera un nouveau rendu + des cellules du tableau, affichant mal les éléments + + + closetext + chaîne de caractères + Non + n/a + définit le texte de fermeture par autre chose + que "Close" + + + noclose + boolean + Non + n/a + N'affiche pas le bouton "Close" pour les fenêtres + "collantes". + + + + status + chaîne de caractères + Non + n/a + défini le texte de la barre de statut + du navigateur + + + autostatus + boolean + Non + n/a + Défini le texte de la barre de statut au contenu + de la popup. NOTE: Ecrase l'attribut status. + + + autostatuscap + chaîne de caractères + Non + n/a + Défini le texte de la barre de statut au libellé + de la popup. NOTE: Ecrase l'attribut status. + + + inarray + integer + Non + n/a + indique à overLib de lire le texte à cet index dans le + tableau ol_text, situé dans overlib.js. Ce paramètre peut être + utilisé à la place de text. + + + caparray + integer + Non + n/a + indique à overlib de lire le libellé depuis le + tableau ol_caps + + + capicon + url + Non + n/a + affiche l'image spécifiée avant le libellé de la + popup + + + snapx + integer + Non + n/a + Aligne la popup sur une grille horizontale + + + snapy + integer + Non + n/a + Aligne la popup sur une grille verticale + + + fixx + integer + Non + n/a + vérrouille la popup à une position horizontale. + Note: remplace les autres paramètres de position + horizontale + + + fixy + integer + Non + n/a + vérouille la popup à une position verticale + Note: remplace les autres paramètres de position + verticale + + + background + url + Non + n/a + défini l'image à utiliser plutôt que le tableau + de fond + + + padx + integer,integer + Non + n/a + écarte l'image de fond du reste des éléments + avec un espace horizontal, pour le positionnement du texte. + Note: c'est un attribut à deux paramètres. + + + pady + integer,integer + Non + n/a + écarte l'image de fond du reste des éléments + avec un espace vertical, pour le positionnement du texte. + Note: c'est un attribut à deux paramètres. + + + fullhtml + boolean + Non + n/a + vous autorise à placer du code html en tant que + contenu de la popup. Le code html est attendu dans + l'attribut text. + + + frame + chaîne de caractères + Non + n/a + contrôle la popup dans un cadre différent. + Voir la documentation d'overlib pour plus de détails + sur cette fonction. + + + timeout + chaîne de caractères + Non + n/a + Appelle la fonction javascript spécifiée et prends + sa valeur de retour comme texte devant être affiché + dans la popup. + + + delay + integer + Non + n/a + la popup se comporte comme une infobulle. + Elle disparaitra au bout d'un certain délai, en + millisecondes. + + + hauto + boolean + Non + n/a + Détermine automatiquement si la popup doit être + à gauche ou à droite de la souris + + + vauto + boolean + Non + n/a + Détermine automatiquement si la popup doit être + au-dessus ou au-dessous de la souris + + + + + + popup est utilisé pour créer une fenêtre popup javascript. + + +popup + +{* popup_init doit être appelé en haut de votre page *} +{popup_init src="/javascripts/overlib.js"} + +{* création d'un lien avec une popup qui apparait sur l'évènement onMouseOver *} +<A href="mypage.html" {popup text="Ce lien vous amène sur ma page!"}>mypage</A> + +{* vous pouvez utiliser du html, des liens, etc dans vos popup *} +<A href="mypage.html" {popup sticky=true caption="mypage contents" +text="<UL><LI>links<LI>pages<LI>images</UL>" snapx=10 snapy=10}>mypage</A> + +SORTIE: + +(allez sur le site officiel de Smarty pour des exemples.) + + + + textformat + + + + + + + + + + Nom attribut + Type + Requis + Defaut + Description + + + + + style + chaîne de caractères + Non + n/a + style prédéfini + + + indent + number + Non + 0 + Taille de l'indentation pour chaque + ligne + + + indent_first + number + Non + 0 + Taille de l'indentation de la + première ligne + + + indent_char + chaîne de caractères + Non + (single space) + Le caractère (ou la chaîne) à utiliser pour + indenter + + + wrap + number + Non + 80 + A combien de caractères doit on ajuster chaque + ligne + + + wrap_char + chaîne de caractères + Non + \n + Le caractère (ou chaîne de caractères) avec lequel + terminer les lignes + + + wrap_cut + boolean + Non + false + Si true, wrap réduira les lignes au caractère exact + au lieu d'ajuster à la fin d'un mot + + + assign + chaîne de caractères + Non + n/a + Le nom de la variable PHP dans laquelle la + sortie sera assignée + + + + + + textformat est une fonction de bloc utilisée pour formater du texte. + Elle nettoie la chaîne de ses espaces et caractères spéciaux, puis + formate les paragraphes en ajustant ces derniers à une certaine limite, + puis en indentant les lignes. + + + Vous pouvez soit utiliser un style prédéfini, soit définir explicitement + chaque attribut. Actuellement, seul le style prédéfini "email" est + disponible. + + +textformat + +{textformat wrap=40} + +This is foo. +This is foo. +This is foo. +This is foo. +This is foo. +This is foo. + +This is bar. + +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. + +{/textformat} + +SORTIE: + +This is foo. This is foo. This is foo. +This is foo. This is foo. This is foo. + +This is bar. + +bar foo bar foo foo. bar foo bar foo +foo. bar foo bar foo foo. bar foo bar +foo foo. bar foo bar foo foo. bar foo +bar foo foo. bar foo bar foo foo. + + +{textformat wrap=40 indent=4} + +This is foo. +This is foo. +This is foo. +This is foo. +This is foo. +This is foo. + +This is bar. + +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. + +{/textformat} + +SORTIE: + + This is foo. This is foo. This is + foo. This is foo. This is foo. This + is foo. + + This is bar. + + bar foo bar foo foo. bar foo bar foo + foo. bar foo bar foo foo. bar foo + bar foo foo. bar foo bar foo foo. + bar foo bar foo foo. bar foo bar + foo foo. + +{textformat wrap=40 indent=4 indent_first=4} + +This is foo. +This is foo. +This is foo. +This is foo. +This is foo. +This is foo. + +This is bar. + +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. + +{/textformat} + +SORTIE: + + This is foo. This is foo. This + is foo. This is foo. This is foo. + This is foo. + + This is bar. + + bar foo bar foo foo. bar foo bar + foo foo. bar foo bar foo foo. bar + foo bar foo foo. bar foo bar foo + foo. bar foo bar foo foo. bar foo + bar foo foo. + +{textformat style="email"} + +This is foo. +This is foo. +This is foo. +This is foo. +This is foo. +This is foo. + +This is bar. + +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. +bar foo bar foo foo. + +{/textformat} + +SORTIE: + +This is foo. This is foo. This is foo. This is foo. This is foo. This is +foo. + +This is bar. + +bar foo bar foo foo. bar foo bar foo foo. bar foo bar foo foo. bar foo +bar foo foo. bar foo bar foo foo. bar foo bar foo foo. bar foo bar foo +foo. + + + + + + + + Fichiers de configuration + + Les fichiers de configuration sont un moyen interressant pour gérer + des variables depuis un seul et même fichier. L'exemple le plus courant + étant le schéma de couleurs du template. Normalement, pour changer le + schéma de couleur d'une application, vous devriez aller + dans chaque template et changer la couleur des éléments (ou les classes css). + Avec un fichier de configuration, il vous est possible de conserver + la couleur dans un seul endroit, puis de la mettre à jour une seule fois. + + + Exemple de fichier de configuration + +# variables globales +titrePage = "Menu principal" +bodyBgColor = #000000 +tableBgColor = #000000 +rowBgColor = #00ff00 + +[client] +titrePage = "Infos client" + +[Login] +titrePage = "Login" +focus = "utilisateur" +Intro = """Une valeur qui tient sur + plusieur lignes. Vous devez la placer + entre trois guillemets.""" + +# hidden section +[.Database] +host=mon.domaine.com +db=ADDRESSBOOK +user=php-user +pass=foobar + + + Les valeurs des variables de fichiers de configuration peuvent être entre + guillemets, sans que cela soit nécessaire. Si vous vouler utiliser des + valeurs sur plusieurs lignes, vous devrez les entourer de triples + guillemets ("""). Vous pouvez insérer des commentaires dans les fichiers de + configuration en utilisant une syntaxe quelquonque, non valide. + Nous recommandons l'utilisation de # (dièse) en début + de ligne. + + + Cet exemple de fichier de configuration contient deux sections. Les noms des + sections sont entourés de crochets []. Les noms de section peuvent être + des chaînes, ne contenant aucun des symboles [ et + ]. Dans notre exemple, les 4 variables du début sont + des variables dites globales, qui ne sont pas contenue dans une section. + Ces variables sont toujours chargées depuis le fichier de configuration. + Si une section est chargée, alors toutes les variables de cette section + ainsi que les variables globales sont chargées. Si une variable existe + à la fois en tant que globale et à la fois en tant que variable de + section, la variable de section est prioritaire. + Si vous appelez deux variables dans une même section de la même façon, + la dernière déclarée prime. + + + Les fichiers de configuration sont chargés dans le template grâce à la + fonction config_load. + + + Vous pouvez masquer des variables ou des sections entières en préfixant + le nom de la variable ou le nom de la section avec une virgule. + Ce procédé est utile si votre application récupère ses données depuis + plusieurs fichiers de configuration et récupère des données sensibles dont + vos templates n'ont pas besoin. Si des tiers éditent des templates, vous + êtes sûr que ces derniers n'accèderont pas à ces données de configuration + en les chargeant depuis le template. + + + + + Console de débogage + + Il existe une console de débogage dans Smarty. La console vous indique + toutes les variables incluses, assignées et chargées depuis un fichier de + configuration pour le template courant. Un template appelé "debug.tpl" + est inclus dans la distribution de Smarty. Si besoin, vous pouvez définir + $debug_tpl de façon à ce que ce dernier contienne le chemin + du template à utiliser(dans SMARTY_DIR par defaut). + Lorsque vous chargez la page, une console javascript est censée surgir + et vous donner les noms de toutes les variables inclues et assignées dans + votre page courante. Pour voir toutes les variables d'un template particulier, + voir la fonction {debug}. + Pour désactiver la console de débogage, définissez $debugging à false. + Vous pouvez également temporairement activer le débogage en indiquant + SMARTY_DEBUG dans l'url si tant est que l'option + $debugging_ctrl soit activée. + + + Note technique + + La console de débogage ne fonctionne pas si vous utilisez l'API fetch (), + mais seulement lorsque vous utilisez display (). C'est en effet un jeu + d'instructions javascripts à la fin du template qui déclenchent l'ouverture + de la fenêtre. Si vous n'aimez pas javascript, vous pouvez modifier + debug.tpl pour formater les données de la façon qui vous conviendra le + mieux. Les données de débogage ne sont pas mises en cache et les + informations de debug.tpl ne sont pas incluses dans la sortie de la + console de débogage. + + + + + Le temps de chargement des templates et des fichiers de configuration sont + indiqués en secondes. + + + + diff --git a/docs/fr/getting-started.sgml b/docs/fr/getting-started.sgml new file mode 100644 index 00000000..44cca6be --- /dev/null +++ b/docs/fr/getting-started.sgml @@ -0,0 +1,427 @@ + + Pour commencer + + + Qu'est-ce que Smarty ? + + Smarty est un moteur de template pour PHP. Plus précisément, il facilite + la séparation entre la logique applicative et la présentation. + Cela s'explique plus facilement dans une situation où le + programmeur et le designer de templates jouent des rôles différents, ou, + comme la plupart du temps, sont deux personnes distinctes. + Supposons par exemple que vous concevez une page Web qui affiche un + article de newsletter. Le titre, le sous-titre, l'auteur et le corps + sont des éléments de contenu, ils ne contiennent aucune information + concernant la présentation. Ils sont transmis à Smarty par l'application, + puis le designer de templates éditent les templates et utilisent une + combinaison de balises HTML et de balises de templates pour formater + la présentation de ces éléments (tableaux HTML, couleurs d'arrière-plan, + tailles des polices, feuilles de styles, etc.). Un beau jour le programmeur + a besoin de changer la façon dont le contenu de l'article + est récupéré (un changement dans la logique applicative). Ce + changement n'affecte pas le designer de templates, le contenu + arrivera toujours au template de la même façon. De même, si le + le designer de templates veut changer complétement l'apparence + du template, aucun changement dans la logique de l'application + n'est nécessaire. Ainsi le programmeur peut changer la logique + de l'application sans restructurer les templates, et le designer + de templates peut changer les templates sans briser la logique + applicative. + + + Et maintenant un mot rapide sur ce que Smarty NE fait PAS. Smarty n'a + pas pour prétention de supprimer complétement les traitements au sein des + templates. + Il est tout à fait envisageable de recontrer un traitement dans un template, + à condition que ce dernier ne désserve que des besoins de présentation. + Un conseil : laissez la logique applicative en dehors des templates et + la logique de présentation en dehors de l'application. A l'avenir, cela permet + une meilleure gestion des évènements. + + + L'un des aspects unique de Smarty est la compilation des templates. + Cela signifie que Smarty lit les templates et crée des scripts PHP à partir + de ces derniers. Une fois créés, ils sont exécutés. + Il n'y a donc pas d'analyse coûteuse de template à chaque requête, + et les templates peuvent bénéficier des solutions de cache PHP + comme Zend Accelerator (http://www.zend.com) ou PHP Accelerator + (http://www.php-accelerator.co.uk). + + + Quelques caractéristiques de Smarty : + + + Il est très rapide. + Il est efficace, le parser PHP s'occupe + du sale travail. + Pas d'analyse de template coûteuse, une seule compilation. + + Il sait ne recompiler que les fichiers de templates + qui ont été modifiés. + Vous pouvez créer des + fonctions utilisateurs et des + modificateurs de variables personnalisés, le langage de + template est donc extrémement extensible. + Syntaxe des templates configurable, vous + pouvez utiliser {}, {{}}, <!--{}-->, etc comme délimiteurs. + + Les instructions if/elseif/else/endif + sont passées au parser PHP, la syntaxe de l'expression {if...} + peut être aussi simple ou aussi complexe que vous + le désirez. + Imbrication illimitée de sections, + de 'if', etc. autorisée. + Il est possible d'inclure du code PHP + directement dans vos templates, bien que cela ne soit pas obligatoire + (ni conseillé), vu que le moteur est extensible. + Support de cache intégré. + Sources de templates arbitraires. + Fonctions de gestion de cache personnalisables. + Architecture de plugins + + + + + Installation + + + Ce dont vous avez besoin + + Smarty nécessite un serveur Web utilisant PHP 4.0.6 ou supérieur. + + + + + Installation de base + + Copiez les fichiers bibliothèques de Smarty du répertoire + /libs/ de la distribution à un emplacement accessible à PHP. + Ce sont des fichiers PHP que vous NE DEVEZ PAS + modifier. Ils sont partagés par toutes les applications et ne seront + mis à jour que lorsque vous installerez une nouvelle version de + Smarty. + + + fichiers de la bibliothèque SMARTY + +Smarty.class.php +Smarty_Compiler.class.php +Config_File.class.php +debug.tpl +/plugins/*.php (tous !) + + + + Smarty utilise une constante PHP appelée SMARTY_DIR qui + représente le chemin complet de la bibliothèque Smarty. En fait, + si votre application trouve le fichier + Smarty.class.php, vous n'aurez pas + besoin de définir la variable SMARTY_DIR, Smarty s'en chargera pour vous. + En revanche, si Smarty.class.php + n'est pas dans votre répertoire d'inclusion ou que vous ne + donnez pas un chemin absolu à votre application, vous + devez définir SMARTY_DIR explicitement. SMARTY_DIR + doit avoir être terminé par un slash. + + + + Voici comment créer une instance de Smarty dans vos scripts PHP : + + + + créer une instance de Smarty + +require('Smarty.class.php'); +$smarty = new Smarty; + + + + Essayez de lancer le script ci-dessus. Si vous obtenez une erreur indiquant + que le fichier Smarty.class.php n'est pas trouvé, + tentez l'une des choses suivantes : + + + + fournir un chemin absolu vers la bibliothèque Smarty + +require('/usr/local/lib/php/Smarty/Smarty.class.php'); +$smarty = new Smarty; + + + + Ajouter le répertoire de la bibliothèque au chemin de php_include + +// Editez le fichier php.ini, ajoutez le répertoire de la +// bibliothèque Smarty au include_path et redémarrez le serveur Web. +// Cela devrait ensuite fonctionner : +require('Smarty.class.php'); +$smarty = new Smarty; + + + + Définir explicitement la constante SMARTY_DIR + +define('SMARTY_DIR','/usr/local/lib/php/Smarty/'); +require(SMARTY_DIR.'Smarty.class.php'); +$smarty = new Smarty; + + + + Maintenant que les fichiers de la librairie sont en place, + il est temps de définir les répertoires de Smarty, pour votre application. + Smarty a besoin de quatre répertoires qui sont (par défaut) + templates, + templates_c, configs et + cache. Chacun d'entre eux peut être défini + via les attributs $template_dir, + $compile_dir, $config_dir et + $cache_dir respectivement. Il est vivement + conseillé que vous régliez ces répertoires séparément pour chaque + application qui utilise Smarty. + + + Assurez-vous de bien connaître chemin de la racine + de votre arborescence Web. Dans notre exemple, la racine + est "/web/www.mydomain.com/docs". Seul Smarty + accède aux répertoires en question, et jamais le serveur Web. + Pour des raisons de sécurité, il est donc conseillé de + sortir ces répertoires dans un répertoire + en dehors de l'arborescence + Web. + + + Dans notre exemple d'installation, nous allons régler l'environnement + de Smarty pour une application de livre d'or. Nous avons ici choisi + une application principalement pour mettre en évidence une + convention de nommage des répertoires. Vous pouvez utiliser le même + environnement pour n'importe quelle autre application, il suffit de + remplacer "livredor" avec le nom de votre application. Nous allons + mettre nos répertoires Smarty dans + "/web/www.mydomain.com/smarty/livredor/". + + + Vous allez avoir besoin d'au moins un fichier à la racine de + l'arborescence Web, + il s'agit du script auquel l'internaute a accès. Nous allons l'appeler + "index.php" et le placer dans un sous-répertoire + appelé "/livredor/". Il est pratique de configurer le serveur Web de + sorte que "index.php" soit identifié comme fichier + par défaut de ce répertoire. Aicnsi, si l'on tape + "http://www.mydomain.com/livredor/", le script index.php soit + exécuté sans que "index.php" ne soit spécifié dans l'URL. Avec Apache + vous pouvez régler cela en ajoutant "index.php" à la ligne où se + trouve DirectoryIndex (séparez chaque entrée par un espace). + + + Jetons un coup d'oeil à la structure de fichier obtenue : + + + + exemple de structure de fichiers + +/usr/local/lib/php/Smarty/Smarty.class.php +/usr/local/lib/php/Smarty/Smarty_Compiler.class.php +/usr/local/lib/php/Smarty/Config_File.class.php +/usr/local/lib/php/Smarty/debug.tpl +/usr/local/lib/php/Smarty/plugins/*.php + +/web/www.mydomain.com/smarty/livredor/templates/ +/web/www.mydomain.com/smarty/livredor/templates_c/ +/web/www.mydomain.com/smarty/livredor/configs/ +/web/www.mydomain.com/smarty/livredor/cache/ + +/web/www.mydomain.com/docs/livredor/index.php + + + + Smarty a besoin d'accéder en écriture aux répertoires + $compile_dir et $cache_dir, + assurez-vous donc que le serveur Web dispose de ces droits d'accès. + Il s'agit généralement de l'utilisateur "nobody" et du group + "nobody". Pour les utilisateurs de OS X, l'utilisateur par défaut + est "web" et le group "web". Si vous utilisez Apache, vous pouvez + parcourir le fichier httpd.conf (en général dans + "/usr/local/apache/conf/") pour déterminer quel est l'utilisateur + et le groupe auquel il appartient. + + + + + régler les permissions d'accès + + +chown nobody:nobody /web/www.mydomain.com/smarty/templates_c/ +chmod 770 /web/www.mydomain.com/smarty/templates_c/ + +chown nobody:nobody /web/www.mydomain.com/smarty/cache/ +chmod 770 /web/www.mydomain.com/smarty/cache/ + + + + Note technique + + La commande chmod 770 est relativement bien sécurisée, elle donne + à l'utilisateur "nobody" et au groupe "nobody" les accès en + lecture/écriture aux répertoires. Si vous voulez donner le droit d'accès + en lecture à tout le monde (principalement pour pouvoir accéder + vous-même à ces fichiers), vous pouvez lui préférer chmod 775. + + + + + Nous devons créer le fichier index.tpl que Smarty va charger. + Il va se trouver dans $template_dir. + + + + Edition de /web/www.mydomain.com/smarty/templates/index.tpl + + +{* Smarty *} + +Hello, {$name}! + + + + + Note technique + + {* Smarty *} est un commentaire de template. Il n'est pas + obligatoire mais il est bon de commencer tous vos templates + avec ce commentaire. Cela rend le fichier facilement + reconnaissable en plus de son extension. Les éditeurs + de texte peuvent par exemple reconnaître le fichier et + adapter la coloration syntaxique. + + + + + Maintenant passons à l'édition du fichier index.php. Nous allons + créer une instance de Smarty, assigner une valeur à une variable + de template et afficher le résultat avec index.tpl. Dans notre + exemple d'environnement, "/usr/local/lib/php/Smarty" est dans notre + include_path. Assurez-vous de faire la même chose ou d'utiliser + des chemins absolus. + + + + édition de /web/www.mydomain.com/docs/livredor/index.php + +// charge la bibliothèque Smarty +require('Smarty.class.php'); + +$smarty = new Smarty; + +$smarty->template_dir = '/web/www.mydomain.com/smarty/livredor/templates/'; +$smarty->compile_dir = '/web/www.mydomain.com/smarty/livredor/templates_c/'; +$smarty->config_dir = '/web/www.mydomain.com/smarty/livredor/configs/'; +$smarty->cache_dir = '/web/www.mydomain.com/smarty/livredor/cache/'; + +$smarty->assign('name','Ned'); + +$smarty->display('index.tpl'); + + + + Note techique + + Dans notre exemple, nous avons configuré les chemins absolus + pour chacun des répertoires Smarty. Si + '/web/www.mydomain.com/smarty/livredor/' est dans votre + include_path PHP alors ces réglages ne sont pas nécessaires. + Quoi qu'il en soit il est plus efficace et (par expérience) + moins générateur d'erreurs de les définir avec des chemins + absolus. Cela nous garantit que Smarty récupèrera les bons fichiers. + + + + + Et maintenant appelez le fichier index.php avec navigateur + Web. Vous devriez voir "Hello, Ned!". + + + Vous venez de terminer l'installation de base de Smarty ! + + + + Configuration avancée + + + Ceci est la suite de l'installation de base, veuillez + lire cette dernière avant de poursuivre. + + + + Une manière un peu plus commode de configurer Smarty est de faire votre + propre classe fille et de l'initialiser selon votre environnement. + De la sorte, nous n'aurons plus besoin de configurer à chaques fois les + chemins de notre environnement. Créons un nouveau répertoire + "/php/includes/livredor/" et un nouveau fichier appelé "setup.php". + Dans notre exemple d'environnement, "/php/includes" est notre + include_path PHP. Assurez-vous de faire la même chose ou alors d'utiliser + des chemins absolus. + + + + édition de /php/includes/livredor/setup.php + + +// charge la librairie Smarty +require('Smarty.class.php'); + +// le fichier setup.php est un bon +// endroit pour charger les fichiers +// de librairies de l'application et vous pouvez +// faire cela juste ici. Par exemple : +// require('livredor/livredor.lib.php'); + +class Smarty_livredor extends Smarty { + + function Smarty_livredor() { + + // Constructeur de la classe. Appelé automatiquement + // à l'instanciation de la classe. + + $this->Smarty(); + + $this->template_dir = '/web/www.mydomain.com/smarty/livredor/templates/'; + $this->compile_dir = '/web/www.mydomain.com/smarty/livredor/templates_c/'; + $this->config_dir = '/web/www.mydomain.com/smarty/livredor/configs/'; + $this->cache_dir = '/web/www.mydomain.com/smarty/livredor/cache/'; + + $this->caching = true; + $this->assign('app_name','Guest Book'); + } + +} + + + + Modifions maintenant le fichier index.php pour qu'il utilise "setup.php" + + + + édition de /web/www.mydomain.com/docs/livredor/index.php + + +require('livredor/setup.php'); + +$smarty = new Smarty_livredor; + +$smarty->assign('name','Ned'); + +$smarty->display('index.tpl'); + + + + Vous savez maintenant qu'il est facile de créer une instance de Smarty, + correctement configurée, en utilisant Smarty_livredor qui initialise + automatiquement tout ce qu'il faut pour votre application. + + + + + + diff --git a/docs/fr/html-common.dsl b/docs/fr/html-common.dsl new file mode 100644 index 00000000..7fd772c5 --- /dev/null +++ b/docs/fr/html-common.dsl @@ -0,0 +1,382 @@ +;; -*- Scheme -*- +;; +;; $Id$ +;; + +;; Returns the depth of the auto-generated TOC (table of contents) that +;; should be made at the nd-level +(define (toc-depth nd) + (if (string=? (gi nd) (normalize "book")) + 3 ; the depth of the top-level TOC + 1 ; the depth of all other TOCs + )) + + + + + + +(element (funcdef function) + ($bold-seq$ + (make sequence + (process-children) + ) + ) + ) + + +(define (is-true-optional nl) + (and (equal? (gi (parent nl)) (normalize "parameter")) + (equal? 0 (string-length (strip (data (preced nl))))) + (equal? 0 (string-length (strip (data (follow nl))))) + ) + ) + + +(define (has-true-optional nl) + (is-true-optional + (node-list-first-element + (select-elements + (descendants nl) + (normalize "optional")) + ) + ) + ) + + +(define (count-true-optionals nl) + (let loop + ((result 0) + (nl (select-elements (descendants nl) (normalize "optional"))) + ) + (if(node-list-empty? nl) + result + (if(is-true-optional(node-list-first nl)) + (loop (+ result 1) (node-list-rest nl)) + (loop result (node-list-rest nl)) + ) + ) + ) + ) + + +;; there are two different kinds of optionals +;; optional parameters and optional parameter parts +;; an optional parameter is identified by an optional tag +;; with a parameter tag as its parent +;; and only whitespace between them +(element optional + ;;check for true optional parameter + (if (is-true-optional (current-node)) + ;; yes - handle '[...]' in paramdef + (process-children-trim) + ;; no - do '[...]' output + (make sequence + (literal %arg-choice-opt-open-str%) + (process-children-trim) + (literal %arg-choice-opt-close-str%) + ) + ) + ) + +;; now this is going to be tricky +(element paramdef + (make sequence + ;; special treatment for first parameter in funcsynopsis + (if (equal? (child-number (current-node)) 1) + ;; is first ? + (make sequence + ;; start parameter list + (literal "(") + ;; is optional ? + ( if (has-true-optional (current-node)) + (literal %arg-choice-opt-open-str%) + (empty-sosofo) + ) + ) + ;; not first + (empty-sosofo) + ) + + ;; + (process-children-trim) + + ;; special treatment for last parameter + (if (equal? (gi (ifollow (current-node))) (normalize "paramdef")) + ;; more parameters will follow + (make sequence + ;; next is optional ? + ( if (has-true-optional (ifollow (current-node))) + ;; optional + (make sequence + (literal " ") + (literal %arg-choice-opt-open-str%) + ) + ;; not optional + (empty-sosofo) + ) + (literal ", " ) + ) + ;; last parameter + (make sequence + (literal + (let loop ((result "")(count (count-true-optionals (parent (current-node))))) + (if (<= count 0) + result + (loop (string-append result %arg-choice-opt-close-str%)(- count 1)) + ) + ) + ) + ( literal ")" ) + ) + ) + ) + ) + + +(element function + (let* ((function-name (data (current-node))) + (linkend + (string-append + "function." + (string-replace + (string-replace function-name "_" "-") + "::" "."))) + (target (element-with-id linkend)) + (parent-gi (gi (parent)))) + (cond + ;; function names should be plain in FUNCDEF + ((equal? parent-gi "funcdef") + (process-children)) + + ;; if a valid ID for the target function is not found, or if the + ;; FUNCTION tag is within the definition of the same function, + ;; make it bold, add (), but don't make a link + ((or (node-list-empty? target) + (equal? (case-fold-down + (data (node-list-first + (select-elements + (node-list-first + (children + (select-elements + (children + (ancestor-member (parent) (list "refentry"))) + "refnamediv"))) + "refname")))) + function-name)) + ($bold-seq$ + (make sequence + (process-children) + (literal "()")))) + + ;; else make a link to the function and add () + (else + (make element gi: "A" + attributes: (list + (list "HREF" (href-to target))) + ($bold-seq$ + (make sequence + (process-children) + (literal + ) + (literal "()")))))))) + +(element command + (let* ((command-name (data (current-node))) + (linkend + (string-append + "language.function." + (string-replace + (string-replace command-name "_" ".") + "::" "."))) + (target (element-with-id linkend)) + (parent-gi (gi (parent)))) + (cond + ;; function names should be plain in FUNCDEF + ((equal? parent-gi "funcdef") + (process-children)) + + ;; if a valid ID for the target function is not found, or if the + ;; FUNCTION tag is within the definition of the same function, + ;; make it bold, add (), but don't make a link + ((or (node-list-empty? target) + (equal? (case-fold-down + (data (node-list-first + (select-elements + (node-list-first + (children + (select-elements + (children + (ancestor-member (parent) (list "refentry"))) + "refnamediv"))) + "refname")))) + command-name)) + ($bold-seq$ + (make sequence + (literal "{") + (process-children) + (literal "}")))) + + ;; else make a link to the function and add () + (else + (make element gi: "A" + attributes: (list + (list "HREF" (href-to target))) + ($bold-seq$ + (make sequence + (literal "{") + (process-children) + (literal "}")))))))) + +(element classname + (let* ((class-name (data (current-node))) + (linkend + (string-append + "class." + (string-replace + (case-fold-down class-name) "_" "-"))) + (target (element-with-id linkend)) + (parent-gi (gi (parent)))) + (cond + ;; function names should be plain in SYNOPSIS + ((equal? parent-gi "synopsis") + (process-children)) + + ;; if a valid ID for the target class is not found, or if the + ;; CLASSNAME tag is within the definition of the same class, + ;; make it bold, but don't make a link + ((or (node-list-empty? target) + (equal? (case-fold-down + (data (node-list-first + (select-elements + (node-list-first + (children + (select-elements + (children + (ancestor-member (parent) (list "refentry"))) + "refnamediv"))) + "refname")))) + class-name)) + ($bold-seq$ + (process-children))) + + ;; else make a link to the function and add () + (else + (make element gi: "A" + attributes: (list + (list "HREF" (href-to target))) + ($bold-seq$ + (process-children))))))) + + +(element constant + (let* ((constant-name (data (current-node))) + (linkend + (string-append "constant." + (case-fold-down + (string-replace constant-name "_" "-")))) + (target (element-with-id linkend)) + (parent-gi (gi (parent)))) + (cond +; ;; constant names should be plain in FUNCDEF +; ((equal? parent-gi "funcdef") +; (process-children)) + + ;; if a valid ID for the target constant is not found, or if the + ;; CONSTANT tag is within the definition of the same constant, + ;; make it bold, add (), but don't make a link + ((or (node-list-empty? target) + (equal? (case-fold-down + (data (node-list-first + (select-elements + (node-list-first + (children + (select-elements + (children + (ancestor-member (parent) (list "refentry"))) + "refnamediv"))) + "refname")))) + constant-name)) + ($bold-mono-seq$ + (process-children))) + + ;; else make a link to the function and add () + (else + (make element gi: "A" + attributes: (list + (list "HREF" (href-to target))) + ($bold-mono-seq$ + (process-children))))))) + + +(element example + (make sequence + (make element gi: "TABLE" + attributes: (list + (list "WIDTH" "100%") + (list "BORDER" "0") + (list "CELLPADDING" "0") + (list "CELLSPACING" "0") + (list "CLASS" "EXAMPLE")) + (make element gi: "TR" + (make element gi: "TD" + ($formal-object$)))))) + + +(element (paramdef parameter) + (make sequence + font-posture: 'italic + (process-children-trim) + ) + ) + +(mode book-titlepage-recto-mode + (element authorgroup + (process-children)) + + (element author + (let ((author-name (author-string)) + (author-affil (select-elements (children (current-node)) + (normalize "affiliation")))) + (make sequence + (make element gi: "DIV" + attributes: (list (list "CLASS" (gi))) + (literal author-name)) + (process-node-list author-affil)))) + ) + +(define (chunk-element-list) + (list (normalize "preface") + (normalize "chapter") + (normalize "appendix") + (normalize "article") + (normalize "glossary") + (normalize "bibliography") + (normalize "index") + (normalize "colophon") + (normalize "setindex") + (normalize "reference") + (normalize "refentry") + (normalize "part") + (normalize "sect1") + (normalize "sect2") + (normalize "section") + (normalize "book") ;; just in case nothing else matches... + (normalize "set") ;; sets are definitely chunks... + )) + +(define ($section-body$) + (make element gi: "DIV" + attributes: (list (list "CLASS" (gi))) + ($section-separator$) + ($section-title$) + + (if (or (not (node-list-empty? (select-elements (children (current-node)) + (normalize "sect2")))) + (not (node-list-empty? (select-elements (children (current-node)) + (normalize "sect3"))))) + (build-toc (current-node) 1) + (empty-sosofo)) + + (process-children))) + diff --git a/docs/fr/html.dsl b/docs/fr/html.dsl new file mode 100644 index 00000000..e312da30 --- /dev/null +++ b/docs/fr/html.dsl @@ -0,0 +1,21 @@ + + + +]> + + + + + +(define %html-ext% ".html") + +&html-common.dsl; +&common.dsl; + + + + + + + diff --git a/docs/fr/manual.sgml b/docs/fr/manual.sgml new file mode 100644 index 00000000..e05dd446 --- /dev/null +++ b/docs/fr/manual.sgml @@ -0,0 +1,44 @@ + + + + + +]> + + + + Smarty - le moteur et compilateur de template PHP + + + MonteOhrt <monte@ispi.net> + + + AndreiZmievski <andrei@php.net> + + + + + + ArnaudCogoluègnes <arnaud.cogoluegnes@free.fr> + + + GéraldCroës <gcroes@aston.fr> + + + + Version 2.0 + + 2001 + 2002 + ispi of Lincoln, Inc. + + + + &preface; + &getting.started; + &smarty.for.designers; + &smarty.for.programmers; + &appendixes; + + diff --git a/docs/fr/php.dsl b/docs/fr/php.dsl new file mode 100644 index 00000000..82a5e5f8 --- /dev/null +++ b/docs/fr/php.dsl @@ -0,0 +1,21 @@ + + + +]> + + + + + +(define %html-ext% ".php") + +&html-common.dsl; +&common.dsl; + + + + + + + diff --git a/docs/fr/preface.sgml b/docs/fr/preface.sgml new file mode 100644 index 00000000..66027b6e --- /dev/null +++ b/docs/fr/preface.sgml @@ -0,0 +1,77 @@ + + Préface + + "Comment rendre mes scripts PHP indépendants de la présentation ?". + Voici sans doute la question la plus posée sur la mailing list + PHP. Alors que PHP est étiqueté "langage de script + pour HTML", on se rend vite compte, après quelques projets qui mélangent + sans complexe HTML et PHP, que la séparation entre la forme et + le contenu est important. De plus, dans de nombreuses entreprises + les rôles du designer et du programmeur sont distincts. La solution template + coule donc de source. + + + Dans notre entreprise par exemple, le développement d'une application + se fait de la manière suivante : une fois le cahier des charges écrit, + le designer réalise une maquette, et donne ses interfaces + au programmeur. Le programmeur implémente les fonctionnalités applicatives + et utilise les maquettes pour faire des squelettes de templates. Le projet + est alors passé au designer HTML/responsable de la mise en page qui amène les + templates jusqu'au faîte de leur gloire. Il est possible que le projet fasse + une fois ou deux des allers/retours entre la programmation et la présentation. + En conséquence, il est important de disposer d'un bon système de template. Les + programmeurs ne veulent pas avoir à faire au HTML, et ne veulent pas non plus + que les designers HTML bidouillent le code PHP. Les designers ont besoin d'outils + comme des fichiers de configuration, des blocs dynamiques et d'autres solutions + pour répondre à des problématiques d'interface, mais ne veulent pas + nécessairement avoir à faire à toutes les subtilités de la programmation PHP. + + + Un rapide tour d'horizon des solutions type template aujourd'hui et + l'on s'aperçoit que la plupart d'entre elles n'offrent que des moyens + rudimentaires pour substituer des variables dans des templates, ainsi que des + fonctionnalités limitées de blocs dynamiques. Cependant nous avons + besoin d'un peu plus. Nous ne voulons pas que les programmeurs + s'occupent de la présentation HTML du TOUT, mais cela est pratiquement + inévitable. Par exemple, si un designer veut des couleurs d'arrière plan + différentes pour alterner entre différents blocs dynamiques, il est nécessaire + que ce dernier travaille avec le programmeur. Nous avons aussi besoin que les + designers soient capables de travailler avec leurs propres fichiers + de configuration pour y récupérer des variables, exploitables dans leurs + templates. Et la liste est longue. + + + Fin 1999, nous avons commencé à écrire une spécification pour un moteur de + template. Une fois la spécification terminée, + nous avons commencé à travailler sur un moteur de template écrit + en C qui pourrait, avec un peu de chance, être inclus à PHP. + Non seulement nous avons rencontré des problèmes techniques complexes, + mais nous avons participés à de nombreux débats sur ce que devait + et ce que ne devait pas faire un moteur de template. De cette expérience nous avons + décidé qu'un moteur de template se devait d'être écrit sous la forme d'une + classe PHP, afin que quiconque puisse l'utiliser à sa convenance. Nous + avons donc réalisé un moteur de template qui se contentait de faire cela, + et SmartTemplate a vu le jour (note : cette + classe n'a jamais été soumise au public). C'était une classe qui + faisait pratiquement tout ce que nous voulions : substitution de variables, + inclusion d'autres templates, intégration avec des fichiers de configuration, + intégration de code PHP, instruction 'if' basique et une gestion plus robuste + des blocks dynamiques imbriqués. Elle faisait tout cela avec des expressions + rationnelles et le code se révéla, comment dire, impénétrable. De plus, elle était + relativement lente pour les grosses applications à cause de l'analyse + et du travail sur les expressions rationnelles qu'elle devait faire à chaque + exécution. Le plus gros problème du point de vue du programmeur était + tout le travail nécessaire en amont, dans le script PHP, pour configurer + et exécuter les templates, et les blocs dynamiques. Comment rendre tout ceci + plus simple ? + + + Puis vint la vision de ce que devait devenir Smarty. Nous + savons combien le code PHP peut être rapide sans le coût + d'analyse des templates. Nous savons aussi combien fastidieux + et décourageant peut paraître le langage pour le designer moyen, et que + cela peut être remplacé par une syntaxe spécifique, beaucoup + plus simple. Et si nous combinions les deux forces ? Ainsi, Smarty + était né... + + diff --git a/docs/fr/programmers.sgml b/docs/fr/programmers.sgml new file mode 100644 index 00000000..92579a9c --- /dev/null +++ b/docs/fr/programmers.sgml @@ -0,0 +1,3090 @@ + + Smarty pour les programmeurs + + + + Constantes + + + + SMARTY_DIR + + Il doit s'agir du chemin complet du répertoire où + se trouvent les fichiers classes de Smarty. + S'il n'est pas défini, Smarty essaiera alors d'en + déterminer automatiquement la valeur. + S'il est défini, le chemin doit se terminer par un slash. + + + + SMARTY_DIR + +// définit le chemin du répertoire de Smarty +define("SMARTY_DIR","/usr/local/lib/php/Smarty/"); + +require_once(SMARTY_DIR."Smarty.class.php"); + + + + + + Variables + + + $template_dir + + C'est le nom par défaut du répertoire des templates. + Si vous ne spécifiez aucun chemin lors de l'utilisation de templates, Smarty + les cherchera à cet emplacement. + Par défaut, il s'agit de "./templates", ce qui signifie + qu'il va chercher le répertoire templates + dans le répertoire où se trouve le script PHP en cours d'exécution. + + + + Note technique + + Il n'est pas conseillé de mettre ce répertoire + dans l'arborescence Web. + + + + + $compile_dir + + C'est le nom du répertoire où se trouvent les templates + compilés. Par défaut, il s'agit de "./templates_c", + ce qui signifie que Smarty va chercher ce répertoire + dans le même répertoire que le script PHP en cours d'exécution. + + + Note technique + + Ce réglage doit être soit un chemin absolu, soit un chemin + relatif. include_path n'est pas utilisé pour écrire des fichiers. + + + + Note technique + + Il n'est pas conseillé de mettre ce répertoire + sous la racine de l'arborescence Web. + + + + + $config_dir + + Il s'agit du répertoire utilisé pour stocker les + fichiers de configuration utilisés dans les templates. + La valeur par défaut est "./configs", ce qui signifie + que Smarty va chercher ce répertoire + dans le même répertoire que le script PHP qui s'exécute. + + + Note technique + + Il n'est pas conseillé de mettre ce répertoire + sous la racine de l'arborescence Web. + + + + + $plugins_dir + + Ce sont les répertoire dans lesquels Smarty ira chercher les plugins + dont il a besoin. La valeur par défaut est "plugins" sous le + répertoire SMARTY_DIR. Si vous donnez un chemin relatif, Smarty + regardera d'abord relativement au SMARTY_DIR, puis relativement au rtc (répertoire + de travail courant), puis relativement à chaque entrée de votre répertoire + d'inclusion PHP. + + + Note technique + + Pour des raisons de performances, ne réglez pas votre plugins_dir + pour qu'il utilise votre include_path PHP. Utilisez un + chemin absolu ou un chemin relatif à SMARTY_DIR ou au rtc. + + + + + $debugging + + Cela active la + console de débogage. + La console est une fenêtre javascript qui vous informe des templates + inclus et des variables assignées dans la page courante. + + + + $debug_tpl + + C'est le nom du fichier template utilisé pour la + console de débuggage. Par défaut debug.tpl, il se situe dans SMARTY_DIR + + + + $debugging_ctrl + + Cela permet d'avoir différents moyens pour activer + le débogage. URL signifie que si SMARTY_DEBUG se + trouve dans QUERY_STRING, le débuggage + est activé à l'invocation du script. Si $debugging + est à vrai, cette valeur est sans effet. + + + + $global_assign + + C'est une liste de variable qui sont toujours + implicitement assignées au moteur de templates. + Ceci est commode pour rendre des variables globales + ou des variables du serveur accessibles à tous les templates + plutôt que de devoir les assigner à la main. Chaque élément + de $global_assign doit être soit le nom de la variable + globale, soit une paire clef/valeur, où clef est le + nom du tableau global et valeur le tableau de variable + assignées depuis ce tableau global. + $SCRIPT_NAME est globalement assigné par défaut depuis + $HTTP_SERVER_VARS. + + + Note technique + + On peut accéder aux variables du serveur avec la variable + $smarty, par exemple {$smarty.server.SCRIPT_NAME}. + Se reporter à la section sur la variable + $smarty. + + + + + $undefined + + Cela règle la valeur de $undefined, null par défaut. + N'est actuellement utilisé que pour initialiser + des variables non-définies dans $global_assign à des + valeurs par défaut. + + + + $autoload_filters + + Si vous désirez charger des filtres à chaque invocation + de templates, vous pouvez le spécifier en utilisant cette + variable. Les types de filtres et les valeurs sont des + tableaux comportant le nom des filtres. + + +$smarty->autoload_filters = array('pre' => array('trim', 'stamp'), + 'output' => array('convert')); + + + + + + $compile_check + + A chaque invocation de l'application PHP, Smarty fait + un test pour voir si le template courant a été modifié + (date de dernière modification différente) depuis sa + dernière compilation. S'il a changé, le template est recompilé. + Si le template n'a pas encore été compilé, il le sera + quelle que soit la valeur ce réglage. + Par défaut cette valeur est à vrai. Quand + une application est mise en production (les templates + ne changent plus), cette vérification n'est pas nécessaire. + Assurez-vous de mettre $compile_check à "false" pour des performances + maximales. Notez que si vous mettez ce paramètre à "false" et qu'un + template est modifié, vous ne verrez *pas* le changement + car le template ne sera *pas* recompilé. Si le processus de cache + est activé et que $compile_check l'est aussi, alors les fichiers + du cache seront regénérés si un template concerné ou un fichier de + configuration concerné est modifié. Voir aussi $force_compile ou clear_compiled_tpl. + + + + + $force_compile + + Cela oblige Smarty à (re)compiler les templates à chaque + invocation. Ce réglage supplante $compile_check. Par défaut, il + est désactivé. Ceci est commode pour le développement et le + débogage mais ne devrait jamais être utilisé dans un environnment + de production. Si le système de cache est actif, les + fichiers du cache seront regénérés à chaque appel. + + + + $caching + + Ce paramètre demande à Smarty de mettre ou non en cache la sortie des + templates. + Par défaut ce réglage est à 0 (désactivé). Si vos templates + génèrent du contenu redondant, il est conseillé d'activer le + cache. Cela permettra un gain de performance conséquent. + Vous pouvez aussi avoir de nombreux fichiers de cache pour un même template. + Une valeur de 1 ou 2 active le cache. 1 indique à Smarty d'utiliser + la variable $cache_lifetime pour déterminer si le fichier de cache a expiré. + Une valeur de 2 indique à Smarty d'utiliser la valeur + $cache_lifetime spécifiée à la génération du cache. Ainsi vous pouvez régler + la durée de vie d'un fichier de cache avant de récupérer le template pour avoir + un certain contrôle quand ce fichier en particulier expire. Voir + aussi is_cached. + + + Si $compile_check est actif, le contenu du cache sera regénéré + si un des templates ou un des fichiers de configuration qui fait partie + de ce fichier de cache a été modifié. Si $force_compile est actif, le contenu + du cache est toujours regénéré. + + + + $cache_dir + + Il s'agit du nom du répertoire où les caches des templates + sont stockés. Par défaut il s'agit de "./cache", ce qui signifie + que Smarty va chercher ce répertoire + dans le même répertoire que le script PHP en cours d'exécution. + + + Note technique + + Ce réglage doit être soit un chemin absolu, soit un chemin + relatif. include_path n'a aucune influence lors de l'écriture des fichiers. + + + + Technical Note + + Il n'est pas conseillé de mettre ce répertoire + dans l'arborescence Web. + + + + + $cache_lifetime + + Il s'agit de la durée en secondes pendant laquelle un cache de template + est valide. Une fois cette durée dépassée, le cache est regénéré. + $caching doit être à "true" pour que $cache_lifetime ait une + quelconque utilité. Avec une valeur de -1, le cache n'expire jamais. + Avec une valeur de 0, le cache est toujours regénéré (utile + à des fins de tests seulement. Une meilleure façon de désactiver + le cache est de mettre $caching à "false"). + + + Si $force_compile est + activé, les fichiers du cache seront regénérés à chaque fois, + désactivant ainsi le cache. Vous pouvez effacer tous les fichiers du cache + avec la function + clear_all_cache() + ou de façon individuelle (ou groupée) + avec la fonction clear_cache(). + + + Note technique + + Si vous souhaitez donner à certains templates leur propre durée de vie + en cache, vous pouvez le faire en réglant + $caching à 2, + puis $cache_lifetime à une unique valeur juste avant d'appeler + display ou fetch(). + + + + + $cache_handler_func + + Vous pouvez utiliser votre propre fonction de gestion du cache plutôt que + d'utiliser celle livrée avec Smarty. + Référez-vous à la section sur la fonction de gestion de cache + personnalisée pour plus de détails. + + + + $cache_modified_check + + Si cette variable est à vrai, Smarty respectera l'en-tête + If-Modified-Since envoyé par le client. Si la date de dernière + modification du fichier de cache n'a pas changé depuis la dernière + visite, alors un en-tête "304 Not Modified" sera envoyé à la place + du contenu. Cela ne fonctionne qu'avec du contenu mis en cache hors de la + balise insert. + + + + $config_overwrite + + Si cette variable est à vrai, les variables lues dans les fichiers + de configuration peuvent s'écraser entre elles. Sinon les variables + seront mises dans un tableau. Très utile si vous voulez stocker + des tableaux de données dans des fichiers de configuration, listez + simplement chaque élément plusieurs fois. Mise à faux par défaut. + + + + $config_booleanize + + Si cette variable est à vrai, les valeurs on/true/yes et off/false/no + dans les fichiers de configuration sont automitiquement converties + en booléen. De cette façon vous pouvez utiliser ces valeurs dans le + template de la façon suivante : {if #foobar#} ... {/if}. Si foobar + est à on, true ou yes, l'instruction {if} sera exécutée. vrai + par défaut. + + + + $config_read_hidden + + Si cette variable est à vrai, les sections cachés (dont les noms + commencent par un point) dans les fichiers de configuration peuvent + être lues depuis les templates. On laisse habituellement cela à faux, de + cette façon vous pouvez stocker des données sensibles dans les fichiers + de configuration, comme par exemple des paramètres de base de données, + sans vous soucier de la façon dont les templates les chargent. + Mise à faux par défaut. + + + + $config_fix_newlines + + Si cette variable est mise à vrai, les caractères de nouvelles lignes mac et dos + (\r et \r\n) sont convertis en \n quand ils sont analysés. vrai par défaut. + + + + $default_template_handler_func + + Cette fonction est appelée quand un template ne peut pas être + obtenu avec sa ressource. + + + + $php_handling + + Indique à Smarty comment interpréter le code PHP + intégré dans les templates. Il y a quatre valeurs possibles, par + défaut SMARTY_PHP_PASSTHRU. Notez que cela n'affecte PAS le code + PHP entouré des balises + {php}{/php} + dans le template. + + + SMARTY_PHP_PASSTHRU - Smarty écrit les balises + telles quelles. + SMARTY_PHP_QUOTE - Smarty transforme les balises + en entités HTML. + SMARTY_PHP_REMOVE - Smarty supprime les balises + des templates. + SMARTY_PHP_ALLOW - Smarty exécute les balises + comme du code PHP. + + + NOTE : Intégrer du code PHP dans les templates est vivement + déconseillé. Préférez les + fonctions utilisateurs + ou les modificateurs de variables. + + + + $security + + Cette variable est à faux par défaut. $security est de rigueur + quand vous n'êtes pas complètement sûr des personnes qui éditent les templates + (par ftp par exemple) et que vous voulez réduire le risque que + la sécurité du système soit compromise par le language de template. + Activer cette option de sécurité applique les règles suivantes + au langage de template, à moins que $security_settings ne spécifie + le contraire : + + + Si $php_handling est réglée à SMARTY_PHP_ALLOW, + cela est implicitement changé à SMARTY_PHP_PASSTHRU. + Les fonctions PHP ne sont pas autorisées dans les + instructions IF, à part celles déclarées dans + $security_settings. + Les templates ne peuvent être inclus que depuis + des répertoires listés dans le tableau $security_dir. + Les fichiers locaux ne peuvent être récupérés que depuis + les répertoires listés dans le tableau $security_dir en + utilisant {fetch}. + Les balises {php}{/php} ne sont pas autorisées. + Les fonctions PHP ne sont pas autorisées en tant + modificateurs, à part celles spécifiées dans $security_settings. + + + + $secure_dir + + Il s'agit d'un tableau contenant tous les répertoires locaux qui sont + considérés comme sécurisés. {include} et {fetch} l'utilisent quand + la sécurité est activée. + + + + $security_settings + + Ces réglages servent à écraser ou spécifier les paramètres de sécurité + quand celle-ci est activée. Les réglages possibles sont les suivants : + + + PHP_HANDLING - true/false. Si vrai, le + réglage $php_handling n'est pas vérifié. + IF_FUNCS - Le tableau des noms de fonctions + PHP autorisées dans les intructions IF. + INCLUDE_ANY - true/false. Si vrai, + les templates peuvent être inclus de n'importe où, quelque soit + le contenu de $secure_dir. + PHP_TAGS - true/false. Si vrai, + les balises {php}{/php} sont autorisées dans les templates. + MODIFIER_FUNCS - Le tableau des noms de fonctions + autorisées à être utilisées comme modificateurs de variables. + + + + $trusted_dir + + $trusted_dir n'est utilisée lorsque $security est activée. C'est un + tableau de tous les répertoires qui peuvent être considérés comme sûrs. + Les répertoires sûrs sont ceux qui contiennent des scripts PHP qui + sont exécutés directement depuis les templates avec + {include_php}. + + + + $left_delimiter + + Il s'agit du délimiteur gauche utilisé par le moteur de templates. La + valeur par défaut est "{". + + + + $right_delimiter + + Il s'agit du délimiteur droit utilisé par le moteur de templates. + La valeur par défaut est "}". + + + + $compiler_class + + Spécifie le nom de la classe du compilateur qui va être utilisée pour + compiler les templates. Le compilateur par défaut est + 'Smarty_Compiler'. Réservé aux utilisateurs avancés. + + + + $request_vars_order + + L'ordre dans lequel les variables de requêtes sont enregistrées, + identique à variables_order dans php.ini. + + + + $compile_id + + Identifiant persistant du compilateur. On peut passer le même compile_id + à chaque appel de fonction mais une alternative consiste à régler ce + compile_id, qui sera utilisé implicitement. + + + + $use_sub_dirs + + Régler cela à faux si votre environnement PHP n'autorise pas Smarty à créer + des sous-répertoires. Les sous-répertoires sont efficaces, utilisez-les quand + vous le pouvez. + + + + $default_modifiers + + Il s'agit d'un tableau de modificateurs utilisé pour assigner + une valeur par défaut à chaque variable dans un template. + Par exemple, pour par défaut échapper les caractères HTML de chaque variable, + utilisez array('escape:"htmlall"'); Pour rendre une variable indépendante + des modificateurs par défaut, passez-lui en paramètre le modificateur + "nodefaults" : {$var|nodefaults}. + + + + + + Méthodes + + append + + + void append + mixed var + + + void append + string varname + mixed var + + + void append + string varname + mixed var + boolean merge + + + + Utilisée pour ajouter un élément à un tableau assigné. Si vous utilisez + cette fonction avec une chaîne de caractère, elle est convertie en + tableau auquel on ajoute ensuite l'élément. Vous pouvez explicitement passer + des paires nom/valeur. Si vous passez le troisième paramètre + (optionel) à vrai, la valeur sera fusionnée avec le tableau plutôt que + d'être ajoutée. + + + Note technique + + Le paramètre de fusion respecte les clés des tableaux, ainsi si vous + fusionnez deux tableaux indexés numériquement, ils pourront s'écraser + l'un l'autre ou donner des clés qui ne se suivent pas. Cela diffère + donc de la fonction PHP array_merge() qui supprime les clés numériques + et les renumérote. + + + + append + +// passe des paires nom/valeur +$smarty->append("Name","Fred"); +$smarty->append("Address",$address); + +// passe un tableau associatif +$smarty->append(array("city" => "Lincoln","state" => "Nebraska")); + + + + append_by_ref + + + void append_by_ref + string varname + mixed var + + + void append_by_ref + string varname + mixed var + boolean merge + + + + Utilisée pour ajouter des valeurs à un template par référence plutôt que + par copie. Si vous ajoutez une variable par référence puis changez sa + valeur, le changement est aussi répercuté sur la valeur assignée. + Pour les objets, append_by_ref ne fait pas de copie en mémoire de l'objet + assigné. Voir la documentation PHP pour plus d'informations sur les + références de variable. + Si vous passez le troisième paramètre à vrai, la valeur sera fusionnée + avec le tableau courant plutôt que d'être ajoutée. + + + Note technique + + Le paramètre de fusion respecte les clés des tableaux, ainsi si vous fusionnez + deux tableaux indexés numériquement, ils pourront s’écraser l’un l’autre + ou donner des clés qui ne se suivent pas. Cela diffère donc de la fonction + PHP array_merge() qui supprime les clés numériques et les renumérote. + + + + append_by_ref + +// ajoute des paires nom/valeur +$smarty->append_by_ref("Name",$myname); +$smarty->append_by_ref("Address",$address); + + + + assign + + + void assign + mixed var + + + void assign + string varname + mixed var + + + + Utilisée pour assigner des valeurs aux templates. Vous pouvez + explicitement passer des paires nom/valeur, ou des tableaux + associatifs contenant des paires nom/valeur. + + + assign + +// passe des paires nom/valeur +$smarty->assign("Name","Fred"); +$smarty->assign("Address",$address); + +// passe un tableau associatif +$smarty->assign(array("city" => "Lincoln","state" => "Nebraska")); + + + + assign_by_ref + + + void assign_by_ref + string varname + mixed var + + + + Utilisée pour assigner des valeurs aux templates par référence plutôt + que par copie. Référez-vous au manuel PHP pour une explication plus précise + sur les références des variables. + + + Note technique + + Si vous assignez une variable par référence puis changez sa + valeur, le changement est aussi répercuté sur la valeur assignée. + Pour les objets, assign_by_ref ne fait pas de copie en mémoire de l'objet + assigné. Référez-vous au manuel PHP pour une explication plus précise sur + les références de variable. + + + + assign_by_ref + +// passe des paires noms/valeurs +$smarty->assign_by_ref("Name",$myname); +$smarty->assign_by_ref("Address",$address); + + + + clear_all_assign + + + void clear_all_assign + + + + + Utilisée pour effacer les valeurs de toutes les variables assignées. + + +clear_all_assign + +// efface toutes les variables assignées +$smarty->clear_all_assign(); + + + + clear_all_cache + + + void clear_all_cache + int expire time + + + + Utilisée pour effacer les fichiers de cache des templates. Vous pouvez passer un + paramètre optionnel afin d'indiquer l'âge minimun que doivent avoir + les fichiers de cache pour qu'ils soient effacés. + + +clear_all_cache + +// efface le cache +$smarty->clear_all_cache(); + + + + clear_assign + + + void clear_assign + string var + + + + Efface la valeur d'une variable assignée. Il peut s'agir + d'une simple valeur ou d'un tableau de valeur. + + +clear_assign + +// efface une variable +$smarty->clear_assign("Name"); + +// efface plusieurs variables +$smarty->clear_assign(array("Name","Address","Zip")); + + + + clear_cache + + + void clear_cache + string template + string cache id + string compile id + int expire time + + + + Utilisée pour nettoyer le(s) fichier(s) de cache d'un template en particulier. + Si vous avez plusieurs fichiers de cache pour ce template vous + pouvez en spécifier un en particulier en passant son identifiant + en deuxième paramètre. Vous pouvez aussi passer un identifiant + de compilation en troisième paramètre. Vous pouvez grouper des + templates ensemble afin qu'ils puissent être supprimés en groupe. + Référez-vous à la section sur le + cache + pour plus d'informations. Vous pouvez passer un quatrième paramètre + pour indiquer un âge minimum en secondes que le fichier en cache doit + avoir avant d'être effacé. + + +clear_cache + +// efface le fichier de cache de ce template +$smarty->clear_cache("index.tpl"); + +// efface un fichier de cache grâce à son identifiant de cache +$smarty->clear_cache("index.tpl","CACHEID"); + + + + clear_compiled_tpl + + + void clear_compiled_tpl + string tpl_file + + + + Utilisée pour effacer la version compilée du template spécifié ou + de tous les templates si aucun n'est spécifié. Cette fonction + est destinée à un usage avancé et n'est pas habituellement utilisée. + + +clear_compiled_tpl + +// efface la version compilée du template spécifié +$smarty->clear_compiled_tpl("index.tpl"); + +// efface tout le contenu du répertoire des templates compilés +$smarty->clear_compiled_tpl(); + + + + clear_config + + + void clear_config + string var + + + + Utilisée pour effacer toutes les variables de configuration s'étant + vues assigner une valeur. Si une variable est spécifiée, seule cette + variable est effacée. + + +clear_config + +// efface toutes les variables de configuration assignées +$smarty->clear_config(); + +// efface une seule variable +$smarty->clear_config('foobar'); + + + + config_load + + + void config_load + string file + string section + + + + Utilisée pour charger des données d'un fichier de config et les + assigner à un template. Cette fonction fonctionne exactement comme + la fonction de template config_load. + + + Note technique + + Comme pour Smarty 2.4.0, les variables de templates assignées + sont conservées entre chaque appel à fetch et display. + Les variables de configuration chargées avec config_load sont + globales. Les fichiers de config sont aussi compilés pour une + exécution plus rapide et respecte les réglages de force_compile et de compile_check. + + + +config_load + +// charge les variables de configuration et les assigne +$smarty->config_load('my.conf'); + +// charge une section +$smarty->config_load('my.conf','foobar'); + + + + display + + + void display + string template + string cache_id + string compile_id + + + + Utilisée pour afficher un template. Il faut fournir un type et un + chemin de ressource template + valides. Vous pouvez passer en second paramètre un identifiant + de fichier de cache. Reportez-vous à la section + cache pour plus de renseignements. + + + Le troisième paramètre optionnel est un identifiant de compilation. + Cela s'avère utile quand vous voulez compiler différentes versions + d'un même template, pour par exemple avoir des templates + compilés séparés pour différents langages. Une autre utilité de ce + paramètre est le cas où vous utilisez plus d'un $template_dir mais un seul + $compile_dir, car certains templates avec le même nom s'écraseraient + entre eux. Vous pouvez aussi régler la variable $compile_id une seule + fois au lieu de la passer à chaque appel. + + +affichage + +include("Smarty.class.php"); +$smarty = new Smarty; +$smarty->caching = true; + +// ne fait un appel à la base de données que si le fichier +// de cache n'existe pas +if(!$smarty->is_cached("index.tpl")) +{ + + // quelques données + $address = "245 N 50th"; + $db_data = array( + "City" => "Lincoln", + "State" => "Nebraska", + "Zip" = > "68502" + ); + + $smarty->assign("Name","Fred"); + $smarty->assign("Address",$address); + $smarty->assign($db_data); + +} + +// display the output +$smarty->display("index.tpl"); + + + Utilisez la syntaxe des ressources templates + pour afficher des fichiers en-dehors du répertoire + $template_dir + + + +exemples de fonction d'affichage de ressources templates + +// chemin absolu +$smarty->display("/usr/local/include/templates/header.tpl"); + +// chemin absolu (pareil) +$smarty->display("file:/usr/local/include/templates/header.tpl"); + +// chemin absolu Windows (on DOIT utiliser le préfixe "file:") +$smarty->display("file:C:/www/pub/templates/header.tpl"); + +// inclue à partir de la ressource template "db" +$smarty->display("db:header.tpl"); + + + + + fetch + + + string fetch + string template + string cache_id + string compile_id + + + + Utilisée pour renvoyer le résultat du template plutôt que de l'afficher. + Il faut passer un type et un chemin de ressource template + valides. Vous pouvez passer un identifiant de cache en deuxième + paramètre. Reportez-vous à la section cache + pour plus de renseignements. + + + Un troisième paramètre optionnel est un identifiant de compilation. + Cela s'avère utile quand vous voulez compiler différentes versions + d'un même template, pour par exemple avoir des templates + compilés séparés pour différents langages. Une autre utilité de ce + paramètre est le cas où vous utilisez plus d'un $template_dir + mais un seul $compile_dir, car certains templates avec le même nom + s'écraseraient entre eux. Vous pouvez aussi régler la variable $compile_id une seule + fois plutôt que de la passer à chaque appel. + + +fetch + +include("Smarty.class.php"); +$smarty = new Smarty; + +$smarty->caching = true; + +// ne fait un appel à la base de données que si le fichier +// de cache n'existe pas +if(!$smarty->is_cached("index.tpl")) +{ + + // quelques données + $address = "245 N 50th"; + $db_data = array( + "City" => "Lincoln", + "State" => "Nebraska", + "Zip" = > "68502" + ); + + $smarty->assign("Name","Fred"); + $smarty->assign("Address",$address); + $smarty->assign($db_data); + +} + +// récupère le résultat +$output = $smarty->fetch("index.tpl"); + +// fait quelque chose avec $output + +echo $output; + + + + get_config_vars + + + array get_config_vars + string varname + + + + Retourne la valeur de la variable de configuration passée en paramètre. + Si aucun paramètre n'est donné, un tableau de toutes les variables de + configuration chargées est renvoyé. + + +get_config_vars + +// récupère la variable de configuration chargée 'foo' +$foo = $smarty->get_config_vars('foo'); + +// récupère toutes les variables de configuration chargées +$config_vars = $smarty->get_config_vars(); + +// les affiche à l'écran +print_r($config_vars); + + + + get_registered_object + + + array get_registered_object + string object_name + + + + Retourne la référence d'un objet enregistré. Utile quand vous + voulez accéder directement à un objet enregistré avec une + fonction utilisateur. + + +get_registered_object + +function smarty_block_foo($params, &$smarty) { + if (isset[$params['object']]) { + // récupère la référence de l'objet enregistré + $obj_ref =& $smarty->get_registered_object($params['object']); + // $obj_ref est maintenant une référence vers l'objet + } +} + + + + get_template_vars + + + array get_template_vars + string varname + + + + Retourne la valeur assignée passée en paramètre. Si aucun paramètre + n'est donné, un tableau de toutes les variables assignées est + renvoyé. + + +get_template_vars + +// récupère la variable 'foo' assignée au template +// get assigned template var 'foo' +$foo = $smarty->get_template_vars('foo'); + +// récupère toutes les variables assignées à ce template +$tpl_vars = $smarty->get_template_vars(); + +// les affiche à l'écran +print_r($tpl_vars); + + + + is_cached + + + void is_cached + string template + [string cache_id] + + + + Retourne vrai s'il y a un fichier de cache valide pour ce template. + Cela fonctionne seulement si caching est à vrai. + + +is_cached + +$smarty->caching = true; + +if(!$smarty->is_cached("index.tpl")) { + // faire des requêtes base de données et assigner + // des variables ici. +} + +$smarty->display("index.tpl"); + + + Vous pouvez aussi passer en second paramètre un identifiant + de cache au cas où vous voudriez plusieurs fichiers de cache + pour ce template. + + +is_cached with multiple-cache template + +$smarty->caching = true; + +if(!$smarty->is_cached("index.tpl","FrontPage")) { + // faire des requêtes base de données et assigner + // des variables ici. +} + +$smarty->display("index.tpl","FrontPage"); + + + + load_filter + + + void load_filter + string type + string name + + + + Cette fonction peut être utilisée pour charger un plugin + de filtrage. Le premier argument spécifie le type du filtre + et peut prendre l'une des valeurs suivantes : 'pre', 'post' + ou 'output'. Le second argument spécifie le nom du plugin + de filtrage, par exemple 'trim'. + + +Chargement de plugins de filtrage + +$smarty->load_filter('pre', 'trim'); // charge le filtre 'trim' de type 'pre' +$smarty->load_filter('pre', 'datefooter'); // charge un autre filtre de type 'pre' appelé 'datefooter' +$smarty->load_filter('output', 'compress'); // charge le filtre 'compress' de type 'output' + + + + register_block + + + void register_block + string name + string impl + + + + Utilisée pour déclarrer dynamiquement des plugins de fonction + de blocs. Il faut passer en paramètre le nom de la fonction + de blocs, suivi du nom de la fonction PHP qui l'implémente. + + +register_block + +/* PHP */ +$smarty->register_block("translate", "do_translation"); + +function do_translation ($params, $content, &$smarty) { + if ($content) { + $lang = $params['lang']; + // fait de la traduction avec la variable $content + echo $translation; + } +} + +{* template *} +{translate lang="br"} + Hello, world! +{/translate} + + + + register_compiler_function + + + void register_compiler_function + string name + string impl + + + + Utilisée pour déclarer dynamiquement un plugin de fonction + de compilation. Il faut passer en paramètres le nom de la fonction + de compilation, suivi par la fonction PHP qui + l'implémente. + + + + register_function + + + void register_function + string name + string impl + + + + Utilisée pour déclarer dynamiquement des plugins de fonction + de templates. Il faut passer en paramètres le nom de la fonction + de templates, suivi par le nom de la fonction PHP qui l'implémente. + + +register_function + +$smarty->register_function("date_now", "print_current_date"); + +function print_current_date ($params) { + extract($params); + if(empty($format)) + $format="%b %e, %Y"; + echo strftime($format,time()); +} + +// vous pouvez maintenant utiliser ceci dans Smarty pour afficher +// la date actuelle : {date_now} ou {date_now format="%Y/%m/%d"} +// pour la formater + + + + register_modifier + + + void register_modifier + string name + string impl + + + + Utilisée pour déclarer dynamiquement un plugin de modificateur. + Il faut passer en paramètre le nom du modificateur de variables, + suivi de la fonction PHP qui l'implémente. + + +register_modifier + +// associons la fonction PHP stripslashes à un modificateur Smarty. + +$smarty->register_modifier("sslash","stripslashes"); + +// vous pouvez maintenant utiliser {$var|sslash} pour supprimer les slash des variables + + + + register_object + + + void register_object + string object_name + object $object + array allowed methods/properties + boolean format + + + + Utilisée pour enregistrer un objet à utiliser dans un template. + Reportez-vous à la section + objet de + ce manuel pour des exemples. + + + + register_outputfilter + + + void register_outputfilter + string function_name + + + + Utilisée pour déclarer dynamiquement des filtres de sortie, pour + agir sur la sortie d'un template avant qu'elle ne soit affichée. + Reportez-vous à la section + filtres de sortie pour plus d'information sur le sujet. + + + + register_postfilter + + + void register_postfilter + string function_name + + + + Utilisée pour déclarer dynamiquement des filtres de post-compilation pour y faire + passer des templates une fois qu'ils ont été compilés. Reportez-vous + à la section + filtres de post-compilation de templates + pour avoir plus de renseignements sur la façon de paramétrer les fonctions + de post-compilation. + + + + register_prefilter + + + void register_prefilter + string function_name + + + + Utilisée pour déclarer dynamiquement des filtres de pré-compilation pour y faire + passer des templates avant qu'ils ne soient compilés. Reportez-vous + à la section + filtres de pré-compilation de templates + pour avoir plus de renseignements sur la façon de paramétrer les fonctions + de pré-compilation. + + + + register_resource + + + void register_resource + string name + array resource_funcs + + + + Utilisée pour déclarer dynamiquement une ressource plugin + dans Smarty. Il faut passer en paramètre le nom de la ressource + et le tableau des fonctions PHP qui l'implémentent. Reportez-vous + à la section ressources templates + pour avoir plus d'informations sur la façon de paramétrer une fonction + récupérant des templates. + + +register_resource + +$smarty->register_resource("db", array("db_get_template", + "db_get_timestamp", + "db_get_secure", + "db_get_trusted")); + + + + trigger_error + + + void trigger_error + string error_msg + [int level] + + + + Cette fonction peut-être utilisée pour afficher un message d'erreur + en utilisant Smarty. Le paramètre level + peut prendre l'une des valeures utilisées par la fonction PHP + trigger_error, i.e. E_USER_NOTICE, E_USER_WARNING, etc. Par défaut + il s'agit de E_USER_WARNING. + + + + + template_exists + + + bool template_exists + string template + + + + Cette fonction vérifie si le template spécifié existe. Elle accepte + soit un chemin vers le template, soit une ressource de type + chaîne de caractères précisant le nom du template. + + + + unregister_block + + + void unregister_block + string name + + + + Utilisée pour désallouer dynamiquement un plugin de fonction + de blocs. Passez en paramètre le nom du bloc. + + + + unregister_compiler_function + + + void unregister_compiler_function + string name + + + + Utilisée pour désallouer dynamiquement un fonction de compilation. + Passez en paramètre le nom de la fonction de compilation. + + + + unregister_function + + + void unregister_function + string name + + + + Utilisée pour désallouer dynamiquement un plugin de fonction + de templates. Passez en paramètres le nom de la fonction de templates. + + +unregister_function + +// nous ne voulons pas que les designers de templates aient accès +// au système de fichiers. + +$smarty->unregister_function("fetch"); + + + + unregister_modifier + + + void unregister_modifier + string name + + + + Utilisée pour désallouer dynamiquement un plugin modificateur de variable. + Passez en paramètre le nom du modificateur de templates. + + +unregister_modifier + +// nous ne voulons pas que les designers de templates +// suppriment les balises des élements + +$smarty->unregister_modifier("strip_tags"); + + + + unregister_object + + + void unregister_object + string object_name + + + + Utilisée pour désallouer un objet. + + + + unregister_outputfilter + + + void unregister_outputfilter + string function_name + + + + Utilisée pour désallouer dynamiquement un filtre de sortie. + + + + unregister_postfilter + + + void unregister_postfilter + string function_name + + + + Utilisée pour désallouer dynamiquement un filtre de post-compilation. + + + + unregister_prefilter + + + void unregister_prefilter + string function_name + + + + Utilisée pour désallouer dynamiquement un filtre de pré-compilation. + + + + unregister_resource + + + void unregister_resource + string name + + + + Utilisée pour désallouer dynamiquement un plugin ressource. + Passez en paramètre le nom de la ressource. + + +unregister_resource + +$smarty->unregister_resource("db"); + + + + + + Cache + + Le cache est utilisée pour accélérer l'appel de display() ou de fetch() en sauvegardant leur résultat + dans un fichier. Si un fichier de cache est disponible lors d'un appel, + il sera affiché sans qu'il ne soit nécessaire de regénérer le résultat. + Le système de cache + peut accélérer les traitements de façon impressionnante, en particulier les + templates dont la compilation est très longue. Comme le résultat de + display() ou de fetch() est dans le cache, un fichier de cache peut + être composé de plusieurs fichiers de templates, plusieurs fichiers + de configuration, etc. + + + Comme les templates sont dynamiques, il est important de faire attention + à la façon dont les fichiers de cache sont générés, et pour combien de temps. + Si par exemple vous affichez la page d'accueil de votre site Web dont le + contenu ne change pas souvent, il peut être intéressant de mettre cette page + dans le cache pour une heure ou plus. A l'inverse, si vous affichez une page + de météo mises à jour toutes les minutes, mettre cette page en cache + n'a aucun sens. + + + Paramétrer le cache + + La première chose à faire est d'activer le cache. Cela est fait en + mettant $caching = true + (ou 1). + + + activation du cache + +require('Smarty.class.php'); +$smarty = new Smarty; + +$smarty->caching = true; + +$smarty->display('index.tpl'); + + + Avec le cache activé, la fonction display('index.tpl') va afficher + le template mais sauvegardera par la même occasion une copie du résultat + dans un fichier (de cache) du répertoire + $cache_dir. Au prochain appel de + display('index.tpl'), le fichier de cache sera préféré à la réutilisation + du template. + + + Note technique + + Les fichiers situés dans $cache_dir sont nommés de la même façon que les templates. + Bien qu'ils aient une extension ".php", ils ne sont pas vraiment exécutable. + N'éditez surtout pas ces fichiers ! + + + + Tout fichier de cache à une durée de vie limitée déterminée par $cache_lifetime. La valeur par + défaut est 3600 secondes, i.e. 1 heure. Une fois que cette durée est + dépassée, le cache est regénéré. Il est possible de donner + une durée d'expiration propre à chaque fichier de cache en réglant + $caching = 2. + Se reporter à la documentation de $cache_lifetime pour plus de + détails. + + + réglage individuel de cache_lifetime + +require('Smarty.class.php'); +$smarty = new Smarty; + +$smarty->caching = 2; // régler la durée de vie individuellement + +// régle la durée de vie du cache à 15 minutes pour index.tpl +$smarty->cache_lifetime = 300; +$smarty->display('index.tpl'); + +// régle la durée de vie du cache à 1 heure pour home.tpl +$smarty->cache_lifetime = 3600; +$smarty->display('home.tpl'); + +// NOTE : le réglage suivant ne fonctionne pas quand $caching = 2. La durée de vie +// du fichier de cache de home.tpl a déjà été réglée à 1 heure et ne respectera +// plus la valeur de $cache_lifetime. Le cache de home.tpl expirera toujours +// dans 1 heure. +$smarty->cache_lifetime = 30; // 30 secondes +$smarty->display('home.tpl'); + + + Si $compile_check est actif, + chaque fichier de template et de configuration qui a un rapport + avec le fichier de cache sera vérifié pour détecter une éventuelle + modification. Si l'un de ces fichiers a été modifié depuis que le fichier de cache a été + généré, le cache est immédiatement regénéré. Ce processus est coûteux, donc, + pour des raisons de performances, mettez ce paramètre à false pour une application + en production. + + + activation de $compile_check + +require('Smarty.class.php'); +$smarty = new Smarty; + +$smarty->caching = true; +$smarty->compile_check = true; + +$smarty->display('index.tpl'); + + + Si $force_compile est actif, + les fichiers de cache sont toujours regénérés. Ceci revient finalement à + désactiver le cache. $force_compile est utilisé à des fins de débogage, + un moyen plus efficace de désactiver le cache est de régler + $caching = false (ou 0). + + + La fonction is_cached() permet + de tester si un template a ou non un fichier de cache valide. + Si vous disposez d'un template en cache qui requiert une requête + à une base de données, vous pouvez utiliser cette méthode plutôt + que $compile_check. + + + utilisation de is_cached() + +require('Smarty.class.php'); +$smarty = new Smarty; + +$smarty->caching = true; + +if(!$smarty->is_cached('index.tpl')) { + // pas de cache disponible, on assigne + $contents = get_database_contents(); + $smarty->assign($contents); +} + +$smarty->display('index.tpl'); + + + Vous pouvez rendre dynamiques seulement certaines parties d'une + page avec la fonction de templates insert. + Imaginons que toute une page doit être mise en cache à part + une bannière en bas à droite. En utilisant une fonction insert pour la + bannière, vous pouvez garder cet élément dynamique dans le contenu qui + est en cache. Reportez-vous à la documentation + insert pour plus de détails + et des exemples. + + + Vous pouvez effacer tous les fichiers du cache avec la fonction clear_all_cache(), ou de façon + individuelle (ou par groupe) avec la fonction clear_cache(). + + + nettoyage du cache + +require('Smarty.class.php'); +$smarty = new Smarty; + +$smarty->caching = true; + +// efface tous les fichiers du cache +$smarty->clear_all_cache(); + +// efface le fichier de cache du template 'index.tpl' +$smarty->clear_cache('index.tpl'); + +$smarty->display('index.tpl'); + + + + Caches multiples pour une seule page + + Vous pouvez avoir plusieurs fichiers de caches pour un même appel + aux fonctions display() ou fetch(). Imaginons qu'un appel à display('index.tpl') + puisse avoir plusieurs résultats, en fonction de certaines conditions, et que + vous vouliez des fichiers de cache séparés pour chacun d'eux. Vous + pouvez faire cela en passant un identifiant de cache (cache_id) en + deuxième paramètre à l'appel de fonction. + + + Passage d'un cache_id à display() + +require('Smarty.class.php'); +$smarty = new Smarty; + +$smarty->caching = true; + +$my_cache_id = $_GET['article_id']; + +$smarty->display('index.tpl',$my_cache_id); + + + Nous passons ci-dessus la variable $my_cache_id à display() comme + identifiant de cache. Pour chaque valeur distincte de $my_cache_id, + un fichier de cache distinct va être créé. Dans cet exemple, + "article_id" a été passé dans l'URL et est utilisé en tant qu'identifiant + de cache. + + + Note technique + + Soyez prudent en passant des valeurs depuis un client (navigateur Web) + vers Smarty (ou vers n'importe quelle application PHP). Bien que l'exemple + ci-dessus consistant à utiliser article_id depuis l'URL puisse paraître + commode, le résultat peut s'avérer mauvais. L'identifiant + de cache est utilisé pour créer un répertoire sur le système de fichiers, + donc si l'utilisateur décide de donner une très grande valeur à article_id + ou d'écrire un script qui envoie des article_id de façon aléatoire, + cela pourra causer des problèmes coté serveur. Assurez-vous de bien + tester toute donnée passée en paramètre avant de l'utiliser. Dans cet + exemple, peut-être savez-vous que article_id a une longueur de 10 + caractères, est exclusivement composé de caractères alph-numériques et + doit avoir une valeur contenue dans la base de données. Vérifiez-le bien ! + + + + Assurez-vous de bien passer le même identifiant aux fonctions + is_cached() et + clear_cache(). + + + passer un cache_id à is_cached() + +require('Smarty.class.php'); +$smarty = new Smarty; + +$smarty->caching = true; + +$my_cache_id = $_GET['article_id']; + +if(!$smarty->is_cached('index.tpl',$my_cache_id)) { + // pas de fichier de cache dispo, on assigne donc les variables + $contents = get_database_contents(); + $smarty->assign($contents); +} + +$smarty->display('index.tpl',$my_cache_id); + + + Vous pouvez effacer tous les fichiers de cache pour un identifiant + de cache particulier en passant null en tant que premier paramètre + à clear_cache(). + + + effacement de tous les fichiers de cache pour un identifiant de cache particulier + +require('Smarty.class.php'); +$smarty = new Smarty; + +$smarty->caching = true; + +// efface tous les fichiers de cache avec "sports" comme identifiant +$smarty->clear_cache(null,"sports"); + +$smarty->display('index.tpl',"sports"); + + + De cette manière vous pouvez "grouper" vos fichiers de cache en leur + donnant le même identifiant. + + + + groupes de fichiers de cache + + Vous pouvez faire des groupements plus élaborés en paramétrant les + groupes d'identifiant de cache. Il suffit de séparer chaque sous-groupes + avec une barre verticale "|" dans la valeur de l'identifiant de cache. + Vous pouvez faire autant de sous-groupes que vous le désirez. + + + groupes d'identifiants de cache + +require('Smarty.class.php'); +$smarty = new Smarty; + +$smarty->caching = true; + +// efface tous les fichiers de cache avec "sports|basketball" comme premiers +// groupes d'identifiants de cache +$smarty->clear_cache(null,"sports|basketball"); + +// efface tous les fichiers de cache "sports" comme premier groupe d'identifiants. +// Inclue donc "sports|basketball" ou "sports|nimportequoi|nimportequoi|..." +$smarty->clear_cache(null,"sports"); + +$smarty->display('index.tpl',"sports|basketball"); + + + Note technique + + Le système de cache n'utilise PAS le chemin vers le template en quoi + que ce soit pour l'identifiant de cache. Si par exemple vous + faites display('themes/blue/index.tpl'), vous ne pouvez pas effacer tous + les fichiers de cache dans le répertoire "theme/blue". Si vous voulez + faire cela, vous devez les grouper avec un même identifiant de cache, + display('themes/blue/index.tpl','themes|blue'). Vous pouvez ensuite effacer les + fichiers de cache pour blue et theme avec clear_cache(null,'theme|blue'). + + + + + + + Fonctionnalités avancées + + Objets + + Smarty donne l'accès aux objets PHP à travers les templates. Il y + a 2 moyens d'y avoir accès. Le premier consiste à allouer les objets + au template puis de les utiliser avec une syntaxe similaire à celles + des fonctions personnalisées. Le deuxième moyen consiste à allouer + des objets aux templates et de les utiliser comme n'importe quelle + variable. La première méthode a une syntaxe beaucoup plus sympathique. + Elle est aussi plus sécurisée, puisqu'un objet alloué ne peut avoir accès + qu'à certaines méthodes et propriétés. Néanmoins, un objet alloué + ne peut pas avoir de lien sur lui-même ou être mis dans un tableau + d'objet, etc. Vous devez choisir la méthode qui correspond à vos + besoins, mais tâchez d'utiliser la première méthode autant que possible + afin de réduire la syntaxe des templates au minimum. + + + Si l'option de sécurité est activée, aucune méthode ou fonctions privées + n'est accessible (commençant par "_"). S'il existe une méthode et une + propriété du même nom, c'est la méthode qui sera utilisée. + + + Vous pouvez restreindre l'accès aux méthodes et aux propriétés en + les listant dans un tableau en tant que troisième paramètre + d'allocation. + + + Par défaut, les paramètres passés aux objets depuis le templates le sont de la + même façon que les fonctions utilisateurs les récupèrent. + Le premier paramètre correspond à un tableau associatif, le second à l'objet + Smarty. Si vous souhaitez que les paramètres soient passées un à un, comme + dans un appel traditionnel, définissez registration, quatrième paramètre optionnel, + à false. + + + utilisation d'un objet alloué ou assigné + +<?php +// la classe + +class My_Object() { + function meth1($params, &$smarty_obj) { + return "this is my meth1"; + } +} + +$myobj = new My_Object; +// enregistre l'objet +$smarty->register_object("foobar",$myobj); +// on restreint l'accès à certaines méthodes et propriétés en les listant +$smarty->register_object("foobar",$myobj,array('meth1','meth2','prop1')); +// pour utiliser le format habituel de paramètre objet, passez le booléen = false +$smarty->register_object("foobar",$myobj,null,false); + +// on peut aussi assigner des objets. Assignez par référence quand c'est possible +$smarty->assign_by_ref("myobj", $myobj); + +$smarty->display("index.tpl"); +?> + +TEMPLATE: + +{* accès à notre objet enregistré *} +{foobar->meth1 p1="foo" p2=$bar} + +{* on peut aussi assigner la sortie *} +{foobar->meth1 p1="foo" p2=$bar assign="output"} +the output was {$output) + +{* access our assigned object *} +{$myobj->meth1("foo",$bar)} + + + + Filtres de pré-compilation + + Les filtres de pré-compilation sont des fonctions PHP que vos templates + exécutent avant qu'ils ne soient compilés. Cela peut être utile + pour pré-traiter vos templates afin d'enlever les commentaires + inutiles, garder un oeil sur ce que les gens mettent dans leurs templates, etc. + Les filtre de pré-compilations peuvent être soit + déclarés soit chargés + à partir des répertoires de plugins en utilisant la fonction + load_filter() ou en réglant + la variable + $autoload_filters. + Smarty passera à la fonction le code source en tant que premier argument, + et attendra en retour le code modifié. + + + Utilisation un filtre de pré-compilation de template + +<?php +// mettre ceci dans votre application +function remove_dw_comments($tpl_source, &$smarty) +{ + return preg_replace("/<!--#.*-->/U","",$tpl_source); +} + +// enregistrer le filtre de pré-compilation +$smarty->register_prefilter("remove_dw_comments"); +$smarty->display("index.tpl"); +?> + +{* template Smarty index.tpl *} +<!--# cette ligne va être supprimée par le filtre de pré-compilation --> + + + + + Filtres de post-compilation + + Les filtres de post-compilation sont des fonctions PHP que vos templates + exécutent après avoir été compilés. Les filtres de post-compilation peuvent + être soit déclarés soit chargés + depuis les répertoires des plugins en utilisant la fonction + load_filter() ou en réglant + la variable $autoload_filters. + Smarty passera le template compilé en tant que premier paramètre et attendra + de la fonction qu'elle retourne le résultat de l'exécution. + + + utilisation d'un filtre de post-compilation de templates + +<?php +// mettez cela dans votre application +function add_header_comment($tpl_source, &$smarty) +{ + return "<?php echo \"<!-- Created by Smarty! -->\n\" ?>\n".$tpl_source; +} + +// enregistre le filtre de post-compilation +$smarty->register_postfilter("add_header_comment"); +$smarty->display("index.tpl"); +?> + +{* template Smarty compilé index.tpl *} +<!-- Created by Smarty! --> +{* reste du contenu du template... *} + + + + + Filtres de sortie + + Quand le template est appelé via les fonctions display() ou fetch(), + sa sortie est envoyée à travers un ou plusieurs filtres de sorties. + Ils diffèrent des filtres de post-compilation dans le sens ou ils agissent + sur la sortie des templates, une fois exécutés, et non sur les sources + des templates. + + + Les filtres de sortie peuvent être soit + déclarés soit + chargés depuis les répertoires des plugins en utilisant la fonction + load_filter() + ou en réglant la variable + $autoload_filters. + Smarty passera la sortie du template en premier argument et attendra + de la fonction qu'elle retourne le résultat de l'exécution. + + + utilisation d'un filtre de sortie + +<?php +// mettez ceci dans votre application +function protect_email($tpl_output, &$smarty) +{ + $tpl_output = + preg_replace('!(\S+)@([a-zA-Z0-9\.\-]+\.([a-zA-Z]{2,3}|[0-9]{1,3}))!', + '$1%40$2', $tpl_output); + return $tpl_output; +} + +// enregistre le filtre de sortie +$smarty->register_outputfilter("protect_email"); +$smarty->display("index.tpl"); + +// dorénavant toute occurence d'un adresse email dans le résultat du template +// aura un protection simple contre les robots spammers +?> + + + + + Fonction de gestion du cache + + Une alternative au mécanisme de cache par défaut (basé sur des fichiers + de cache) consiste à spécifier une fonction de gestion de cache utilisateur + qui sera utilisée pour lire, écrire et effacer les fichiers de cache. + + + Il suffit de créer dans votre application une fonction que Smarty + utilisera pour la gestion du cache et d'assigner le nom de cette + fonction à la variable de classe + $cache_handler_func. + Smarty utilisera alors cette fonction pour gérer les données du cache. + Le premier argument est l'action, qui sera 'read', 'write' ou 'clear'. + Le second paramètre est l'objet Smarty. Le troisième est le contenu + du cache. Pour écrire, Smarty passe le contenu du cache dans ces paramètres. + Pour lire, Smarty s'attend à ce que votre fonction accepte ce paramètre + par référence et que vous le remplissiez avec les données du cache. Pour effacer, + il suffit de passer une variable fictive car cette dernière n'est pas utilisée. + Le quatrième paramètre est le nom du fichier de template (utile pour + lire/écrire), le cinquième paramètre est l'identifiant de cache (optionnel) + et le sixième est l'identifiant de compilation. + + + exemple d'utilisation de MySQL pour la source du cache + +<?php +/* + +exemple d'usage : + +include('Smarty.class.php'); +include('mysql_cache_handler.php'); + +$smarty = new Smarty; +$smarty->cache_handler_func = 'mysql_cache_handler'; + +$smarty->display('index.tpl'); + + +la base mysql est attendu dans ce format : + +create database SMARTY_CACHE; + +create table CACHE_PAGES( +CacheID char(32) PRIMARY KEY, +CacheContents MEDIUMTEXT NOT NULL +); + +*/ + +function mysql_cache_handler($action, &$smarty_obj, &$cache_content, $tpl_file=null, $cache_id=null, $compile_id=null) +{ + // l'hôte de la bd, l'utilisateur, et le mot de passe + $db_host = 'localhost'; + $db_user = 'myuser'; + $db_pass = 'mypass'; + $db_name = 'SMARTY_CACHE'; + $use_gzip = false; + + // crée un identifiant de cache unique + $CacheID = md5($tpl_file.$cache_id.$compile_id); + + if(! $link = mysql_pconnect($db_host, $db_user, $db_pass)) { + $smarty_obj->_trigger_error_msg("cache_handler: could not connect to database"); + return false; + } + mysql_select_db($db_name); + + switch ($action) { + case 'read': + // récupère le cache dans la base de données + $results = mysql_query("select CacheContents from CACHE_PAGES where CacheID='$CacheID'"); + if(!$results) { + $smarty_obj->_trigger_error_msg("cache_handler: query failed."); + } + $row = mysql_fetch_array($results,MYSQL_ASSOC); + + if($use_gzip && function_exists("gzuncompress")) { + $cache_contents = gzuncompress($row["CacheContents"]); + } else { + $cache_contents = $row["CacheContents"]; + } + $return = $results; + break; + case 'write': + // sauvegarde le cache dans la base de données + + if($use_gzip && function_exists("gzcompress")) { + // compresse le contenu pour gagner de la place + $contents = gzcompress($cache_content); + } else { + $contents = $cache_content; + } + $results = mysql_query("replace into CACHE_PAGES values( + '$CacheID', + '".addslashes($contents)."') + "); + if(!$results) { + $smarty_obj->_trigger_error_msg("cache_handler: query failed."); + } + $return = $results; + break; + case 'clear': + // efface les données du cache + if(empty($cache_id) && empty($compile_id) && empty($tpl_file)) { + // les efface toutes + $results = mysql_query("delete from CACHE_PAGES"); + } else { + $results = mysql_query("delete from CACHE_PAGES where CacheID='$CacheID'"); + } + if(!$results) { + $smarty_obj->_trigger_error_msg("cache_handler: query failed."); + } + $return = $results; + break; + default: + // erreur, action inconnue + $smarty_obj->_trigger_error_msg("cache_handler: unknown action \"$action\""); + $return = false; + break; + } + mysql_close($link); + return $return; + +} + +?> + + + + + Ressources + + Les templates peuvent provenir d'une grande variété de ressources. Quand vous + affichez ou récupérez un template, ou quand vous incluez un template + dans un autre template, vous fournissez un type de ressource, suivi + par le chemin approprié et le nom du template. + + + Templates depuis $template_dir + + Les templates du répertoire $template_dir n'ont pas + besoin d'une ressource template, bien que vous puissiez utiliser + la ressource "file" pour être cohérent. Vous n'avez qu'à fournir + le chemin vers le template que vous voulez utiliser, relatif + au répertoire racine $template_dir. + + + Utilisation de templates depuis $template_dir + +// le script PHP +$smarty->display("index.tpl"); +$smarty->display("admin/menu.tpl"); +$smarty->display("file:admin/menu.tpl"); // le même que celui ci-dessus + +{* le template Smarty *} +{include file="index.tpl"} +{include file="file:index.tpl"} {* le même que celui ci-dessus *} + + + + Templates à partir de n'importe quel répertoire + + Les templates en-dehors du répertoire $template_dir nécessitent + le type de ressource template, suivi du chemin absolu et du nom du + template. + + + utilisation d'un template depuis n'importe quel répertoire + +// le script PHP +$smarty->display("file:/export/templates/index.tpl"); +$smarty->display("file:/path/to/my/templates/menu.tpl"); + +{* le template Smarty *} +{include file="file:/usr/local/share/templates/navigation.tpl"} + + + + Chemin de fichiers Windows + + Si vous utilisez Windows, les chemins de fichiers sont la plupart + du temps sur un disque identifié par une lettre (c:) au début du chemin. + Assurez-vous de bien mettre "file:" dans le chemin pour éviter des + conflits d'espace de nommage et obtenir les résultats escomptés. + + + utilisation de templates avec des chemins de fichiers Windows + +// le script PHP +$smarty->display("file:C:/export/templates/index.tpl"); +$smarty->display("file:F:/path/to/my/templates/menu.tpl"); + +{* le template Smarty *} +{include file="file:D:/usr/local/share/templates/navigation.tpl"} + + + + + + Templates depuis d'autres sources + + Vous pouvez récupérer les templates à partir n'importe quelle + source à laquelle vous avez accès avec PHP : base de données, + sockets, LDAP et ainsi de suite. Il suffit d'écrire les fonctions + de ressource plugins et de les enregistrer auprès de Smarty. + + + Reportez-vous à la section ressource plugins + pour plus d'informations sur les fonctions que vous êtes censé fournir. + + + + Notez que vous ne pouvez pas écraser la ressource file native, + toutefois, vous pouvez fournir une ressource qui récupère un template depuis + le système de fichier par un autre moyen en l'enregistrant sous un autre + nom de ressource. + + + + utilisation de ressources utilisateurs + +// le script PHP + +// mettez ces fonctions quelque part dans votre application +function db_get_template ($tpl_name, &$tpl_source, &$smarty_obj) +{ + // requête BD pour récupérer le template + // et remplir $tpl_source + $sql = new SQL; + $sql->query("select tpl_source + from my_table + where tpl_name='$tpl_name'"); + if ($sql->num_rows) { + $tpl_source = $sql->record['tpl_source']; + return true; + } else { + return false; + } +} + +function db_get_timestamp($tpl_name, &$tpl_timestamp, &$smarty_obj) +{ + // requête BD pour remplir $tpl_timestamp + $sql = new SQL; + $sql->query("select tpl_timestamp + from my_table + where tpl_name='$tpl_name'"); + if ($sql->num_rows) { + $tpl_timestamp = $sql->record['tpl_timestamp']; + return true; + } else { + return false; + } +} + +function db_get_secure($tpl_name, &$smarty_obj) +{ + // on suppose que tous les templates sont sûrs + return true; +} + +function db_get_trusted($tpl_name, &$smarty_obj) +{ + // pas utilisée pour les templates dans notre cas +} + +// enregistre le nom de ressource "db" +$smarty->register_resource("db", array("db_get_template", + "db_get_timestamp", + "db_get_secure", + "db_get_trusted")); + +// utilise la ressource depuis le script PHP +$smarty->display("db:index.tpl"); + +{* utilise la ressource depuis le template Smarty *} +{include file="db:/extras/navigation.tpl"} + + + + + Fonction de gestion de template par défaut + + Vous pouvez spécifier une fonction qui sera utilisée pour + récupérer le contenu d'un template dans le cas où le template + ne peut pas être récupéré depuis sa ressource. Une utilisation possible est + la création de templates à la volée. + + + utilisation de la fonction de gestion de template par défaut + +<?php +// mettez cette fonction quelque part dans votre application + +function make_template ($resource_type, $resource_name, &$template_source, &$template_timestamp, &$smarty_obj) +{ + if( $resource_type == 'file' ) { + if ( ! is_readable ( $resource_name )) { + // crée le fichier de template et renvoie le contenu + $template_source = "This is a new template."; + $template_timestamp = time(); + $smarty_obj->_write_file($resource_name,$template_source); + return true; + } + } else { + // pas un fichier + return false; + } +} + +// régle la fonction par défaut +$smarty->default_template_handler_func = 'make_template'; +?> + + + + + + + Etendre Smarty avec des plugins + + La version 2.0 a introduit l'architecture de plugin qui est + utilisée pour pratiquement toute les fonctionnalités + personnalisables de Smarty. Ceci comprend : + + les fonctions + les modificateurs + les fonctions de blocs + les fonctions de compilation + les filtres de pré-compilation + les filtres de post-compilation + les filtres de sorties + les ressources + les insertions + + A part pour les ressources, la compatibilité avec les anciennes + façons d'enregistrer les fonctions de gestion avec l'API register_ + est conservée. Si vous n'avez pas utilisé cette API et que vous avez + à la place directement modifié les variables de classes + $custom_funcs, $custom_mods et + d'autres, vous devez alors modifier vos scripts pour utiliser + l'API ou convertir vos fonctionnalités personnalisées en plugins. + + + + Comment fonctionnent les plugins + + Les plugins sont toujours chargés à la demande. Seuls les modificateurs + de variables, les ressources, etc invoqués dans les scripts de templates + seront chargés. De plus, chaque plugin n'est chargé qu'une fois, et ce + même si vous avez plusieurs instances de Smarty qui tournent dans + la même requête. + + + Les filtres de post/pré-compilation et les filtres de sortie sont des cas + un peu spéciaux. + Comme ils ne sont pas mentionnés dans les templates, ils doivent être déclarés + ou chargés explicitement via les fonctions de l'API avant que le template + ne soit exécuté. L'ordre dans lequel les filtres multiples d'un même type + sont exécutés dépend de l'ordre dans lequel ils sont enregistrés ou chargés. + + + Il n'existe qu'un seul répertoire de plugin (pour des raisons de performances). + Pour installer un plugin, copiez-le simplement dans le répertoire et Smarty + l'utilisera automatiquement. + + + + + Conventions de nommage + + Les fichiers et les fonctions de plugins doivent suivre une convention + de nommage très spécifique pour être localisés par Smarty. + + + Les fichiers de plugins doivent être nommés de la façon suivante : +
+ + + type.nom.php + + +
+ + + Où type est l'une des valeurs suivantes : + + function + modifier + block + compiler + prefilter + postfilter + outputfilter + resource + insert + + + + Et nom doit être un identifiant valide (lettres, nombres + et underscore seulement). + + + Quelques exemples : function.html_select_date.php, + resource.db.php, + modifier.spacify.php. + + + Les fonctions de plugins dans les fichiers de plugins doivent être + nommées de la façon suivante : +
+ + smarty_type_nom + +
+ + + Les significations de type et de nom sont les mêmes + que précédemment. + + + Smarty donnera des messages d'erreur approprié si le fichier de plugin + n'est pas trouvé, ou si le fichier ou la fonction de plugin ne sont + pas nommés correctement. + + + + + Ecrire des plugins + + Les plugins peuvent être soit chargés automatiquement par Smarty + depuis le système de fichier, soit être déclarés + pendant l'exécution via une fonction register_* de l'API. Ils peuvent + aussi être désalloués en utilisant une fonction unregister_* de + l'API. + + + Pour les plugins qui ne sont pas enregistrés pendant l'exécution, le nom + des fonctions n'ont pas à suivre la convention de nommage. + + + Si certaines fonctionnalités d'un plugin dépendent d'un autre plugin + (comme c'est le cas de certains plugins accompagnant Smarty), alors la manière appropriée + de charger le plugin est la suivante : + + + +require_once SMARTY_DIR . 'plugins/function.html_options.php'; + + Une règle générale est que chaque objet Smarty est toujours passé au plugin + en tant que dernier paramètre (à part pour les modificateurs). + + + + Les fonctions de templates + + + void smarty_function_name + array $params + object &$smarty + + + + Tous les attributs passés aux fonctions de template à partir du template + sont contenus dans le tableau associatif $params. + Vous pouvez accéder à ces valeurs soit directement, par exemple + $params['start'], soit en utilisant + extract($params) pour les importer dans la table + des symboles. + + + Le retour de la fonction sera substituée à la balise de fonction + du template (fonction fetch par exemple). Sinon, + la fonction peut simplement accomplir une autre tâche sans sortie + (la fonction assign par exemple) + + + Si la fonction a besoin d'assigner des variables aux templates ou d'utiliser + d'autres fonctionnalités fournies par Smarty, elle peut recevoir un + objet $smarty pour cela. + + + Référez-vous aussi à : + register_function(), + unregister_function(). + + + + fonction de plugin avec sortie + +<?php +/* + * Smarty plugin + * ------------------------------------------------------------- + * Fichier : function.eightball.php + * Type : fonction + * Nom : eightball + * Rôle : renvoie une phrase magique au hasard + * ------------------------------------------------------------- + */ +function smarty_function_eightball($params, &$smarty) +{ + $answers = array('Yes', + 'No', + 'No way', + 'Outlook not so good', + 'Ask again soon', + 'Maybe in your reality'); + + $result = array_rand($answers); + return $answers[$result]; +} +?> + + + + peut être utilisée dans le template de la façon suivante : + + +Question: Will we ever have time travel? +Answer: {eightball}. + + + fonction de plugin sans sortie + +<?php +/* + * Smarty plugin + * ------------------------------------------------------------- + * Fichier : function.assign.php + * Type : fonction + * Nom : assign + * Purpose : assigne une valeur à une variable de template + * ------------------------------------------------------------- + */ +function smarty_function_assign($params, &$smarty) +{ + extract($params); + + if (empty($var)) { + $smarty->trigger_error("assign: missing 'var' parameter"); + return; + } + + if (!in_array('value', array_keys($params))) { + $smarty->trigger_error("assign: missing 'value' parameter"); + return; + } + + $smarty->assign($var, $value); +} +?> + + + + + Modificateurs + + Les modificateurs sont des petites fonctions appliquées à une variable + de template avant qu'elle ne soit affichée ou utilisée dans un autre contexte. + Les modificateurs peuvent être chaînés entre eux. + + + + mixed smarty_modifier_name + mixed $value + [mixed $param1, ...] + + + + Le premier paramètre passé au modificateur est la valeur + sur laquelle le modificateur est supposé opérer. Les autres paramètres + peuvent être optionnels, dépendant de quel genre d'opération doit être + effectué. + + + Le modificateur doit retourner le résultat de son exécution. + + + Regardez aussi + register_modifier(), + unregister_modifier(). + + + plugin modificateur simple + + Ce plugin est un alias d'une fonction PHP. Il n'a aucun paramètre + supplémentaires. + + +<?php +/* + * Smarty plugin + * ------------------------------------------------------------- + * Fichier : modifier.capitalize.php + * Type : modificateur + * Name : capitalize + * Rôle : met une majuscule aux mots d'une phrase + * ------------------------------------------------------------- + */ +function smarty_modifier_capitalize($string) +{ + return ucwords($string); +} +?> + + + + un plugin modificateur un peu plus complexe + +<?php +/* + * Smarty plugin + * ------------------------------------------------------------- + * Fichier : modifier.truncate.php + * Type : modificateur + * Name : truncate + * Rôle : Tronque une chaîne à une certaine longueur si + * nécessaire, la coupe optionnellement au milieu + * d'un mot et ajoute la chaîne $etc + * ------------------------------------------------------------- + */ +function smarty_modifier_truncate($string, $length = 80, $etc = '...', + $break_words = false) +{ + if ($length == 0) + return ''; + + if (strlen($string) > $length) { + $length -= strlen($etc); + $fragment = substr($string, 0, $length+1); + if ($break_words) + $fragment = substr($fragment, 0, -1); + else + $fragment = preg_replace('/\s+(\S+)?$/', '', $fragment); + return $fragment.$etc; + } else + return $string; +} +?> + + + + Fonctions de blocs + + + void smarty_block_name + array $params + mixed $content + object &$smarty + + + + Les fonctions de blocs sont des fonctions de la forme {func} .. {/func}. + En d'autres mots, elles englobent des blocs de template et opèrent sur les + contenus de ces blocs. Les fonctions de blocs ont la priorité sur les + fonctions utilisateurs de même nom, ce qui signifie que vous ne + pouvez avoir une fonction utilisateur {func} et une fonction de bloc + {func} .. {/func}. + + + L'implémentation de votre fonction est appelée deux fois par Smarty : + une fois pour la balise ouvrante et une autre fois pour la balise + fermante. + + + Seule la balise ouvrante d'une fonction de bloc peut avoir des attributs. + Tous les attributs passés par le template aux fonctions de templates sont + contenues dans le tableau associatif $params. + Vous pouvez accéder à ces valeurs soit directement, par exemple + $params['start'], soit en utilisant + extract($params) pour les importer dans la table + des symboles. Votre fonction a aussi accès aux attributs de la balise + ouvrante quand c'est la balise fermante qui est exécutée. + + + La valeur de la variable $content est différente + selon si votre fonction est appelée pour la balise ouvrante ou la + balise fermante. Si c'est pour la balise ouvrante, elle sera à + null et si c'est la balise fermante elle sera + égale au contenu du bloc de template. Notez que le bloc de template + aura déjà été exécuté par Smarty, vous recevrez donc la sortie du + template et non sa source. + + + Si vous imbriqué des fonctions de bloc, il est possible de connaître + la fonction de bloc parente grâce à la variable $smarty->_tag_stack. + Faites un var_dump() dessus et la structure devrait apparaître. + + + Regardez aussi : + register_block(), + unregister_block(). + + + fonction de bloc + +<?php +/* + * Smarty plugin + * ------------------------------------------------------------- + * Fichier : block.translate.php + * Type : bloc + * Nom : translate + * Rôle : traduire un bloc de texte + * ------------------------------------------------------------- + */ +function smarty_block_translate($params, $content, &$smarty) +{ + if ($content) { + $lang = $params['lang']; + // fait une traduction de $content + echo $translation; + } +} + + + + Fonctions de compilation + + Les fonctions de compilation sont appelées durant la compilation du template. + Elles sont utiles pour injecter du code PHP ou du contenu "statique variant + avec le temps" (bandeau de pub par ex.). Si une fonction de compilation et + une fonction personnalisée ont le même + nom, la fonction de compilation a priorité. + + + + mixed smarty_compiler_name + string $tag_arg + object &$smarty + + + + Les fonctions de compilation ont deux paramètres : une chaîne contenant + la balise - en gros, tout, depuis le nom de la fonction jusqu'au délimiteur de fin - et + l'objet Smarty. Elles sont censées retourner le code PHP qui doit être + injecté dans le template compilé. + + + Regardez aussi + register_compiler_function(), + unregister_compiler_function(). + + + fonction de compilation simple + +<?php +/* + * Smarty plugin + * ------------------------------------------------------------- + * Fichier : compiler.tplheader.php + * Type : compilation + * Nom : tplheader + * Rôle : Renvoie l'en-tête contenant le nom du fichier + * source et le temps de compilation. + * ------------------------------------------------------------- + */ +function smarty_compiler_tplheader($tag_arg, &$smarty) +{ + return "\necho '" . $smarty->_current_file . " compiled at " . date('Y-m-d H:M'). "';"; +} +?> + + Cette fonction peut-être appelé depuis le template comme suivant : + + +{* cette fonction n'est executée que lors de la compilation *} +{tplheader} + + Le code PHP résultant dans les templates compilés ressemblerait à ça : + + +<php +echo 'index.tpl compiled at 2002-02-20 20:02'; +?> + + + + + filtres de pré-compilation/filtres de post-compilation + + Les filtres de pré-compilation et les filtres de post-compilation ont des concepts très + proches. Ils différent dans leur exécution, plus précisément dans le + moment où ils sont exécutés. + + + + string smarty_prefilter_name + string $source + object &$smarty + + + + Les filtres de pré-compilation sont utilisés pour transformer la source d'un template + juste avant la compilation. Le premier paramètre passé à la fonction + de filtre de pré-compilation est la source du template, éventuellement modifiée par + d'autres filtre de pré-compilations. Le plugin est supposé retourner la source modifiée. + Notez que cette source n'est sauvegardée nulle part, elle est seulement + utilisé pour la compilation. + + + + string smarty_postfilter_name + string $compiled + object &$smarty + + + + Les filtres de post-compilation sont utilisés pour modifier la sortie du template + (le code PHP) juste après que la compilation a été faite mais juste + avant que le template ne soit sauvegardé sur le système de fichiers. + Le premier paramètre passé à la fonction de filtre de post-compilation est le code + du template compilé, éventuellement déjà modifié par d'autres filtre de post-compilations. + Le plugin est censé retourner la version modifié du code. + + + plugin de filtre de post-compilation + +<?php +/* + * Smarty plugin + * ------------------------------------------------------------- + * Fichier : prefilter.pre01.php + * Type : filtre de pré-compilation + * Nom : pre01 + * Rôle : Passe les balises HTML en minuscules. + * ------------------------------------------------------------- + */ + function smarty_prefilter_pre01($source, &$smarty) + { + return preg_replace('!<(\w+)[^>]+>!e', 'strtolower("$1")', $source); + } +?> + + + + plugin de filtre de post-compilation + +<?php +/* + * Smarty plugin + * ------------------------------------------------------------- + * Fichier : postfilter.post01.php + * Type: filtre de post-compilation + * Nom : post01 + * Rôle : Renvoie du code qui liste toutes les variables + * du template. + * ------------------------------------------------------------- + */ + function smarty_postfilter_post01($compiled, &$smarty) + { + $compiled = "<pre>\n<?php print_r(\$this->get_template_vars()); ?>\n</pre>" . $compiled; + return $compiled; + } +?> + + + + Filtres de sortie + + Les plugins de filtres de sortie opèrent sur la sortie du template, + après que le template a été chargé et exécuté, mais avant que + la sortie ne soit affichée. + + + + string smarty_outputfilter_name + string $template_output + object &$smarty + + + + Le premier paramètre passé à la fonction du filtre de sortie est la + sortie du template qui doit être modifiée et le second paramètre + est l'instance de Smarty appelant le plugin. Le plugin est supposé + faire un traitement et en retourner le résultat. + + + plugin de filtre de sortie + +/* + * Smarty plugin + * ------------------------------------------------------------- + * Fichier : outputfilter.protect_email.php + * Type : filtre de sortie + * Nom : protect_email + * Rôle: Convertie les @ en %40 pour protéger des + * robots spammers. + * ------------------------------------------------------------- + */ + function smarty_outputfilter_protect_email($output, &$smarty) + { + return preg_replace('!(\S+)@([a-zA-Z0-9\.\-]+\.([a-zA-Z]{2,3}|[0-9]{1,3}))!', + '$1%40$2', $output); + } + + + + + Ressources + + Les plugins ressources sont un moyen générique de fournir des sources + de templates ou des composants de scripts PHP à Smarty. Quelques exemples + de ressources : bases de données, LDAP, mémoire partagée, sockets, et ainsi + de suite. + + + Il y au total 4 fonctions qui ont besoin d'être enregistrées pour + chaque type de ressource. Chaque fonction reçoit le nom de la ressource demandée + comme premier paramètre et l'objet Smarty comme dernier paramètre. + Les autres paramètres dépendent de la fonction. + + + + bool smarty_resource_name_source + string $rsrc_name + string &$source + object &$smarty + + + bool smarty_resource_name_timestamp + string $rsrc_name + int &$timestamp + object &$smarty + + + bool smarty_resource_name_secure + string $rsrc_name + object &$smarty + + + bool smarty_resource_name_trusted + string $rsrc_name + object &$smarty + + + + + La première fonction est supposée récupérer la ressource. Son second + paramètre est une variable passée par référence où le résultat doit être + stocké. La fonction est supposée retourner true si + elle réussi à récupérer la ressource et false sinon. + + + + La seconde fonction est supposée récupérer la date de dernière modification + de la ressource demandée (comme un timestamp UNIX). Le second paramètre + est une variable passée par référence dans laquelle la date doit + être stockée. La fonction est supposée renvoyer true si elle + a réussi à récupérer la date et false sinon. + + + + La troisième fonction est supposée retourner true + ou false selon si la ressource demandée est sûre + ou non. La fonction est utilisée seulement pour les ressources templates + mais doit tout de même être définie. + + + + La quatrième fonction est supposée retourner true + ou false selon si on peut faire confiance ou + non à la ressource demandée. Cette fonction est utilisée seulement + pour les composants de scripts PHP demandés par les balises + include_php ou insert + ayant un attribut src. Quoiqu'il en soit, + elle doit être définie pour les ressources templates. + + + + Regardez aussi + register_resource(), + unregister_resource(). + + + resource plugin + +<?php +/* + * Smarty plugin + * ------------------------------------------------------------- + * Fichier : resource.db.php + * Type : ressource + * Nom : db + * Rôle : Récupère des templates depuis une base de données + * ------------------------------------------------------------- + */ +function smarty_resource_db_source($tpl_name, &$tpl_source, &$smarty) +{ + // fait des requêtes BD pour récupérer votre template + // et remplir $tpl_source + $sql = new SQL; + $sql->query("select tpl_source + from my_table + where tpl_name='$tpl_name'"); + if ($sql->num_rows) { + $tpl_source = $sql->record['tpl_source']; + return true; + } else { + return false; + } +} + +function smarty_resource_db_timestamp($tpl_name, &$tpl_timestamp, &$smarty) +{ + // fait des requêtes BD pour remplir $tpl_timestamp + $sql = new SQL; + $sql->query("select tpl_timestamp + from my_table + where tpl_name='$tpl_name'"); + if ($sql->num_rows) { + $tpl_timestamp = $sql->record['tpl_timestamp']; + return true; + } else { + return false; + } +} + +function smarty_resource_db_secure($tpl_name, &$smarty) +{ + // suppose que tous les templates sont sûrs + return true; +} + +function smarty_resource_db_trusted($tpl_name, &$smarty) +{ + // inutilisée pour les templates +} +?> + + + + Insertions + + Les plugins d'insertion sont utilisés pour implémenter les fonctions + qui sont appelées par les balises + insert + dans les templates. + + + + string smarty_insert_name + array $params + object &$smarty + + + + Le premier paramètre passé à la fonction est une tableau associatif + d'attributs. Vous pouvez accéder à ces valeurs soit directement, par exemple + $params['start'], soit en utilisant + extract($params) pour les importer dans la table + des symboles. + + + La fonction d'insertion est supposée retourner le résultat qui sera + substitué à la balise insert dans le template. + + + plugin d'insertion + +<?php +/* + * Smarty plugin + * ------------------------------------------------------------- + * Fichier : insert.time.php + * Type : temps + * Nom : time + * Rôle : Insert la date/heure courante conformément + * au format + * ------------------------------------------------------------- + */ +function smarty_insert_time($params, &$smarty) +{ + if (empty($params['format'])) { + $smarty->trigger_error("insert time: missing 'format' parameter"); + return; + } + + $datetime = strftime($params['format']); + return $datetime; +} +?> + + + +