smarty-php/smarty
1
0
Fork 0
mirror of https://github.com/smarty-php/smarty.git synced 2025-08-06 03:14:27 +02:00
Code Issues Packages Projects Releases Wiki Activity

sync with EN & typo

Browse Source
This commit is contained in:
yannick
2004-12-26 20:05:31 +00:00
parent ee6a5a5cf2
commit 2504b1b6c4
17 changed files with 579 additions and 452 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
docs/fr/language-defs.ent
View File

@@ -1,4 +1,5 @@
<!-- $Revision$ --> <!-- $Revision$ -->
<!-- EN-Revision: 1.1 Maintainer: yannick Status: ready -->
<!ENTITY SMARTYManual "Smarty - le moteur et compilateur de template PHP"> <!ENTITY SMARTYManual "Smarty - le moteur et compilateur de template PHP">
<!ENTITY SMARTYDesigners "Smarty pour les graphistes"> <!ENTITY SMARTYDesigners "Smarty pour les graphistes">

27
docs/fr/language-snippets.ent
View File

@@ -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<61>tre <parameter>merge</parameter> respecte les cl<63>s du tableau,
donc, si vous fusionnez deux tableaux index<65>s num<75>riquement, ils peuvent
se recouvrir les uns les autres ou aboutir <20> des cl<63>s non s<>quentielles. Ceci
est dif<69>rent de la fonction PHP array_merge() qui <20>limine des cl<63>s num<75>riques
et les renum<75>rote.
</para>
</note>'>
<!ENTITY parameter.compileid '<para>
En tant que troisi<73>me param<61>tre optionnel, vous pouvez passer un
identifiant de compilation <parameter>compile_id</parameter>.
C&#39;est au cas o<> vous voudriez compiler plusieurs versions du
m<>me template, par exemple, pour avoir des templates compil<69>s
pour diff<66>rents langages. Une autre utilit<69> pour l&#39;identifiant de compilation
compile_id est lorsque vous utilisez plus d&#39;un $template_dir mais
seulement un $compile_dir. D<>finissez un <parameter>compile_id</parameter>
s<>par<61> pour chaque $template_dir, sinon, les templates du m<>me nom
s&#39;effaceront. Vous pouvez <20>galement d<>finir la variable
<link linkend="variable.compile.id">$compile_id</link> une seule fois
plut<75>t que de la passer <20> chaque appel <20> la fonction.
</para>'>

2
docs/fr/livedocs.ent
View File

@@ -1,5 +1,5 @@
<!-- $Revision$ --> <!-- $Revision$ -->
<!-- EN-Revision: 1.1 Maintainer: didou status: ready --> <!-- EN-Revision: 1.1 Maintainer: didou Status: ready -->
<!ENTITY livedocs.author 'Auteurs :<br />'> <!ENTITY livedocs.author 'Auteurs :<br />'>
<!ENTITY livedocs.editors 'Editeurs :<br />'> <!ENTITY livedocs.editors 'Editeurs :<br />'>

53
docs/fr/programmers/caching/caching-groups.xml
View File

@@ -1,17 +1,43 @@
<?xml version="1.0" encoding="iso-8859-1"?> <?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision$ --> <!-- $Revision$ -->
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial --> <!-- EN-Revision: 1.3 Maintainer: yannick Status: ready -->
<sect1 id="caching.groups"> <sect1 id="caching.groups">
<title>groupes de fichiers de cache</title> <title>Groupes de fichiers de cache</title>
<para> <para>
Vous pouvez faire des groupements plus <20>labor<6F>s en param<61>trant les Vous pouvez faire des groupements plus <20>labor<6F>s en param<61>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. avec une barre verticale "|" dans la valeur de l'identifiant de cache.
Vous pouvez faire autant de sous-groupes que vous le d<>sirez. Vous pouvez faire autant de sous-groupes que vous le d<>sirez.
</para> </para>
<para>
Vous pouvez voir les groupes de cache comme une hi<68>rarchie de dossiers.
Par exemple, un groupe de cache "a|b|c" peut <20>tre consid<69>r<EFBFBD> comme
la hi<68>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<73>cifiez un compile_id de cette fa<66>on : clear_cache(null,"a|b","foo"),
il sera trait<69> comme un groupe de cache appos<6F> "/a/b/c/foo/". Si vous
sp<73>cifiez un nom de template de cette fa<66>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<73>cifi<66> sous un groupe de cache multiple comme
"/a/b/*/foo.tpl", le groupement de cache fonctionne UNIQUEMENT de gauche <20> droite.
Vous pourriez vouloir grouper vos templates sous un groupe de cache simple
hi<68>rarchis<69> pour <20>tre capable de les effacer comme un groupe.
</para>
<para>
Le groupement de cache ne devrait pas <20>tre confondu avec votre hi<68>rarchie
de dossiers de templates, le groupement de cache n'a aucune connaissance
de la fa<66>on dont vos templates sont structur<75>s. Donc, par exemple, si
vous avez une structure de template comme "themes/blue/index.tpl" et
que vous voulez <20>tre capable d'effacer tous les fichiers de cache pour le th<74>me "blue",
vous devriez cr<63>er une structure de groupe de cache qui refl<66>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> <example>
<title>groupes d'identifiants de cache</title> <title>Groupes d'identifiants de cache</title>
<programlisting> <programlisting role="php">
<![CDATA[
<?php
require('Smarty.class.php'); require('Smarty.class.php');
$smarty = new Smarty; $smarty = new Smarty;
@@ -25,20 +51,11 @@ $smarty->clear_cache(null,"sports|basketball");
// Inclue donc "sports|basketball" ou "sports|nimportequoi|nimportequoi|..." // Inclue donc "sports|basketball" ou "sports|nimportequoi|nimportequoi|..."
$smarty->clear_cache(null,"sports"); $smarty->clear_cache(null,"sports");
$smarty->display('index.tpl',"sports|basketball");</programlisting> $smarty->display('index.tpl',"sports|basketball");
?>
]]>
</programlisting>
</example> </example>
<note>
<title>Note technique</title>
<para>
Le syst<73>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> </sect1>
<!-- Keep this comment at the end of the file <!-- Keep this comment at the end of the file
Local variables: Local variables:

10
docs/fr/programmers/caching/caching-multiple-caches.xml
View File

@@ -57,7 +57,7 @@ $smarty->display('index.tpl',$my_cache_id);
<link linkend="api.clear.cache">clear_cache()</link>. <link linkend="api.clear.cache">clear_cache()</link>.
</para> </para>
<example> <example>
<title>passer un cache_id a is_cached()</title> <title>Passer un cache_id a is_cached()</title>
<programlisting> <programlisting>
<![CDATA[ <![CDATA[
require('Smarty.class.php'); require('Smarty.class.php');
@@ -68,9 +68,9 @@ $smarty->caching = true;
$my_cache_id = $_GET['article_id']; $my_cache_id = $_GET['article_id'];
if(!$smarty->is_cached('index.tpl',$my_cache_id)) { if(!$smarty->is_cached('index.tpl',$my_cache_id)) {
// pas de fichier de cache dispo, on assigne donc les variables // pas de fichier de cache dispo, on assigne donc les variables
$contents = get_database_contents(); $contents = get_database_contents();
$smarty->assign($contents); $smarty->assign($contents);
} }
$smarty->display('index.tpl',$my_cache_id); $smarty->display('index.tpl',$my_cache_id);
@@ -83,7 +83,7 @@ $smarty->display('index.tpl',$my_cache_id);
a clear_cache(). a clear_cache().
</para> </para>
<example> <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> <programlisting>
<![CDATA[ <![CDATA[
require('Smarty.class.php'); require('Smarty.class.php');

201
docs/fr/programmers/caching/caching-setting-up.xml
View File

@@ -1,53 +1,60 @@
<?xml version="1.0" encoding="iso-8859-1"?> <?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision$ --> <!-- $Revision$ -->
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial --> <!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
<sect1 id="caching.setting.up"> <sect1 id="caching.setting.up">
<title>Param<EFBFBD>trer le cache</title> <title>Param<EFBFBD>trer le cache</title>
<para> <para>
La premi<6D>re chose a faire est d'activer le cache. Cela est fait en La premi<6D>re chose <EFBFBD> faire est d'activer le cache. Cela est fait en
mettant <link linkend="variable.caching">$caching</link> = true mettant <link linkend="variable.caching">$caching</link> = true
(ou 1). (ou 1).
</para> </para>
<example> <example>
<title>activation du cache</title> <title>Activation du cache</title>
<programlisting> <programlisting role="php">
<![CDATA[
<?php
require('Smarty.class.php'); require('Smarty.class.php');
$smarty = new Smarty; $smarty = new Smarty;
$smarty->caching = true; $smarty->caching = true;
$smarty->display('index.tpl');</programlisting> $smarty->display('index.tpl');
?>
]]>
</programlisting>
</example> </example>
<para> <para>
Avec le cache activ<69>, la fonction display('index.tpl') va afficher Avec le cache activ<69>, la fonction display('index.tpl') va afficher
le template mais sauvegardera par la m<>me occasion une copie du r<>sultat le template mais sauvegardera par la m<>me occasion une copie du r<>sultat
dans un fichier (de cache) du r<>pertoire dans un fichier (de cache) du r<>pertoire
<link linkend="variable.cache.dir">$cache_dir</link>. Au prochain appel de <link linkend="variable.cache.dir">$cache_dir</link>. Au prochain appel de
display('index.tpl'), le fichier de cache sera pr<70>f<EFBFBD>r<EFBFBD> a la r<>utilisation display('index.tpl'), le fichier de cache sera pr<70>f<EFBFBD>r<EFBFBD> <EFBFBD> la r<>utilisation
du template. du template.
</para> </para>
<note> <note>
<title>Note technique</title> <title>Note technique</title>
<para>
Les fichiers situ<74>s dans $cache_dir sont nomm<6D>s de la m<>me faton que les templates.
Bien qu'ils aient une extension ".php", ils ne sont pas vraiment ex<65>cutable.
N'<27>ditez surtout pas ces fichiers !
</para>
</note>
<para> <para>
Tout fichier de cache a une dur<75>e de vie limit<69>e d<>termin<69>e par <link Les fichiers situ<74>s dans $cache_dir sont nomm<6D>s de la m<>me fa<66>on que les templates.
linkend="variable.cache.lifetime">$cache_lifetime</link>. La valeur par Bien qu'ils aient une extension ".php", ils ne sont pas vraiment ex<65>cutable.
d<EFBFBD>faut est 3600 secondes, i.e. 1 heure. Une fois que cette dur<75>e est N'<27>ditez surtout pas ces fichiers !
d<>pass<73>e, le cache est reg<65>n<EFBFBD>r<EFBFBD>. Il est possible de donner
une dur<75>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.
</para> </para>
<example> </note>
<title>r<EFBFBD>glage individuel de cache_lifetime</title> <para>
<programlisting> Tout fichier de cache a une dur<75>e de vie limit<69>e d<>termin<69>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<75>e est
d<>pass<73>e, le cache est reg<65>n<EFBFBD>r<EFBFBD>. Il est possible de donner
une dur<75>e d'expiration propre <20> chaque fichier de cache en r<>glant
$caching = 2.
Se reporter <20> la documentation de <link
linkend="variable.cache.lifetime">$cache_lifetime</link> pour plus de
d<>tails.
</para>
<example>
<title>R<EFBFBD>glage individuel de cache_lifetime</title>
<programlisting role="php">
<![CDATA[
<?php
require('Smarty.class.php'); require('Smarty.class.php');
$smarty = new Smarty; $smarty = new Smarty;
@@ -66,45 +73,55 @@ $smarty->display('home.tpl');
// plus la valeur de $cache_lifetime. Le cache de home.tpl expirera toujours // plus la valeur de $cache_lifetime. Le cache de home.tpl expirera toujours
// dans 1 heure. // dans 1 heure.
$smarty->cache_lifetime = 30; // 30 secondes $smarty->cache_lifetime = 30; // 30 secondes
$smarty->display('home.tpl');</programlisting> $smarty->display('home.tpl');
</example> ?>
<para> ]]>
Si <link linkend="variable.compile.check">$compile_check</link> est actif, </programlisting>
chaque fichier de template et de configuration qui a un rapport </example>
avec le fichier de cache sera v<>rifi<66> pour d<>tecter une <20>ventuelle <para>
modification. Si l'un de ces fichiers a <20>t<EFBFBD> modifi<66> depuis que le fichier de cache a <20>t<EFBFBD> Si <link linkend="variable.compile.check">$compile_check</link> est actif,
g<>n<EFBFBD>r<EFBFBD>, le cache est imm<6D>diatement reg<65>n<EFBFBD>r<EFBFBD>. Ce processus est covteux, donc, chaque fichier de template et de configuration qui a un rapport
pour des raisons de performances, mettez ce param<61>tre a false pour une application avec le fichier de cache sera v<>rifi<66> pour d<>tecter une <20>ventuelle
en production. modification. Si l'un de ces fichiers a <20>t<EFBFBD> modifi<66> depuis que le fichier de cache a <20>t<EFBFBD>
</para> g<EFBFBD>n<EFBFBD>r<EFBFBD>, le cache est imm<6D>diatement reg<65>n<EFBFBD>r<EFBFBD>. Ce processus est couteux, donc,
<example> pour des raisons de performances, mettez ce param<61>tre <20> false pour une application
<title>activation de $compile_check</title> en production.
<programlisting> </para>
<example>
<title>Activation de $compile_check</title>
<programlisting role="php">
<![CDATA[
<?php
require('Smarty.class.php'); require('Smarty.class.php');
$smarty = new Smarty; $smarty = new Smarty;
$smarty->caching = true; $smarty->caching = true;
$smarty->compile_check = true; $smarty->compile_check = true;
$smarty->display('index.tpl');</programlisting> $smarty->display('index.tpl');
</example> ?>
<para> ]]>
Si <link linkend="variable.force.compile">$force_compile</link> est actif, </programlisting>
les fichiers de cache sont toujours reg<65>n<EFBFBD>r<EFBFBD>s. Ceci revient finalement a </example>
d<>sactiver le cache. $force_compile est utilis<69> a des fins de d<>bogage, <para>
un moyen plus efficace de d<>sactiver le cache est de r<>gler Si <link linkend="variable.force.compile">$force_compile</link> est actif,
<link linkend="variable.caching">$caching</link> = false (ou 0). les fichiers de cache sont toujours reg<65>n<EFBFBD>r<EFBFBD>s. Ceci revient finalement <20>
</para> d<EFBFBD>sactiver le cache. $force_compile est utilis<69> <20> des fins de d<>bogage,
<para> un moyen plus efficace de d<>sactiver le cache est de r<>gler
La fonction <link linkend="api.is.cached">is_cached()</link> permet <link linkend="variable.caching">$caching</link> = false (ou 0).
de tester si un template a ou non un fichier de cache valide. </para>
Si vous disposez d'un template en cache qui requiert une requ<71>te <para>
a une base de donn<6E>es, vous pouvez utiliser cette m<>thode plut(t La fonction <link linkend="api.is.cached">is_cached()</link> permet
que $compile_check. de tester si un template a ou non un fichier de cache valide.
</para> Si vous disposez d'un template en cache qui requiert une requ<71>te
<example> <EFBFBD> une base de donn<6E>es, vous pouvez utiliser cette m<>thode plut<75>t
<title>utilisation de is_cached()</title> que $compile_check.
<programlisting> </para>
<example>
<title>Exemple avec is_cached()</title>
<programlisting role="php">
<![CDATA[
<?php
require('Smarty.class.php'); require('Smarty.class.php');
$smarty = new Smarty; $smarty = new Smarty;
@@ -112,32 +129,37 @@ $smarty->caching = true;
if(!$smarty->is_cached('index.tpl')) { if(!$smarty->is_cached('index.tpl')) {
// pas de cache disponible, on assigne // pas de cache disponible, on assigne
$contents = get_database_contents(); $contents = get_database_contents();
$smarty->assign($contents); $smarty->assign($contents);
} }
$smarty->display('index.tpl');</programlisting> $smarty->display('index.tpl');
</example> ?>
<para> ]]>
Vous pouvez rendre dynamiques seulement certaines parties d'une </programlisting>
page avec la fonction de templates <link </example>
linkend="language.function.insert">insert</link>. <para>
Imaginons que toute une page doit <20>tre mise en cache a part Vous pouvez rendre dynamiques seulement certaines parties d'une
une banni<6E>re en bas a droite. En utilisant une fonction insert pour la page avec la fonction de template <link
banni<6E>re, vous pouvez garder cet <20>l<EFBFBD>ment dynamique dans le contenu qui linkend="language.function.insert">insert</link>.
est en cache. Reportez-vous a la documentation Imaginons que toute une page doit <20>tre mise en cache <20> part
<link linkend="language.function.insert">insert</link> pour plus de d<>tails une banni<6E>re en bas <20> droite. En utilisant une fonction insert pour la
et des exemples. banni<EFBFBD>re, vous pouvez garder cet <20>l<EFBFBD>ment dynamique dans le contenu qui
</para> est en cache. Reportez-vous <20> la documentation
<para> <link linkend="language.function.insert">insert</link> pour plus de d<>tails
Vous pouvez effacer tous les fichiers du cache avec la fonction <link ainsi que des exemples.
linkend="api.clear.all.cache">clear_all_cache(),</link> ou de faton </para>
individuelle (ou par groupe) avec la fonction <link <para>
linkend="api.clear.cache">clear_cache()</link>. Vous pouvez effacer tous les fichiers du cache avec la fonction <link
</para> linkend="api.clear.all.cache">clear_all_cache()</link>, ou de fa<66>on
<example> individuelle (ou par groupe) avec la fonction <link
<title>nettoyage du cache</title> linkend="api.clear.cache">clear_cache()</link>.
<programlisting> </para>
<example>
<title>Nettoyage du cache</title>
<programlisting role="php">
<![CDATA[
<?php
require('Smarty.class.php'); require('Smarty.class.php');
$smarty = new Smarty; $smarty = new Smarty;
@@ -149,9 +171,12 @@ $smarty->clear_all_cache();
// efface le fichier de cache du template 'index.tpl' // efface le fichier de cache du template 'index.tpl'
$smarty->clear_cache('index.tpl'); $smarty->clear_cache('index.tpl');
$smarty->display('index.tpl');</programlisting> $smarty->display('index.tpl');
</example> ?>
</sect1> ]]>
</programlisting>
</example>
</sect1>
<!-- Keep this comment at the end of the file <!-- Keep this comment at the end of the file
Local variables: Local variables:
mode: sgml mode: sgml

137
docs/fr/programmers/plugins/plugins-block-functions.xml
View File

@@ -1,61 +1,79 @@
<?xml version="1.0" encoding="iso-8859-1"?> <?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision$ --> <!-- $Revision$ -->
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial --> <!-- EN-Revision: 1.3 Maintainer: yannick Status: ready -->
<sect1 id="plugins.block.functions"><title>Fonctions de blocs</title> <sect1 id="plugins.block.functions">
<funcsynopsis> <title>Fonctions de blocs</title>
<funcprototype> <funcsynopsis>
<funcdef>void <function>smarty_block_<replaceable>name</replaceable></function></funcdef> <funcprototype>
<paramdef>array <parameter>$params</parameter></paramdef> <funcdef>void <function>smarty_block_<replaceable>name</replaceable></function></funcdef>
<paramdef>mixed <parameter>$content</parameter></paramdef> <paramdef>array <parameter>$params</parameter></paramdef>
<paramdef>object <parameter>&amp;$smarty</parameter></paramdef> <paramdef>mixed <parameter>$content</parameter></paramdef>
</funcprototype> <paramdef>object <parameter>&amp;$smarty</parameter></paramdef>
</funcsynopsis> </funcprototype>
<para> </funcsynopsis>
Les fonctions de blocs sont des fonctions de la forme {func} .. {/func}. <para>
En d'autres mots, elles englobent des blocs de template et op<6F>rent sur les Les fonctions de blocs sont des fonctions de la forme {func} .. {/func}.
contenus de ces blocs. Les fonctions de blocs ont la priorit<69> sur les En d'autres mots, elles englobent des blocs de template et op<6F>rent sur les
fonctions utilisateurs de m<>me nom, ce qui signifie que vous ne contenus de ces blocs. Les fonctions de blocs ont la priorit<69> sur les
pouvez avoir une fonction utilisateur {func} et une fonction de bloc fonctions utilisateurs de m<>me nom, ce qui signifie que vous ne
{func} .. {/func}. pouvez avoir une fonction utilisateur {func} et une fonction de bloc
</para> {func} .. {/func}.
<para> </para>
L'impl<70>mentation de votre fonction est appel<65>e deux fois par Smarty : <para>
une fois pour la balise ouvrante et une autre fois pour la balise Par d<>faut, l'impl<70>mentation de votre fonction est appel<EFBFBD>e deux fois par Smarty :
fermante. une fois pour la balise ouvrante et une autre fois pour la balise
</para> fermante (voir <literal>&amp;$repeat</literal> ci-dessous
<para> sur la fa<66>on de modifier ce comportement).
Seule la balise ouvrante d'une fonction de bloc peut avoir des attributs. </para>
Tous les attributs pass<73>s par le template aux fonctions de templates sont <para>
contenues dans le tableau associatif <parameter>$params</parameter>. Seule la balise ouvrante d'une fonction de bloc peut avoir des attributs.
Vous pouvez acc<63>der a ces valeurs soit directement, par exemple Tous les attributs pass<73>s par le template aux fonctions de templates sont
<varname>$params['start']</varname>, soit en utilisant contenus dans le tableau associatif <parameter>$params</parameter>.
<varname>extract($params)</varname> pour les importer dans la table Vous pouvez acc<63>der <20> ces valeurs directement par
des symboles. Votre fonction a aussi acc<63>s aux attributs de la balise <varname>$params['start']</varname>.
ouvrante quand c'est la balise fermante qui est ex<65>cut<75>e. Votre fonction a aussi acc<63>s aux attributs de la balise
</para> ouvrante quand c'est la balise fermante qui est ex<65>cut<75>e.
<para> </para>
La valeur de la variable <parameter>$content</parameter> est diff<66>rente <para>
selon si votre fonction est appel<65>e pour la balise ouvrante ou la La valeur de la variable <parameter>$content</parameter> est diff<66>rente
balise fermante. Si c'est pour la balise ouvrante, elle sera a selon si votre fonction est appel<65>e pour la balise ouvrante ou la
<literal>null</literal> et si c'est la balise fermante elle sera balise fermante. Si c'est pour la balise ouvrante, elle sera <20>
<EFBFBD>gale au contenu du bloc de template. Notez que le bloc de template <literal>null</literal> et si c'est la balise fermante, elle sera
aura d<>j<EFBFBD> <20>t<EFBFBD> ex<65>cut<75> par Smarty, vous recevrez donc la sortie du <20>gale au contenu du bloc de template. Notez que le bloc de template
template et non sa source. aura d<>j<EFBFBD> <20>t<EFBFBD> ex<65>cut<75> par Smarty, vous recevrez donc la sortie du
</para> template et non sa source.
<para> </para>
Si vous imbriqu<71> des fonctions de bloc, il est possible de connaetre
la fonction de bloc parente grGce a la variable <varname>$smarty->_tag_stack</varname>. <para>
Faites un var_dump() dessus et la structure devrait apparaetre. Le param<61>tre <parameter>&amp;$repeat</parameter> est pass<73>
</para> par r<>f<EFBFBD>rence <20> la fonction d'impl<70>mentation et fournit la possibilit<69>
<para> de contr<74>ler le nombre d'affichage du bloc. Par d<>faut,
Regardez aussi : <parameter>$repeat</parameter> vaut <literal>true</literal>
<link linkend="api.register.block">register_block()</link>, lors du premier appel <20> la fonction de bloc (le bloc d'ouverture du tag) et
<literal>false</literal> lors de tous les autres appels <20> la fonction
de bloc (le bloc de fermeture du tag). Chaque fois que la fonction
d'impl<70>mentation retourne avec le param<61>tre
<parameter>&amp;$repeat</parameter> vallant true, le contenu situ<74>
entre {func} .. {/func} est <20>valu<6C> et la fonction d'impl<70>mentation est appel<65>
une nouvelle fois avec le nouveau bloc de contenu en tant que param<61>tre
<parameter>$content</parameter>.
</para>
<para>
Si vous imbriqu<71> des fonctions de bloc, il est possible de conna<6E>tre
la fonction de bloc parente gr<67>ce <20> la variable <varname>$smarty->_tag_stack</varname>.
Fa<46>tes un var_dump() dessus et la structure devrait appara<72>tre.
</para>
<para>
Regardez aussi :
<link linkend="api.register.block">register_block()</link>,
<link linkend="api.unregister.block">unregister_block()</link>. <link linkend="api.unregister.block">unregister_block()</link>.
</para> </para>
<example> <example>
<title>fonction de bloc</title> <title>Fonction de bloc</title>
<programlisting> <programlisting role="php">
&lt;?php <![CDATA[
<?php
/* /*
* Smarty plugin * Smarty plugin
* ------------------------------------------------------------- * -------------------------------------------------------------
@@ -72,9 +90,12 @@ function smarty_block_translate($params, $content, &amp;$smarty)
// fait une traduction de $content // fait une traduction de $content
echo $translation; echo $translation;
} }
}</programlisting> }
</example> ?>
</sect1> ]]>
</programlisting>
</example>
</sect1>
<!-- Keep this comment at the end of the file <!-- Keep this comment at the end of the file
Local variables: Local variables:
mode: sgml mode: sgml

95
docs/fr/programmers/plugins/plugins-compiler-functions.xml
View File

@@ -1,36 +1,37 @@
<?xml version="1.0" encoding="iso-8859-1"?> <?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision$ --> <!-- $Revision$ -->
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial --> <!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
<sect1 id="plugins.compiler.functions"><title>Fonctions de compilation</title> <sect1 id="plugins.compiler.functions">
<para> <title>Fonctions de compilation</title>
Les fonctions de compilation sont appel<65>es durant la compilation du template. <para>
Elles sont utiles pour injecter du code PHP ou du contenu "statique variant Les fonctions de compilation sont appel<65>es durant la compilation du template.
avec le temps" (bandeau de pub par ex.). Si une fonction de compilation et Elles sont utiles pour injecter du code PHP ou du contenu "statique variant
une fonction personnalis<69>e ont le m<>me avec le temps" (bandeau de pub par ex.). Si une fonction de compilation et
nom, la fonction de compilation a priorit<69>. une fonction personnalis<69>e ont le m<>me nom, la fonction de compilation a priorit<69>.
</para> </para>
<funcsynopsis> <funcsynopsis>
<funcprototype> <funcprototype>
<funcdef>mixed <function>smarty_compiler_<replaceable>name</replaceable></function></funcdef> <funcdef>mixed <function>smarty_compiler_<replaceable>name</replaceable></function></funcdef>
<paramdef>string <parameter>$tag_arg</parameter></paramdef> <paramdef>string <parameter>$tag_arg</parameter></paramdef>
<paramdef>object <parameter>&amp;$smarty</parameter></paramdef> <paramdef>object <parameter>&amp;$smarty</parameter></paramdef>
</funcprototype> </funcprototype>
</funcsynopsis> </funcsynopsis>
<para> <para>
Les fonctions de compilation ont deux param<61>tres : une chaene contenant Les fonctions de compilation ont deux param<61>tres : une cha<EFBFBD>ne contenant
la balise - en gros, tout, depuis le nom de la fonction jusqu'au d<>limiteur de fin - et la balise - en gros, tout, depuis le nom de la fonction jusqu'au d<>limiteur de fin - et
l'objet Smarty. Elles sont cens<6E>es retourner le code PHP qui doit <20>tre l'objet Smarty. Elles sont cens<6E>es retourner le code PHP qui doit <20>tre
inject<63> dans le template compil<69>. inject<63> dans le template compil<69>.
</para> </para>
<para> <para>
Regardez aussi Regardez aussi
<link linkend="api.register.compiler.function">register_compiler_function()</link>, <link linkend="api.register.compiler.function">register_compiler_function()</link>,
<link linkend="api.unregister.compiler.function">unregister_compiler_function()</link>. <link linkend="api.unregister.compiler.function">unregister_compiler_function()</link>.
</para> </para>
<example> <example>
<title>fonction de compilation simple</title> <title>Fonction de compilation simple</title>
<programlisting> <programlisting role="php">
&lt;?php <![CDATA[
<?php
/* /*
* Smarty plugin * Smarty plugin
* ------------------------------------------------------------- * -------------------------------------------------------------
@@ -45,22 +46,28 @@ function smarty_compiler_tplheader($tag_arg, &amp;$smarty)
{ {
return "\necho '" . $smarty-&gt;_current_file . " compiled at " . date('Y-m-d H:M'). "';"; return "\necho '" . $smarty-&gt;_current_file . " compiled at " . date('Y-m-d H:M'). "';";
} }
?&gt;</programlisting> ?>
<para> ]]>
Cette fonction peut-<2D>tre appel<65> depuis le template comme suivant : </programlisting>
</para> <para>
<programlisting> Cette fonction peut-<2D>tre appel<65>e depuis le template comme suivant :
</para>
<programlisting>
{* cette fonction n'est execut<75>e que lors de la compilation *} {* cette fonction n'est execut<75>e que lors de la compilation *}
{tplheader}</programlisting> {tplheader}
<para> </programlisting>
Le code PHP r<>sultant dans les templates compil<69>s ressemblerait a ta : <para>
</para> Le code PHP r<>sultant dans les templates compil<69>s ressemblerait <20> <20>a :
<programlisting> </para>
&lt;php <programlisting role="php">
<![CDATA[
<?php
echo 'index.tpl compiled at 2002-02-20 20:02'; echo 'index.tpl compiled at 2002-02-20 20:02';
?&gt;</programlisting> ?>
</example> ]]>
</sect1> </programlisting>
</example>
</sect1>
<!-- Keep this comment at the end of the file <!-- Keep this comment at the end of the file
Local variables: Local variables:
mode: sgml mode: sgml

116
docs/fr/programmers/plugins/plugins-functions.xml
View File

@@ -1,43 +1,41 @@
<?xml version="1.0" encoding="iso-8859-1"?> <?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision$ --> <!-- $Revision$ -->
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial --> <!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
<sect1 id="plugins.functions"><title>Les fonctions de templates</title> <sect1 id="plugins.functions">
<funcsynopsis> <title>Les fonctions de templates</title>
<funcprototype> <funcsynopsis>
<funcdef>void <function>smarty_function_<replaceable>name</replaceable></function></funcdef> <funcprototype>
<paramdef>array <parameter>$params</parameter></paramdef> <funcdef>void <function>smarty_function_<replaceable>name</replaceable></function></funcdef>
<paramdef>object <parameter>&amp;$smarty</parameter></paramdef> <paramdef>array <parameter>$params</parameter></paramdef>
</funcprototype> <paramdef>object <parameter>&amp;$smarty</parameter></paramdef>
</funcsynopsis> </funcprototype>
<para> </funcsynopsis>
Tous les attributs pass<73>s aux fonctions de template a partir du template <para>
sont contenus dans le tableau associatif <parameter>$params</parameter>. Tous les attributs pass<73>s aux fonctions de template <20> partir du template
Vous pouvez acc<63>der a ces valeurs soit directement, par exemple sont contenus dans le tableau associatif <parameter>$params</parameter>.
<varname>$params['start']</varname>, soit en utilisant </para>
<varname>extract($params)</varname> pour les importer dans la table <para>
des symboles. Le retour de la fonction sera substitu<74>e <20> la balise de fonction
</para> du template (fonction <function>fetch</function> par exemple). Sinon,
<para> la fonction peut simplement accomplir une autre t<>che sans sortie
Le retour de la fonction sera substitu<74>e a la balise de fonction (la fonction <function>assign</function> par exemple).
du template (fonction <function>fetch</function> par exemple). Sinon, </para>
la fonction peut simplement accomplir une autre tGche sans sortie <para>
(la fonction <function>assign</function> par exemple) Si la fonction a besoin d'assigner des variables aux templates ou d'utiliser
</para> d'autres fonctionnalit<69>s fournies par Smarty, elle peut recevoir un
<para> objet <parameter>$smarty</parameter> pour cel<65>.
Si la fonction a besoin d'assigner des variables aux templates ou d'utiliser </para>
d'autres fonctionnalit<69>s fournies par Smarty, elle peut recevoir un <para>
objet <parameter>$smarty</parameter> pour cela. R<>f<EFBFBD>rez-vous aussi <20> :
</para> <link linkend="api.register.function">register_function()</link>,
<para>
R<>f<EFBFBD>rez-vous aussi a :
<link linkend="api.register.function">register_function()</link>,
<link linkend="api.unregister.function">unregister_function()</link>. <link linkend="api.unregister.function">unregister_function()</link>.
</para> </para>
<para> <para>
<example> <example>
<title>fonction de plugin avec sortie</title> <title>Fonction de plugin avec sortie</title>
<programlisting> <programlisting role="php">
&lt;?php <![CDATA[
<?php
/* /*
* Smarty plugin * Smarty plugin
* ------------------------------------------------------------- * -------------------------------------------------------------
@@ -47,7 +45,7 @@
* R<>le : renvoie une phrase magique au hasard * R<>le : renvoie une phrase magique au hasard
* ------------------------------------------------------------- * -------------------------------------------------------------
*/ */
function smarty_function_eightball($params, &amp;$smarty) function smarty_function_eightball($params, &$smarty)
{ {
$answers = array('Yes', $answers = array('Yes',
'No', 'No',
@@ -59,20 +57,24 @@ function smarty_function_eightball($params, &amp;$smarty)
$result = array_rand($answers); $result = array_rand($answers);
return $answers[$result]; return $answers[$result];
} }
?&gt;</programlisting> ?>
</example> ]]>
</para> </programlisting>
<para> </example>
peut <20>tre utilis<69>e dans le template de la faton suivante : </para>
</para> <para>
<programlisting> peut <20>tre utilis<69>e dans le template de la fa<66>on suivante :
</para>
<programlisting>
Question: Will we ever have time travel? Question: Will we ever have time travel?
Answer: {eightball}.</programlisting> Answer: {eightball}.
<para> </programlisting>
<example> <para>
<title>fonction de plugin sans sortie</title> <example>
<programlisting> <title>Fonction de plugin sans sortie</title>
&lt;?php <programlisting role="php">
<![CDATA[
<?php
/* /*
* Smarty plugin * Smarty plugin
* ------------------------------------------------------------- * -------------------------------------------------------------
@@ -82,7 +84,7 @@ Answer: {eightball}.</programlisting>
* Purpose : assigne une valeur a une variable de template * Purpose : assigne une valeur a une variable de template
* ------------------------------------------------------------- * -------------------------------------------------------------
*/ */
function smarty_function_assign($params, &amp;$smarty) function smarty_function_assign($params, &$smarty)
{ {
extract($params); extract($params);
@@ -98,10 +100,12 @@ function smarty_function_assign($params, &amp;$smarty)
$smarty->assign($var, $value); $smarty->assign($var, $value);
} }
?&gt;</programlisting> ?>
</example> ]]>
</para> </programlisting>
</sect1> </example>
</para>
</sect1>
<!-- Keep this comment at the end of the file <!-- Keep this comment at the end of the file
Local variables: Local variables:
mode: sgml mode: sgml

11
docs/fr/programmers/plugins/plugins-howto.xml
View File

@@ -1,10 +1,10 @@
<?xml version="1.0" encoding="iso-8859-1"?> <?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision$ --> <!-- $Revision$ -->
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial --> <!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
<sect1 id="plugins.howto"> <sect1 id="plugins.howto">
<title>Comment fonctionnent les plugins</title> <title>Comment fonctionnent les plugins</title>
<para> <para>
Les plugins sont toujours charg<72>s a la demande. Seuls les modificateurs Les plugins sont toujours charg<72>s <EFBFBD> la demande. Seuls les modificateurs
de variables, les ressources, etc invoqu<71>s dans les scripts de templates de variables, les ressources, etc invoqu<71>s dans les scripts de templates
seront charg<72>s. De plus, chaque plugin n'est charg<72> qu'une fois, et ce seront charg<72>s. De plus, chaque plugin n'est charg<72> qu'une fois, et ce
m<>me si vous avez plusieurs instances de Smarty qui tournent dans m<>me si vous avez plusieurs instances de Smarty qui tournent dans
@@ -19,9 +19,10 @@
sont ex<65>cut<75>s d<>pend de l'ordre dans lequel ils sont enregistr<74>s ou charg<72>s. sont ex<65>cut<75>s d<>pend de l'ordre dans lequel ils sont enregistr<74>s ou charg<72>s.
</para> </para>
<para> <para>
Il n'existe qu'un seul r<>pertoire de plugin (pour des raisons de performances). Le <link linkend="variable.plugins.dir">r<EFBFBD>pertoire de plugin</link> peut
Pour installer un plugin, copiez-le simplement dans le r<>pertoire et Smarty <EFBFBD>tre une cha<68>ne de caract<63>res contenant un chemin ou un tableau contenant
l'utilisera automatiquement. de multiples chemins. Pour installer un plugin, placez-le simplement
dans un de ces dossiers et Smarty l'utilisera automatiquement.
</para> </para>
</sect1> </sect1>
<!-- Keep this comment at the end of the file <!-- Keep this comment at the end of the file

67
docs/fr/programmers/plugins/plugins-inserts.xml
View File

@@ -1,35 +1,34 @@
<?xml version="1.0" encoding="iso-8859-1"?> <?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision$ --> <!-- $Revision$ -->
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial --> <!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
<sect1 id="plugins.inserts"><title>Insertions</title> <sect1 id="plugins.inserts">
<para> <title>Insertions</title>
Les plugins d'insertion sont utilis<69>s pour impl<70>menter les fonctions <para>
qui sont appel<65>es par les balises Les plugins d'insertion sont utilis<69>s pour impl<70>menter les fonctions
<link linkend="language.function.insert"><command>insert</command></link> qui sont appel<65>es par les balises
dans les templates. <link linkend="language.function.insert"><command>insert</command></link>
</para> dans les templates.
<funcsynopsis> </para>
<funcprototype> <funcsynopsis>
<funcdef>string <function>smarty_insert_<replaceable>name</replaceable></function></funcdef> <funcprototype>
<paramdef>array <parameter>$params</parameter></paramdef> <funcdef>string <function>smarty_insert_<replaceable>name</replaceable></function></funcdef>
<paramdef>object <parameter>&amp;$smarty</parameter></paramdef> <paramdef>array <parameter>$params</parameter></paramdef>
</funcprototype> <paramdef>object <parameter>&amp;$smarty</parameter></paramdef>
</funcsynopsis> </funcprototype>
<para> </funcsynopsis>
Le premier param<61>tre pass<73> a la fonction est une tableau associatif <para>
d'attributs. Vous pouvez acc<63>der a ces valeurs soit directement, par exemple Le premier param<61>tre pass<73> <20> la fonction est une tableau associatif
<varname>$params['start']</varname>, soit en utilisant d'attributs.
<varname>extract($params)</varname> pour les importer dans la table </para>
des symboles. <para>
</para> La fonction d'insertion est suppos<6F>e retourner le r<>sultat qui sera
<para> substitu<74> <20> la balise <command>insert</command> dans le template.
La fonction d'insertion est suppos<6F>e retourner le r<>sultat qui sera </para>
substitu<EFBFBD> a la balise <command>insert</command> dans le template. <example>
</para> <title>Plugin d'insertion</title>
<example> <programlisting role="php">
<title>plugin d'insertion</title> <![CDATA[
<programlisting> <?php
&lt;?php
/* /*
* Smarty plugin * Smarty plugin
* ------------------------------------------------------------- * -------------------------------------------------------------
@@ -40,7 +39,7 @@
* au format * au format
* ------------------------------------------------------------- * -------------------------------------------------------------
*/ */
function smarty_insert_time($params, &amp;$smarty) function smarty_insert_time($params, &$smarty)
{ {
if (empty($params['format'])) { if (empty($params['format'])) {
$smarty->trigger_error("insert time: missing 'format' parameter"); $smarty->trigger_error("insert time: missing 'format' parameter");
@@ -50,8 +49,10 @@ function smarty_insert_time($params, &amp;$smarty)
$datetime = strftime($params['format']); $datetime = strftime($params['format']);
return $datetime; return $datetime;
} }
?&gt;</programlisting> ?>
</example> ]]>
</programlisting>
</example>
</sect1> </sect1>
<!-- Keep this comment at the end of the file <!-- Keep this comment at the end of the file
Local variables: Local variables:

95
docs/fr/programmers/plugins/plugins-modifiers.xml
View File

@@ -1,41 +1,43 @@
<?xml version="1.0" encoding="iso-8859-1"?> <?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision$ --> <!-- $Revision$ -->
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial --> <!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
<sect1 id="plugins.modifiers"><title>Modificateurs</title> <sect1 id="plugins.modifiers">
<para> <title>Modificateurs</title>
Les modificateurs sont des petites fonctions appliqu<71>es a une variable <para>
de template avant qu'elle ne soit affich<63>e ou utilis<69>e dans un autre contexte. Les modificateurs sont des petites fonctions appliqu<71>es <20> une variable
Les modificateurs peuvent <20>tre chaen<65>s entre eux. de template avant qu'elle ne soit affich<63>e ou utilis<69>e dans un autre contexte.
</para> Les modificateurs peuvent <20>tre cha<68>n<EFBFBD>s entre eux.
<funcsynopsis> </para>
<funcprototype> <funcsynopsis>
<funcdef>mixed <function>smarty_modifier_<replaceable>name</replaceable></function></funcdef> <funcprototype>
<paramdef>mixed <parameter>$value</parameter></paramdef> <funcdef>mixed <function>smarty_modifier_<replaceable>name</replaceable></function></funcdef>
<paramdef>[mixed <parameter>$param1</parameter>, ...]</paramdef> <paramdef>mixed <parameter>$value</parameter></paramdef>
</funcprototype> <paramdef>[mixed <parameter>$param1</parameter>, ...]</paramdef>
</funcsynopsis> </funcprototype>
<para> </funcsynopsis>
Le premier param<61>tre pass<73> au modificateur est la valeur <para>
sur laquelle le modificateur est suppos<6F> op<6F>rer. Les autres param<61>tres Le premier param<61>tre pass<73> au modificateur est la valeur
peuvent <20>tre optionnels, d<>pendant de quel genre d'op<6F>ration doit <EFBFBD>tre sur laquelle le modificateur est suppos<6F> op<6F>rer. Les autres param<EFBFBD>tres
effectu<EFBFBD>. peuvent <20>tre optionnels, d<>pendant de quel genre d'op<6F>ration doit <20>tre
</para> effectu<74>.
<para> </para>
Le modificateur doit retourner le r<>sultat de son ex<65>cution. <para>
</para> Le modificateur doit retourner le r<>sultat de son ex<65>cution.
<para> </para>
Regardez aussi <para>
<link linkend="api.register.modifier">register_modifier()</link>, Lisez <20>galement
<link linkend="api.register.modifier">register_modifier()</link> et
<link linkend="api.unregister.modifier">unregister_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 param<61>tre
suppl<70>mentaires.
</para> </para>
<example> <programlisting role="php">
<title>plugin modificateur simple</title> <![CDATA[
<para> <?php
Ce plugin est un alias d'une fonction PHP. Il n'a aucun param<61>tre
suppl<70>mentaires.
</para>
<programlisting>
&lt;?php
/* /*
* Smarty plugin * Smarty plugin
* ------------------------------------------------------------- * -------------------------------------------------------------
@@ -49,13 +51,16 @@ function smarty_modifier_capitalize($string)
{ {
return ucwords($string); return ucwords($string);
} }
?&gt;</programlisting> ?>
</example> ]]>
<para></para> </programlisting>
<example> </example>
<title>un plugin modificateur un peu plus complexe</title> <para></para>
<programlisting> <example>
&lt;?php <title>Un plugin modificateur un peu plus complexe</title>
<programlisting role="php">
<![CDATA[
<?php
/* /*
* Smarty plugin * Smarty plugin
* ------------------------------------------------------------- * -------------------------------------------------------------
@@ -84,9 +89,11 @@ function smarty_modifier_truncate($string, $length = 80, $etc = '...',
} else } else
return $string; return $string;
} }
?&gt;</programlisting> ?>
</example> ]]>
</sect1> </programlisting>
</example>
</sect1>
<!-- Keep this comment at the end of the file <!-- Keep this comment at the end of the file
Local variables: Local variables:
mode: sgml mode: sgml

14
docs/fr/programmers/plugins/plugins-naming-conventions.xml
View File

@@ -1,14 +1,14 @@
<?xml version="1.0" encoding="iso-8859-1"?> <?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision$ --> <!-- $Revision$ -->
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial --> <!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
<sect1 id="plugins.naming.conventions"> <sect1 id="plugins.naming.conventions">
<title>Conventions de nommage</title> <title>Conventions de nommage</title>
<para> <para>
Les fichiers et les fonctions de plugins doivent suivre une convention Les fichiers et les fonctions de plugins doivent suivre une convention
de nommage tr<74>s sp<73>cifique pour <20>tre localis<69>s par Smarty. de nommage tr<74>s sp<73>cifique pour <20>tre localis<69>s par Smarty.
</para> </para>
<para> <para>
Les fichiers de plugins doivent <20>tre nomm<6D>s de la faton suivante : Les fichiers de plugins doivent <20>tre nomm<6D>s de la fa<EFBFBD>on suivante :
<blockquote> <blockquote>
<para> <para>
<filename> <filename>
@@ -18,7 +18,7 @@
</blockquote> </blockquote>
</para> </para>
<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"> <itemizedlist spacing="compact">
<listitem><simpara>function</simpara></listitem> <listitem><simpara>function</simpara></listitem>
<listitem><simpara>modifier</simpara></listitem> <listitem><simpara>modifier</simpara></listitem>
@@ -42,7 +42,7 @@
</para> </para>
<para> <para>
Les fonctions de plugins dans les fichiers de plugins doivent <20>tre Les fonctions de plugins dans les fichiers de plugins doivent <20>tre
nomm<6D>es de la faton suivante : nomm<6D>es de la fa<EFBFBD>on suivante :
<blockquote> <blockquote>
<para> <para>
<function>smarty_<replaceable>type</replaceable>_<replaceable>nom</replaceable></function> <function>smarty_<replaceable>type</replaceable>_<replaceable>nom</replaceable></function>
@@ -54,8 +54,8 @@
que pr<70>c<EFBFBD>demment. que pr<70>c<EFBFBD>demment.
</para> </para>
<para> <para>
Smarty donnera des messages d'erreur appropri<72> si le fichier de plugin Smarty donnera des messages d'erreurs appropri<72>s si le fichier de plugin
n'est pas trouv<75>, ou si le fichier ou la fonction de plugin ne sont n'est pas trouv<75> ou si le fichier ou la fonction de plugin ne sont
pas nomm<6D>s correctement. pas nomm<6D>s correctement.
</para> </para>
</sect1> </sect1>

61
docs/fr/programmers/plugins/plugins-outputfilters.xml
View File

@@ -1,28 +1,31 @@
<?xml version="1.0" encoding="iso-8859-1"?> <?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision$ --> <!-- $Revision$ -->
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial --> <!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
<sect1 id="plugins.outputfilters"><title>Filtres de sortie</title> <sect1 id="plugins.outputfilters">
<para> <title>Filtres de sortie</title>
Les plugins de filtres de sortie op<6F>rent sur la sortie du template, <para>
apr<EFBFBD>s que le template a <20>t<EFBFBD> charg<72> et ex<65>cut<75>, mais avant que Les plugins de filtres de sortie op<6F>rent sur la sortie du template,
la sortie ne soit affich<63>e. apr<70>s que le template a <20>t<EFBFBD> charg<72> et ex<65>cut<75>, mais avant que
</para> la sortie ne soit affich<63>e.
<funcsynopsis> </para>
<funcprototype> <funcsynopsis>
<funcdef>string <function>smarty_outputfilter_<replaceable>name</replaceable></function></funcdef> <funcprototype>
<paramdef>string <parameter>$template_output</parameter></paramdef> <funcdef>string <function>smarty_outputfilter_<replaceable>name</replaceable></function></funcdef>
<paramdef>object <parameter>&amp;$smarty</parameter></paramdef> <paramdef>string <parameter>$template_output</parameter></paramdef>
</funcprototype> <paramdef>object <parameter>&amp;$smarty</parameter></paramdef>
</funcsynopsis> </funcprototype>
<para> </funcsynopsis>
Le premier param<61>tre pass<73> a la fonction du filtre de sortie est la <para>
sortie du template qui doit <20>tre modifi<66>e et le second param<61>tre Le premier param<61>tre pass<73> <20> la fonction du filtre de sortie est la
est l'instance de Smarty appelant le plugin. Le plugin est suppos<EFBFBD> sortie du template qui doit <20>tre modifi<66>e et le second param<61>tre
faire un traitement et en retourner le r<>sultat. est l'instance de Smarty appelant le plugin. Le plugin est suppos<6F>
</para> faire un traitement et en retourner le r<>sultat.
<example> </para>
<title>plugin de filtre de sortie</title> <example>
<programlisting> <title>Plugin de filtre de sortie</title>
<programlisting role="php">
<![CDATA[
<?php
/* /*
* Smarty plugin * Smarty plugin
* ------------------------------------------------------------- * -------------------------------------------------------------
@@ -33,13 +36,15 @@
* robots spammers. * robots spammers.
* ------------------------------------------------------------- * -------------------------------------------------------------
*/ */
function smarty_outputfilter_protect_email($output, &amp;$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}))!', return preg_replace('!(\S+)@([a-zA-Z0-9\.\-]+\.([a-zA-Z]{2,3}|[0-9]{1,3}))!',
'$1%40$2', $output); '$1%40$2', $output);
} }
</programlisting> ?>
</example> ]]>
</programlisting>
</example>
</sect1> </sect1>
<!-- Keep this comment at the end of the file <!-- Keep this comment at the end of the file
Local variables: Local variables:

49
docs/fr/programmers/plugins/plugins-prefilters-postfilters.xml
View File

@@ -1,12 +1,12 @@
<?xml version="1.0" encoding="iso-8859-1"?> <?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision$ --> <!-- $Revision$ -->
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial --> <!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
<sect1 id="plugins.prefilters.postfilters"> <sect1 id="plugins.prefilters.postfilters">
<title>filtres de pr<70>-compilation/filtres de post-compilation</title> <title>filtres de pr<70>-compilation/filtres de post-compilation</title>
<para> <para>
Les filtres de pr<70>-compilation et les filtres de post-compilation ont des concepts tr<74>s Les filtres de pr<70>-compilation et les filtres de post-compilation ont des concepts tr<74>s
proches. Ils diff<66>rent dans leur ex<65>cution, plus pr<70>cis<69>ment dans le proches. Ils diff<66>rent dans leur ex<65>cution, plus pr<70>cis<69>ment dans le
moment o<> ils sont ex<65>cut<75>s. moment o<> ils sont ex<65>cut<75>s.
</para> </para>
<funcsynopsis> <funcsynopsis>
<funcprototype> <funcprototype>
@@ -17,9 +17,9 @@
</funcsynopsis> </funcsynopsis>
<para> <para>
Les filtres de pr<70>-compilation sont utilis<69>s pour transformer la source d'un template Les filtres de pr<70>-compilation sont utilis<69>s pour transformer la source d'un template
juste avant la compilation. Le premier param<61>tre pass<73> a la fonction juste avant la compilation. Le premier param<61>tre pass<73> <EFBFBD> la fonction
de filtre de pr<70>-compilation est la source du template, <20>ventuellement modifi<66>e par de filtre de pr<70>-compilation est la source du template, <20>ventuellement modifi<66>e par
d'autres filtre de pr<70>-compilations. Le plugin est suppos<6F> retourner la source modifi<66>e. d'autres filtres de pr<70>-compilations. Le plugin est suppos<6F> retourner la source modifi<66>e.
Notez que cette source n'est sauvegard<72>e nulle part, elle est seulement Notez que cette source n'est sauvegard<72>e nulle part, elle est seulement
utilis<69> pour la compilation. utilis<69> pour la compilation.
</para> </para>
@@ -32,16 +32,17 @@
</funcsynopsis> </funcsynopsis>
<para> <para>
Les filtres de post-compilation sont utilis<69>s pour modifier la sortie du template Les filtres de post-compilation sont utilis<69>s pour modifier la sortie du template
(le code PHP) juste apr<70>s que la compilation a <20>t<EFBFBD> faite mais juste (le code PHP) juste apr<70>s que la compilation a <20>t<EFBFBD> fa<EFBFBD>te mais juste
avant que le template ne soit sauvegard<72> sur le syst<73>me de fichiers. avant que le template ne soit sauvegard<72> sur le syst<73>me de fichiers.
Le premier param<61>tre pass<73> a la fonction de filtre de post-compilation est le code Le premier param<61>tre pass<73> <EFBFBD> la fonction de filtre de post-compilation est le code
du template compil<69>, <20>ventuellement d<>ja modifi<66> par d'autres filtre de post-compilations. du template compil<69>, <20>ventuellement d<>ja modifi<66> par d'autres filtres de post-compilations.
Le plugin est cens<6E> retourner la version modifi<66> du code. Le plugin est cens<6E> retourner la version modifi<66>e du code.
</para> </para>
<example> <example>
<title>plugin de filtre de post-compilation</title> <title>Plugin de filtre de post-compilation</title>
<programlisting> <programlisting role="php">
&lt;?php <![CDATA[
<?php
/* /*
* Smarty plugin * Smarty plugin
* ------------------------------------------------------------- * -------------------------------------------------------------
@@ -51,17 +52,19 @@
* R<>le : Passe les balises HTML en minuscules. * R<>le : Passe les balises HTML en minuscules.
* ------------------------------------------------------------- * -------------------------------------------------------------
*/ */
function smarty_prefilter_pre01($source, &amp;$smarty) function smarty_prefilter_pre01($source, &$smarty)
{ {
return preg_replace('!&lt;(\w+)[^&gt;]+&gt;!e', 'strtolower("$1")', $source); return preg_replace('!<(\w+)[^>]+>!e', 'strtolower("$1")', $source);
} }
?&gt;</programlisting> ?>
]]>
</programlisting>
</example> </example>
<para></para> <para></para>
<example> <example>
<title>plugin de filtre de post-compilation</title> <title>Plugin de filtre de post-compilation</title>
<programlisting> <programlisting role="php">
&lt;?php <![CDATA[
/* /*
* Smarty plugin * Smarty plugin
* ------------------------------------------------------------- * -------------------------------------------------------------
@@ -72,12 +75,14 @@
* du template. * du template.
* ------------------------------------------------------------- * -------------------------------------------------------------
*/ */
function smarty_postfilter_post01($compiled, &amp;$smarty) function smarty_postfilter_post01($compiled, &$smarty)
{ {
$compiled = "&lt;pre&gt;\n&lt;?php print_r(\$this-&gt;get_template_vars()); ?&gt;\n&lt;/pre&gt;" . $compiled; $compiled = "<pre>\n<?php print_r(\$this->get_template_vars()); ?>\n</pre>" . $compiled;
return $compiled; return $compiled;
} }
?&gt;</programlisting> ?>
]]>
</programlisting>
</example> </example>
</sect1> </sect1>
<!-- Keep this comment at the end of the file <!-- Keep this comment at the end of the file

68
docs/fr/programmers/plugins/plugins-resources.xml
View File

@@ -1,18 +1,17 @@
<?xml version="1.0" encoding="iso-8859-1"?> <?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision$ --> <!-- $Revision$ -->
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial --> <!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
<sect1 id="plugins.resources"><title>Ressources</title> <sect1 id="plugins.resources"><title>Ressources</title>
<para> <para>
Les plugins ressources sont un moyen g<>n<EFBFBD>rique de fournir des sources Les plugins ressources sont un moyen g<>n<EFBFBD>rique de fournir des sources
de templates ou des composants de scripts PHP a Smarty. Quelques exemples de templates ou des composants de scripts PHP <EFBFBD> Smarty. Quelques exemples
de ressources : bases de donn<6E>es, LDAP, m<>moire partag<61>e, sockets, et ainsi de ressources : bases de donn<6E>es, LDAP, m<>moire partag<61>e, sockets, etc.
de suite.
</para> </para>
<para> <para>
Il y au total 4 fonctions qui ont besoin d'<27>tre enregistr<74>es pour Il y au total 4 fonctions qui ont besoin d'<27>tre enregistr<74>es pour
chaque type de ressource. Chaque fonction retoit le nom de la ressource demand<6E>e chaque type de ressource. Chaque fonction re<EFBFBD>oit le nom de la ressource demand<6E>e
comme premier param<61>tre et l'objet Smarty comme dernier param<61>tre. comme premier param<61>tre et l'objet Smarty comme dernier param<61>tre.
Les autres param<61>tres d<>pendent de la fonction. Les autres param<61>tres d<>pendent de la fonction.
</para> </para>
<funcsynopsis> <funcsynopsis>
<funcprototype> <funcprototype>
@@ -40,31 +39,31 @@
</funcsynopsis> </funcsynopsis>
<para> <para>
La premi<6D>re fonction est suppos<6F>e r<>cup<75>rer la ressource. Son second La premi<6D>re fonction est suppos<6F>e r<>cup<75>rer la ressource. Son second
param<61>tre est une variable pass<73>e par r<>f<EFBFBD>rence o<> le r<>sultat doit <20>tre param<61>tre est une variable pass<73>e par r<>f<EFBFBD>rence o<> le r<>sultat doit <20>tre
stock<63>. La fonction est suppos<6F>e retourner <literal>true</literal> si stock<63>. La fonction est suppos<6F>e retourner <literal>true</literal> si
elle r<>ussi a r<>cup<75>rer la ressource et <literal>false</literal> sinon. elle r<>ussit <20> r<>cup<75>rer la ressource et <literal>false</literal> sinon.
</para> </para>
<para> <para>
La seconde fonction est suppos<6F>e r<>cup<75>rer la date de derni<6E>re modification La seconde fonction est suppos<6F>e r<>cup<75>rer la date de derni<6E>re modification
de la ressource demand<6E>e (comme un timestamp UNIX). Le second param<61>tre de la ressource demand<6E>e (comme un timestamp UNIX). Le second param<61>tre
est une variable pass<73>e par r<>f<EFBFBD>rence dans laquelle la date doit est une variable pass<73>e par r<>f<EFBFBD>rence dans laquelle la date doit
<20>tre stock<63>e. La fonction est suppos<6F>e renvoyer <literal>true</literal> si elle <20>tre stock<63>e. La fonction est suppos<6F>e renvoyer <literal>true</literal> si elle
a r<>ussi a r<>cup<75>rer la date et <literal>false</literal> sinon. r<>ussit <20> r<>cup<75>rer la date et <literal>false</literal> sinon.
</para> </para>
<para> <para>
La troisi<73>me fonction est suppos<6F>e retourner <literal>true</literal> La troisi<73>me fonction est suppos<6F>e retourner <literal>true</literal>
ou <literal>false</literal> selon si la ressource demand<6E>e est svre ou <literal>false</literal> selon si la ressource demand<6E>e est s<EFBFBD>re
ou non. La fonction est utilis<69>e seulement pour les ressources templates ou non. La fonction est utilis<69>e seulement pour les ressources templates
mais doit tout de m<>me <20>tre d<>finie. mais doit tout de m<>me <20>tre d<>finie.
</para> </para>
<para> <para>
La quatri<72>me fonction est suppos<6F>e retourner <literal>true</literal> La quatri<72>me fonction est suppos<6F>e retourner <literal>true</literal>
ou <literal>false</literal> selon si on peut faire confiance ou ou <literal>false</literal> selon si l'on peut faire confiance ou
non a la ressource demand<6E>e. Cette fonction est utilis<69>e seulement non <EFBFBD> la ressource demand<6E>e. Cette fonction est utilis<69>e seulement
pour les composants de scripts PHP demand<6E>s par les balises pour les composants de scripts PHP demand<6E>s par les balises
<command>include_php</command> ou <command>insert</command> <command>include_php</command> ou <command>insert</command>
ayant un attribut <structfield>src</structfield>. Quoiqu'il en soit, ayant un attribut <structfield>src</structfield>. Quoiqu'il en soit,
@@ -72,14 +71,15 @@
</para> </para>
<para> <para>
Regardez aussi Lisez <20>galement
<link linkend="api.register.resource">register_resource()</link>, <link linkend="api.register.resource">register_resource()</link> et
<link linkend="api.unregister.resource">unregister_resource()</link>. <link linkend="api.unregister.resource">unregister_resource()</link>.
</para> </para>
<example> <example>
<title>resource plugin</title> <title>resource plugin</title>
<programlisting> <programlisting role="php">
&lt;?php <![CDATA[
<?php
/* /*
* Smarty plugin * Smarty plugin
* ------------------------------------------------------------- * -------------------------------------------------------------
@@ -89,7 +89,7 @@
* R<>le : R<>cup<75>re des templates depuis une base de donn<6E>es * R<>le : R<>cup<75>re des templates depuis une base de donn<6E>es
* ------------------------------------------------------------- * -------------------------------------------------------------
*/ */
function smarty_resource_db_source($tpl_name, &amp;$tpl_source, &amp;$smarty) function smarty_resource_db_source($tpl_name, &$tpl_source, &$smarty)
{ {
// fait des requ<71>tes BD pour r<>cup<75>rer votre template // fait des requ<71>tes BD pour r<>cup<75>rer votre template
// et remplir $tpl_source // et remplir $tpl_source
@@ -105,7 +105,7 @@ function smarty_resource_db_source($tpl_name, &amp;$tpl_source, &amp;$smarty)
} }
} }
function smarty_resource_db_timestamp($tpl_name, &amp;$tpl_timestamp, &amp;$smarty) function smarty_resource_db_timestamp($tpl_name, &$tpl_timestamp, &$smarty)
{ {
// fait des requ<71>tes BD pour remplir $tpl_timestamp // fait des requ<71>tes BD pour remplir $tpl_timestamp
$sql = new SQL; $sql = new SQL;
@@ -120,19 +120,21 @@ function smarty_resource_db_timestamp($tpl_name, &amp;$tpl_timestamp, &amp;$smar
} }
} }
function smarty_resource_db_secure($tpl_name, &amp;$smarty) function smarty_resource_db_secure($tpl_name, &$smarty)
{ {
// suppose que tous les templates sont svrs // suppose que tous les templates sont svrs
return true; return true;
} }
function smarty_resource_db_trusted($tpl_name, &amp;$smarty) function smarty_resource_db_trusted($tpl_name, &$smarty)
{ {
// inutilis<69>e pour les templates // inutilis<69>e pour les templates
} }
?&gt;</programlisting> ?>
</example> ]]>
</sect1> </programlisting>
</example>
</sect1>
<!-- Keep this comment at the end of the file <!-- Keep this comment at the end of the file
Local variables: Local variables:
mode: sgml mode: sgml

24
docs/fr/programmers/plugins/plugins-writing.xml
View File

@@ -1,30 +1,34 @@
<?xml version="1.0" encoding="iso-8859-1"?> <?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision$ --> <!-- $Revision$ -->
<!-- EN-Revision: 1.1 Maintainer: nobody Status: partial --> <!-- EN-Revision: 1.2 Maintainer: yannick Status: ready -->
<sect1 id="plugins.writing"> <sect1 id="plugins.writing">
<title>Ecrire des plugins</title> <title>Ecrire des plugins</title>
<para> <para>
Les plugins peuvent <20>tre soit charg<72>s automatiquement par Smarty Les plugins peuvent <20>tre soit charg<72>s automatiquement par Smarty
depuis le syst<73>me de fichier, soit <20>tre d<>clar<61>s depuis le syst<73>me de fichier, soit <20>tre d<>clar<61>s
pendant l'ex<65>cution via une fonction register_* de l'API. Ils peuvent pendant l'ex<65>cution via une fonction register_* de l'API. Ils peuvent
aussi <20>tre d<>sallou<6F>s en utilisant une fonction unregister_* de aussi <20>tre d<>sallou<6F>s en utilisant une fonction unregister_* de
l'API. l'API.
</para> </para>
<para> <para>
Pour les plugins qui ne sont pas enregistr<74>s pendant l'ex<65>cution, le nom Pour les plugins qui ne sont pas enregistr<74>s pendant l'ex<65>cution, le nom
des fonctions n'ont pas a suivre la convention de nommage. des fonctions n'ont pas <EFBFBD> suivre la convention de nommage.
</para> </para>
<para> <para>
Si certaines fonctionnalit<69>s d'un plugin d<>pendent d'un autre plugin Si certaines fonctionnalit<69>s d'un plugin d<>pendent d'un autre plugin
(comme c'est le cas de certains plugins accompagnant Smarty), alors la mani<6E>re appropri<72>e (comme c'est le cas de certains plugins accompagnant Smarty), alors
de charger le plugin est la suivante : la mani<6E>re appropri<72>e de charger le plugin est la suivante :
</para> </para>
<programlisting role="php">
<programlisting> <![CDATA[
require_once SMARTY_DIR . 'plugins/function.html_options.php';</programlisting> <?php
require_once $smarty->_get_plugin_filepath('function', 'html_options');
?>
]]>
</programlisting>
<para> <para>
Une r<>gle g<>n<EFBFBD>rale est que chaque objet Smarty est toujours pass<73> au plugin Une r<>gle g<>n<EFBFBD>rale est que chaque objet Smarty est toujours pass<73> au plugin
en tant que dernier param<61>tre (a part pour les modificateurs). en tant que dernier param<61>tre (<EFBFBD> part pour les modificateurs).
</para> </para>
</sect1> </sect1>
<!-- Keep this comment at the end of the file <!-- Keep this comment at the end of the file