mirror of
https://github.com/smarty-php/smarty.git
synced 2026-05-04 11:44:16 +02:00
sync with EN & typo
This commit is contained in:
yannick
@@ -1,4 +1,5 @@
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.1 Maintainer: yannick Status: ready -->
|
||||
|
||||
<!ENTITY SMARTYManual "Smarty - le moteur et compilateur de template PHP">
|
||||
<!ENTITY SMARTYDesigners "Smarty pour les graphistes">
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
|
||||
|
||||
<!ENTITY note.parameter.merge '<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
Le paramètre <parameter>merge</parameter> respecte les clés du tableau,
|
||||
donc, si vous fusionnez deux tableaux indexés numériquement, ils peuvent
|
||||
se recouvrir les uns les autres ou aboutir à des clés non séquentielles. Ceci
|
||||
est diférent de la fonction PHP array_merge() qui élimine des clés numériques
|
||||
et les renumérote.
|
||||
</para>
|
||||
</note>'>
|
||||
|
||||
<!ENTITY parameter.compileid '<para>
|
||||
En tant que troisième paramètre optionnel, vous pouvez passer un
|
||||
identifiant de compilation <parameter>compile_id</parameter>.
|
||||
C'est au cas où vous voudriez compiler plusieurs versions du
|
||||
même template, par exemple, pour avoir des templates compilés
|
||||
pour différents langages. Une autre utilité pour l'identifiant de compilation
|
||||
compile_id est lorsque vous utilisez plus d'un $template_dir mais
|
||||
seulement un $compile_dir. Définissez un <parameter>compile_id</parameter>
|
||||
séparé pour chaque $template_dir, sinon, les templates du même nom
|
||||
s'effaceront. Vous pouvez également définir la variable
|
||||
<link linkend="variable.compile.id">$compile_id</link> une seule fois
|
||||
plutôt que de la passer à chaque appel à la fonction.
|
||||
</para>'>
|
||||
@@ -1,5 +1,5 @@
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.1 Maintainer: didou status: ready -->
|
||||
<!-- EN-Revision: 1.1 Maintainer: didou Status: ready -->
|
||||
|
||||
<!ENTITY livedocs.author 'Auteurs :<br />'>
|
||||
<!ENTITY livedocs.editors 'Editeurs :<br />'>
|
||||
|
||||
@@ -1,17 +1,43 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial -->
|
||||
<!-- EN-Revision: 1.3 Maintainer: yannick Status: ready -->
|
||||
<sect1 id="caching.groups">
|
||||
<title>groupes de fichiers de cache</title>
|
||||
<title>Groupes de fichiers de cache</title>
|
||||
<para>
|
||||
Vous pouvez faire des groupements plus élaborés en paramétrant les
|
||||
groupes d'identifiant de cache. Il suffit de séparer chaque sous-groupes
|
||||
groupes d'identifiant de cache. Il suffit de séparer chaque sous-groupe
|
||||
avec une barre verticale "|" dans la valeur de l'identifiant de cache.
|
||||
Vous pouvez faire autant de sous-groupes que vous le désirez.
|
||||
</para>
|
||||
<para>
|
||||
Vous pouvez voir les groupes de cache comme une hiérarchie de dossiers.
|
||||
Par exemple, un groupe de cache "a|b|c" peut être considéré comme
|
||||
la hiérarchie de dossiers "/a/b/c/". Ainsi, clear_cache(null,"a|b|c") supprimerait
|
||||
les fichiers "/a/b/c/*". clear_cache(null,"a|b") supprimerait les fichiers
|
||||
"/a/b/*". Si vous spécifiez un compile_id de cette façon : clear_cache(null,"a|b","foo"),
|
||||
il sera traité comme un groupe de cache apposé "/a/b/c/foo/". Si vous
|
||||
spécifiez un nom de template de cette façon : clear_cache("foo.tpl","a|b|c"),
|
||||
alors Smarty tentera d'effacer "/a/b/c/foo.tpl". Vous ne POUVEZ PAS effacer
|
||||
un nom de template spécifié sous un groupe de cache multiple comme
|
||||
"/a/b/*/foo.tpl", le groupement de cache fonctionne UNIQUEMENT de gauche à droite.
|
||||
Vous pourriez vouloir grouper vos templates sous un groupe de cache simple
|
||||
hiérarchisé pour être capable de les effacer comme un groupe.
|
||||
</para>
|
||||
<para>
|
||||
Le groupement de cache ne devrait pas être confondu avec votre hiérarchie
|
||||
de dossiers de templates, le groupement de cache n'a aucune connaissance
|
||||
de la façon dont vos templates sont structurés. Donc, par exemple, si
|
||||
vous avez une structure de template comme "themes/blue/index.tpl" et
|
||||
que vous voulez être capable d'effacer tous les fichiers de cache pour le thème "blue",
|
||||
vous devriez créer une structure de groupe de cache qui reflète la structure
|
||||
de fichiers de vos templates, comme display("themes/blue/index.tpl","themes|blue"),
|
||||
et les effacer avec clear_cache(null,"themes|blue").
|
||||
</para>
|
||||
<example>
|
||||
<title>groupes d'identifiants de cache</title>
|
||||
<programlisting>
|
||||
<title>Groupes d'identifiants de cache</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
require('Smarty.class.php');
|
||||
$smarty = new Smarty;
|
||||
|
||||
@@ -25,20 +51,11 @@ $smarty->clear_cache(null,"sports|basketball");
|
||||
// Inclue donc "sports|basketball" ou "sports|nimportequoi|nimportequoi|..."
|
||||
$smarty->clear_cache(null,"sports");
|
||||
|
||||
$smarty->display('index.tpl',"sports|basketball");</programlisting>
|
||||
$smarty->display('index.tpl',"sports|basketball");
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
Le systéme de cache n'utilise PAS le chemin vers le template en quoi
|
||||
que ce soit pour l'identifiant de cache. Si par exemple vous
|
||||
faites display('themes/blue/index.tpl'), vous ne pouvez pas effacer tous
|
||||
les fichiers de cache dans le répertoire "theme/blue". Si vous voulez
|
||||
faire cela, vous devez les grouper avec un même identifiant de cache,
|
||||
display('themes/blue/index.tpl','themes|blue'). Vous pouvez ensuite effacer les
|
||||
fichiers de cache pour blue et theme avec clear_cache(null,'theme|blue').
|
||||
</para>
|
||||
</note>
|
||||
</sect1>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
|
||||
@@ -57,7 +57,7 @@ $smarty->display('index.tpl',$my_cache_id);
|
||||
<link linkend="api.clear.cache">clear_cache()</link>.
|
||||
</para>
|
||||
<example>
|
||||
<title>passer un cache_id a is_cached()</title>
|
||||
<title>Passer un cache_id a is_cached()</title>
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
require('Smarty.class.php');
|
||||
@@ -68,9 +68,9 @@ $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);
|
||||
// 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);
|
||||
@@ -83,7 +83,7 @@ $smarty->display('index.tpl',$my_cache_id);
|
||||
a clear_cache().
|
||||
</para>
|
||||
<example>
|
||||
<title>effacement de tous les fichiers de cache pour un identifiant de cache particulier</title>
|
||||
<title>Effacement de tous les fichiers de cache pour un identifiant de cache particulier</title>
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
require('Smarty.class.php');
|
||||
|
||||
@@ -1,53 +1,60 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial -->
|
||||
<!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
|
||||
<sect1 id="caching.setting.up">
|
||||
<title>Paramétrer le cache</title>
|
||||
<para>
|
||||
La premiére chose a faire est d'activer le cache. Cela est fait en
|
||||
La première chose à 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>
|
||||
<title>Activation du cache</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
require('Smarty.class.php');
|
||||
$smarty = new Smarty;
|
||||
|
||||
$smarty->caching = true;
|
||||
|
||||
$smarty->display('index.tpl');</programlisting>
|
||||
$smarty->display('index.tpl');
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Avec le cache activé, la fonction display('index.tpl') va afficher
|
||||
le template mais sauvegardera par la même occasion une copie du résultat
|
||||
dans un fichier (de cache) du répertoire
|
||||
<link linkend="variable.cache.dir">$cache_dir</link>. Au prochain appel de
|
||||
display('index.tpl'), le fichier de cache sera préféré a la réutilisation
|
||||
du template.
|
||||
</para>
|
||||
<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
Les fichiers situés dans $cache_dir sont nommés de la même faton que les templates.
|
||||
Bien qu'ils aient une extension ".php", ils ne sont pas vraiment exécutable.
|
||||
N'éditez surtout pas ces fichiers !
|
||||
</para>
|
||||
</note>
|
||||
display('index.tpl'), le fichier de cache sera préféré à la réutilisation
|
||||
du template.
|
||||
</para>
|
||||
<note>
|
||||
<title>Note technique</title>
|
||||
<para>
|
||||
Tout fichier de cache a une durée de vie limitée déterminée par <link
|
||||
linkend="variable.cache.lifetime">$cache_lifetime</link>. La valeur par
|
||||
défaut est 3600 secondes, i.e. 1 heure. Une fois que cette durée est
|
||||
dépassée, le cache est regénéré. Il est possible de donner
|
||||
une durée d'expiration propre a chaque fichier de cache en réglant
|
||||
$caching = 2.
|
||||
Se reporter a la documentation de <link
|
||||
linkend="variable.cache.lifetime">$cache_lifetime</link> pour plus de
|
||||
détails.
|
||||
Les fichiers situés dans $cache_dir sont nommés de la même façon que les templates.
|
||||
Bien qu'ils aient une extension ".php", ils ne sont pas vraiment exécutable.
|
||||
N'éditez surtout pas ces fichiers !
|
||||
</para>
|
||||
<example>
|
||||
<title>réglage individuel de cache_lifetime</title>
|
||||
<programlisting>
|
||||
</note>
|
||||
<para>
|
||||
Tout fichier de cache a une durée de vie limitée déterminée par <link
|
||||
linkend="variable.cache.lifetime">$cache_lifetime</link>. La valeur par
|
||||
défaut est 3600 secondes, i.e. 1 heure. Une fois que cette durée est
|
||||
dépassée, le cache est regénéré. Il est possible de donner
|
||||
une durée d'expiration propre à chaque fichier de cache en réglant
|
||||
$caching = 2.
|
||||
Se reporter à la documentation de <link
|
||||
linkend="variable.cache.lifetime">$cache_lifetime</link> pour plus de
|
||||
détails.
|
||||
</para>
|
||||
<example>
|
||||
<title>Réglage individuel de cache_lifetime</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
require('Smarty.class.php');
|
||||
$smarty = new Smarty;
|
||||
|
||||
@@ -66,45 +73,55 @@ $smarty->display('home.tpl');
|
||||
// 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 vérifié pour détecter une éventuelle
|
||||
modification. Si l'un de ces fichiers a été modifié depuis que le fichier de cache a été
|
||||
généré, le cache est immédiatement regénéré. Ce processus est covteux, donc,
|
||||
pour des raisons de performances, mettez ce paramétre a false pour une application
|
||||
en production.
|
||||
</para>
|
||||
<example>
|
||||
<title>activation de $compile_check</title>
|
||||
<programlisting>
|
||||
$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 vérifié pour détecter une éventuelle
|
||||
modification. Si l'un de ces fichiers a été modifié depuis que le fichier de cache a été
|
||||
généré, le cache est immédiatement regénéré. Ce processus est couteux, donc,
|
||||
pour des raisons de performances, mettez ce paramètre à false pour une application
|
||||
en production.
|
||||
</para>
|
||||
<example>
|
||||
<title>Activation de $compile_check</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
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 regénérés. Ceci revient finalement a
|
||||
désactiver le cache. $force_compile est utilisé a des fins de débogage,
|
||||
un moyen plus efficace de désactiver le cache est de régler
|
||||
<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 requête
|
||||
a une base de données, vous pouvez utiliser cette méthode plut(t
|
||||
que $compile_check.
|
||||
</para>
|
||||
<example>
|
||||
<title>utilisation de is_cached()</title>
|
||||
<programlisting>
|
||||
$smarty->display('index.tpl');
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Si <link linkend="variable.force.compile">$force_compile</link> est actif,
|
||||
les fichiers de cache sont toujours regénérés. Ceci revient finalement à
|
||||
désactiver le cache. $force_compile est utilisé à des fins de débogage,
|
||||
un moyen plus efficace de désactiver le cache est de régler
|
||||
<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 requête
|
||||
à une base de données, vous pouvez utiliser cette méthode plutôt
|
||||
que $compile_check.
|
||||
</para>
|
||||
<example>
|
||||
<title>Exemple avec is_cached()</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
require('Smarty.class.php');
|
||||
$smarty = new Smarty;
|
||||
|
||||
@@ -112,32 +129,37 @@ $smarty->caching = true;
|
||||
|
||||
if(!$smarty->is_cached('index.tpl')) {
|
||||
// pas de cache disponible, on assigne
|
||||
$contents = get_database_contents();
|
||||
$smarty->assign($contents);
|
||||
$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 être mise en cache a part
|
||||
une banniére en bas a droite. En utilisant une fonction insert pour la
|
||||
banniére, vous pouvez garder cet élément dynamique dans le contenu qui
|
||||
est en cache. Reportez-vous a la documentation
|
||||
<link linkend="language.function.insert">insert</link> pour plus de détails
|
||||
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>
|
||||
$smarty->display('index.tpl');
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Vous pouvez rendre dynamiques seulement certaines parties d'une
|
||||
page avec la fonction de template <link
|
||||
linkend="language.function.insert">insert</link>.
|
||||
Imaginons que toute une page doit être mise en cache à part
|
||||
une bannière en bas à droite. En utilisant une fonction insert pour la
|
||||
bannière, vous pouvez garder cet élément dynamique dans le contenu qui
|
||||
est en cache. Reportez-vous à la documentation
|
||||
<link linkend="language.function.insert">insert</link> pour plus de détails
|
||||
ainsi que 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 façon
|
||||
individuelle (ou par groupe) avec la fonction <link
|
||||
linkend="api.clear.cache">clear_cache()</link>.
|
||||
</para>
|
||||
<example>
|
||||
<title>Nettoyage du cache</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
require('Smarty.class.php');
|
||||
$smarty = new Smarty;
|
||||
|
||||
@@ -149,9 +171,12 @@ $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>
|
||||
$smarty->display('index.tpl');
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
|
||||
@@ -1,61 +1,79 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial -->
|
||||
<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 opérent sur les
|
||||
contenus de ces blocs. Les fonctions de blocs ont la priorité sur les
|
||||
fonctions utilisateurs de même nom, ce qui signifie que vous ne
|
||||
pouvez avoir une fonction utilisateur {func} et une fonction de bloc
|
||||
{func} .. {/func}.
|
||||
</para>
|
||||
<para>
|
||||
L'implémentation de votre fonction est appelée deux fois par Smarty :
|
||||
une fois pour la balise ouvrante et une autre fois pour la balise
|
||||
fermante.
|
||||
</para>
|
||||
<para>
|
||||
Seule la balise ouvrante d'une fonction de bloc peut avoir des attributs.
|
||||
Tous les attributs passés par le template aux fonctions de templates sont
|
||||
contenues dans le tableau associatif <parameter>$params</parameter>.
|
||||
Vous pouvez accéder 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 accés aux attributs de la balise
|
||||
ouvrante quand c'est la balise fermante qui est exécutée.
|
||||
</para>
|
||||
<para>
|
||||
La valeur de la variable <parameter>$content</parameter> est différente
|
||||
selon si votre fonction est appelée pour la balise ouvrante ou la
|
||||
balise fermante. Si c'est pour la balise ouvrante, elle sera a
|
||||
<literal>null</literal> et si c'est la balise fermante elle sera
|
||||
égale au contenu du bloc de template. Notez que le bloc de template
|
||||
aura déjà été exécuté par Smarty, vous recevrez donc la sortie du
|
||||
template et non sa source.
|
||||
</para>
|
||||
<para>
|
||||
Si vous imbriqué 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>,
|
||||
<!-- EN-Revision: 1.3 Maintainer: yannick Status: ready -->
|
||||
<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 opèrent sur les
|
||||
contenus de ces blocs. Les fonctions de blocs ont la priorité sur les
|
||||
fonctions utilisateurs de même nom, ce qui signifie que vous ne
|
||||
pouvez avoir une fonction utilisateur {func} et une fonction de bloc
|
||||
{func} .. {/func}.
|
||||
</para>
|
||||
<para>
|
||||
Par défaut, l'implémentation de votre fonction est appelée deux fois par Smarty :
|
||||
une fois pour la balise ouvrante et une autre fois pour la balise
|
||||
fermante (voir <literal>&$repeat</literal> ci-dessous
|
||||
sur la façon de modifier ce comportement).
|
||||
</para>
|
||||
<para>
|
||||
Seule la balise ouvrante d'une fonction de bloc peut avoir des attributs.
|
||||
Tous les attributs passés par le template aux fonctions de templates sont
|
||||
contenus dans le tableau associatif <parameter>$params</parameter>.
|
||||
Vous pouvez accéder à ces valeurs directement par
|
||||
<varname>$params['start']</varname>.
|
||||
Votre fonction a aussi accès aux attributs de la balise
|
||||
ouvrante quand c'est la balise fermante qui est exécutée.
|
||||
</para>
|
||||
<para>
|
||||
La valeur de la variable <parameter>$content</parameter> est différente
|
||||
selon si votre fonction est appelée pour la balise ouvrante ou la
|
||||
balise fermante. Si c'est pour la balise ouvrante, elle sera à
|
||||
<literal>null</literal> et si c'est la balise fermante, elle sera
|
||||
égale au contenu du bloc de template. Notez que le bloc de template
|
||||
aura déjà été exécuté par Smarty, vous recevrez donc la sortie du
|
||||
template et non sa source.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Le paramètre <parameter>&$repeat</parameter> est passé
|
||||
par référence à la fonction d'implémentation et fournit la possibilité
|
||||
de contrôler le nombre d'affichage du bloc. Par défaut,
|
||||
<parameter>$repeat</parameter> vaut <literal>true</literal>
|
||||
lors du premier appel à la fonction de bloc (le bloc d'ouverture du tag) et
|
||||
<literal>false</literal> lors de tous les autres appels à la fonction
|
||||
de bloc (le bloc de fermeture du tag). Chaque fois que la fonction
|
||||
d'implémentation retourne avec le paramètre
|
||||
<parameter>&$repeat</parameter> vallant true, le contenu situé
|
||||
entre {func} .. {/func} est évalué et la fonction d'implémentation est appelé
|
||||
une nouvelle fois avec le nouveau bloc de contenu en tant que paramètre
|
||||
<parameter>$content</parameter>.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Si vous imbriqué des fonctions de bloc, il est possible de connaître
|
||||
la fonction de bloc parente grâce à la variable <varname>$smarty->_tag_stack</varname>.
|
||||
Faîtes un var_dump() dessus et la structure devrait apparaître.
|
||||
</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
|
||||
</para>
|
||||
<example>
|
||||
<title>Fonction de bloc</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
@@ -72,9 +90,12 @@ function smarty_block_translate($params, $content, &$smarty)
|
||||
// fait une traduction de $content
|
||||
echo $translation;
|
||||
}
|
||||
}</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
}
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
|
||||
@@ -1,36 +1,37 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial -->
|
||||
<sect1 id="plugins.compiler.functions"><title>Fonctions de compilation</title>
|
||||
<para>
|
||||
Les fonctions de compilation sont appelées durant la compilation du template.
|
||||
Elles sont utiles pour injecter du code PHP ou du contenu "statique variant
|
||||
avec le temps" (bandeau de pub par ex.). Si une fonction de compilation et
|
||||
une fonction personnalisée ont le même
|
||||
nom, la fonction de compilation a priorité.
|
||||
</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 paramétres : une chaene contenant
|
||||
la balise - en gros, tout, depuis le nom de la fonction jusqu'au délimiteur de fin - et
|
||||
l'objet Smarty. Elles sont censées retourner le code PHP qui doit être
|
||||
injecté dans le template compilé.
|
||||
</para>
|
||||
<para>
|
||||
Regardez aussi
|
||||
<link linkend="api.register.compiler.function">register_compiler_function()</link>,
|
||||
<!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
|
||||
<sect1 id="plugins.compiler.functions">
|
||||
<title>Fonctions de compilation</title>
|
||||
<para>
|
||||
Les fonctions de compilation sont appelées durant la compilation du template.
|
||||
Elles sont utiles pour injecter du code PHP ou du contenu "statique variant
|
||||
avec le temps" (bandeau de pub par ex.). Si une fonction de compilation et
|
||||
une fonction personnalisée ont le même nom, la fonction de compilation a priorité.
|
||||
</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 paramètres : une chaîne contenant
|
||||
la balise - en gros, tout, depuis le nom de la fonction jusqu'au délimiteur de fin - et
|
||||
l'objet Smarty. Elles sont censées retourner le code PHP qui doit être
|
||||
injecté dans le template compilé.
|
||||
</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
|
||||
</para>
|
||||
<example>
|
||||
<title>Fonction de compilation simple</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
@@ -45,22 +46,28 @@ 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-être appelé depuis le template comme suivant :
|
||||
</para>
|
||||
<programlisting>
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
<para>
|
||||
Cette fonction peut-être appelée depuis le template comme suivant :
|
||||
</para>
|
||||
<programlisting>
|
||||
{* cette fonction n'est executée que lors de la compilation *}
|
||||
{tplheader}</programlisting>
|
||||
<para>
|
||||
Le code PHP résultant dans les templates compilés ressemblerait a ta :
|
||||
</para>
|
||||
<programlisting>
|
||||
<php
|
||||
{tplheader}
|
||||
</programlisting>
|
||||
<para>
|
||||
Le code PHP résultant dans les templates compilés ressemblerait à ça :
|
||||
</para>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
echo 'index.tpl compiled at 2002-02-20 20:02';
|
||||
?></programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
|
||||
@@ -1,43 +1,41 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial -->
|
||||
<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 passés aux fonctions de template a partir du template
|
||||
sont contenus dans le tableau associatif <parameter>$params</parameter>.
|
||||
Vous pouvez accéder 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 substituée 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 fonctionnalités fournies par Smarty, elle peut recevoir un
|
||||
objet <parameter>$smarty</parameter> pour cela.
|
||||
</para>
|
||||
<para>
|
||||
Référez-vous aussi a :
|
||||
<link linkend="api.register.function">register_function()</link>,
|
||||
<!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
|
||||
<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 passés aux fonctions de template à partir du template
|
||||
sont contenus dans le tableau associatif <parameter>$params</parameter>.
|
||||
</para>
|
||||
<para>
|
||||
Le retour de la fonction sera substituée à la balise de fonction
|
||||
du template (fonction <function>fetch</function> par exemple). Sinon,
|
||||
la fonction peut simplement accomplir une autre tâche 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 fonctionnalités fournies par Smarty, elle peut recevoir un
|
||||
objet <parameter>$smarty</parameter> pour celà.
|
||||
</para>
|
||||
<para>
|
||||
Référez-vous aussi à :
|
||||
<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
|
||||
</para>
|
||||
<para>
|
||||
<example>
|
||||
<title>Fonction de plugin avec sortie</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
@@ -47,7 +45,7 @@
|
||||
* Rôle : renvoie une phrase magique au hasard
|
||||
* -------------------------------------------------------------
|
||||
*/
|
||||
function smarty_function_eightball($params, &$smarty)
|
||||
function smarty_function_eightball($params, &$smarty)
|
||||
{
|
||||
$answers = array('Yes',
|
||||
'No',
|
||||
@@ -59,20 +57,24 @@ function smarty_function_eightball($params, &$smarty)
|
||||
$result = array_rand($answers);
|
||||
return $answers[$result];
|
||||
}
|
||||
?></programlisting>
|
||||
</example>
|
||||
</para>
|
||||
<para>
|
||||
peut être utilisée dans le template de la faton suivante :
|
||||
</para>
|
||||
<programlisting>
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
</para>
|
||||
<para>
|
||||
peut être utilisée dans le template de la façon suivante :
|
||||
</para>
|
||||
<programlisting>
|
||||
Question: Will we ever have time travel?
|
||||
Answer: {eightball}.</programlisting>
|
||||
<para>
|
||||
<example>
|
||||
<title>fonction de plugin sans sortie</title>
|
||||
<programlisting>
|
||||
<?php
|
||||
Answer: {eightball}.
|
||||
</programlisting>
|
||||
<para>
|
||||
<example>
|
||||
<title>Fonction de plugin sans sortie</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
@@ -82,7 +84,7 @@ Answer: {eightball}.</programlisting>
|
||||
* Purpose : assigne une valeur a une variable de template
|
||||
* -------------------------------------------------------------
|
||||
*/
|
||||
function smarty_function_assign($params, &$smarty)
|
||||
function smarty_function_assign($params, &$smarty)
|
||||
{
|
||||
extract($params);
|
||||
|
||||
@@ -98,10 +100,12 @@ function smarty_function_assign($params, &$smarty)
|
||||
|
||||
$smarty->assign($var, $value);
|
||||
}
|
||||
?></programlisting>
|
||||
</example>
|
||||
</para>
|
||||
</sect1>
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
</para>
|
||||
</sect1>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial -->
|
||||
<!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
|
||||
<sect1 id="plugins.howto">
|
||||
<title>Comment fonctionnent les plugins</title>
|
||||
<para>
|
||||
Les plugins sont toujours chargés a la demande. Seuls les modificateurs
|
||||
Les plugins sont toujours chargés à la demande. Seuls les modificateurs
|
||||
de variables, les ressources, etc invoqués dans les scripts de templates
|
||||
seront chargés. De plus, chaque plugin n'est chargé qu'une fois, et ce
|
||||
même si vous avez plusieurs instances de Smarty qui tournent dans
|
||||
@@ -19,9 +19,10 @@
|
||||
sont exécutés dépend de l'ordre dans lequel ils sont enregistrés ou chargés.
|
||||
</para>
|
||||
<para>
|
||||
Il n'existe qu'un seul répertoire de plugin (pour des raisons de performances).
|
||||
Pour installer un plugin, copiez-le simplement dans le répertoire et Smarty
|
||||
l'utilisera automatiquement.
|
||||
Le <link linkend="variable.plugins.dir">répertoire de plugin</link> peut
|
||||
être une chaîne de caractères contenant un chemin ou un tableau contenant
|
||||
de multiples chemins. Pour installer un plugin, placez-le simplement
|
||||
dans un de ces dossiers et Smarty l'utilisera automatiquement.
|
||||
</para>
|
||||
</sect1>
|
||||
<!-- Keep this comment at the end of the file
|
||||
|
||||
@@ -1,35 +1,34 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial -->
|
||||
<sect1 id="plugins.inserts"><title>Insertions</title>
|
||||
<para>
|
||||
Les plugins d'insertion sont utilisés pour implémenter les fonctions
|
||||
qui sont appelées 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 paramétre passé a la fonction est une tableau associatif
|
||||
d'attributs. Vous pouvez accéder 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 supposée retourner le résultat qui sera
|
||||
substitué a la balise <command>insert</command> dans le template.
|
||||
</para>
|
||||
<example>
|
||||
<title>plugin d'insertion</title>
|
||||
<programlisting>
|
||||
<?php
|
||||
<!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
|
||||
<sect1 id="plugins.inserts">
|
||||
<title>Insertions</title>
|
||||
<para>
|
||||
Les plugins d'insertion sont utilisés pour implémenter les fonctions
|
||||
qui sont appelées 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 paramétre passé à la fonction est une tableau associatif
|
||||
d'attributs.
|
||||
</para>
|
||||
<para>
|
||||
La fonction d'insertion est supposée retourner le résultat qui sera
|
||||
substitué à la balise <command>insert</command> dans le template.
|
||||
</para>
|
||||
<example>
|
||||
<title>Plugin d'insertion</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
@@ -40,7 +39,7 @@
|
||||
* au format
|
||||
* -------------------------------------------------------------
|
||||
*/
|
||||
function smarty_insert_time($params, &$smarty)
|
||||
function smarty_insert_time($params, &$smarty)
|
||||
{
|
||||
if (empty($params['format'])) {
|
||||
$smarty->trigger_error("insert time: missing 'format' parameter");
|
||||
@@ -50,8 +49,10 @@ function smarty_insert_time($params, &$smarty)
|
||||
$datetime = strftime($params['format']);
|
||||
return $datetime;
|
||||
}
|
||||
?></programlisting>
|
||||
</example>
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
|
||||
@@ -1,41 +1,43 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial -->
|
||||
<sect1 id="plugins.modifiers"><title>Modificateurs</title>
|
||||
<para>
|
||||
Les modificateurs sont des petites fonctions appliquées a une variable
|
||||
de template avant qu'elle ne soit affichée ou utilisée dans un autre contexte.
|
||||
Les modificateurs peuvent être chaenés 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 paramétre passé au modificateur est la valeur
|
||||
sur laquelle le modificateur est supposé opérer. Les autres paramétres
|
||||
peuvent être optionnels, dépendant de quel genre d'opération doit être
|
||||
effectué.
|
||||
</para>
|
||||
<para>
|
||||
Le modificateur doit retourner le résultat de son exécution.
|
||||
</para>
|
||||
<para>
|
||||
Regardez aussi
|
||||
<link linkend="api.register.modifier">register_modifier()</link>,
|
||||
<!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
|
||||
<sect1 id="plugins.modifiers">
|
||||
<title>Modificateurs</title>
|
||||
<para>
|
||||
Les modificateurs sont des petites fonctions appliquées à une variable
|
||||
de template avant qu'elle ne soit affichée ou utilisée dans un autre contexte.
|
||||
Les modificateurs peuvent être chaînés entre eux.
|
||||
</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 paramètre passé au modificateur est la valeur
|
||||
sur laquelle le modificateur est supposé opérer. Les autres paramétres
|
||||
peuvent être optionnels, dépendant de quel genre d'opération doit être
|
||||
effectué.
|
||||
</para>
|
||||
<para>
|
||||
Le modificateur doit retourner le résultat de son exécution.
|
||||
</para>
|
||||
<para>
|
||||
Lisez également
|
||||
<link linkend="api.register.modifier">register_modifier()</link> et
|
||||
<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 paramètre
|
||||
supplémentaires.
|
||||
</para>
|
||||
<example>
|
||||
<title>plugin modificateur simple</title>
|
||||
<para>
|
||||
Ce plugin est un alias d'une fonction PHP. Il n'a aucun paramétre
|
||||
supplémentaires.
|
||||
</para>
|
||||
<programlisting>
|
||||
<?php
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
@@ -49,13 +51,16 @@ function smarty_modifier_capitalize($string)
|
||||
{
|
||||
return ucwords($string);
|
||||
}
|
||||
?></programlisting>
|
||||
</example>
|
||||
<para></para>
|
||||
<example>
|
||||
<title>un plugin modificateur un peu plus complexe</title>
|
||||
<programlisting>
|
||||
<?php
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
<para></para>
|
||||
<example>
|
||||
<title>Un plugin modificateur un peu plus complexe</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
@@ -84,9 +89,11 @@ function smarty_modifier_truncate($string, $length = 80, $etc = '...',
|
||||
} else
|
||||
return $string;
|
||||
}
|
||||
?></programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
|
||||
@@ -1,14 +1,14 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial -->
|
||||
<!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
|
||||
<sect1 id="plugins.naming.conventions">
|
||||
<title>Conventions de nommage</title>
|
||||
<para>
|
||||
Les fichiers et les fonctions de plugins doivent suivre une convention
|
||||
de nommage trés spécifique pour être localisés par Smarty.
|
||||
de nommage très spécifique pour être localisés par Smarty.
|
||||
</para>
|
||||
<para>
|
||||
Les fichiers de plugins doivent être nommés de la faton suivante :
|
||||
Les fichiers de plugins doivent être nommés de la façon suivante :
|
||||
<blockquote>
|
||||
<para>
|
||||
<filename>
|
||||
@@ -18,7 +18,7 @@
|
||||
</blockquote>
|
||||
</para>
|
||||
<para>
|
||||
Oú <literal>type</literal> est l'une des valeurs suivantes :
|
||||
Où <literal>type</literal> est l'une des valeurs suivantes :
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><simpara>function</simpara></listitem>
|
||||
<listitem><simpara>modifier</simpara></listitem>
|
||||
@@ -42,7 +42,7 @@
|
||||
</para>
|
||||
<para>
|
||||
Les fonctions de plugins dans les fichiers de plugins doivent être
|
||||
nommées de la faton suivante :
|
||||
nommées de la façon suivante :
|
||||
<blockquote>
|
||||
<para>
|
||||
<function>smarty_<replaceable>type</replaceable>_<replaceable>nom</replaceable></function>
|
||||
@@ -54,8 +54,8 @@
|
||||
que précédemment.
|
||||
</para>
|
||||
<para>
|
||||
Smarty donnera des messages d'erreur approprié si le fichier de plugin
|
||||
n'est pas trouvé, ou si le fichier ou la fonction de plugin ne sont
|
||||
Smarty donnera des messages d'erreurs appropriés si le fichier de plugin
|
||||
n'est pas trouvé ou si le fichier ou la fonction de plugin ne sont
|
||||
pas nommés correctement.
|
||||
</para>
|
||||
</sect1>
|
||||
|
||||
@@ -1,28 +1,31 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial -->
|
||||
<sect1 id="plugins.outputfilters"><title>Filtres de sortie</title>
|
||||
<para>
|
||||
Les plugins de filtres de sortie opérent sur la sortie du template,
|
||||
aprés que le template a été chargé et exécuté, mais avant que
|
||||
la sortie ne soit affichée.
|
||||
</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 paramétre passé a la fonction du filtre de sortie est la
|
||||
sortie du template qui doit être modifiée et le second paramétre
|
||||
est l'instance de Smarty appelant le plugin. Le plugin est supposé
|
||||
faire un traitement et en retourner le résultat.
|
||||
</para>
|
||||
<example>
|
||||
<title>plugin de filtre de sortie</title>
|
||||
<programlisting>
|
||||
<!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
|
||||
<sect1 id="plugins.outputfilters">
|
||||
<title>Filtres de sortie</title>
|
||||
<para>
|
||||
Les plugins de filtres de sortie opèrent sur la sortie du template,
|
||||
après que le template a été chargé et exécuté, mais avant que
|
||||
la sortie ne soit affichée.
|
||||
</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 paramètre passé à la fonction du filtre de sortie est la
|
||||
sortie du template qui doit être modifiée et le second paramètre
|
||||
est l'instance de Smarty appelant le plugin. Le plugin est supposé
|
||||
faire un traitement et en retourner le résultat.
|
||||
</para>
|
||||
<example>
|
||||
<title>Plugin de filtre de sortie</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
@@ -33,13 +36,15 @@
|
||||
* robots spammers.
|
||||
* -------------------------------------------------------------
|
||||
*/
|
||||
function smarty_outputfilter_protect_email($output, &$smarty)
|
||||
{
|
||||
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>
|
||||
}
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial -->
|
||||
<!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
|
||||
<sect1 id="plugins.prefilters.postfilters">
|
||||
<title>filtres de pré-compilation/filtres de post-compilation</title>
|
||||
<para>
|
||||
Les filtres de pré-compilation et les filtres de post-compilation ont des concepts trés
|
||||
Les filtres de pré-compilation et les filtres de post-compilation ont des concepts très
|
||||
proches. Ils différent dans leur exécution, plus précisément dans le
|
||||
moment oú ils sont exécutés.
|
||||
moment où ils sont exécutés.
|
||||
</para>
|
||||
<funcsynopsis>
|
||||
<funcprototype>
|
||||
@@ -17,9 +17,9 @@
|
||||
</funcsynopsis>
|
||||
<para>
|
||||
Les filtres de pré-compilation sont utilisés pour transformer la source d'un template
|
||||
juste avant la compilation. Le premier paramétre passé a la fonction
|
||||
juste avant la compilation. Le premier paramètre passé à la fonction
|
||||
de filtre de pré-compilation est la source du template, éventuellement modifiée par
|
||||
d'autres filtre de pré-compilations. Le plugin est supposé retourner la source modifiée.
|
||||
d'autres filtres de pré-compilations. Le plugin est supposé retourner la source modifiée.
|
||||
Notez que cette source n'est sauvegardée nulle part, elle est seulement
|
||||
utilisé pour la compilation.
|
||||
</para>
|
||||
@@ -32,16 +32,17 @@
|
||||
</funcsynopsis>
|
||||
<para>
|
||||
Les filtres de post-compilation sont utilisés pour modifier la sortie du template
|
||||
(le code PHP) juste aprés que la compilation a été faite mais juste
|
||||
avant que le template ne soit sauvegardé sur le systéme de fichiers.
|
||||
Le premier paramétre passé a la fonction de filtre de post-compilation est le code
|
||||
du template compilé, éventuellement déja modifié par d'autres filtre de post-compilations.
|
||||
Le plugin est censé retourner la version modifié du code.
|
||||
(le code PHP) juste après que la compilation a été faîte mais juste
|
||||
avant que le template ne soit sauvegardé sur le système de fichiers.
|
||||
Le premier paramètre passé à la fonction de filtre de post-compilation est le code
|
||||
du template compilé, éventuellement déja modifié par d'autres filtres de post-compilations.
|
||||
Le plugin est censé retourner la version modifiée du code.
|
||||
</para>
|
||||
<example>
|
||||
<title>plugin de filtre de post-compilation</title>
|
||||
<programlisting>
|
||||
<?php
|
||||
<title>Plugin de filtre de post-compilation</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
@@ -51,17 +52,19 @@
|
||||
* Rôle : Passe les balises HTML en minuscules.
|
||||
* -------------------------------------------------------------
|
||||
*/
|
||||
function smarty_prefilter_pre01($source, &$smarty)
|
||||
function smarty_prefilter_pre01($source, &$smarty)
|
||||
{
|
||||
return preg_replace('!<(\w+)[^>]+>!e', 'strtolower("$1")', $source);
|
||||
return preg_replace('!<(\w+)[^>]+>!e', 'strtolower("$1")', $source);
|
||||
}
|
||||
?></programlisting>
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
<para></para>
|
||||
<example>
|
||||
<title>plugin de filtre de post-compilation</title>
|
||||
<programlisting>
|
||||
<?php
|
||||
<title>Plugin de filtre de post-compilation</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
@@ -72,12 +75,14 @@
|
||||
* du template.
|
||||
* -------------------------------------------------------------
|
||||
*/
|
||||
function smarty_postfilter_post01($compiled, &$smarty)
|
||||
function smarty_postfilter_post01($compiled, &$smarty)
|
||||
{
|
||||
$compiled = "<pre>\n<?php print_r(\$this->get_template_vars()); ?>\n</pre>" . $compiled;
|
||||
$compiled = "<pre>\n<?php print_r(\$this->get_template_vars()); ?>\n</pre>" . $compiled;
|
||||
return $compiled;
|
||||
}
|
||||
?></programlisting>
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<!-- Keep this comment at the end of the file
|
||||
|
||||
@@ -1,18 +1,17 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial -->
|
||||
<!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
|
||||
<sect1 id="plugins.resources"><title>Ressources</title>
|
||||
<para>
|
||||
Les plugins ressources sont un moyen générique de fournir des sources
|
||||
de templates ou des composants de scripts PHP a Smarty. Quelques exemples
|
||||
de ressources : bases de données, LDAP, mémoire partagée, sockets, et ainsi
|
||||
de suite.
|
||||
de templates ou des composants de scripts PHP à Smarty. Quelques exemples
|
||||
de ressources : bases de données, LDAP, mémoire partagée, sockets, etc.
|
||||
</para>
|
||||
<para>
|
||||
Il y au total 4 fonctions qui ont besoin d'être enregistrées pour
|
||||
chaque type de ressource. Chaque fonction retoit le nom de la ressource demandée
|
||||
comme premier paramétre et l'objet Smarty comme dernier paramétre.
|
||||
Les autres paramétres dépendent de la fonction.
|
||||
chaque type de ressource. Chaque fonction reçoit le nom de la ressource demandée
|
||||
comme premier paramètre et l'objet Smarty comme dernier paramètre.
|
||||
Les autres paramètres dépendent de la fonction.
|
||||
</para>
|
||||
<funcsynopsis>
|
||||
<funcprototype>
|
||||
@@ -40,31 +39,31 @@
|
||||
</funcsynopsis>
|
||||
|
||||
<para>
|
||||
La premiére fonction est supposée récupérer la ressource. Son second
|
||||
paramétre est une variable passée par référence oú le résultat doit être
|
||||
La première fonction est supposée récupérer la ressource. Son second
|
||||
paramètre est une variable passée par référence où le résultat doit être
|
||||
stocké. La fonction est supposée retourner <literal>true</literal> si
|
||||
elle réussi a récupérer la ressource et <literal>false</literal> sinon.
|
||||
elle réussit à récupérer la ressource et <literal>false</literal> sinon.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
La seconde fonction est supposée récupérer la date de derniére modification
|
||||
de la ressource demandée (comme un timestamp UNIX). Le second paramétre
|
||||
La seconde fonction est supposée récupérer la date de dernière modification
|
||||
de la ressource demandée (comme un timestamp UNIX). Le second paramètre
|
||||
est une variable passée par référence dans laquelle la date doit
|
||||
être stockée. La fonction est supposée renvoyer <literal>true</literal> si elle
|
||||
a réussi a récupérer la date et <literal>false</literal> sinon.
|
||||
réussit à récupérer la date et <literal>false</literal> sinon.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
La troisiéme fonction est supposée retourner <literal>true</literal>
|
||||
ou <literal>false</literal> selon si la ressource demandée est svre
|
||||
La troisième fonction est supposée retourner <literal>true</literal>
|
||||
ou <literal>false</literal> selon si la ressource demandée est sûre
|
||||
ou non. La fonction est utilisée seulement pour les ressources templates
|
||||
mais doit tout de même être définie.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
La quatriéme fonction est supposée retourner <literal>true</literal>
|
||||
ou <literal>false</literal> selon si on peut faire confiance ou
|
||||
non a la ressource demandée. Cette fonction est utilisée seulement
|
||||
La quatrième fonction est supposée retourner <literal>true</literal>
|
||||
ou <literal>false</literal> selon si l'on peut faire confiance ou
|
||||
non à la ressource demandée. Cette fonction est utilisée seulement
|
||||
pour les composants de scripts PHP demandés par les balises
|
||||
<command>include_php</command> ou <command>insert</command>
|
||||
ayant un attribut <structfield>src</structfield>. Quoiqu'il en soit,
|
||||
@@ -72,14 +71,15 @@
|
||||
</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
|
||||
Lisez également
|
||||
<link linkend="api.register.resource">register_resource()</link> et
|
||||
<link linkend="api.unregister.resource">unregister_resource()</link>.
|
||||
</para>
|
||||
<example>
|
||||
<title>resource plugin</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
/*
|
||||
* Smarty plugin
|
||||
* -------------------------------------------------------------
|
||||
@@ -89,7 +89,7 @@
|
||||
* Rôle : Récupére des templates depuis une base de données
|
||||
* -------------------------------------------------------------
|
||||
*/
|
||||
function smarty_resource_db_source($tpl_name, &$tpl_source, &$smarty)
|
||||
function smarty_resource_db_source($tpl_name, &$tpl_source, &$smarty)
|
||||
{
|
||||
// fait des requêtes BD pour récupérer votre template
|
||||
// et remplir $tpl_source
|
||||
@@ -105,7 +105,7 @@ function smarty_resource_db_source($tpl_name, &$tpl_source, &$smarty)
|
||||
}
|
||||
}
|
||||
|
||||
function smarty_resource_db_timestamp($tpl_name, &$tpl_timestamp, &$smarty)
|
||||
function smarty_resource_db_timestamp($tpl_name, &$tpl_timestamp, &$smarty)
|
||||
{
|
||||
// fait des requêtes BD pour remplir $tpl_timestamp
|
||||
$sql = new SQL;
|
||||
@@ -120,19 +120,21 @@ function smarty_resource_db_timestamp($tpl_name, &$tpl_timestamp, &$smar
|
||||
}
|
||||
}
|
||||
|
||||
function smarty_resource_db_secure($tpl_name, &$smarty)
|
||||
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)
|
||||
function smarty_resource_db_trusted($tpl_name, &$smarty)
|
||||
{
|
||||
// inutilisée pour les templates
|
||||
}
|
||||
?></programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
|
||||
@@ -1,30 +1,34 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial -->
|
||||
<!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
|
||||
<sect1 id="plugins.writing">
|
||||
<title>Ecrire des plugins</title>
|
||||
<para>
|
||||
Les plugins peuvent être soit chargés automatiquement par Smarty
|
||||
depuis le systéme de fichier, soit être déclarés
|
||||
depuis le système de fichier, soit être déclarés
|
||||
pendant l'exécution via une fonction register_* de l'API. Ils peuvent
|
||||
aussi être désalloués en utilisant une fonction unregister_* de
|
||||
l'API.
|
||||
</para>
|
||||
<para>
|
||||
Pour les plugins qui ne sont pas enregistrés pendant l'exécution, le nom
|
||||
des fonctions n'ont pas a suivre la convention de nommage.
|
||||
des fonctions n'ont pas à suivre la convention de nommage.
|
||||
</para>
|
||||
<para>
|
||||
Si certaines fonctionnalités d'un plugin dépendent d'un autre plugin
|
||||
(comme c'est le cas de certains plugins accompagnant Smarty), alors la maniére appropriée
|
||||
de charger le plugin est la suivante :
|
||||
(comme c'est le cas de certains plugins accompagnant Smarty), alors
|
||||
la maniére appropriée de charger le plugin est la suivante :
|
||||
</para>
|
||||
|
||||
<programlisting>
|
||||
require_once SMARTY_DIR . 'plugins/function.html_options.php';</programlisting>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
require_once $smarty->_get_plugin_filepath('function', 'html_options');
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
<para>
|
||||
Une régle générale est que chaque objet Smarty est toujours passé au plugin
|
||||
en tant que dernier paramétre (a part pour les modificateurs).
|
||||
Une règle générale est que chaque objet Smarty est toujours passé au plugin
|
||||
en tant que dernier paramètre (à part pour les modificateurs).
|
||||
</para>
|
||||
</sect1>
|
||||
<!-- Keep this comment at the end of the file
|
||||
|
||||
Reference in New Issue
Block a user