mirror of
https://github.com/smarty-php/smarty.git
synced 2026-04-28 18:02:07 +02:00
split the french dir
This commit is contained in:
didou
@@ -0,0 +1,29 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<chapter id="bugs">
|
||||
<title>BUGS</title>
|
||||
<para>
|
||||
Vérifiez le fichier de BUGS fourni avec la dernière version de Smarty ou
|
||||
consultez le site Web.
|
||||
</para>
|
||||
</chapter>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
sgml-omittag:t
|
||||
sgml-shorttag:t
|
||||
sgml-minimize-attributes:nil
|
||||
sgml-always-quote-attributes:t
|
||||
sgml-indent-step:1
|
||||
sgml-indent-data:t
|
||||
indent-tabs-mode:nil
|
||||
sgml-parent-document:nil
|
||||
sgml-default-dtd-file:"../../../../manual.ced"
|
||||
sgml-exposed-tags:nil
|
||||
sgml-local-catalogs:nil
|
||||
sgml-local-ecat-files:nil
|
||||
End:
|
||||
vim600: syn=xml fen fdm=syntax fdl=2 si
|
||||
vim: et tw=78 syn=sgml
|
||||
vi: ts=1 sw=1
|
||||
-->
|
||||
@@ -0,0 +1,32 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<chapter id="resources">
|
||||
<title>Ressources</title>
|
||||
<para>
|
||||
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
|
||||
</para>
|
||||
</chapter>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
sgml-omittag:t
|
||||
sgml-shorttag:t
|
||||
sgml-minimize-attributes:nil
|
||||
sgml-always-quote-attributes:t
|
||||
sgml-indent-step:1
|
||||
sgml-indent-data:t
|
||||
indent-tabs-mode:nil
|
||||
sgml-parent-document:nil
|
||||
sgml-default-dtd-file:"../../../../manual.ced"
|
||||
sgml-exposed-tags:nil
|
||||
sgml-local-catalogs:nil
|
||||
sgml-local-ecat-files:nil
|
||||
End:
|
||||
vim600: syn=xml fen fdm=syntax fdl=2 si
|
||||
vim: et tw=78 syn=sgml
|
||||
vi: ts=1 sw=1
|
||||
-->
|
||||
@@ -0,0 +1,361 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<chapter id="tips">
|
||||
<title>Trucs et astuces</title>
|
||||
<para>
|
||||
</para>
|
||||
<sect1 id="tips.blank.var.handling">
|
||||
<title>Gestion des variables non-assignées</title>
|
||||
<para>
|
||||
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 <emphasis>default</emphasis>.
|
||||
</para>
|
||||
<example>
|
||||
<title>afficher &nbsp; quand une variable est vide</title>
|
||||
<programlisting>
|
||||
|
||||
{* la méthode pas adaptée *}
|
||||
|
||||
{if $title eq ""}
|
||||
&nbsp;
|
||||
{else}
|
||||
{$title}
|
||||
{/if}
|
||||
|
||||
|
||||
{* la bonne méthode *}
|
||||
|
||||
{$title|default:"&nbsp;"}</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="tips.default.var.handling">
|
||||
<title>Gestion des variables par défaut</title>
|
||||
<para>
|
||||
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 <link linkend="language.function.assign">assign</link>.
|
||||
</para>
|
||||
<example>
|
||||
<title>assigner une valeur par défaut à une variable de template</title>
|
||||
<programlisting>
|
||||
{* 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}</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<sect1 id="tips.passing.vars">
|
||||
<title>Passage du titre à un template d'en-tête</title>
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
<example>
|
||||
<title>passer le titre au template d'en-tête</title>
|
||||
<programlisting>
|
||||
|
||||
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></programlisting>
|
||||
</example>
|
||||
<para>
|
||||
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 <emphasis>default</emphasis>.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="tips.dates">
|
||||
<title>Dates</title>
|
||||
<para>
|
||||
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
|
||||
<link linkend="language.modifier.date.format">date_format</link>
|
||||
pour avoir un contrôle total sur le formatage des dates et de comparer
|
||||
facilement les dates entre elles.
|
||||
</para>
|
||||
<para>
|
||||
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().
|
||||
</para>
|
||||
<example>
|
||||
<title>utilisation de date_format</title>
|
||||
<programlisting>
|
||||
{$startDate|date_format}
|
||||
|
||||
OUTPUT:
|
||||
|
||||
Jan 4, 2001
|
||||
|
||||
|
||||
{$startDate|date_format:"%Y/%m/%d"}
|
||||
|
||||
OUTPUT:
|
||||
|
||||
2001/01/04
|
||||
|
||||
|
||||
{if $date1 < $date2}
|
||||
...
|
||||
{/if}</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
<example>
|
||||
<title>conversion des éléments date d'un formulaire en timestamp</title>
|
||||
<programlisting>
|
||||
// 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);
|
||||
}</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<sect1 id="tips.wap">
|
||||
<title>WAP/WML</title>
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
<example>
|
||||
<title>utilisation d'insert pour écrire un en-tête Content-Type WML</title>
|
||||
<programlisting>
|
||||
// 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></programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<sect1 id="tips.componentized.templates">
|
||||
<title>Templates composants</title>
|
||||
<para>
|
||||
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. ;-)
|
||||
</para>
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
<example>
|
||||
<title>template composant</title>
|
||||
<programlisting>
|
||||
{* 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}</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
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 <link
|
||||
linkend="language.function.include.php">include_php</link> pour plus
|
||||
d'informations.
|
||||
</para>
|
||||
<example>
|
||||
<title>template composant avec include_php</title>
|
||||
<programlisting>
|
||||
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}</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<sect1 id="tips.obfuscating.email">
|
||||
<title>Dissimuler les adresses email</title>
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
<example>
|
||||
<title>exemple de dissimulation d'une adresse email</title>
|
||||
<programlisting>
|
||||
|
||||
index.tpl
|
||||
---------
|
||||
|
||||
Send inquiries to
|
||||
{mailto address=$EmailAddress encode="javascript" subject="Hello"}
|
||||
|
||||
</programlisting>
|
||||
</example>
|
||||
<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
</note>
|
||||
</sect1>
|
||||
</chapter>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
sgml-omittag:t
|
||||
sgml-shorttag:t
|
||||
sgml-minimize-attributes:nil
|
||||
sgml-always-quote-attributes:t
|
||||
sgml-indent-step:1
|
||||
sgml-indent-data:t
|
||||
indent-tabs-mode:nil
|
||||
sgml-parent-document:nil
|
||||
sgml-default-dtd-file:"../../../../manual.ced"
|
||||
sgml-exposed-tags:nil
|
||||
sgml-local-catalogs:nil
|
||||
sgml-local-ecat-files:nil
|
||||
End:
|
||||
vim600: syn=xml fen fdm=syntax fdl=2 si
|
||||
vim: et tw=78 syn=sgml
|
||||
vi: ts=1 sw=1
|
||||
-->
|
||||
@@ -0,0 +1,71 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<chapter id="troubleshooting">
|
||||
<title>Diagnostic des erreurs</title>
|
||||
<para></para>
|
||||
<sect1 id="smarty.php.errors">
|
||||
<title>Erreurs Smarty/PHP</title>
|
||||
<para>
|
||||
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 à :
|
||||
</para>
|
||||
<example>
|
||||
<title>erreurs Smarty</title>
|
||||
<programlisting>
|
||||
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</programlisting>
|
||||
</example>
|
||||
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
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é.
|
||||
</para>
|
||||
|
||||
<example>
|
||||
<title>erreur d'analyse PHP</title>
|
||||
<programlisting>
|
||||
Parse error: parse error in /path/to/smarty/templates_c/index.tpl.php on line 75</programlisting>
|
||||
</example>
|
||||
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
</sect1>
|
||||
</chapter>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
sgml-omittag:t
|
||||
sgml-shorttag:t
|
||||
sgml-minimize-attributes:nil
|
||||
sgml-always-quote-attributes:t
|
||||
sgml-indent-step:1
|
||||
sgml-indent-data:t
|
||||
indent-tabs-mode:nil
|
||||
sgml-parent-document:nil
|
||||
sgml-default-dtd-file:"../../../../manual.ced"
|
||||
sgml-exposed-tags:nil
|
||||
sgml-local-catalogs:nil
|
||||
sgml-local-ecat-files:nil
|
||||
End:
|
||||
vim600: syn=xml fen fdm=syntax fdl=2 si
|
||||
vim: et tw=78 syn=sgml
|
||||
vi: ts=1 sw=1
|
||||
-->
|
||||
@@ -0,0 +1,61 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<chapter id="chapter.debugging.console">
|
||||
<title>Console de débogage</title>
|
||||
<para>
|
||||
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 <link linkend="language.function.debug">{debug}</link>.
|
||||
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
|
||||
<link
|
||||
linkend="variable.debugging.ctrl">$debugging_ctrl</link> soit activée.
|
||||
</para>
|
||||
<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
</note>
|
||||
<note>
|
||||
<para>
|
||||
Le temps de chargement des templates et des fichiers de configuration sont
|
||||
indiqués en secondes.
|
||||
</para>
|
||||
</note>
|
||||
</chapter>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
sgml-omittag:t
|
||||
sgml-shorttag:t
|
||||
sgml-minimize-attributes:nil
|
||||
sgml-always-quote-attributes:t
|
||||
sgml-indent-step:1
|
||||
sgml-indent-data:t
|
||||
indent-tabs-mode:nil
|
||||
sgml-parent-document:nil
|
||||
sgml-default-dtd-file:"../../../../manual.ced"
|
||||
sgml-exposed-tags:nil
|
||||
sgml-local-catalogs:nil
|
||||
sgml-local-ecat-files:nil
|
||||
End:
|
||||
vim600: syn=xml fen fdm=syntax fdl=2 si
|
||||
vim: et tw=78 syn=sgml
|
||||
vi: ts=1 sw=1
|
||||
-->
|
||||
@@ -0,0 +1,96 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<chapter id="config.files">
|
||||
<title>Fichiers de configuration</title>
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
<example>
|
||||
<title>Exemple de fichier de configuration</title>
|
||||
<programlisting>
|
||||
# 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</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
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 <literal>#</literal> (dièse) en début
|
||||
de ligne.
|
||||
</para>
|
||||
<para>
|
||||
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 <literal>[</literal> et
|
||||
<literal>]</literal>. 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.
|
||||
</para>
|
||||
<para>
|
||||
Les fichiers de configuration sont chargés dans le template grâce à la
|
||||
fonction <command>config_load</command>.
|
||||
</para>
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
</chapter>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
sgml-omittag:t
|
||||
sgml-shorttag:t
|
||||
sgml-minimize-attributes:nil
|
||||
sgml-always-quote-attributes:t
|
||||
sgml-indent-step:1
|
||||
sgml-indent-data:t
|
||||
indent-tabs-mode:nil
|
||||
sgml-parent-document:nil
|
||||
sgml-default-dtd-file:"../../../../manual.ced"
|
||||
sgml-exposed-tags:nil
|
||||
sgml-local-catalogs:nil
|
||||
sgml-local-ecat-files:nil
|
||||
End:
|
||||
vim600: syn=xml fen fdm=syntax fdl=2 si
|
||||
vim: et tw=78 syn=sgml
|
||||
vi: ts=1 sw=1
|
||||
-->
|
||||
@@ -0,0 +1,163 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<chapter id="language.basic.syntax">
|
||||
<title>Bases syntaxiques</title>
|
||||
<para>
|
||||
Toutes les balises Smarty sont entourées de délimiteurs. Par défaut,
|
||||
ces délimiteurs sont <literal>{</literal> et
|
||||
<literal>}</literal>, mais ils peuvent être modifiés.
|
||||
</para>
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
|
||||
<sect1 id="language.syntax.comments">
|
||||
<title>Commentaires</title>
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
<example>
|
||||
<title>Commentaires</title>
|
||||
<programlisting>
|
||||
{* 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></programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="language.syntax.functions">
|
||||
<title>Fonctions</title>
|
||||
<para>
|
||||
Les balises Smarty affichent une <link linkend="language.variables">variable</link>
|
||||
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"}.
|
||||
</para>
|
||||
<example>
|
||||
<title>syntaxe des fonctions</title>
|
||||
<programlisting>
|
||||
{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"}</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
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 <command>if</command>,
|
||||
<command>section</command> et <command>strip</command>. 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. <command>html_options</command> et
|
||||
<command>html_select_date</command> sont deux exemples de fonctions
|
||||
utilisateurs.
|
||||
</para>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="language.syntax.attributes">
|
||||
<title>Paramètres</title>
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
<para>
|
||||
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: <literal>true</literal>, <literal>on</literal>, et <literal>yes</literal>,
|
||||
ou <literal>false</literal>, <literal>off</literal>, et <literal>no</literal>.
|
||||
</para>
|
||||
<example>
|
||||
<title>Paramètres de fonction, syntaxe</title>
|
||||
<programlisting>
|
||||
{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></programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<sect1 id="language.syntax.quotes">
|
||||
<title>Variables insérées dans des chaînes de caractères</title>
|
||||
<para>
|
||||
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 (`).
|
||||
</para>
|
||||
<example>
|
||||
<title>Syntaxe d'insertion de variables dans des chaînes</title>
|
||||
<programlisting>
|
||||
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</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
|
||||
</chapter>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
sgml-omittag:t
|
||||
sgml-shorttag:t
|
||||
sgml-minimize-attributes:nil
|
||||
sgml-always-quote-attributes:t
|
||||
sgml-indent-step:1
|
||||
sgml-indent-data:t
|
||||
indent-tabs-mode:nil
|
||||
sgml-parent-document:nil
|
||||
sgml-default-dtd-file:"../../../../manual.ced"
|
||||
sgml-exposed-tags:nil
|
||||
sgml-local-catalogs:nil
|
||||
sgml-local-ecat-files:nil
|
||||
End:
|
||||
vim600: syn=xml fen fdm=syntax fdl=2 si
|
||||
vim: et tw=78 syn=sgml
|
||||
vi: ts=1 sw=1
|
||||
-->
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,58 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<chapter id="language.combining.modifiers">
|
||||
<title>Combiner des modificateurs de variable.</title>
|
||||
<para>
|
||||
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 <literal>|</literal> (pipe).
|
||||
</para>
|
||||
<example>
|
||||
<title>Combiner des modificateurs</title>
|
||||
<programlisting>
|
||||
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. . .</programlisting>
|
||||
</example>
|
||||
</chapter>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
sgml-omittag:t
|
||||
sgml-shorttag:t
|
||||
sgml-minimize-attributes:nil
|
||||
sgml-always-quote-attributes:t
|
||||
sgml-indent-step:1
|
||||
sgml-indent-data:t
|
||||
indent-tabs-mode:nil
|
||||
sgml-parent-document:nil
|
||||
sgml-default-dtd-file:"../../../../manual.ced"
|
||||
sgml-exposed-tags:nil
|
||||
sgml-local-catalogs:nil
|
||||
sgml-local-ecat-files:nil
|
||||
End:
|
||||
vim600: syn=xml fen fdm=syntax fdl=2 si
|
||||
vim: et tw=78 syn=sgml
|
||||
vi: ts=1 sw=1
|
||||
-->
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,341 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<chapter id="language.variables">
|
||||
<title>Variables</title>
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
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 :
|
||||
<programlisting>
|
||||
{$Nom}
|
||||
|
||||
{$Contacts[enreg].Telephone}
|
||||
|
||||
<body bgcolor="{#bgcolor#}"></programlisting>
|
||||
</para>
|
||||
|
||||
<sect1 id="language.assigned.variables">
|
||||
<title>Variables assignées depuis PHP</title>
|
||||
<para>
|
||||
Pour utiliser une variables assignées depuis PHP, il faut la préfixer par le
|
||||
symbole dollar <literal>$</literal>. Les variables asignées depuis un
|
||||
template grâce à la fonction <link linkend="language.function.assign">assign</link>
|
||||
sont manipulées de la même façon.
|
||||
</para>
|
||||
<example>
|
||||
|
||||
<title>Variables assignées</title>
|
||||
<programlisting>
|
||||
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.</programlisting>
|
||||
</example>
|
||||
|
||||
<sect2 id="language.variables.assoc.arrays">
|
||||
<title>Tableaux associatifs</title>
|
||||
<para>
|
||||
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).
|
||||
</para>
|
||||
<example>
|
||||
<title>accéder aux variables de tableaux associatifs</title>
|
||||
<programlisting>
|
||||
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></programlisting>
|
||||
</example>
|
||||
</sect2>
|
||||
<sect2 id="language.variables.array.indexes">
|
||||
<title>Tableaux indexés</title>
|
||||
<para>
|
||||
Vous pouvez utiliser des tableaux indexés de la même façon que vous le
|
||||
faites en PHP.
|
||||
</para>
|
||||
<example>
|
||||
<title>Accès aux tableaux grâce à l'index</title>
|
||||
<programlisting>
|
||||
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></programlisting>
|
||||
</example>
|
||||
</sect2>
|
||||
<sect2 id="language.variables.objects">
|
||||
<title>Objets</title>
|
||||
<para>
|
||||
Les attributs des objets assignés depuis PHP peuvent être utilisées en
|
||||
en spécifiant le nom après le symbole '->'.
|
||||
</para>
|
||||
<example>
|
||||
<title>accéder aux attributs des objets</title>
|
||||
<programlisting>
|
||||
nom: {$person->name}<br>
|
||||
email: {$person->email}<br>
|
||||
|
||||
SORTIE:
|
||||
|
||||
nom: Zaphod Beeblebrox<br>
|
||||
email: zaphod@slartibartfast.com<br></programlisting>
|
||||
</example>
|
||||
</sect2>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="language.config.variables">
|
||||
<title>Variables chargées depuis des fichiers de configuration</title>
|
||||
<para>
|
||||
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
|
||||
<link
|
||||
linkend="language.variables.smarty.config">$smarty.config</link>.
|
||||
</para>
|
||||
<example>
|
||||
|
||||
<title>variables de fichiers de configuration</title>
|
||||
<programlisting>
|
||||
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></programlisting>
|
||||
</example>
|
||||
<para>
|
||||
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 <command>config_load</command>.
|
||||
</para>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="language.variables.smarty">
|
||||
<title>Variable réservée {$smarty}</title>
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
|
||||
<sect2 id="language.variables.smarty.request">
|
||||
<title>Variables de requête</title>
|
||||
<para>
|
||||
Les variables de requête comme GET, POST, COOKIES, SERVER, ENVIRONNEMENT
|
||||
et SESSION peuvent être utilisées comme dans l'exemple suivant:
|
||||
</para>
|
||||
<example>
|
||||
|
||||
<title>Afficher des variables de requête</title>
|
||||
<programlisting>
|
||||
{* 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}</programlisting>
|
||||
</example>
|
||||
</sect2>
|
||||
|
||||
<sect2 id="language.variables.smarty.now">
|
||||
<title>{$smarty.now}</title>
|
||||
<para>
|
||||
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.
|
||||
</para>
|
||||
<example>
|
||||
|
||||
<title>utilisation de {$smarty.now}</title>
|
||||
<programlisting>
|
||||
{* utilise le modificateur de variable date_format pour afficher la date et heure *}
|
||||
{$smarty.now|date_format:"%d-%m-%Y %H:%M:%S"}</programlisting>
|
||||
</example>
|
||||
</sect2>
|
||||
<sect2 id="language.variables.smarty.const">
|
||||
<title>{$smarty.const}</title>
|
||||
<para>
|
||||
Vous pouvez directement accéder aux constantes PHP.
|
||||
</para>
|
||||
<example>
|
||||
|
||||
<title>Utiliser {$smarty.const}</title>
|
||||
<programlisting>
|
||||
{$smarty.const._MA_CONSTANTE_}</programlisting>
|
||||
</example>
|
||||
</sect2>
|
||||
|
||||
<sect2 id="language.variables.smarty.capture">
|
||||
<title>{$smarty.capture}</title>
|
||||
<para>
|
||||
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 <link linkend="language.function.capture">capture</link> pour un
|
||||
exemple à ce sujet.
|
||||
</para>
|
||||
</sect2>
|
||||
|
||||
<sect2 id="language.variables.smarty.config">
|
||||
<title>{$smarty.config}</title>
|
||||
<para>
|
||||
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 <link
|
||||
linkend="language.function.config.load">config_load</link>
|
||||
pour un exemple à ce sujet.
|
||||
</para>
|
||||
</sect2>
|
||||
|
||||
<sect2 id="language.variables.smarty.loops">
|
||||
<title>{$smarty.section}, {$smarty.foreach}</title>
|
||||
<para>
|
||||
La variable {$smarty} peut être utilisée pour accéder aux propriétés
|
||||
des boucles 'section' et 'foreach'. Voir la documentation de
|
||||
<link linkend="language.function.section">section</link> et
|
||||
<link linkend="language.function.foreach">foreach</link>.
|
||||
</para>
|
||||
</sect2>
|
||||
|
||||
<sect2 id="language.variables.smarty.template">
|
||||
<title>{$smarty.template}</title>
|
||||
<para>
|
||||
Cette variable contient le nom du template en cours de traitement.
|
||||
</para>
|
||||
</sect2>
|
||||
|
||||
</sect1>
|
||||
</chapter>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
sgml-omittag:t
|
||||
sgml-shorttag:t
|
||||
sgml-minimize-attributes:nil
|
||||
sgml-always-quote-attributes:t
|
||||
sgml-indent-step:1
|
||||
sgml-indent-data:t
|
||||
indent-tabs-mode:nil
|
||||
sgml-parent-document:nil
|
||||
sgml-default-dtd-file:"../../../../manual.ced"
|
||||
sgml-exposed-tags:nil
|
||||
sgml-local-catalogs:nil
|
||||
sgml-local-ecat-files:nil
|
||||
End:
|
||||
vim600: syn=xml fen fdm=syntax fdl=2 si
|
||||
vim: et tw=78 syn=sgml
|
||||
vi: ts=1 sw=1
|
||||
-->
|
||||
@@ -0,0 +1,6 @@
|
||||
<!-- $Revision$ -->
|
||||
|
||||
<!ENTITY SMARTYManual "Smarty - le moteur et compilateur de template PHP">
|
||||
<!ENTITY SMARTYDesigners "Smarty pour les graphistes">
|
||||
<!ENTITY SMARTYProgrammers "Smarty pour les programmeurs">
|
||||
<!ENTITY Appendixes "Appendices">
|
||||
@@ -0,0 +1,527 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<chapter id="advanced.features">
|
||||
<title>FonctionnalitTs avancTes</title>
|
||||
<sect1 id="advanced.features.objects">
|
||||
<title>Objets</title>
|
||||
<para>
|
||||
Smarty donne l'accFs aux objets PHP a travers les templates. Il y
|
||||
a 2 moyens d'y avoir accFs. Le premier consiste a allouer les objets
|
||||
au template puis de les utiliser avec une syntaxe similaire a celles
|
||||
des fonctions personnalisTes. Le deuxiFme moyen consiste a allouer
|
||||
des objets aux templates et de les utiliser comme n'importe quelle
|
||||
variable. La premiFre mTthode a une syntaxe beaucoup plus sympathique.
|
||||
Elle est aussi plus sTcurisTe, puisqu'un objet allouT ne peut avoir accFs
|
||||
qu'a certaines mTthodes et propriTtTs. NTanmoins, un objet allouT
|
||||
ne peut pas avoir de lien sur lui-mOme ou Otre mis dans un tableau
|
||||
d'objet, etc. Vous devez choisir la mTthode qui correspond a vos
|
||||
besoins, mais tGchez d'utiliser la premiFre mTthode autant que possible
|
||||
afin de rTduire la syntaxe des templates au minimum.
|
||||
</para>
|
||||
<para>
|
||||
Si l'option de sTcuritT est activTe, aucune mTthode ou fonctions privTes
|
||||
n'est accessible (commentant par "_"). S'il existe une mTthode et une
|
||||
propriTtT du mOme nom, c'est la mTthode qui sera utilisTe.
|
||||
</para>
|
||||
<para>
|
||||
Vous pouvez restreindre l'accFs aux mTthodes et aux propriTtTs en
|
||||
les listant dans un tableau en tant que troisiFme paramFtre
|
||||
d'allocation.
|
||||
</para>
|
||||
<para>
|
||||
Par dTfaut, les paramFtres passTs aux objets depuis le templates le sont de la
|
||||
mOme faton que les fonctions utilisateurs les rTcupFrent.
|
||||
Le premier paramFtre correspond a un tableau associatif, le second a l'objet
|
||||
Smarty. Si vous souhaitez que les paramFtres soient passTes un a un, comme
|
||||
dans un appel traditionnel, dTfinissez registration, quatriFme paramFtre optionnel,
|
||||
a false.
|
||||
</para>
|
||||
<example>
|
||||
<title>utilisation d'un objet allouT ou assignT</title>
|
||||
<programlisting>
|
||||
<?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'accFs a certaines mTthodes et propriTtTs en les listant
|
||||
$smarty->register_object("foobar",$myobj,array('meth1','meth2','prop1'));
|
||||
// pour utiliser le format habituel de paramFtre objet, passez le boolTen = false
|
||||
$smarty->register_object("foobar",$myobj,null,false);
|
||||
|
||||
// on peut aussi assigner des objets. Assignez par rTfTrence quand c'est possible
|
||||
$smarty->assign_by_ref("myobj", $myobj);
|
||||
|
||||
$smarty->display("index.tpl");
|
||||
?>
|
||||
|
||||
TEMPLATE:
|
||||
|
||||
{* accFs a notre objet enregistrT *}
|
||||
{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)}</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<sect1 id="advanced.features.prefilters">
|
||||
<title>Filtres de prT-compilation</title>
|
||||
<para>
|
||||
Les filtres de prT-compilation sont des fonctions PHP que vos templates
|
||||
exTcutent avant qu'ils ne soient compilTs. Cela peut Otre utile
|
||||
pour prT-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 prT-compilations peuvent Otre soit
|
||||
<link linkend="api.register.prefilter">dTclarTs</link> soit chargTs
|
||||
a partir des rTpertoires de plugins en utilisant la fonction
|
||||
<link linkend="api.load.filter">load_filter()</link> ou en rTglant
|
||||
la variable
|
||||
<link linkend="variable.autoload.filters">$autoload_filters</link>.
|
||||
Smarty passera a la fonction le code source en tant que premier argument,
|
||||
et attendra en retour le code modifiT.
|
||||
</para>
|
||||
<example>
|
||||
<title>Utilisation un filtre de prT-compilation de template</title>
|
||||
<programlisting>
|
||||
<?php
|
||||
// mettre ceci dans votre application
|
||||
function remove_dw_comments($tpl_source, &$smarty)
|
||||
{
|
||||
return preg_replace("/<!--#.*-->/U","",$tpl_source);
|
||||
}
|
||||
|
||||
// enregistrer le filtre de prT-compilation
|
||||
$smarty->register_prefilter("remove_dw_comments");
|
||||
$smarty->display("index.tpl");
|
||||
?>
|
||||
|
||||
{* template Smarty index.tpl *}
|
||||
<!--# cette ligne va Otre supprimTe par le filtre de prT-compilation --></programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="advanced.features.postfilters">
|
||||
<title>Filtres de post-compilation</title>
|
||||
<para>
|
||||
Les filtres de post-compilation sont des fonctions PHP que vos templates
|
||||
exTcutent aprFs avoir TtT compilTs. Les filtres de post-compilation peuvent
|
||||
Otre soit <link linkend="api.register.postfilter">dTclarTs</link> soit chargTs
|
||||
depuis les rTpertoires des plugins en utilisant la fonction
|
||||
<link linkend="api.load.filter">load_filter()</link> ou en rTglant
|
||||
la variable <link linkend="variable.autoload.filters">$autoload_filters</link>.
|
||||
Smarty passera le template compilT en tant que premier paramFtre et attendra
|
||||
de la fonction qu'elle retourne le rTsultat de l'exTcution.
|
||||
</para>
|
||||
<example>
|
||||
<title>utilisation d'un filtre de post-compilation de templates</title>
|
||||
<programlisting>
|
||||
<?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 compilT index.tpl *}
|
||||
<!-- Created by Smarty! -->
|
||||
{* reste du contenu du template... *}</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="advanced.features.outputfilters">
|
||||
<title>Filtres de sortie</title>
|
||||
<para>
|
||||
Quand le template est appelT via les fonctions display() ou fetch(),
|
||||
sa sortie est envoyTe a travers un ou plusieurs filtres de sorties.
|
||||
Ils diffFrent des filtres de post-compilation dans le sens ou ils agissent
|
||||
sur la sortie des templates, une fois exTcutTs, et non sur les sources
|
||||
des templates.
|
||||
</para>
|
||||
<para>
|
||||
Les filtres de sortie peuvent Otre soit
|
||||
<link linkend="api.register.outputfilter">dTclarTs</link> soit
|
||||
chargTs depuis les rTpertoires des plugins en utilisant la fonction
|
||||
<link linkend="api.load.filter">load_filter()</link>
|
||||
ou en rTglant la variable
|
||||
<link linkend="variable.autoload.filters">$autoload_filters</link>.
|
||||
Smarty passera la sortie du template en premier argument et attendra
|
||||
de la fonction qu'elle retourne le rTsultat de l'exTcution.
|
||||
</para>
|
||||
<example>
|
||||
<title>utilisation d'un filtre de sortie</title>
|
||||
<programlisting>
|
||||
<?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");
|
||||
|
||||
// dorTnavant toute occurence d'un adresse email dans le rTsultat du template
|
||||
// aura un protection simple contre les robots spammers
|
||||
?></programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="section.template.cache.handler.func">
|
||||
<title>Fonction de gestion du cache</title>
|
||||
<para>
|
||||
Une alternative au mTcanisme de cache par dTfaut (basT sur des fichiers
|
||||
de cache) consiste a spTcifier une fonction de gestion de cache utilisateur
|
||||
qui sera utilisTe pour lire, Tcrire et effacer les fichiers de cache.
|
||||
</para>
|
||||
<para>
|
||||
Il suffit de crTer dans votre application une fonction que Smarty
|
||||
utilisera pour la gestion du cache et d'assigner le nom de cette
|
||||
fonction a la variable de classe
|
||||
<link linkend="variable.cache.handler.func">$cache_handler_func</link>.
|
||||
Smarty utilisera alors cette fonction pour gTrer les donnTes du cache.
|
||||
Le premier argument est l'action, qui sera 'read', 'write' ou 'clear'.
|
||||
Le second paramFtre est l'objet Smarty. Le troisiFme est le contenu
|
||||
du cache. Pour Tcrire, Smarty passe le contenu du cache dans ces paramFtres.
|
||||
Pour lire, Smarty s'attend a ce que votre fonction accepte ce paramFtre
|
||||
par rTfTrence et que vous le remplissiez avec les donnTes du cache. Pour effacer,
|
||||
il suffit de passer une variable fictive car cette derniFre n'est pas utilisTe.
|
||||
Le quatriFme paramFtre est le nom du fichier de template (utile pour
|
||||
lire/Tcrire), le cinquiFme paramFtre est l'identifiant de cache (optionnel)
|
||||
et le sixiFme est l'identifiant de compilation.
|
||||
</para>
|
||||
<example>
|
||||
<title>exemple d'utilisation de MySQL pour la source du cache</title>
|
||||
<programlisting>
|
||||
<?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;
|
||||
|
||||
// crTe 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':
|
||||
// rTcupFre le cache dans la base de donnTes
|
||||
$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 donnTes
|
||||
|
||||
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 donnTes 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;
|
||||
|
||||
}
|
||||
|
||||
?></programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="template.resources">
|
||||
<title>Ressources</title>
|
||||
<para>
|
||||
Les templates peuvent provenir d'une grande variTtT de ressources. Quand vous
|
||||
affichez ou rTcupTrez un template, ou quand vous incluez un template
|
||||
dans un autre template, vous fournissez un type de ressource, suivi
|
||||
par le chemin appropriT et le nom du template.
|
||||
</para>
|
||||
<sect2 id="templates.from.template.dir">
|
||||
<title>Templates depuis $template_dir</title>
|
||||
<para>
|
||||
Les templates du rTpertoire $template_dir n'ont pas
|
||||
besoin d'une ressource template, bien que vous puissiez utiliser
|
||||
la ressource "file" pour Otre cohTrent. Vous n'avez qu'a fournir
|
||||
le chemin vers le template que vous voulez utiliser, relatif
|
||||
au rTpertoire racine $template_dir.
|
||||
</para>
|
||||
<example>
|
||||
<title>Utilisation de templates depuis $template_dir</title>
|
||||
<programlisting>
|
||||
// le script PHP
|
||||
$smarty->display("index.tpl");
|
||||
$smarty->display("admin/menu.tpl");
|
||||
$smarty->display("file:admin/menu.tpl"); // le mOme que celui ci-dessus
|
||||
|
||||
{* le template Smarty *}
|
||||
{include file="index.tpl"}
|
||||
{include file="file:index.tpl"} {* le mOme que celui ci-dessus *}</programlisting>
|
||||
</example>
|
||||
</sect2>
|
||||
<sect2 id="templates.from.any.dir">
|
||||
<title>Templates a partir de n'importe quel rTpertoire</title>
|
||||
<para>
|
||||
Les templates en-dehors du rTpertoire $template_dir nTcessitent
|
||||
le type de ressource template, suivi du chemin absolu et du nom du
|
||||
template.
|
||||
</para>
|
||||
<example>
|
||||
<title>utilisation d'un template depuis n'importe quel rTpertoire</title>
|
||||
<programlisting>
|
||||
// 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"}</programlisting>
|
||||
</example>
|
||||
|
||||
<sect3>
|
||||
<title>Chemin de fichiers Windows</title>
|
||||
<para>
|
||||
Si vous utilisez Windows, les chemins de fichiers sont la plupart
|
||||
du temps sur un disque identifiT par une lettre (c:) au dTbut du chemin.
|
||||
Assurez-vous de bien mettre "file:" dans le chemin pour Tviter des
|
||||
conflits d'espace de nommage et obtenir les rTsultats escomptTs.
|
||||
</para>
|
||||
<example>
|
||||
<title>utilisation de templates avec des chemins de fichiers Windows</title>
|
||||
<programlisting>
|
||||
// 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"}</programlisting>
|
||||
</example>
|
||||
</sect3>
|
||||
</sect2>
|
||||
|
||||
<sect2 id="templates.from.elsewhere">
|
||||
<title>Templates depuis d'autres sources</title>
|
||||
<para>
|
||||
Vous pouvez rTcupTrer les templates a partir n'importe quelle
|
||||
source a laquelle vous avez accFs avec PHP : base de donnTes,
|
||||
sockets, LDAP et ainsi de suite. Il suffit d'Tcrire les fonctions
|
||||
de ressource plugins et de les enregistrer auprFs de Smarty.
|
||||
</para>
|
||||
<para>
|
||||
Reportez-vous a la section <link linkend="plugins.resources">ressource plugins</link>
|
||||
pour plus d'informations sur les fonctions que vous Otes censT fournir.
|
||||
</para>
|
||||
<note>
|
||||
<para>
|
||||
Notez que vous ne pouvez pas Tcraser la ressource <literal>file</literal> native,
|
||||
toutefois, vous pouvez fournir une ressource qui rTcupFre un template depuis
|
||||
le systFme de fichier par un autre moyen en l'enregistrant sous un autre
|
||||
nom de ressource.
|
||||
</para>
|
||||
</note>
|
||||
<example>
|
||||
<title>utilisation de ressources utilisateurs</title>
|
||||
<programlisting>
|
||||
// le script PHP
|
||||
|
||||
// mettez ces fonctions quelque part dans votre application
|
||||
function db_get_template ($tpl_name, &$tpl_source, &$smarty_obj)
|
||||
{
|
||||
// requOte BD pour rTcupTrer 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)
|
||||
{
|
||||
// requOte 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 svrs
|
||||
return true;
|
||||
}
|
||||
|
||||
function db_get_trusted($tpl_name, &$smarty_obj)
|
||||
{
|
||||
// pas utilisTe 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"}</programlisting>
|
||||
</example>
|
||||
</sect2>
|
||||
|
||||
<sect2 id="default.template.handler.function">
|
||||
<title>Fonction de gestion de template par dTfaut</title>
|
||||
<para>
|
||||
Vous pouvez spTcifier une fonction qui sera utilisTe pour
|
||||
rTcupTrer le contenu d'un template dans le cas oú le template
|
||||
ne peut pas Otre rTcupTrT depuis sa ressource. Une utilisation possible est
|
||||
la crTation de templates a la volTe.
|
||||
</para>
|
||||
<example>
|
||||
<title>utilisation de la fonction de gestion de template par dTfaut</title>
|
||||
<programlisting>
|
||||
<?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 )) {
|
||||
// crTe 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;
|
||||
}
|
||||
}
|
||||
|
||||
// rTgle la fonction par dTfaut
|
||||
$smarty->default_template_handler_func = 'make_template';
|
||||
?></programlisting>
|
||||
</example>
|
||||
</sect2>
|
||||
</sect1>
|
||||
</chapter>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
sgml-omittag:t
|
||||
sgml-shorttag:t
|
||||
sgml-minimize-attributes:nil
|
||||
sgml-always-quote-attributes:t
|
||||
sgml-indent-step:1
|
||||
sgml-indent-data:t
|
||||
indent-tabs-mode:nil
|
||||
sgml-parent-document:nil
|
||||
sgml-default-dtd-file:"../../../../manual.ced"
|
||||
sgml-exposed-tags:nil
|
||||
sgml-local-catalogs:nil
|
||||
sgml-local-ecat-files:nil
|
||||
End:
|
||||
vim600: syn=xml fen fdm=syntax fdl=2 si
|
||||
vim: et tw=78 syn=sgml
|
||||
vi: ts=1 sw=1
|
||||
-->
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,511 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<chapter id="api.variables">
|
||||
<title>Variables</title>
|
||||
|
||||
<sect1 id="variable.template.dir">
|
||||
<title>$template_dir</title>
|
||||
<para>
|
||||
C'est le nom par dTfaut du rTpertoire des templates.
|
||||
Si vous ne spTcifiez aucun chemin lors de l'utilisation de templates, Smarty
|
||||
les cherchera a cet emplacement.
|
||||
Par dTfaut, il s'agit de "./templates", ce qui signifie
|
||||
qu'il va chercher le rTpertoire templates
|
||||
dans le rTpertoire oú se trouve le script PHP en cours d'exTcution.
|
||||
</para>
|
||||
|
||||
<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
Il n'est pas conseillT de mettre ce rTpertoire
|
||||
dans l'arborescence Web.
|
||||
</para>
|
||||
</note>
|
||||
</sect1>
|
||||
<sect1 id="variable.compile.dir">
|
||||
<title>$compile_dir</title>
|
||||
<para>
|
||||
C'est le nom du rTpertoire oú se trouvent les templates
|
||||
compilTs. Par dTfaut, il s'agit de "./templates_c",
|
||||
ce qui signifie que Smarty va chercher ce rTpertoire
|
||||
dans le mOme rTpertoire que le script PHP en cours d'exTcution.
|
||||
</para>
|
||||
<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
Ce rTglage doit Otre soit un chemin absolu, soit un chemin
|
||||
relatif. include_path n'est pas utilisT pour Tcrire des fichiers.
|
||||
</para>
|
||||
</note>
|
||||
<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
Il n'est pas conseillT de mettre ce rTpertoire
|
||||
sous la racine de l'arborescence Web.
|
||||
</para>
|
||||
</note>
|
||||
</sect1>
|
||||
<sect1 id="variable.config.dir">
|
||||
<title>$config_dir</title>
|
||||
<para>
|
||||
Il s'agit du rTpertoire utilisT pour stocker les
|
||||
fichiers de configuration utilisTs dans les templates.
|
||||
La valeur par dTfaut est "./configs", ce qui signifie
|
||||
que Smarty va chercher ce rTpertoire
|
||||
dans le mOme rTpertoire que le script PHP qui s'exTcute.
|
||||
</para>
|
||||
<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
Il n'est pas conseillT de mettre ce rTpertoire
|
||||
sous la racine de l'arborescence Web.
|
||||
</para>
|
||||
</note>
|
||||
</sect1>
|
||||
<sect1 id="variable.plugins.dir">
|
||||
<title>$plugins_dir</title>
|
||||
<para>
|
||||
Ce sont les rTpertoire dans lesquels Smarty ira chercher les plugins
|
||||
dont il a besoin. La valeur par dTfaut est "plugins" sous le
|
||||
rTpertoire SMARTY_DIR. Si vous donnez un chemin relatif, Smarty
|
||||
regardera d'abord relativement au SMARTY_DIR, puis relativement au rtc (rTpertoire
|
||||
de travail courant), puis relativement a chaque entrTe de votre rTpertoire
|
||||
d'inclusion PHP.
|
||||
</para>
|
||||
<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
Pour des raisons de performances, ne rTglez pas votre plugins_dir
|
||||
pour qu'il utilise votre include_path PHP. Utilisez un
|
||||
chemin absolu ou un chemin relatif a SMARTY_DIR ou au rtc.
|
||||
</para>
|
||||
</note>
|
||||
</sect1>
|
||||
<sect1 id="variable.debugging">
|
||||
<title>$debugging</title>
|
||||
<para>
|
||||
Cela active la
|
||||
<link
|
||||
linkend="chapter.debugging.console">console de dTbogage</link>.
|
||||
La console est une fenOtre javascript qui vous informe des templates
|
||||
inclus et des variables assignTes dans la page courante.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.debug.tpl">
|
||||
<title>$debug_tpl</title>
|
||||
<para>
|
||||
C'est le nom du fichier template utilisT pour la
|
||||
console de dTbuggage. Par dTfaut debug.tpl, il se situe dans <link
|
||||
linkend="constant.smarty.dir">SMARTY_DIR</link>
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.debugging.ctrl">
|
||||
<title>$debugging_ctrl</title>
|
||||
<para>
|
||||
Cela permet d'avoir diffTrents moyens pour activer
|
||||
le dTbogage. URL signifie que si SMARTY_DEBUG se
|
||||
trouve dans QUERY_STRING, le dTbuggage
|
||||
est activT a l'invocation du script. Si $debugging
|
||||
est a vrai, cette valeur est sans effet.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.global.assign">
|
||||
<title>$global_assign</title>
|
||||
<para>
|
||||
C'est une liste de variable qui sont toujours
|
||||
implicitement assignTes au moteur de templates.
|
||||
Ceci est commode pour rendre des variables globales
|
||||
ou des variables du serveur accessibles a tous les templates
|
||||
plut(t que de devoir les assigner a la main. Chaque TlTment
|
||||
de $global_assign doit Otre 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
|
||||
assignTes depuis ce tableau global.
|
||||
$SCRIPT_NAME est globalement assignT par dTfaut depuis
|
||||
$HTTP_SERVER_VARS.
|
||||
</para>
|
||||
<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
On peut accTder aux variables du serveur avec la variable
|
||||
$smarty, par exemple {$smarty.server.SCRIPT_NAME}.
|
||||
Se reporter a la section sur la variable
|
||||
<link linkend="language.variables.smarty">$smarty</link>.
|
||||
</para>
|
||||
</note>
|
||||
</sect1>
|
||||
<sect1 id="variable.undefined">
|
||||
<title>$undefined</title>
|
||||
<para>
|
||||
Cela rFgle la valeur de $undefined, null par dTfaut.
|
||||
N'est actuellement utilisT que pour initialiser
|
||||
des variables non-dTfinies dans $global_assign a des
|
||||
valeurs par dTfaut.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.autoload.filters">
|
||||
<title>$autoload_filters</title>
|
||||
<para>
|
||||
Si vous dTsirez charger des filtres a chaque invocation
|
||||
de templates, vous pouvez le spTcifier en utilisant cette
|
||||
variable. Les types de filtres et les valeurs sont des
|
||||
tableaux comportant le nom des filtres.
|
||||
<informalexample>
|
||||
<programlisting>
|
||||
$smarty->autoload_filters = array('pre' => array('trim', 'stamp'),
|
||||
'output' => array('convert'));
|
||||
</programlisting>
|
||||
</informalexample>
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.compile.check">
|
||||
<title>$compile_check</title>
|
||||
<para>
|
||||
A chaque invocation de l'application PHP, Smarty fait
|
||||
un test pour voir si le template courant a TtT modifiT
|
||||
(date de derniFre modification diffTrente) depuis sa
|
||||
derniFre compilation. S'il a changT, le template est recompilT.
|
||||
Si le template n'a pas encore TtT compilT, il le sera
|
||||
quelle que soit la valeur ce rTglage.
|
||||
Par dTfaut cette valeur est a vrai. Quand
|
||||
une application est mise en production (les templates
|
||||
ne changent plus), cette vTrification n'est pas nTcessaire.
|
||||
Assurez-vous de mettre $compile_check a "false" pour des performances
|
||||
maximales. Notez que si vous mettez ce paramFtre a "false" et qu'un
|
||||
template est modifiT, vous ne verrez *pas* le changement
|
||||
car le template ne sera *pas* recompilT. Si le processus de cache
|
||||
est activT et que $compile_check l'est aussi, alors les fichiers
|
||||
du cache seront regTnTrTs si un template concernT ou un fichier de
|
||||
configuration concernT est modifiT. Voir aussi <link
|
||||
linkend="variable.force.compile">$force_compile</link> ou <link
|
||||
linkend="api.clear.compiled.tpl">clear_compiled_tpl</link>.
|
||||
</para>
|
||||
|
||||
</sect1>
|
||||
<sect1 id="variable.force.compile">
|
||||
<title>$force_compile</title>
|
||||
<para>
|
||||
Cela oblige Smarty a (re)compiler les templates a chaque
|
||||
invocation. Ce rTglage supplante $compile_check. Par dTfaut, il
|
||||
est dTsactivT. Ceci est commode pour le dTveloppement et le
|
||||
dTbogage mais ne devrait jamais Otre utilisT dans un environnment
|
||||
de production. Si le systFme de cache est actif, les
|
||||
fichiers du cache seront regTnTrTs a chaque appel.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.caching">
|
||||
<title>$caching</title>
|
||||
<para>
|
||||
Ce paramFtre demande a Smarty de mettre ou non en cache la sortie des
|
||||
templates.
|
||||
Par dTfaut ce rTglage est a 0 (dTsactivT). Si vos templates
|
||||
gTnFrent du contenu redondant, il est conseillT d'activer le
|
||||
cache. Cela permettra un gain de performance consTquent.
|
||||
Vous pouvez aussi avoir de nombreux fichiers de cache pour un mOme template.
|
||||
Une valeur de 1 ou 2 active le cache. 1 indique a Smarty d'utiliser
|
||||
la variable $cache_lifetime pour dTterminer si le fichier de cache a expirT.
|
||||
Une valeur de 2 indique a Smarty d'utiliser la valeur
|
||||
$cache_lifetime spTcifiTe a la gTnTration du cache. Ainsi vous pouvez rTgler
|
||||
la durTe de vie d'un fichier de cache avant de rTcupTrer le template pour avoir
|
||||
un certain contr(le quand ce fichier en particulier expire. Voir
|
||||
aussi <link linkend="api.is.cached">is_cached</link>.
|
||||
</para>
|
||||
<para>
|
||||
Si $compile_check est actif, le contenu du cache sera regTnTrT
|
||||
si un des templates ou un des fichiers de configuration qui fait partie
|
||||
de ce fichier de cache a TtT modifiT. Si $force_compile est actif, le contenu
|
||||
du cache est toujours regTnTrT.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.cache.dir">
|
||||
<title>$cache_dir</title>
|
||||
<para>
|
||||
Il s'agit du nom du rTpertoire oú les caches des templates
|
||||
sont stockTs. Par dTfaut il s'agit de "./cache", ce qui signifie
|
||||
que Smarty va chercher ce rTpertoire
|
||||
dans le mOme rTpertoire que le script PHP en cours d'exTcution.
|
||||
</para>
|
||||
<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
Ce rTglage doit Otre soit un chemin absolu, soit un chemin
|
||||
relatif. include_path n'a aucune influence lors de l'Tcriture des fichiers.
|
||||
</para>
|
||||
</note>
|
||||
<note>
|
||||
<title>Technical Note</title>
|
||||
<para>
|
||||
Il n'est pas conseillT de mettre ce rTpertoire
|
||||
dans l'arborescence Web.
|
||||
</para>
|
||||
</note>
|
||||
</sect1>
|
||||
<sect1 id="variable.cache.lifetime">
|
||||
<title>$cache_lifetime</title>
|
||||
<para>
|
||||
Il s'agit de la durTe en secondes pendant laquelle un cache de template
|
||||
est valide. Une fois cette durTe dTpassTe, le cache est regTnTrT.
|
||||
$caching doit Otre a "true" pour que $cache_lifetime ait une
|
||||
quelconque utilitT. Avec une valeur de -1, le cache n'expire jamais.
|
||||
Avec une valeur de 0, le cache est toujours regTnTrT (utile
|
||||
a des fins de tests seulement. Une meilleure faton de dTsactiver
|
||||
le cache est de mettre <link
|
||||
linkend="variable.caching">$caching</link> a "false").
|
||||
</para>
|
||||
<para>
|
||||
Si <link linkend="variable.force.compile">$force_compile</link> est
|
||||
activT, les fichiers du cache seront regTnTrTs a chaque fois,
|
||||
dTsactivant ainsi le cache. Vous pouvez effacer tous les fichiers du cache
|
||||
avec la function
|
||||
<link linkend="api.clear.all.cache">clear_all_cache()</link>
|
||||
ou de faton individuelle (ou groupTe)
|
||||
avec la fonction <link
|
||||
linkend="api.clear.cache">clear_cache()</link>.
|
||||
</para>
|
||||
<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
Si vous souhaitez donner a certains templates leur propre durTe de vie
|
||||
en cache, vous pouvez le faire en rTglant
|
||||
<link linkend="variable.caching">$caching</link> a 2,
|
||||
puis $cache_lifetime a une unique valeur juste avant d'appeler
|
||||
display ou fetch().
|
||||
</para>
|
||||
</note>
|
||||
</sect1>
|
||||
<sect1 id="variable.cache.handler.func">
|
||||
<title>$cache_handler_func</title>
|
||||
<para>
|
||||
Vous pouvez utiliser votre propre fonction de gestion du cache plut(t que
|
||||
d'utiliser celle livrTe avec Smarty.
|
||||
RTfTrez-vous a la section sur la fonction de gestion de cache
|
||||
personnalisTe pour plus de dTtails.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.cache.modified.check">
|
||||
<title>$cache_modified_check</title>
|
||||
<para>
|
||||
Si cette variable est a vrai, Smarty respectera l'en-tOte
|
||||
If-Modified-Since envoyT par le client. Si la date de derniFre
|
||||
modification du fichier de cache n'a pas changT depuis la derniFre
|
||||
visite, alors un en-tOte "304 Not Modified" sera envoyT a la place
|
||||
du contenu. Cela ne fonctionne qu'avec du contenu mis en cache hors de la
|
||||
balise <command>insert</command>.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.config.overwrite">
|
||||
<title>$config_overwrite</title>
|
||||
<para>
|
||||
Si cette variable est a vrai, les variables lues dans les fichiers
|
||||
de configuration peuvent s'Tcraser entre elles. Sinon les variables
|
||||
seront mises dans un tableau. TrFs utile si vous voulez stocker
|
||||
des tableaux de donnTes dans des fichiers de configuration, listez
|
||||
simplement chaque TlTment plusieurs fois. Mise a faux par dTfaut.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.config.booleanize">
|
||||
<title>$config_booleanize</title>
|
||||
<para>
|
||||
Si cette variable est a vrai, les valeurs on/true/yes et off/false/no
|
||||
dans les fichiers de configuration sont automitiquement converties
|
||||
en boolTen. De cette faton vous pouvez utiliser ces valeurs dans le
|
||||
template de la faton suivante : {if #foobar#} ... {/if}. Si foobar
|
||||
est a on, true ou yes, l'instruction {if} sera exTcutTe. vrai
|
||||
par dTfaut.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.config.read.hidden">
|
||||
<title>$config_read_hidden</title>
|
||||
<para>
|
||||
Si cette variable est a vrai, les sections cachTs (dont les noms
|
||||
commencent par un point) dans les fichiers de configuration peuvent
|
||||
Otre lues depuis les templates. On laisse habituellement cela a faux, de
|
||||
cette faton vous pouvez stocker des donnTes sensibles dans les fichiers
|
||||
de configuration, comme par exemple des paramFtres de base de donnTes,
|
||||
sans vous soucier de la faton dont les templates les chargent.
|
||||
Mise a faux par dTfaut.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.config.fix.newlines">
|
||||
<title>$config_fix_newlines</title>
|
||||
<para>
|
||||
Si cette variable est mise a vrai, les caractFres de nouvelles lignes mac et dos
|
||||
(\r et \r\n) sont convertis en \n quand ils sont analysTs. vrai par dTfaut.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.default.template.handler.func">
|
||||
<title>$default_template_handler_func</title>
|
||||
<para>
|
||||
Cette fonction est appelTe quand un template ne peut pas Otre
|
||||
obtenu avec sa ressource.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.php.handling">
|
||||
<title>$php_handling</title>
|
||||
<para>
|
||||
Indique a Smarty comment interprTter le code PHP
|
||||
intTgrT dans les templates. Il y a quatre valeurs possibles, par
|
||||
dTfaut SMARTY_PHP_PASSTHRU. Notez que cela n'affecte PAS le code
|
||||
PHP entourT des balises
|
||||
<link linkend="language.function.php">{php}{/php}</link>
|
||||
dans le template.
|
||||
</para>
|
||||
<itemizedlist>
|
||||
<listitem><para>SMARTY_PHP_PASSTHRU - Smarty Tcrit les balises
|
||||
telles quelles.</para></listitem>
|
||||
<listitem><para>SMARTY_PHP_QUOTE - Smarty transforme les balises
|
||||
en entitTs HTML.</para></listitem>
|
||||
<listitem><para>SMARTY_PHP_REMOVE - Smarty supprime les balises
|
||||
des templates.</para></listitem>
|
||||
<listitem><para>SMARTY_PHP_ALLOW - Smarty exTcute les balises
|
||||
comme du code PHP.</para></listitem>
|
||||
</itemizedlist>
|
||||
<para>
|
||||
NOTE : IntTgrer du code PHP dans les templates est vivement
|
||||
dTconseillT. PrTfTrez les
|
||||
<link linkend="language.custom.functions">fonctions utilisateurs</link>
|
||||
ou les <link linkend="language.modifiers">modificateurs de variables</link>.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.security">
|
||||
<title>$security</title>
|
||||
<para>
|
||||
Cette variable est a faux par dTfaut. $security est de rigueur
|
||||
quand vous n'Otes pas complFtement svr des personnes qui Tditent les templates
|
||||
(par ftp par exemple) et que vous voulez rTduire le risque que
|
||||
la sTcuritT du systFme soit compromise par le language de template.
|
||||
Activer cette option de sTcuritT applique les rFgles suivantes
|
||||
au langage de template, a moins que $security_settings ne spTcifie
|
||||
le contraire :
|
||||
</para>
|
||||
<itemizedlist>
|
||||
<listitem><para>Si $php_handling est rTglTe a SMARTY_PHP_ALLOW,
|
||||
cela est implicitement changT a SMARTY_PHP_PASSTHRU.</para></listitem>
|
||||
<listitem><para>Les fonctions PHP ne sont pas autorisTes dans les
|
||||
instructions IF, a part celles dTclarTes dans
|
||||
$security_settings.</para></listitem>
|
||||
<listitem><para>Les templates ne peuvent Otre inclus que depuis
|
||||
des rTpertoires listTs dans le tableau $security_dir.</para></listitem>
|
||||
<listitem><para>Les fichiers locaux ne peuvent Otre rTcupTrTs que depuis
|
||||
les rTpertoires listTs dans le tableau $security_dir en
|
||||
utilisant {fetch}.</para></listitem>
|
||||
<listitem><para>Les balises {php}{/php} ne sont pas autorisTes.</para></listitem>
|
||||
<listitem><para>Les fonctions PHP ne sont pas autorisTes en tant
|
||||
modificateurs, a part celles spTcifiTes dans $security_settings.</para></listitem>
|
||||
</itemizedlist>
|
||||
</sect1>
|
||||
<sect1 id="variable.secure.dir">
|
||||
<title>$secure_dir</title>
|
||||
<para>
|
||||
Il s'agit d'un tableau contenant tous les rTpertoires locaux qui sont
|
||||
considTrTs comme sTcurisTs. {include} et {fetch} l'utilisent quand
|
||||
la sTcuritT est activTe.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.security.settings">
|
||||
<title>$security_settings</title>
|
||||
<para>
|
||||
Ces rTglages servent a Tcraser ou spTcifier les paramFtres de sTcuritT
|
||||
quand celle-ci est activTe. Les rTglages possibles sont les suivants :
|
||||
</para>
|
||||
<itemizedlist>
|
||||
<listitem><para>PHP_HANDLING - true/false. Si vrai, le
|
||||
rTglage $php_handling n'est pas vTrifiT.</para></listitem>
|
||||
<listitem><para>IF_FUNCS - Le tableau des noms de fonctions
|
||||
PHP autorisTes dans les intructions IF.</para></listitem>
|
||||
<listitem><para>INCLUDE_ANY - true/false. Si vrai,
|
||||
les templates peuvent Otre inclus de n'importe oú, quelque soit
|
||||
le contenu de $secure_dir.</para></listitem>
|
||||
<listitem><para>PHP_TAGS - true/false. Si vrai,
|
||||
les balises {php}{/php} sont autorisTes dans les templates.</para></listitem>
|
||||
<listitem><para>MODIFIER_FUNCS - Le tableau des noms de fonctions
|
||||
autorisTes a Otre utilisTes comme modificateurs de variables.</para></listitem>
|
||||
</itemizedlist>
|
||||
</sect1>
|
||||
<sect1 id="variable.trusted.dir">
|
||||
<title>$trusted_dir</title>
|
||||
<para>
|
||||
$trusted_dir n'est utilisTe lorsque $security est activTe. C'est un
|
||||
tableau de tous les rTpertoires qui peuvent Otre considTrTs comme svrs.
|
||||
Les rTpertoires svrs sont ceux qui contiennent des scripts PHP qui
|
||||
sont exTcutTs directement depuis les templates avec
|
||||
<link linkend="language.function.include.php">{include_php}</link>.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.left.delimiter">
|
||||
<title>$left_delimiter</title>
|
||||
<para>
|
||||
Il s'agit du dTlimiteur gauche utilisT par le moteur de templates. La
|
||||
valeur par dTfaut est "{".
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.right.delimiter">
|
||||
<title>$right_delimiter</title>
|
||||
<para>
|
||||
Il s'agit du dTlimiteur droit utilisT par le moteur de templates.
|
||||
La valeur par dTfaut est "}".
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.compiler.class">
|
||||
<title>$compiler_class</title>
|
||||
<para>
|
||||
SpTcifie le nom de la classe du compilateur qui va Otre utilisTe pour
|
||||
compiler les templates. Le compilateur par dTfaut est
|
||||
'Smarty_Compiler'. RTservT aux utilisateurs avancTs.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.request.vars.order">
|
||||
<title>$request_vars_order</title>
|
||||
<para>
|
||||
L'ordre dans lequel les variables de requOtes sont enregistrTes,
|
||||
identique a variables_order dans php.ini.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.compile.id">
|
||||
<title>$compile_id</title>
|
||||
<para>
|
||||
Identifiant persistant du compilateur. On peut passer le mOme compile_id
|
||||
a chaque appel de fonction mais une alternative consiste a rTgler ce
|
||||
compile_id, qui sera utilisT implicitement.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.use.sub.dirs">
|
||||
<title>$use_sub_dirs</title>
|
||||
<para>
|
||||
RTgler cela a faux si votre environnement PHP n'autorise pas Smarty a crTer
|
||||
des sous-rTpertoires. Les sous-rTpertoires sont efficaces, utilisez-les quand
|
||||
vous le pouvez.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="variable.default.modifiers">
|
||||
<title>$default_modifiers</title>
|
||||
<para>
|
||||
Il s'agit d'un tableau de modificateurs utilisT pour assigner
|
||||
une valeur par dTfaut a chaque variable dans un template.
|
||||
Par exemple, pour par dTfaut Tchapper les caractFres HTML de chaque variable,
|
||||
utilisez array('escape:"htmlall"'); Pour rendre une variable indTpendante
|
||||
des modificateurs par dTfaut, passez-lui en paramFtre le modificateur
|
||||
"nodefaults" : {$var|nodefaults}.
|
||||
</para>
|
||||
</sect1>
|
||||
</chapter>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
sgml-omittag:t
|
||||
sgml-shorttag:t
|
||||
sgml-minimize-attributes:nil
|
||||
sgml-always-quote-attributes:t
|
||||
sgml-indent-step:1
|
||||
sgml-indent-data:t
|
||||
indent-tabs-mode:nil
|
||||
sgml-parent-document:nil
|
||||
sgml-default-dtd-file:"../../../../manual.ced"
|
||||
sgml-exposed-tags:nil
|
||||
sgml-local-catalogs:nil
|
||||
sgml-local-ecat-files:nil
|
||||
End:
|
||||
vim600: syn=xml fen fdm=syntax fdl=2 si
|
||||
vim: et tw=78 syn=sgml
|
||||
vi: ts=1 sw=1
|
||||
-->
|
||||
@@ -0,0 +1,329 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<chapter id="caching">
|
||||
<title>Cache</title>
|
||||
<para>
|
||||
Le cache est utilisTe pour accTlTrer l'appel de <link
|
||||
linkend="api.display">display()</link> ou de <link
|
||||
linkend="api.fetch">fetch()</link> en sauvegardant leur rTsultat
|
||||
dans un fichier. Si un fichier de cache est disponible lors d'un appel,
|
||||
il sera affichT sans qu'il ne soit nTcessaire de regTnTrer le rTsultat.
|
||||
Le systFme de cache
|
||||
peut accTlTrer les traitements de faton impressionnante, en particulier les
|
||||
templates dont la compilation est trFs longue. Comme le rTsultat de
|
||||
display() ou de fetch() est dans le cache, un fichier de cache peut
|
||||
Otre composT de plusieurs fichiers de templates, plusieurs fichiers
|
||||
de configuration, etc.
|
||||
</para>
|
||||
<para>
|
||||
Comme les templates sont dynamiques, il est important de faire attention
|
||||
a la faton dont les fichiers de cache sont gTnTrTs, 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 Otre intTressant de mettre cette page
|
||||
dans le cache pour une heure ou plus. A l'inverse, si vous affichez une page
|
||||
de mTtTo mises a jour toutes les minutes, mettre cette page en cache
|
||||
n'a aucun sens.
|
||||
</para>
|
||||
<sect1 id="caching.setting.up">
|
||||
<title>ParamTtrer le cache</title>
|
||||
<para>
|
||||
La premiFre chose a faire est d'activer le cache. Cela est fait en
|
||||
mettant <link linkend="variable.caching">$caching</link> = true
|
||||
(ou 1).
|
||||
</para>
|
||||
<example>
|
||||
<title>activation du cache</title>
|
||||
<programlisting>
|
||||
require('Smarty.class.php');
|
||||
$smarty = new Smarty;
|
||||
|
||||
$smarty->caching = true;
|
||||
|
||||
$smarty->display('index.tpl');</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Avec le cache activT, la fonction display('index.tpl') va afficher
|
||||
le template mais sauvegardera par la mOme occasion une copie du rTsultat
|
||||
dans un fichier (de cache) du rTpertoire
|
||||
<link linkend="variable.cache.dir">$cache_dir</link>. Au prochain appel de
|
||||
display('index.tpl'), le fichier de cache sera prTfTrT a la rTutilisation
|
||||
du template.
|
||||
</para>
|
||||
<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
Les fichiers situTs dans $cache_dir sont nommTs de la mOme faton que les templates.
|
||||
Bien qu'ils aient une extension ".php", ils ne sont pas vraiment exTcutable.
|
||||
N'Tditez surtout pas ces fichiers !
|
||||
</para>
|
||||
</note>
|
||||
<para>
|
||||
Tout fichier de cache a une durTe de vie limitTe dTterminTe par <link
|
||||
linkend="variable.cache.lifetime">$cache_lifetime</link>. La valeur par
|
||||
dTfaut est 3600 secondes, i.e. 1 heure. Une fois que cette durTe est
|
||||
dTpassTe, le cache est regTnTrT. Il est possible de donner
|
||||
une durTe d'expiration propre a chaque fichier de cache en rTglant
|
||||
$caching = 2.
|
||||
Se reporter a la documentation de <link
|
||||
linkend="variable.cache.lifetime">$cache_lifetime</link> pour plus de
|
||||
dTtails.
|
||||
</para>
|
||||
<example>
|
||||
<title>rTglage individuel de cache_lifetime</title>
|
||||
<programlisting>
|
||||
require('Smarty.class.php');
|
||||
$smarty = new Smarty;
|
||||
|
||||
$smarty->caching = 2; // rTgler la durTe de vie individuellement
|
||||
|
||||
// rTgle la durTe de vie du cache a 15 minutes pour index.tpl
|
||||
$smarty->cache_lifetime = 300;
|
||||
$smarty->display('index.tpl');
|
||||
|
||||
// rTgle la durTe de vie du cache a 1 heure pour home.tpl
|
||||
$smarty->cache_lifetime = 3600;
|
||||
$smarty->display('home.tpl');
|
||||
|
||||
// NOTE : le rTglage suivant ne fonctionne pas quand $caching = 2. La durTe de vie
|
||||
// du fichier de cache de home.tpl a dTja TtT rTglTe a 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');</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Si <link linkend="variable.compile.check">$compile_check</link> est actif,
|
||||
chaque fichier de template et de configuration qui a un rapport
|
||||
avec le fichier de cache sera vTrifiT pour dTtecter une Tventuelle
|
||||
modification. Si l'un de ces fichiers a TtT modifiT depuis que le fichier de cache a TtT
|
||||
gTnTrT, le cache est immTdiatement regTnTrT. Ce processus est covteux, donc,
|
||||
pour des raisons de performances, mettez ce paramFtre a false pour une application
|
||||
en production.
|
||||
</para>
|
||||
<example>
|
||||
<title>activation de $compile_check</title>
|
||||
<programlisting>
|
||||
require('Smarty.class.php');
|
||||
$smarty = new Smarty;
|
||||
|
||||
$smarty->caching = true;
|
||||
$smarty->compile_check = true;
|
||||
|
||||
$smarty->display('index.tpl');</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Si <link linkend="variable.force.compile">$force_compile</link> est actif,
|
||||
les fichiers de cache sont toujours regTnTrTs. Ceci revient finalement a
|
||||
dTsactiver le cache. $force_compile est utilisT a des fins de dTbogage,
|
||||
un moyen plus efficace de dTsactiver le cache est de rTgler
|
||||
<link linkend="variable.caching">$caching</link> = false (ou 0).
|
||||
</para>
|
||||
<para>
|
||||
La fonction <link linkend="api.is.cached">is_cached()</link> 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 requOte
|
||||
a une base de donnTes, vous pouvez utiliser cette mTthode plut(t
|
||||
que $compile_check.
|
||||
</para>
|
||||
<example>
|
||||
<title>utilisation de is_cached()</title>
|
||||
<programlisting>
|
||||
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');</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Vous pouvez rendre dynamiques seulement certaines parties d'une
|
||||
page avec la fonction de templates <link
|
||||
linkend="language.function.insert">insert</link>.
|
||||
Imaginons que toute une page doit Otre mise en cache a part
|
||||
une banniFre en bas a droite. En utilisant une fonction insert pour la
|
||||
banniFre, vous pouvez garder cet TlTment dynamique dans le contenu qui
|
||||
est en cache. Reportez-vous a la documentation
|
||||
<link linkend="language.function.insert">insert</link> pour plus de dTtails
|
||||
et des exemples.
|
||||
</para>
|
||||
<para>
|
||||
Vous pouvez effacer tous les fichiers du cache avec la fonction <link
|
||||
linkend="api.clear.all.cache">clear_all_cache(),</link> ou de faton
|
||||
individuelle (ou par groupe) avec la fonction <link
|
||||
linkend="api.clear.cache">clear_cache()</link>.
|
||||
</para>
|
||||
<example>
|
||||
<title>nettoyage du cache</title>
|
||||
<programlisting>
|
||||
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');</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<sect1 id="caching.multiple.caches">
|
||||
<title>Caches multiples pour une seule page</title>
|
||||
<para>
|
||||
Vous pouvez avoir plusieurs fichiers de caches pour un mOme appel
|
||||
aux fonctions display() ou fetch(). Imaginons qu'un appel a display('index.tpl')
|
||||
puisse avoir plusieurs rTsultats, en fonction de certaines conditions, et que
|
||||
vous vouliez des fichiers de cache sTparTs pour chacun d'eux. Vous
|
||||
pouvez faire cela en passant un identifiant de cache (cache_id) en
|
||||
deuxiFme paramFtre a l'appel de fonction.
|
||||
</para>
|
||||
<example>
|
||||
<title>Passage d'un cache_id a display()</title>
|
||||
<programlisting>
|
||||
require('Smarty.class.php');
|
||||
$smarty = new Smarty;
|
||||
|
||||
$smarty->caching = true;
|
||||
|
||||
$my_cache_id = $_GET['article_id'];
|
||||
|
||||
$smarty->display('index.tpl',$my_cache_id);</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Nous passons ci-dessus la variable $my_cache_id a display() comme
|
||||
identifiant de cache. Pour chaque valeur distincte de $my_cache_id,
|
||||
un fichier de cache distinct va Otre crTT. Dans cet exemple,
|
||||
"article_id" a TtT passT dans l'URL et est utilisT en tant qu'identifiant
|
||||
de cache.
|
||||
</para>
|
||||
<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
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 a utiliser article_id depuis l'URL puisse paraetre
|
||||
commode, le rTsultat peut s'avTrer mauvais. L'identifiant
|
||||
de cache est utilisT pour crTer un rTpertoire sur le systFme de fichiers,
|
||||
donc si l'utilisateur dTcide de donner une trFs grande valeur a article_id
|
||||
ou d'Tcrire un script qui envoie des article_id de faton alTatoire,
|
||||
cela pourra causer des problFmes cotT serveur. Assurez-vous de bien
|
||||
tester toute donnTe passTe en paramFtre avant de l'utiliser. Dans cet
|
||||
exemple, peut-Otre savez-vous que article_id a une longueur de 10
|
||||
caractFres, est exclusivement composT de caractFres alph-numTriques et
|
||||
doit avoir une valeur contenue dans la base de donnTes. VTrifiez-le bien !
|
||||
</para>
|
||||
</note>
|
||||
<para>
|
||||
Assurez-vous de bien passer le mOme identifiant aux fonctions
|
||||
<link linkend="api.is.cached">is_cached()</link> et
|
||||
<link linkend="api.clear.cache">clear_cache()</link>.
|
||||
</para>
|
||||
<example>
|
||||
<title>passer un cache_id a is_cached()</title>
|
||||
<programlisting>
|
||||
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);</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Vous pouvez effacer tous les fichiers de cache pour un identifiant
|
||||
de cache particulier en passant null en tant que premier paramFtre
|
||||
a clear_cache().
|
||||
</para>
|
||||
<example>
|
||||
<title>effacement de tous les fichiers de cache pour un identifiant de cache particulier</title>
|
||||
<programlisting>
|
||||
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");</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
De cette maniFre vous pouvez "grouper" vos fichiers de cache en leur
|
||||
donnant le mOme identifiant.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="caching.groups">
|
||||
<title>groupes de fichiers de cache</title>
|
||||
<para>
|
||||
Vous pouvez faire des groupements plus TlaborTs en paramTtrant les
|
||||
groupes d'identifiant de cache. Il suffit de sTparer 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 dTsirez.
|
||||
</para>
|
||||
<example>
|
||||
<title>groupes d'identifiants de cache</title>
|
||||
<programlisting>
|
||||
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");</programlisting>
|
||||
</example>
|
||||
<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
Le systFme 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 rTpertoire "theme/blue". Si vous voulez
|
||||
faire cela, vous devez les grouper avec un mOme 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').
|
||||
</para>
|
||||
</note>
|
||||
</sect1>
|
||||
</chapter>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
sgml-omittag:t
|
||||
sgml-shorttag:t
|
||||
sgml-minimize-attributes:nil
|
||||
sgml-always-quote-attributes:t
|
||||
sgml-indent-step:1
|
||||
sgml-indent-data:t
|
||||
indent-tabs-mode:nil
|
||||
sgml-parent-document:nil
|
||||
sgml-default-dtd-file:"../../../../manual.ced"
|
||||
sgml-exposed-tags:nil
|
||||
sgml-local-catalogs:nil
|
||||
sgml-local-ecat-files:nil
|
||||
End:
|
||||
vim600: syn=xml fen fdm=syntax fdl=2 si
|
||||
vim: et tw=78 syn=sgml
|
||||
vi: ts=1 sw=1
|
||||
-->
|
||||
@@ -0,0 +1,790 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<chapter id="plugins">
|
||||
<title>Etendre Smarty avec des plugins</title>
|
||||
<para>
|
||||
La version 2.0 a introduit l'architecture de plugin qui est
|
||||
utilisTe pour pratiquement toute les fonctionnalitTs
|
||||
personnalisables de Smarty. Ceci comprend :
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><simpara>les fonctions</simpara></listitem>
|
||||
<listitem><simpara>les modificateurs</simpara></listitem>
|
||||
<listitem><simpara>les fonctions de blocs</simpara></listitem>
|
||||
<listitem><simpara>les fonctions de compilation</simpara></listitem>
|
||||
<listitem><simpara>les filtres de prT-compilation</simpara></listitem>
|
||||
<listitem><simpara>les filtres de post-compilation</simpara></listitem>
|
||||
<listitem><simpara>les filtres de sorties</simpara></listitem>
|
||||
<listitem><simpara>les ressources</simpara></listitem>
|
||||
<listitem><simpara>les insertions</simpara></listitem>
|
||||
</itemizedlist>
|
||||
A part pour les ressources, la compatibilitT avec les anciennes
|
||||
fatons d'enregistrer les fonctions de gestion avec l'API register_
|
||||
est conservTe. Si vous n'avez pas utilisT cette API et que vous avez
|
||||
a la place directement modifiT les variables de classes
|
||||
<literal>$custom_funcs</literal>, <literal>$custom_mods</literal> et
|
||||
d'autres, vous devez alors modifier vos scripts pour utiliser
|
||||
l'API ou convertir vos fonctionnalitTs personnalisTes en plugins.
|
||||
</para>
|
||||
|
||||
<sect1>
|
||||
<title>Comment fonctionnent les plugins</title>
|
||||
<para>
|
||||
Les plugins sont toujours chargTs a la demande. Seuls les modificateurs
|
||||
de variables, les ressources, etc invoquTs dans les scripts de templates
|
||||
seront chargTs. De plus, chaque plugin n'est chargT qu'une fois, et ce
|
||||
mOme si vous avez plusieurs instances de Smarty qui tournent dans
|
||||
la mOme requOte.
|
||||
</para>
|
||||
<para>
|
||||
Les filtres de post/prT-compilation et les filtres de sortie sont des cas
|
||||
un peu spTciaux.
|
||||
Comme ils ne sont pas mentionnTs dans les templates, ils doivent Otre dTclarTs
|
||||
ou chargTs explicitement via les fonctions de l'API avant que le template
|
||||
ne soit exTcutT. L'ordre dans lequel les filtres multiples d'un mOme type
|
||||
sont exTcutTs dTpend de l'ordre dans lequel ils sont enregistrTs ou chargTs.
|
||||
</para>
|
||||
<para>
|
||||
Il n'existe qu'un seul rTpertoire de plugin (pour des raisons de performances).
|
||||
Pour installer un plugin, copiez-le simplement dans le rTpertoire et Smarty
|
||||
l'utilisera automatiquement.
|
||||
</para>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="plugins.naming.conventions">
|
||||
<title>Conventions de nommage</title>
|
||||
<para>
|
||||
Les fichiers et les fonctions de plugins doivent suivre une convention
|
||||
de nommage trFs spTcifique pour Otre localisTs par Smarty.
|
||||
</para>
|
||||
<para>
|
||||
Les fichiers de plugins doivent Otre nommTs de la faton suivante :
|
||||
<blockquote>
|
||||
<para>
|
||||
<filename>
|
||||
<replaceable>type</replaceable>.<replaceable>nom</replaceable>.php
|
||||
</filename>
|
||||
</para>
|
||||
</blockquote>
|
||||
</para>
|
||||
<para>
|
||||
Oú <literal>type</literal> est l'une des valeurs suivantes :
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><simpara>function</simpara></listitem>
|
||||
<listitem><simpara>modifier</simpara></listitem>
|
||||
<listitem><simpara>block</simpara></listitem>
|
||||
<listitem><simpara>compiler</simpara></listitem>
|
||||
<listitem><simpara>prefilter</simpara></listitem>
|
||||
<listitem><simpara>postfilter</simpara></listitem>
|
||||
<listitem><simpara>outputfilter</simpara></listitem>
|
||||
<listitem><simpara>resource</simpara></listitem>
|
||||
<listitem><simpara>insert</simpara></listitem>
|
||||
</itemizedlist>
|
||||
</para>
|
||||
<para>
|
||||
Et <literal>nom</literal> doit Otre un identifiant valide (lettres, nombres
|
||||
et underscore seulement).
|
||||
</para>
|
||||
<para>
|
||||
Quelques exemples : <literal>function.html_select_date.php</literal>,
|
||||
<literal>resource.db.php</literal>,
|
||||
<literal>modifier.spacify.php</literal>.
|
||||
</para>
|
||||
<para>
|
||||
Les fonctions de plugins dans les fichiers de plugins doivent Otre
|
||||
nommTes de la faton suivante :
|
||||
<blockquote>
|
||||
<para>
|
||||
<function>smarty_<replaceable>type</replaceable>_<replaceable>nom</replaceable></function>
|
||||
</para>
|
||||
</blockquote>
|
||||
</para>
|
||||
<para>
|
||||
Les significations de <literal>type</literal> et de <literal>nom</literal> sont les mOmes
|
||||
que prTcTdemment.
|
||||
</para>
|
||||
<para>
|
||||
Smarty donnera des messages d'erreur appropriT si le fichier de plugin
|
||||
n'est pas trouvT, ou si le fichier ou la fonction de plugin ne sont
|
||||
pas nommTs correctement.
|
||||
</para>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="plugins.writing">
|
||||
<title>Ecrire des plugins</title>
|
||||
<para>
|
||||
Les plugins peuvent Otre soit chargTs automatiquement par Smarty
|
||||
depuis le systFme de fichier, soit Otre dTclarTs
|
||||
pendant l'exTcution via une fonction register_* de l'API. Ils peuvent
|
||||
aussi Otre dTsallouTs en utilisant une fonction unregister_* de
|
||||
l'API.
|
||||
</para>
|
||||
<para>
|
||||
Pour les plugins qui ne sont pas enregistrTs pendant l'exTcution, le nom
|
||||
des fonctions n'ont pas a suivre la convention de nommage.
|
||||
</para>
|
||||
<para>
|
||||
Si certaines fonctionnalitTs d'un plugin dTpendent d'un autre plugin
|
||||
(comme c'est le cas de certains plugins accompagnant Smarty), alors la maniFre appropriTe
|
||||
de charger le plugin est la suivante :
|
||||
</para>
|
||||
|
||||
<programlisting>
|
||||
require_once SMARTY_DIR . 'plugins/function.html_options.php';</programlisting>
|
||||
<para>
|
||||
Une rFgle gTnTrale est que chaque objet Smarty est toujours passT au plugin
|
||||
en tant que dernier paramFtre (a part pour les modificateurs).
|
||||
</para>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="plugins.functions"><title>Les fonctions de templates</title>
|
||||
<funcsynopsis>
|
||||
<funcprototype>
|
||||
<funcdef>void <function>smarty_function_<replaceable>name</replaceable></function></funcdef>
|
||||
<paramdef>array <parameter>$params</parameter></paramdef>
|
||||
<paramdef>object <parameter>&$smarty</parameter></paramdef>
|
||||
</funcprototype>
|
||||
</funcsynopsis>
|
||||
<para>
|
||||
Tous les attributs passTs aux fonctions de template a partir du template
|
||||
sont contenus dans le tableau associatif <parameter>$params</parameter>.
|
||||
Vous pouvez accTder a ces valeurs soit directement, par exemple
|
||||
<varname>$params['start']</varname>, soit en utilisant
|
||||
<varname>extract($params)</varname> pour les importer dans la table
|
||||
des symboles.
|
||||
</para>
|
||||
<para>
|
||||
Le retour de la fonction sera substituTe a la balise de fonction
|
||||
du template (fonction <function>fetch</function> par exemple). Sinon,
|
||||
la fonction peut simplement accomplir une autre tGche sans sortie
|
||||
(la fonction <function>assign</function> par exemple)
|
||||
</para>
|
||||
<para>
|
||||
Si la fonction a besoin d'assigner des variables aux templates ou d'utiliser
|
||||
d'autres fonctionnalitTs fournies par Smarty, elle peut recevoir un
|
||||
objet <parameter>$smarty</parameter> pour cela.
|
||||
</para>
|
||||
<para>
|
||||
RTfTrez-vous aussi a :
|
||||
<link linkend="api.register.function">register_function()</link>,
|
||||
<link linkend="api.unregister.function">unregister_function()</link>.
|
||||
</para>
|
||||
<para>
|
||||
<example>
|
||||
<title>fonction de plugin avec sortie</title>
|
||||
<programlisting>
|
||||
<?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];
|
||||
}
|
||||
?></programlisting>
|
||||
</example>
|
||||
</para>
|
||||
<para>
|
||||
peut Otre utilisTe dans le template de la faton suivante :
|
||||
</para>
|
||||
<programlisting>
|
||||
Question: Will we ever have time travel?
|
||||
Answer: {eightball}.</programlisting>
|
||||
<para>
|
||||
<example>
|
||||
<title>fonction de plugin sans sortie</title>
|
||||
<programlisting>
|
||||
<?php
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
* Fichier : function.assign.php
|
||||
* Type : fonction
|
||||
* Nom : assign
|
||||
* Purpose : assigne une valeur a 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);
|
||||
}
|
||||
?></programlisting>
|
||||
</example>
|
||||
</para>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="plugins.modifiers"><title>Modificateurs</title>
|
||||
<para>
|
||||
Les modificateurs sont des petites fonctions appliquTes a une variable
|
||||
de template avant qu'elle ne soit affichTe ou utilisTe dans un autre contexte.
|
||||
Les modificateurs peuvent Otre chaenTs entre eux.
|
||||
</para>
|
||||
<funcsynopsis>
|
||||
<funcprototype>
|
||||
<funcdef>mixed <function>smarty_modifier_<replaceable>name</replaceable></function></funcdef>
|
||||
<paramdef>mixed <parameter>$value</parameter></paramdef>
|
||||
<paramdef>[mixed <parameter>$param1</parameter>, ...]</paramdef>
|
||||
</funcprototype>
|
||||
</funcsynopsis>
|
||||
<para>
|
||||
Le premier paramFtre passT au modificateur est la valeur
|
||||
sur laquelle le modificateur est supposT opTrer. Les autres paramFtres
|
||||
peuvent Otre optionnels, dTpendant de quel genre d'opTration doit Otre
|
||||
effectuT.
|
||||
</para>
|
||||
<para>
|
||||
Le modificateur doit retourner le rTsultat de son exTcution.
|
||||
</para>
|
||||
<para>
|
||||
Regardez aussi
|
||||
<link linkend="api.register.modifier">register_modifier()</link>,
|
||||
<link linkend="api.unregister.modifier">unregister_modifier()</link>.
|
||||
</para>
|
||||
<example>
|
||||
<title>plugin modificateur simple</title>
|
||||
<para>
|
||||
Ce plugin est un alias d'une fonction PHP. Il n'a aucun paramFtre
|
||||
supplTmentaires.
|
||||
</para>
|
||||
<programlisting>
|
||||
<?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);
|
||||
}
|
||||
?></programlisting>
|
||||
</example>
|
||||
<para></para>
|
||||
<example>
|
||||
<title>un plugin modificateur un peu plus complexe</title>
|
||||
<programlisting>
|
||||
<?php
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
* Fichier : modifier.truncate.php
|
||||
* Type : modificateur
|
||||
* Name : truncate
|
||||
* R(le : Tronque une chaene a une certaine longueur si
|
||||
* nTcessaire, la coupe optionnellement au milieu
|
||||
* d'un mot et ajoute la chaene $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;
|
||||
}
|
||||
?></programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="plugins.block.functions"><title>Fonctions de blocs</title>
|
||||
<funcsynopsis>
|
||||
<funcprototype>
|
||||
<funcdef>void <function>smarty_block_<replaceable>name</replaceable></function></funcdef>
|
||||
<paramdef>array <parameter>$params</parameter></paramdef>
|
||||
<paramdef>mixed <parameter>$content</parameter></paramdef>
|
||||
<paramdef>object <parameter>&$smarty</parameter></paramdef>
|
||||
</funcprototype>
|
||||
</funcsynopsis>
|
||||
<para>
|
||||
Les fonctions de blocs sont des fonctions de la forme {func} .. {/func}.
|
||||
En d'autres mots, elles englobent des blocs de template et opFrent sur les
|
||||
contenus de ces blocs. Les fonctions de blocs ont la prioritT sur les
|
||||
fonctions utilisateurs de mOme nom, ce qui signifie que vous ne
|
||||
pouvez avoir une fonction utilisateur {func} et une fonction de bloc
|
||||
{func} .. {/func}.
|
||||
</para>
|
||||
<para>
|
||||
L'implTmentation de votre fonction est appelTe deux fois par Smarty :
|
||||
une fois pour la balise ouvrante et une autre fois pour la balise
|
||||
fermante.
|
||||
</para>
|
||||
<para>
|
||||
Seule la balise ouvrante d'une fonction de bloc peut avoir des attributs.
|
||||
Tous les attributs passTs par le template aux fonctions de templates sont
|
||||
contenues dans le tableau associatif <parameter>$params</parameter>.
|
||||
Vous pouvez accTder a ces valeurs soit directement, par exemple
|
||||
<varname>$params['start']</varname>, soit en utilisant
|
||||
<varname>extract($params)</varname> pour les importer dans la table
|
||||
des symboles. Votre fonction a aussi accFs aux attributs de la balise
|
||||
ouvrante quand c'est la balise fermante qui est exTcutTe.
|
||||
</para>
|
||||
<para>
|
||||
La valeur de la variable <parameter>$content</parameter> est diffTrente
|
||||
selon si votre fonction est appelTe pour la balise ouvrante ou la
|
||||
balise fermante. Si c'est pour la balise ouvrante, elle sera a
|
||||
<literal>null</literal> et si c'est la balise fermante elle sera
|
||||
Tgale au contenu du bloc de template. Notez que le bloc de template
|
||||
aura dTja TtT exTcutT par Smarty, vous recevrez donc la sortie du
|
||||
template et non sa source.
|
||||
</para>
|
||||
<para>
|
||||
Si vous imbriquT des fonctions de bloc, il est possible de connaetre
|
||||
la fonction de bloc parente grGce a la variable <varname>$smarty->_tag_stack</varname>.
|
||||
Faites un var_dump() dessus et la structure devrait apparaetre.
|
||||
</para>
|
||||
<para>
|
||||
Regardez aussi :
|
||||
<link linkend="api.register.block">register_block()</link>,
|
||||
<link linkend="api.unregister.block">unregister_block()</link>.
|
||||
</para>
|
||||
<example>
|
||||
<title>fonction de bloc</title>
|
||||
<programlisting>
|
||||
<?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;
|
||||
}
|
||||
}</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="plugins.compiler.functions"><title>Fonctions de compilation</title>
|
||||
<para>
|
||||
Les fonctions de compilation sont appelTes 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 personnalisTe ont le mOme
|
||||
nom, la fonction de compilation a prioritT.
|
||||
</para>
|
||||
<funcsynopsis>
|
||||
<funcprototype>
|
||||
<funcdef>mixed <function>smarty_compiler_<replaceable>name</replaceable></function></funcdef>
|
||||
<paramdef>string <parameter>$tag_arg</parameter></paramdef>
|
||||
<paramdef>object <parameter>&$smarty</parameter></paramdef>
|
||||
</funcprototype>
|
||||
</funcsynopsis>
|
||||
<para>
|
||||
Les fonctions de compilation ont deux paramFtres : une chaene contenant
|
||||
la balise - en gros, tout, depuis le nom de la fonction jusqu'au dTlimiteur de fin - et
|
||||
l'objet Smarty. Elles sont censTes retourner le code PHP qui doit Otre
|
||||
injectT dans le template compilT.
|
||||
</para>
|
||||
<para>
|
||||
Regardez aussi
|
||||
<link linkend="api.register.compiler.function">register_compiler_function()</link>,
|
||||
<link linkend="api.unregister.compiler.function">unregister_compiler_function()</link>.
|
||||
</para>
|
||||
<example>
|
||||
<title>fonction de compilation simple</title>
|
||||
<programlisting>
|
||||
<?php
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
* Fichier : compiler.tplheader.php
|
||||
* Type : compilation
|
||||
* Nom : tplheader
|
||||
* R(le : Renvoie l'en-tOte 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'). "';";
|
||||
}
|
||||
?></programlisting>
|
||||
<para>
|
||||
Cette fonction peut-Otre appelT depuis le template comme suivant :
|
||||
</para>
|
||||
<programlisting>
|
||||
{* cette fonction n'est executTe que lors de la compilation *}
|
||||
{tplheader}</programlisting>
|
||||
<para>
|
||||
Le code PHP rTsultant dans les templates compilTs ressemblerait a ta :
|
||||
</para>
|
||||
<programlisting>
|
||||
<php
|
||||
echo 'index.tpl compiled at 2002-02-20 20:02';
|
||||
?></programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="plugins.prefilters.postfilters">
|
||||
<title>filtres de prT-compilation/filtres de post-compilation</title>
|
||||
<para>
|
||||
Les filtres de prT-compilation et les filtres de post-compilation ont des concepts trFs
|
||||
proches. Ils diffTrent dans leur exTcution, plus prTcisTment dans le
|
||||
moment oú ils sont exTcutTs.
|
||||
</para>
|
||||
<funcsynopsis>
|
||||
<funcprototype>
|
||||
<funcdef>string <function>smarty_prefilter_<replaceable>name</replaceable></function></funcdef>
|
||||
<paramdef>string <parameter>$source</parameter></paramdef>
|
||||
<paramdef>object <parameter>&$smarty</parameter></paramdef>
|
||||
</funcprototype>
|
||||
</funcsynopsis>
|
||||
<para>
|
||||
Les filtres de prT-compilation sont utilisTs pour transformer la source d'un template
|
||||
juste avant la compilation. Le premier paramFtre passT a la fonction
|
||||
de filtre de prT-compilation est la source du template, Tventuellement modifiTe par
|
||||
d'autres filtre de prT-compilations. Le plugin est supposT retourner la source modifiTe.
|
||||
Notez que cette source n'est sauvegardTe nulle part, elle est seulement
|
||||
utilisT pour la compilation.
|
||||
</para>
|
||||
<funcsynopsis>
|
||||
<funcprototype>
|
||||
<funcdef>string <function>smarty_postfilter_<replaceable>name</replaceable></function></funcdef>
|
||||
<paramdef>string <parameter>$compiled</parameter></paramdef>
|
||||
<paramdef>object <parameter>&$smarty</parameter></paramdef>
|
||||
</funcprototype>
|
||||
</funcsynopsis>
|
||||
<para>
|
||||
Les filtres de post-compilation sont utilisTs pour modifier la sortie du template
|
||||
(le code PHP) juste aprFs que la compilation a TtT faite mais juste
|
||||
avant que le template ne soit sauvegardT sur le systFme de fichiers.
|
||||
Le premier paramFtre passT a la fonction de filtre de post-compilation est le code
|
||||
du template compilT, Tventuellement dTja modifiT par d'autres filtre de post-compilations.
|
||||
Le plugin est censT retourner la version modifiT du code.
|
||||
</para>
|
||||
<example>
|
||||
<title>plugin de filtre de post-compilation</title>
|
||||
<programlisting>
|
||||
<?php
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
* Fichier : prefilter.pre01.php
|
||||
* Type : filtre de prT-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);
|
||||
}
|
||||
?></programlisting>
|
||||
</example>
|
||||
<para></para>
|
||||
<example>
|
||||
<title>plugin de filtre de post-compilation</title>
|
||||
<programlisting>
|
||||
<?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;
|
||||
}
|
||||
?></programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="plugins.outputfilters"><title>Filtres de sortie</title>
|
||||
<para>
|
||||
Les plugins de filtres de sortie opFrent sur la sortie du template,
|
||||
aprFs que le template a TtT chargT et exTcutT, mais avant que
|
||||
la sortie ne soit affichTe.
|
||||
</para>
|
||||
<funcsynopsis>
|
||||
<funcprototype>
|
||||
<funcdef>string <function>smarty_outputfilter_<replaceable>name</replaceable></function></funcdef>
|
||||
<paramdef>string <parameter>$template_output</parameter></paramdef>
|
||||
<paramdef>object <parameter>&$smarty</parameter></paramdef>
|
||||
</funcprototype>
|
||||
</funcsynopsis>
|
||||
<para>
|
||||
Le premier paramFtre passT a la fonction du filtre de sortie est la
|
||||
sortie du template qui doit Otre modifiTe et le second paramFtre
|
||||
est l'instance de Smarty appelant le plugin. Le plugin est supposT
|
||||
faire un traitement et en retourner le rTsultat.
|
||||
</para>
|
||||
<example>
|
||||
<title>plugin de filtre de sortie</title>
|
||||
<programlisting>
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
* Fichier : outputfilter.protect_email.php
|
||||
* Type : filtre de sortie
|
||||
* Nom : protect_email
|
||||
* R(le: Convertie les @ en %40 pour protTger 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);
|
||||
}
|
||||
</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="plugins.resources"><title>Ressources</title>
|
||||
<para>
|
||||
Les plugins ressources sont un moyen gTnTrique de fournir des sources
|
||||
de templates ou des composants de scripts PHP a Smarty. Quelques exemples
|
||||
de ressources : bases de donnTes, LDAP, mTmoire partagTe, sockets, et ainsi
|
||||
de suite.
|
||||
</para>
|
||||
<para>
|
||||
Il y au total 4 fonctions qui ont besoin d'Otre enregistrTes pour
|
||||
chaque type de ressource. Chaque fonction retoit le nom de la ressource demandTe
|
||||
comme premier paramFtre et l'objet Smarty comme dernier paramFtre.
|
||||
Les autres paramFtres dTpendent de la fonction.
|
||||
</para>
|
||||
<funcsynopsis>
|
||||
<funcprototype>
|
||||
<funcdef>bool <function>smarty_resource_<replaceable>name</replaceable>_source</function></funcdef>
|
||||
<paramdef>string <parameter>$rsrc_name</parameter></paramdef>
|
||||
<paramdef>string <parameter>&$source</parameter></paramdef>
|
||||
<paramdef>object <parameter>&$smarty</parameter></paramdef>
|
||||
</funcprototype>
|
||||
<funcprototype>
|
||||
<funcdef>bool <function>smarty_resource_<replaceable>name</replaceable>_timestamp</function></funcdef>
|
||||
<paramdef>string <parameter>$rsrc_name</parameter></paramdef>
|
||||
<paramdef>int <parameter>&$timestamp</parameter></paramdef>
|
||||
<paramdef>object <parameter>&$smarty</parameter></paramdef>
|
||||
</funcprototype>
|
||||
<funcprototype>
|
||||
<funcdef>bool <function>smarty_resource_<replaceable>name</replaceable>_secure</function></funcdef>
|
||||
<paramdef>string <parameter>$rsrc_name</parameter></paramdef>
|
||||
<paramdef>object <parameter>&$smarty</parameter></paramdef>
|
||||
</funcprototype>
|
||||
<funcprototype>
|
||||
<funcdef>bool <function>smarty_resource_<replaceable>name</replaceable>_trusted</function></funcdef>
|
||||
<paramdef>string <parameter>$rsrc_name</parameter></paramdef>
|
||||
<paramdef>object <parameter>&$smarty</parameter></paramdef>
|
||||
</funcprototype>
|
||||
</funcsynopsis>
|
||||
|
||||
<para>
|
||||
La premiFre fonction est supposTe rTcupTrer la ressource. Son second
|
||||
paramFtre est une variable passTe par rTfTrence oú le rTsultat doit Otre
|
||||
stockT. La fonction est supposTe retourner <literal>true</literal> si
|
||||
elle rTussi a rTcupTrer la ressource et <literal>false</literal> sinon.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
La seconde fonction est supposTe rTcupTrer la date de derniFre modification
|
||||
de la ressource demandTe (comme un timestamp UNIX). Le second paramFtre
|
||||
est une variable passTe par rTfTrence dans laquelle la date doit
|
||||
Otre stockTe. La fonction est supposTe renvoyer <literal>true</literal> si elle
|
||||
a rTussi a rTcupTrer la date et <literal>false</literal> sinon.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
La troisiFme fonction est supposTe retourner <literal>true</literal>
|
||||
ou <literal>false</literal> selon si la ressource demandTe est svre
|
||||
ou non. La fonction est utilisTe seulement pour les ressources templates
|
||||
mais doit tout de mOme Otre dTfinie.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
La quatriFme fonction est supposTe retourner <literal>true</literal>
|
||||
ou <literal>false</literal> selon si on peut faire confiance ou
|
||||
non a la ressource demandTe. Cette fonction est utilisTe seulement
|
||||
pour les composants de scripts PHP demandTs par les balises
|
||||
<command>include_php</command> ou <command>insert</command>
|
||||
ayant un attribut <structfield>src</structfield>. Quoiqu'il en soit,
|
||||
elle doit Otre dTfinie pour les ressources templates.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Regardez aussi
|
||||
<link linkend="api.register.resource">register_resource()</link>,
|
||||
<link linkend="api.unregister.resource">unregister_resource()</link>.
|
||||
</para>
|
||||
<example>
|
||||
<title>resource plugin</title>
|
||||
<programlisting>
|
||||
<?php
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
* Fichier : resource.db.php
|
||||
* Type : ressource
|
||||
* Nom : db
|
||||
* R(le : RTcupFre des templates depuis une base de donnTes
|
||||
* -------------------------------------------------------------
|
||||
*/
|
||||
function smarty_resource_db_source($tpl_name, &$tpl_source, &$smarty)
|
||||
{
|
||||
// fait des requOtes BD pour rTcupTrer 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 requOtes 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 svrs
|
||||
return true;
|
||||
}
|
||||
|
||||
function smarty_resource_db_trusted($tpl_name, &$smarty)
|
||||
{
|
||||
// inutilisTe pour les templates
|
||||
}
|
||||
?></programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="plugins.inserts"><title>Insertions</title>
|
||||
<para>
|
||||
Les plugins d'insertion sont utilisTs pour implTmenter les fonctions
|
||||
qui sont appelTes par les balises
|
||||
<link linkend="language.function.insert"><command>insert</command></link>
|
||||
dans les templates.
|
||||
</para>
|
||||
<funcsynopsis>
|
||||
<funcprototype>
|
||||
<funcdef>string <function>smarty_insert_<replaceable>name</replaceable></function></funcdef>
|
||||
<paramdef>array <parameter>$params</parameter></paramdef>
|
||||
<paramdef>object <parameter>&$smarty</parameter></paramdef>
|
||||
</funcprototype>
|
||||
</funcsynopsis>
|
||||
<para>
|
||||
Le premier paramFtre passT a la fonction est une tableau associatif
|
||||
d'attributs. Vous pouvez accTder a ces valeurs soit directement, par exemple
|
||||
<varname>$params['start']</varname>, soit en utilisant
|
||||
<varname>extract($params)</varname> pour les importer dans la table
|
||||
des symboles.
|
||||
</para>
|
||||
<para>
|
||||
La fonction d'insertion est supposTe retourner le rTsultat qui sera
|
||||
substituT a la balise <command>insert</command> dans le template.
|
||||
</para>
|
||||
<example>
|
||||
<title>plugin d'insertion</title>
|
||||
<programlisting>
|
||||
<?php
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
* Fichier : insert.time.php
|
||||
* Type : temps
|
||||
* Nom : time
|
||||
* R(le : Insert la date/heure courante conformTment
|
||||
* 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;
|
||||
}
|
||||
?></programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
</chapter>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
sgml-omittag:t
|
||||
sgml-shorttag:t
|
||||
sgml-minimize-attributes:nil
|
||||
sgml-always-quote-attributes:t
|
||||
sgml-indent-step:1
|
||||
sgml-indent-data:t
|
||||
indent-tabs-mode:nil
|
||||
sgml-parent-document:nil
|
||||
sgml-default-dtd-file:"../../../../manual.ced"
|
||||
sgml-exposed-tags:nil
|
||||
sgml-local-catalogs:nil
|
||||
sgml-local-ecat-files:nil
|
||||
End:
|
||||
vim600: syn=xml fen fdm=syntax fdl=2 si
|
||||
vim: et tw=78 syn=sgml
|
||||
vi: ts=1 sw=1
|
||||
-->
|
||||
@@ -0,0 +1,46 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<chapter id="smarty.constants">
|
||||
<title>Constantes</title>
|
||||
<para></para>
|
||||
|
||||
<sect1 id="constant.smarty.dir">
|
||||
<title>SMARTY_DIR</title>
|
||||
<para>
|
||||
Il doit s'agir du chemin complet du rTpertoire oú
|
||||
se trouvent les fichiers classes de Smarty.
|
||||
S'il n'est pas dTfini, Smarty essaiera alors d'en
|
||||
dTterminer automatiquement la valeur.
|
||||
S'il est dTfini, le chemin doit se terminer par un slash.
|
||||
</para>
|
||||
|
||||
<example>
|
||||
<title>SMARTY_DIR</title>
|
||||
<programlisting>
|
||||
// dTfinit le chemin du rTpertoire de Smarty
|
||||
define("SMARTY_DIR","/usr/local/lib/php/Smarty/");
|
||||
|
||||
require_once(SMARTY_DIR."Smarty.class.php");</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
</chapter>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
sgml-omittag:t
|
||||
sgml-shorttag:t
|
||||
sgml-minimize-attributes:nil
|
||||
sgml-always-quote-attributes:t
|
||||
sgml-indent-step:1
|
||||
sgml-indent-data:t
|
||||
indent-tabs-mode:nil
|
||||
sgml-parent-document:nil
|
||||
sgml-default-dtd-file:"../../../../manual.ced"
|
||||
sgml-exposed-tags:nil
|
||||
sgml-local-catalogs:nil
|
||||
sgml-local-ecat-files:nil
|
||||
End:
|
||||
vim600: syn=xml fen fdm=syntax fdl=2 si
|
||||
vim: et tw=78 syn=sgml
|
||||
vi: ts=1 sw=1
|
||||
-->
|
||||
Reference in New Issue
Block a user