smarty/docs/fr/programmers.sgml

  <part id="smarty.for.programmers">
   <title>Smarty pour les programmeurs</title>


	<chapter id="smarty.constants">
	 <title>Constantes</title>
	 <para></para>

	 <sect1 id="constant.smarty.dir">
      <title>SMARTY_DIR</title>
      <para>
      Il doit s'agir du chemin complet du r<>pertoire o<>
      se trouvent les fichiers classes de Smarty.
      S'il n'est pas d<>fini, Smarty essaiera alors d'en
      d<>terminer automatiquement la valeur.
      S'il est d<>fini, le chemin doit se terminer par un slash.
      </para>

      <example>
       <title>SMARTY_DIR</title>
       <programlisting>
// d<>finit le chemin du r<>pertoire de Smarty
define("SMARTY_DIR","/usr/local/lib/php/Smarty/");

require_once(SMARTY_DIR."Smarty.class.php");</programlisting>
      </example>
	 </sect1>
	</chapter>

    <chapter id="api.variables">
     <title>Variables</title>

     <sect1 id="variable.template.dir">
      <title>$template_dir</title>
      <para>
      C'est le nom par d<>faut du r<>pertoire des templates.
      Si vous ne sp<73>cifiez aucun chemin lors de l'utilisation de templates, Smarty
      les cherchera <20> cet emplacement.
      Par d<>faut, il s'agit de "./templates", ce qui signifie
      qu'il va chercher le r<>pertoire templates
      dans le r<>pertoire o<> se trouve le script PHP en cours d'ex<65>cution.
      </para>

	   <note>
		   <title>Note technique</title>
         <para>
         Il n'est pas conseill<6C> de mettre ce r<>pertoire
         dans l'arborescence Web.
         </para>
	  </note>
     </sect1>		
     <sect1 id="variable.compile.dir">
      <title>$compile_dir</title>
      <para>
      C'est le nom du r<>pertoire o<> se trouvent les templates
      compil<69>s. Par d<>faut, il s'agit de "./templates_c",
      ce qui signifie que Smarty va chercher ce r<>pertoire
      dans le m<>me r<>pertoire que le script PHP en cours d'ex<65>cution.
      </para>
	 <note>
	 <title>Note technique</title>
	 <para>
	 Ce r<>glage doit <20>tre soit un chemin absolu, soit un chemin
	 relatif. include_path n'est pas utilis<69> pour <20>crire des fichiers.
	 </para>
	 </note>
	 <note>
	 <title>Note technique</title>
	 <para>
	 Il n'est pas conseill<6C> de mettre ce r<>pertoire
    sous la racine de l'arborescence Web.
	 </para>
	 </note>
     </sect1>
     <sect1 id="variable.config.dir">
      <title>$config_dir</title>
      <para>
      Il s'agit du r<>pertoire utilis<69> pour stocker les
      fichiers de configuration utilis<69>s dans les templates.
      La valeur par d<>faut est "./configs", ce qui signifie
      que Smarty va chercher ce r<>pertoire
      dans le m<>me r<>pertoire que le script PHP qui s'ex<65>cute.
      </para>
	 <note>
	 <title>Note technique</title>
	 <para>
       Il n'est pas conseill<6C> de mettre ce r<>pertoire
      sous la racine de l'arborescence Web.
    </para>
	 </note>
     </sect1>
     <sect1 id="variable.plugins.dir">
      <title>$plugins_dir</title>
      <para>
      Ce sont les r<>pertoire dans lesquels Smarty ira chercher les plugins
      dont il a besoin. La valeur par d<>faut est "plugins" sous le
      r<>pertoire SMARTY_DIR. Si vous donnez un chemin relatif, Smarty
      regardera d'abord relativement au SMARTY_DIR, puis relativement au rtc (r<>pertoire
      de travail courant), puis relativement <20> chaque entr<74>e de votre r<>pertoire
      d'inclusion PHP.
      </para>
	  <note>
	  <title>Note technique</title>
	  <para>
	  Pour des raisons de performances, ne r<>glez pas votre plugins_dir
	  pour qu'il utilise votre include_path PHP. Utilisez un
	  chemin absolu ou un chemin relatif <20> SMARTY_DIR ou au rtc.
	  </para>
	  </note>
     </sect1>
     <sect1 id="variable.debugging">
      <title>$debugging</title>
      <para>
      Cela active la
      <link
        linkend="chapter.debugging.console">console de d<>bogage</link>.
      La console est une fen<65>tre javascript qui vous informe des templates
      inclus et des variables assign<67>es dans la page courante.
      </para>
     </sect1>
     <sect1 id="variable.debug.tpl">
      <title>$debug_tpl</title>
      <para>
      C'est le nom du fichier template utilis<69> pour la
      console de d<>buggage. Par d<>faut debug.tpl, il se situe dans <link
	   linkend="constant.smarty.dir">SMARTY_DIR</link>
      </para>
     </sect1>
     <sect1 id="variable.debugging.ctrl">
      <title>$debugging_ctrl</title>
      <para>
      Cela permet d'avoir diff<66>rents moyens pour activer
      le d<>bogage. URL signifie que si SMARTY_DEBUG se
      trouve dans QUERY_STRING, le d<>buggage
      est activ<69> <20> l'invocation du script. Si $debugging
      est <20> vrai, cette valeur est sans effet.
      </para>
     </sect1>
     <sect1 id="variable.global.assign">
      <title>$global_assign</title>
      <para>
      C'est une liste de variable qui sont toujours
      implicitement assign<67>es au moteur de templates.
      Ceci est commode pour rendre des variables globales
      ou des variables du serveur accessibles <20> tous les templates
      plut<75>t que de devoir les assigner <20> la main. Chaque <20>l<EFBFBD>ment
      de $global_assign doit <20>tre soit le nom de la variable
      globale, soit une paire clef/valeur, o<> clef est le
      nom du tableau global et valeur le tableau de variable
      assign<67>es depuis ce tableau global.
      $SCRIPT_NAME est globalement assign<67> par d<>faut depuis
      $HTTP_SERVER_VARS.
      </para>
	 <note>
	 <title>Note technique</title>
	 <para>
	 On peut acc<63>der aux variables du serveur avec la variable
	 $smarty, par exemple {$smarty.server.SCRIPT_NAME}.
	 Se reporter <20> la section sur la variable
	 <link linkend="language.variables.smarty">$smarty</link>.
	 </para>
	 </note>
     </sect1>
     <sect1 id="variable.undefined">
      <title>$undefined</title>
      <para>
      Cela r<>gle la valeur de $undefined, null par d<>faut.
      N'est actuellement utilis<69> que pour initialiser
      des variables non-d<>finies dans $global_assign <20> des
      valeurs par d<>faut.
      </para>
     </sect1>
     <sect1 id="variable.autoload.filters">
      <title>$autoload_filters</title>
      <para>
      Si vous d<>sirez charger des filtres <20> chaque invocation
      de templates, vous pouvez le sp<73>cifier en utilisant cette
      variable. Les types de filtres et les valeurs sont des
      tableaux comportant le nom des filtres.
       <informalexample>
        <programlisting>
$smarty-&gt;autoload_filters = array('pre' =&gt; array('trim', 'stamp'),
                                  'output' => array('convert')); 
        </programlisting>
       </informalexample> 
      </para>
     </sect1>
     <sect1 id="variable.compile.check">
      <title>$compile_check</title>
      <para>
      A chaque invocation de l'application PHP, Smarty fait
      un test pour voir si le template courant a <20>t<EFBFBD> modifi<66>
      (date de derni<6E>re modification diff<66>rente) depuis sa
      derni<6E>re compilation. S'il a chang<6E>, le template est recompil<69>.
      Si le template n'a pas encore <20>t<EFBFBD> compil<69>, il le sera
      quelle que soit la valeur ce r<>glage.
      Par d<>faut cette valeur est <20> vrai. Quand
      une application est mise en production (les templates
      ne changent plus), cette v<>rification n'est pas n<>cessaire.
      Assurez-vous de mettre $compile_check <20> "false" pour des performances
      maximales. Notez que si vous mettez ce param<61>tre <20> "false" et qu'un
      template est modifi<66>, vous ne verrez *pas* le changement
      car le template ne sera *pas* recompil<69>. Si le processus de cache
      est activ<69> et que $compile_check l'est aussi, alors les fichiers
      du cache seront reg<65>n<EFBFBD>r<EFBFBD>s si un template concern<72> ou un fichier de
      configuration concern<72> est modifi<66>. Voir aussi <link
	   linkend="variable.force.compile">$force_compile</link> ou <link
	   linkend="api.clear.compiled.tpl">clear_compiled_tpl</link>.
      </para>

     </sect1>
     <sect1 id="variable.force.compile">
      <title>$force_compile</title>
      <para>
      Cela oblige Smarty <20> (re)compiler les templates <20> chaque
      invocation. Ce r<>glage supplante $compile_check. Par d<>faut, il
      est d<>sactiv<69>. Ceci est commode pour le d<>veloppement et le
      d<>bogage mais ne devrait jamais <20>tre utilis<69> dans un environnment
      de production. Si le syst<73>me de cache est actif, les
      fichiers du cache seront reg<65>n<EFBFBD>r<EFBFBD>s <20> chaque appel.
      </para>
     </sect1>
     <sect1 id="variable.caching">
      <title>$caching</title>
      <para>
      Ce param<61>tre demande <20> Smarty de mettre ou non en cache la sortie des
      templates.
      Par d<>faut ce r<>glage est <20> 0 (d<>sactiv<69>). Si vos templates
      g<>n<EFBFBD>rent du contenu redondant, il est conseill<6C> d'activer le
      cache. Cela permettra un gain de performance cons<6E>quent.
      Vous pouvez aussi avoir de nombreux fichiers de cache pour un m<>me template.
      Une valeur de 1 ou 2 active le cache. 1 indique <20> Smarty d'utiliser
      la variable $cache_lifetime pour d<>terminer si le fichier de cache a expir<69>.
      Une valeur de 2 indique <20> Smarty d'utiliser la valeur
      $cache_lifetime sp<73>cifi<66>e <20> la g<>n<EFBFBD>ration du cache. Ainsi vous pouvez r<>gler
      la dur<75>e de vie d'un fichier de cache avant de r<>cup<75>rer le template pour avoir
      un certain contr<74>le quand ce fichier en particulier expire. Voir
      aussi <link linkend="api.is.cached">is_cached</link>.
      </para>
      <para>
      Si $compile_check est actif, le contenu du cache sera reg<65>n<EFBFBD>r<EFBFBD>
      si un des templates ou un des fichiers de configuration qui fait partie
      de ce fichier de cache a <20>t<EFBFBD> modifi<66>. Si $force_compile est actif, le contenu
      du cache est toujours reg<65>n<EFBFBD>r<EFBFBD>.
      </para>
     </sect1>
     <sect1 id="variable.cache.dir">
      <title>$cache_dir</title>
      <para>
      Il s'agit du nom du r<>pertoire o<> les caches des templates
      sont stock<63>s. Par d<>faut il s'agit de "./cache", ce qui signifie
      que Smarty va chercher ce r<>pertoire
      dans le m<>me r<>pertoire que le script PHP en cours d'ex<65>cution.
      </para>
	 <note>
	 <title>Note technique</title>
	 <para>
       Ce r<>glage doit <20>tre soit un chemin absolu, soit un chemin
	 relatif. include_path n'a aucune influence lors de l'<27>criture des fichiers.
      </para>
	  </note>
	  <note>
		  <title>Technical Note</title>
		  <para>
         Il n'est pas conseill<6C> de mettre ce r<>pertoire
         dans l'arborescence Web.
    	  </para>
	  </note>
     </sect1>
     <sect1 id="variable.cache.lifetime">
      <title>$cache_lifetime</title>
      <para>
      Il s'agit de la dur<75>e en secondes pendant laquelle un cache de template
      est valide. Une fois cette dur<75>e d<>pass<73>e, le cache est reg<65>n<EFBFBD>r<EFBFBD>.
      $caching doit <20>tre <20> "true" pour que $cache_lifetime ait une
      quelconque utilit<69>. Avec une valeur de -1, le cache n'expire jamais.
      Avec une valeur de 0, le cache est toujours reg<65>n<EFBFBD>r<EFBFBD> (utile
      <20> des fins de tests seulement. Une meilleure fa<66>on de d<>sactiver
      le cache est de mettre <link
	   linkend="variable.caching">$caching</link> <20> "false").
      </para>
      <para>
      Si <link linkend="variable.force.compile">$force_compile</link> est
      activ<69>, les fichiers du cache seront reg<65>n<EFBFBD>r<EFBFBD>s <20> chaque fois,
      d<>sactivant ainsi le cache. Vous pouvez effacer tous les fichiers du cache
      avec la function
      <link linkend="api.clear.all.cache">clear_all_cache()</link>
      ou de fa<66>on individuelle (ou group<75>e)
      avec la fonction <link
	   linkend="api.clear.cache">clear_cache()</link>.
      </para>
	  <note>
	  <title>Note technique</title>
	  <para>
	  Si vous souhaitez donner <20> certains templates leur propre dur<75>e de vie
	  en cache, vous pouvez le faire en r<>glant
	  <link linkend="variable.caching">$caching</link> <20> 2,
	  puis $cache_lifetime <20> une unique valeur juste avant d'appeler
	  display ou fetch().
	  </para>
	  </note>
     </sect1>
     <sect1 id="variable.cache.handler.func">
      <title>$cache_handler_func</title>
      <para>
      Vous pouvez utiliser votre propre fonction de gestion du cache plut<75>t que
      d'utiliser celle livr<76>e avec Smarty.
      R<>f<EFBFBD>rez-vous <20> la section sur la fonction de gestion de cache
      personnalis<69>e pour plus de d<>tails.
      </para>
     </sect1>
     <sect1 id="variable.cache.modified.check">
      <title>$cache_modified_check</title>
      <para>
      Si cette variable est <20> vrai, Smarty respectera l'en-t<>te
      If-Modified-Since envoy<6F> par le client. Si la date de derni<6E>re
      modification du fichier de cache n'a pas chang<6E> depuis la derni<6E>re
      visite, alors un en-t<>te "304 Not Modified" sera envoy<6F> <20> la place
      du contenu. Cela ne fonctionne qu'avec du contenu mis en cache hors de la
      balise <command>insert</command>.
      </para>
     </sect1>
     <sect1 id="variable.config.overwrite">
      <title>$config_overwrite</title>
      <para>
      Si cette variable est <20> vrai, les variables lues dans les fichiers
      de configuration peuvent s'<27>craser entre elles. Sinon les variables
      seront mises dans un tableau. Tr<54>s utile si vous voulez stocker
      des tableaux de donn<6E>es dans des fichiers de configuration, listez
      simplement chaque <20>l<EFBFBD>ment plusieurs fois. Mise <20> faux par d<>faut.
      </para>
     </sect1>
     <sect1 id="variable.config.booleanize">
      <title>$config_booleanize</title>
      <para>
      Si cette variable est <20> vrai, les valeurs on/true/yes et off/false/no
      dans les fichiers de configuration sont automitiquement converties
      en bool<6F>en. De cette fa<66>on vous pouvez utiliser ces valeurs dans le
      template de la fa<66>on suivante : {if #foobar#} ... {/if}. Si foobar
      est <20> on, true ou yes, l'instruction {if} sera ex<65>cut<75>e. vrai
      par d<>faut.
      </para>
     </sect1>
     <sect1 id="variable.config.read.hidden">
      <title>$config_read_hidden</title>
      <para>
      Si cette variable est <20> vrai, les sections cach<63>s (dont les noms
      commencent par un point) dans les fichiers de configuration peuvent
      <20>tre lues depuis les templates. On laisse habituellement cela <20> faux, de
      cette fa<66>on vous pouvez stocker des donn<6E>es sensibles dans les fichiers
      de configuration, comme par exemple des param<61>tres de base de donn<6E>es,
      sans vous soucier de la fa<66>on dont les templates les chargent.
      Mise <20> faux par d<>faut.
      </para>
     </sect1>
     <sect1 id="variable.config.fix.newlines">
      <title>$config_fix_newlines</title>
      <para>
      Si cette variable est mise <20> vrai, les caract<63>res de nouvelles lignes mac et dos
      (\r et \r\n) sont convertis en \n quand ils sont analys<79>s. vrai par d<>faut.
      </para>
     </sect1>
     <sect1 id="variable.default.template.handler.func">
      <title>$default_template_handler_func</title>
      <para>
      Cette fonction est appel<65>e quand un template ne peut pas <20>tre
      obtenu avec sa ressource.
      </para>
     </sect1>
     <sect1 id="variable.php.handling">
      <title>$php_handling</title>
      <para>
      Indique <20> Smarty comment interpr<70>ter le code PHP
      int<6E>gr<67> dans les templates. Il y a quatre valeurs possibles, par
      d<>faut SMARTY_PHP_PASSTHRU. Notez que cela n'affecte PAS le code
      PHP entour<75> des balises
      <link linkend="language.function.php">{php}{/php}</link>
      dans le template.
      </para>
      <itemizedlist>
       <listitem><para>SMARTY_PHP_PASSTHRU - Smarty <20>crit les balises
       telles quelles.</para></listitem>
       <listitem><para>SMARTY_PHP_QUOTE - Smarty transforme les balises
       en entit<69>s HTML.</para></listitem>
       <listitem><para>SMARTY_PHP_REMOVE - Smarty supprime les balises
       des templates.</para></listitem>
       <listitem><para>SMARTY_PHP_ALLOW - Smarty ex<65>cute les balises
       comme du code PHP.</para></listitem>
      </itemizedlist>
      <para>
      NOTE : Int<6E>grer du code PHP dans les templates est vivement
      d<>conseill<6C>. Pr<50>f<EFBFBD>rez les
      <link linkend="language.custom.functions">fonctions utilisateurs</link>
      ou les <link linkend="language.modifiers">modificateurs de variables</link>.
      </para>
     </sect1>
     <sect1 id="variable.security">
      <title>$security</title>
      <para>
      Cette variable est <20> faux par d<>faut. $security est de rigueur
      quand vous n'<27>tes pas compl<70>tement s<>r des personnes qui <20>ditent les templates
      (par ftp par exemple) et que vous voulez r<>duire le risque que
      la s<>curit<69> du syst<73>me soit compromise par le language de template.
      Activer cette option de s<>curit<69> applique les r<>gles suivantes
      au langage de template, <20> moins que $security_settings ne sp<73>cifie
      le contraire :
      </para>
      <itemizedlist>
       <listitem><para>Si $php_handling est r<>gl<67>e <20> SMARTY_PHP_ALLOW,
         cela est implicitement chang<6E> <20> SMARTY_PHP_PASSTHRU.</para></listitem>
       <listitem><para>Les fonctions PHP ne sont pas autoris<69>es dans les
         instructions IF, <20> part celles d<>clar<61>es dans
         $security_settings.</para></listitem>
       <listitem><para>Les templates ne peuvent <20>tre inclus que depuis
         des r<>pertoires list<73>s dans le tableau $security_dir.</para></listitem>
       <listitem><para>Les fichiers locaux ne peuvent <20>tre r<>cup<75>r<EFBFBD>s que depuis
         les r<>pertoires list<73>s dans le tableau $security_dir en
         utilisant {fetch}.</para></listitem>
       <listitem><para>Les balises {php}{/php} ne sont pas autoris<69>es.</para></listitem>
       <listitem><para>Les fonctions PHP ne sont pas autoris<69>es en tant
         modificateurs, <20> part celles sp<73>cifi<66>es dans $security_settings.</para></listitem>
      </itemizedlist>
     </sect1>
     <sect1 id="variable.secure.dir">
      <title>$secure_dir</title>
      <para>
      Il s'agit d'un tableau contenant tous les r<>pertoires locaux qui sont
      consid<69>r<EFBFBD>s comme s<>curis<69>s. {include} et {fetch} l'utilisent quand
      la s<>curit<69> est activ<69>e.
      </para>
     </sect1>
     <sect1 id="variable.security.settings">
      <title>$security_settings</title>
      <para>
      Ces r<>glages servent <20> <20>craser ou sp<73>cifier les param<61>tres de s<>curit<69>
      quand celle-ci est activ<69>e. Les r<>glages possibles sont les suivants :
      </para>
      <itemizedlist>
       <listitem><para>PHP_HANDLING - true/false. Si vrai, le
       r<>glage $php_handling n'est pas v<>rifi<66>.</para></listitem>
       <listitem><para>IF_FUNCS - Le tableau des noms de fonctions
       PHP autoris<69>es dans les intructions IF.</para></listitem>
       <listitem><para>INCLUDE_ANY - true/false. Si vrai,
       les templates peuvent <20>tre inclus de n'importe o<>, quelque soit
       le contenu de $secure_dir.</para></listitem>
       <listitem><para>PHP_TAGS - true/false. Si vrai,
       les balises {php}{/php} sont autoris<69>es dans les templates.</para></listitem>
       <listitem><para>MODIFIER_FUNCS - Le tableau des noms de fonctions
       autoris<69>es <20> <20>tre utilis<69>es comme modificateurs de variables.</para></listitem>
      </itemizedlist>
     </sect1>
     <sect1 id="variable.trusted.dir">
      <title>$trusted_dir</title>
      <para>
      $trusted_dir n'est utilis<69>e lorsque $security est activ<69>e. C'est un
      tableau de tous les r<>pertoires qui peuvent <20>tre consid<69>r<EFBFBD>s comme s<>rs.
      Les r<>pertoires s<>rs sont ceux qui contiennent des scripts PHP qui
      sont ex<65>cut<75>s directement depuis les templates avec
      <link linkend="language.function.include.php">{include_php}</link>.
      </para>
     </sect1>
     <sect1 id="variable.left.delimiter">
      <title>$left_delimiter</title>
      <para>
      Il s'agit du d<>limiteur gauche utilis<69> par le moteur de templates. La
      valeur par d<>faut est "{".
      </para>
     </sect1>
     <sect1 id="variable.right.delimiter">
      <title>$right_delimiter</title>
      <para>
      Il s'agit du d<>limiteur droit utilis<69> par le moteur de templates.
      La valeur par d<>faut est "}".
      </para>
     </sect1>
     <sect1 id="variable.compiler.class">
      <title>$compiler_class</title>
      <para>
      Sp<53>cifie le nom de la classe du compilateur qui va <20>tre utilis<69>e pour
      compiler les templates. Le compilateur par d<>faut est
      'Smarty_Compiler'. R<>serv<72> aux utilisateurs avanc<6E>s.
      </para>
     </sect1>
     <sect1 id="variable.request.vars.order">
      <title>$request_vars_order</title>
      <para>
      L'ordre dans lequel les variables de requ<71>tes sont enregistr<74>es,
      identique <20> variables_order dans php.ini.
      </para>
     </sect1>
     <sect1 id="variable.compile.id">
      <title>$compile_id</title>
      <para>
      Identifiant persistant du compilateur. On peut passer le m<>me compile_id
      <20> chaque appel de fonction mais une alternative consiste <20> r<>gler ce
      compile_id, qui sera utilis<69> implicitement.
      </para>
     </sect1>
     <sect1 id="variable.use.sub.dirs">
      <title>$use_sub_dirs</title>
      <para>
      R<>gler cela <20> faux si votre environnement PHP n'autorise pas Smarty <20> cr<63>er
      des sous-r<>pertoires. Les sous-r<>pertoires sont efficaces, utilisez-les quand
      vous le pouvez.
      </para>
     </sect1>
     <sect1 id="variable.default.modifiers">
      <title>$default_modifiers</title>
      <para>
      Il s'agit d'un tableau de modificateurs utilis<69> pour assigner
      une valeur par d<>faut <20> chaque variable dans un template.
      Par exemple, pour par d<>faut <20>chapper les caract<63>res HTML de chaque variable,
      utilisez array('escape:"htmlall"'); Pour rendre une variable ind<6E>pendante
      des modificateurs par d<>faut, passez-lui en param<61>tre le modificateur
      "nodefaults" : {$var|nodefaults}.
      </para>
     </sect1>
    </chapter>

   <chapter id="api.functions">
     <title>M<>thodes</title>
        <sect1 id="api.append">
         <title>append</title>
         <funcsynopsis>
          <funcprototype>
           <funcdef>void <function>append</function></funcdef>
           <paramdef>mixed <parameter>var</parameter></paramdef>
          </funcprototype>
          <funcprototype>
           <funcdef>void <function>append</function></funcdef>
           <paramdef>string <parameter>varname</parameter></paramdef>
           <paramdef>mixed <parameter>var</parameter></paramdef>
          </funcprototype>
          <funcprototype>
           <funcdef>void <function>append</function></funcdef>
           <paramdef>string <parameter>varname</parameter></paramdef>
           <paramdef>mixed <parameter>var</parameter></paramdef>
           <paramdef>boolean <parameter>merge</parameter></paramdef>
          </funcprototype>
         </funcsynopsis>
         <para>
         Utilis<69>e pour ajouter un <20>l<EFBFBD>ment <20> un tableau assign<67>. Si vous utilisez
         cette fonction avec une cha<68>ne de caract<63>re, elle est convertie en
         tableau auquel on ajoute ensuite l'<27>l<EFBFBD>ment. Vous pouvez explicitement passer
         des paires nom/valeur. Si vous passez le troisi<73>me param<61>tre
         (optionel) <20> vrai, la valeur sera fusionn<6E>e avec le tableau plut<75>t que
         d'<27>tre ajout<75>e.
         </para>
		 <note>
		 <title>Note technique</title>
		 <para>
		 Le param<61>tre de fusion respecte les cl<63>s des tableaux, ainsi si vous
		 fusionnez deux tableaux index<65>s num<75>riquement, ils pourront s'<27>craser
		 l'un l'autre ou donner des cl<63>s qui ne se suivent pas. Cela diff<66>re
		 donc de la fonction PHP array_merge() qui supprime les cl<63>s num<75>riques
		 et les renum<75>rote.
		 </para>
		 </note>
         <example>
          <title>append</title>
          <programlisting>
// passe des paires nom/valeur
$smarty->append("Name","Fred");
$smarty->append("Address",$address);

// passe un tableau associatif
$smarty->append(array("city" => "Lincoln","state" => "Nebraska"));</programlisting>
</example>
		</sect1>
     <sect1 id="api.append.by.ref">
      <title>append_by_ref</title>
      <funcsynopsis>
       <funcprototype>
        <funcdef>void <function>append_by_ref</function></funcdef>
        <paramdef>string <parameter>varname</parameter></paramdef>
        <paramdef>mixed <parameter>var</parameter></paramdef>
       </funcprototype>
       <funcprototype>
        <funcdef>void <function>append_by_ref</function></funcdef>
        <paramdef>string <parameter>varname</parameter></paramdef>
        <paramdef>mixed <parameter>var</parameter></paramdef>
        <paramdef>boolean <parameter>merge</parameter></paramdef>
       </funcprototype>
      </funcsynopsis>
      <para>
      Utilis<69>e pour ajouter des valeurs <20> un template par r<>f<EFBFBD>rence plut<75>t que
      par copie. Si vous ajoutez une variable par r<>f<EFBFBD>rence puis changez sa
      valeur, le changement est aussi r<>percut<75> sur la valeur assign<67>e.
      Pour les objets, append_by_ref ne fait pas de copie en m<>moire de l'objet
      assign<67>. Voir la documentation PHP pour plus d'informations sur les
      r<>f<EFBFBD>rences de variable.
      Si vous passez le troisi<73>me param<61>tre <20> vrai, la valeur sera fusionn<6E>e
      avec le tableau courant plut<75>t que d'<27>tre ajout<75>e.
      </para>
	  <note>
	  <title>Note technique</title>
     <para>
       Le param<61>tre de fusion respecte les cl<63>s des tableaux, ainsi si vous
      fusionnez deux tableaux index<65>s num<75>riquement, ils pourront s'<27>craser
      l'un l'autre ou donner des cl<63>s qui ne se suivent pas. Cela diff<66>re
      donc de la fonction PHP array_merge() qui supprime les cl<63>s num<75>riques
      et les renum<75>rote.
     </para>
	  </note>
      <example>
       <title>append_by_ref</title>
       <programlisting>
// ajoute des paires nom/valeur
$smarty->append_by_ref("Name",$myname);
$smarty->append_by_ref("Address",$address);</programlisting>
</example>
		</sect1>
     <sect1 id="api.assign">
      <title>assign</title>
      <funcsynopsis>
       <funcprototype>
        <funcdef>void <function>assign</function></funcdef>
        <paramdef>mixed <parameter>var</parameter></paramdef>
       </funcprototype>
       <funcprototype>
        <funcdef>void <function>assign</function></funcdef>
        <paramdef>string <parameter>varname</parameter></paramdef>
        <paramdef>mixed <parameter>var</parameter></paramdef>
       </funcprototype>
      </funcsynopsis>
      <para>
      Utilis<69>e pour assigner des valeurs aux templates. Vous pouvez
      explicitement passer des paires nom/valeur, ou des tableaux
      associatifs contenant des paires nom/valeur.
      </para>
      <example>
       <title>assign</title>
       <programlisting>
// passe des paires nom/valeur
$smarty->assign("Name","Fred");
$smarty->assign("Address",$address);

// passe un tableau associatif
$smarty->assign(array("city" => "Lincoln","state" => "Nebraska"));</programlisting>
</example>
		</sect1>
     <sect1 id="api.assign.by.ref">
      <title>assign_by_ref</title>
      <funcsynopsis>
       <funcprototype>
        <funcdef>void <function>assign_by_ref</function></funcdef>
        <paramdef>string <parameter>varname</parameter></paramdef>
        <paramdef>mixed <parameter>var</parameter></paramdef>
       </funcprototype>
      </funcsynopsis>
      <para>
      Utilis<69>e pour assigner des valeurs aux templates par r<>f<EFBFBD>rence plut<75>t
      que par copie. R<>f<EFBFBD>rez-vous au manuel PHP pour une explication plus pr<70>cise
      sur les r<>f<EFBFBD>rences des variables.
      </para>
	  <note>
	  <title>Note technique</title>
	  <para>
	    Si vous assignez une variable par r<>f<EFBFBD>rence puis changez sa
      valeur, le changement est aussi r<>percut<75> sur la valeur assign<67>e.
      Pour les objets, assign_by_ref ne fait pas de copie en m<>moire de l'objet
      assign<67>. R<>f<EFBFBD>rez-vous au manuel PHP pour une explication plus pr<70>cise sur
      les r<>f<EFBFBD>rences de variable.
	  </para>
	  </note>
      <example>
       <title>assign_by_ref</title>
       <programlisting>
// passe des paires noms/valeurs
$smarty->assign_by_ref("Name",$myname);
$smarty->assign_by_ref("Address",$address);</programlisting>
</example>
		</sect1>
		<sect1 id="api.clear.all.assign">
			<title>clear_all_assign</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>clear_all_assign</function></funcdef>
				<paramdef><parameter></parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Utilis<69>e pour effacer les valeurs de toutes les variables assign<67>es.
			</para>
<example>
<title>clear_all_assign</title>
<programlisting>
// efface toutes les variables assign<67>es
$smarty->clear_all_assign();</programlisting>
</example>
		</sect1>
		<sect1 id="api.clear.all.cache">
			<title>clear_all_cache</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>clear_all_cache</function></funcdef>
				<paramdef>int <parameter>expire time</parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
         Utilis<69>e pour effacer les fichiers de cache des templates. Vous pouvez passer un
         param<61>tre optionnel afin d'indiquer l'<27>ge minimun que doivent avoir
         les fichiers  de cache pour qu'ils soient effac<61>s.
			</para>
<example>
<title>clear_all_cache</title>
<programlisting>
// efface le cache
$smarty->clear_all_cache();</programlisting>
</example>
		</sect1>
		<sect1 id="api.clear.assign">
			<title>clear_assign</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>clear_assign</function></funcdef>
				<paramdef>string <parameter>var</parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
         <para>
         Efface la valeur d'une variable assign<67>e. Il peut s'agir
         d'une simple valeur ou d'un tableau de valeur.
         </para>
<example>
<title>clear_assign</title>
<programlisting>
// efface une variable
$smarty->clear_assign("Name");

// efface plusieurs variables
$smarty->clear_assign(array("Name","Address","Zip"));</programlisting>
</example>
		</sect1>
		<sect1 id="api.clear.cache">
			<title>clear_cache</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>clear_cache</function></funcdef>
				<paramdef>string <parameter>template</parameter></paramdef>
				<paramdef>string <parameter><optional>cache id</optional></parameter></paramdef>
				<paramdef>string <parameter><optional>compile id</optional></parameter></paramdef>
				<paramdef>int <parameter><optional>expire time</optional></parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Utilis<69>e pour nettoyer le(s) fichier(s) de cache d'un template en particulier.
			Si vous avez plusieurs fichiers de cache pour ce template vous
			pouvez en sp<73>cifier un en  particulier en passant son identifiant
			en deuxi<78>me param<61>tre. Vous pouvez aussi passer un identifiant
			de compilation en troisi<73>me param<61>tre. Vous pouvez grouper des
			templates ensemble afin qu'ils puissent <20>tre supprim<69>s en groupe.
			R<>f<EFBFBD>rez-vous <20> la section sur le
			<link linkend="caching">cache</link>
			pour plus d'informations. Vous pouvez passer un quatri<72>me param<61>tre
			pour indiquer un <20>ge minimum en secondes que le fichier en cache doit
			avoir avant d'<27>tre effac<61>.
			</para>
<example>
<title>clear_cache</title>
<programlisting>
// efface le fichier de cache de ce template
$smarty->clear_cache("index.tpl");

// efface un fichier de cache gr<67>ce <20> son identifiant de cache
$smarty->clear_cache("index.tpl","CACHEID");</programlisting>
</example>
		</sect1>
		<sect1 id="api.clear.compiled.tpl">
			<title>clear_compiled_tpl</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>clear_compiled_tpl</function></funcdef>
				<paramdef>string <parameter>tpl_file</parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Utilis<69>e pour effacer la version compil<69>e du template sp<73>cifi<66> ou
			de tous les templates si aucun n'est sp<73>cifi<66>. Cette fonction
			est destin<69>e <20> un usage avanc<6E> et n'est pas habituellement utilis<69>e.
			</para>
<example>
<title>clear_compiled_tpl</title>
<programlisting>
// efface la version compil<69>e du template sp<73>cifi<66>
$smarty->clear_compiled_tpl("index.tpl");

// efface tout le contenu du r<>pertoire des templates compil<69>s
$smarty->clear_compiled_tpl();</programlisting>
</example>
		</sect1>
		<sect1 id="api.clear.config">
			<title>clear_config</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>clear_config</function></funcdef>
				<paramdef>string <parameter><optional>var</optional></parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
         Utilis<69>e pour effacer toutes les variables de configuration s'<27>tant
         vues assigner une valeur. Si une variable est sp<73>cifi<66>e, seule cette
         variable est effac<61>e.
			</para>
<example>
<title>clear_config</title>
<programlisting>
// efface toutes les variables de configuration assign<67>es
$smarty->clear_config();

// efface une seule variable
$smarty->clear_config('foobar');</programlisting>
</example>
		</sect1>
		<sect1 id="api.config.load">
			<title>config_load</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>config_load</function></funcdef>
				<paramdef>string <parameter>file</parameter></paramdef>
				<paramdef>string <parameter><optional>section</optional></parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Utilis<69>e pour charger des donn<6E>es d'un fichier de config et les
			assigner <20> un template. Cette fonction fonctionne exactement comme
			la fonction de template <link
			linkend="language.function.config.load">config_load</link>.
			</para>
		  <note>
		  <title>Note technique</title>
		  <para>
		  Comme pour Smarty 2.4.0, les variables de templates assign<67>es
        sont conserv<72>es entre chaque appel <20> fetch et display.
		  Les variables de configuration charg<72>es avec config_load sont
        globales. Les fichiers de config sont aussi compil<69>s pour une
        ex<65>cution plus rapide et respecte les r<>glages de <link
		   linkend="variable.force.compile">force_compile</link> et de <link
		   linkend="variable.compile.check">compile_check</link>.
		  </para>
		  </note>
<example>
<title>config_load</title>
<programlisting>
// charge les variables de configuration et les assigne
$smarty->config_load('my.conf');

// charge une section
$smarty->config_load('my.conf','foobar');</programlisting>
</example>
		</sect1>
		<sect1 id="api.display">
			<title>display</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>display</function></funcdef>
				<paramdef>string <parameter>template</parameter></paramdef>
				<paramdef>string <parameter><optional>cache_id</optional></parameter></paramdef>
				<paramdef>string <parameter><optional>compile_id</optional></parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
         Utilis<69>e pour afficher un template. Il faut fournir un type et un
         chemin de <link
                linkend="template.resources">ressource template</link>
         valides. Vous pouvez passer en second param<61>tre un identifiant
         de fichier de cache. Reportez-vous <20> la section
         <link linkend="caching">cache</link> pour plus de renseignements.
			</para>
			<para>
			Le troisi<73>me param<61>tre optionnel est un identifiant de compilation.
         Cela s'av<61>re utile quand vous voulez compiler diff<66>rentes versions
         d'un m<>me template, pour par exemple avoir des templates
         compil<69>s s<>par<61>s pour diff<66>rents langages. Une autre utilit<69> de ce
         param<61>tre est le cas o<> vous utilisez plus d'un $template_dir mais un seul
         $compile_dir, car certains templates avec le m<>me nom s'<27>craseraient
         entre eux. Vous pouvez aussi r<>gler la variable <link
			linkend="variable.compile.id">$compile_id</link> une seule
			fois au lieu de la passer <20> chaque appel.
			</para>
<example>
<title>affichage</title>
<programlisting>
include("Smarty.class.php");
$smarty = new Smarty;
$smarty->caching = true;

// ne fait un appel <20> la base de donn<6E>es que si le fichier
// de cache n'existe pas
if(!$smarty->is_cached("index.tpl"))
{

    // quelques donn<6E>es
    $address = "245 N 50th";
    $db_data = array(
	    "City" => "Lincoln",
	    "State" => "Nebraska",
	    "Zip" = > "68502"
	    );

    $smarty->assign("Name","Fred");
    $smarty->assign("Address",$address);
    $smarty->assign($db_data);

}

// display the output
$smarty->display("index.tpl");</programlisting>
</example>
         <para>
         Utilisez la syntaxe des <link
			linkend="template.resources">ressources templates</link>
         pour afficher des fichiers en-dehors du r<>pertoire
         $template_dir
         </para>

<example>
<title>exemples de fonction d'affichage de ressources templates</title>
<programlisting>
// chemin absolu
$smarty->display("/usr/local/include/templates/header.tpl");

// chemin absolu (pareil)
$smarty->display("file:/usr/local/include/templates/header.tpl");

// chemin absolu Windows (on DOIT utiliser le pr<70>fixe "file:")
$smarty->display("file:C:/www/pub/templates/header.tpl");

// inclue <20> partir de la ressource template "db"
$smarty->display("db:header.tpl");</programlisting>
</example>

		</sect1>
		<sect1 id="api.fetch">
			<title>fetch</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>string <function>fetch</function></funcdef>
				<paramdef>string <parameter>template</parameter></paramdef>
				<paramdef>string <parameter><optional>cache_id</optional></parameter></paramdef>
				<paramdef>string <parameter><optional>compile_id</optional></parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Utilis<69>e pour renvoyer le r<>sultat du template plut<75>t que de l'afficher.
         Il faut passer un type et un chemin de <link
         linkend="template.resources">ressource template</link>
         valides. Vous pouvez passer un identifiant de cache en deuxi<78>me
         param<61>tre. Reportez-vous <20> la section <link linkend="caching">cache
         </link> pour plus de renseignements.
			</para>
			<para>
         Un troisi<73>me param<61>tre optionnel est un identifiant de compilation.
         Cela s'av<61>re utile quand vous voulez compiler diff<66>rentes versions
         d'un m<>me template, pour par exemple avoir des templates
         compil<69>s s<>par<61>s pour diff<66>rents langages. Une autre utilit<69> de ce
         param<61>tre est le cas o<> vous utilisez plus d'un $template_dir
         mais un seul $compile_dir, car certains templates avec le m<>me nom
         s'<27>craseraient entre eux. Vous pouvez aussi r<>gler la variable <link
			linkend="variable.compile.id">$compile_id</link> une seule
			fois plut<75>t que de la passer <20> chaque appel.
			</para>
<example>
<title>fetch</title>
<programlisting>
include("Smarty.class.php");
$smarty = new Smarty;

$smarty->caching = true;

// ne fait un appel <20> la base de donn<6E>es que si le fichier
// de cache n'existe pas
if(!$smarty->is_cached("index.tpl"))
{

    // quelques donn<6E>es
    $address = "245 N 50th";
    $db_data = array(
	    "City" => "Lincoln",
	    "State" => "Nebraska",
	    "Zip" = > "68502"
	    );

    $smarty->assign("Name","Fred");
    $smarty->assign("Address",$address);
    $smarty->assign($db_data);

}

// r<>cup<75>re le r<>sultat
$output = $smarty->fetch("index.tpl");

// fait quelque chose avec $output

echo $output;</programlisting>
</example>
		</sect1>
		<sect1 id="api.get.config.vars">
			<title>get_config_vars</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>array <function>get_config_vars</function></funcdef>
				<paramdef>string <parameter><optional>varname</optional></parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Retourne la valeur de la variable de configuration pass<73>e en param<61>tre.
			Si aucun param<61>tre n'est donn<6E>, un tableau de toutes les variables de
			configuration charg<72>es est renvoy<6F>.
			</para>
<example>
<title>get_config_vars</title>
<programlisting>
// r<>cup<75>re la variable de configuration charg<72>e 'foo'
$foo = $smarty->get_config_vars('foo');

// r<>cup<75>re toutes les variables de configuration charg<72>es
$config_vars = $smarty->get_config_vars();

// les affiche <20> l'<27>cran
print_r($config_vars);</programlisting>
</example>
		</sect1>
		<sect1 id="api.get.registered.object">
			<title>get_registered_object</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>array <function>get_registered_object</function></funcdef>
				<paramdef>string <parameter>object_name</parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Retourne la r<>f<EFBFBD>rence d'un objet enregistr<74>. Utile quand vous
			voulez acc<63>der directement <20> un objet enregistr<74> avec une
			fonction utilisateur.
			</para>
<example>
<title>get_registered_object</title>
<programlisting>
function smarty_block_foo($params, &amp;$smarty) {
	if (isset[$params['object']]) {
      // r<>cup<75>re la r<>f<EFBFBD>rence de l'objet enregistr<74>
   		$obj_ref =&amp; $smarty->get_registered_object($params['object']);
   	// $obj_ref est maintenant une r<>f<EFBFBD>rence vers l'objet
	}
}</programlisting>
</example>
		</sect1>
		<sect1 id="api.get.template.vars">
			<title>get_template_vars</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>array <function>get_template_vars</function></funcdef>
				<paramdef>string <parameter><optional>varname</optional></parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Retourne la valeur assign<67>e pass<73>e en param<61>tre. Si aucun param<61>tre
			n'est donn<6E>, un tableau de toutes les variables assign<67>es est
			renvoy<6F>.
			</para>
<example>
<title>get_template_vars</title>
<programlisting>
// r<>cup<75>re la variable 'foo' assign<67>e au template
// get assigned template var 'foo'
$foo = $smarty->get_template_vars('foo');

// r<>cup<75>re toutes les variables assign<67>es <20> ce template
$tpl_vars = $smarty->get_template_vars();

// les affiche <20> l'<27>cran
print_r($tpl_vars);</programlisting>
</example>
		</sect1>
		<sect1 id="api.is.cached">
			<title>is_cached</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>is_cached</function></funcdef>
				<paramdef>string <parameter>template</parameter></paramdef>
				<paramdef>[string <parameter>cache_id</parameter>]</paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Retourne vrai s'il y a un fichier de cache valide pour ce template.
			Cela fonctionne seulement si <link
         linkend="variable.caching">caching</link> est <20> vrai.
			</para>
<example>
<title>is_cached</title>
<programlisting>
$smarty->caching = true;

if(!$smarty->is_cached("index.tpl")) {
    // faire des requ<71>tes base de donn<6E>es et assigner
    // des variables ici.
}

$smarty->display("index.tpl");</programlisting>
</example>
            <para>
            Vous pouvez aussi passer en second param<61>tre un identifiant
            de cache au cas o<> vous voudriez plusieurs fichiers de cache
            pour ce template.
            </para>
<example>
<title>is_cached with multiple-cache template</title>
<programlisting>
$smarty->caching = true;

if(!$smarty->is_cached("index.tpl","FrontPage")) {
    // faire des requ<71>tes base de donn<6E>es et assigner
    // des variables ici.
}

$smarty->display("index.tpl","FrontPage");</programlisting>
</example>
		</sect1>
        <sect1 id="api.load.filter">
         <title>load_filter</title>
         <funcsynopsis>
          <funcprototype>
           <funcdef>void <function>load_filter</function></funcdef>
           <paramdef>string <parameter>type</parameter></paramdef>
           <paramdef>string <parameter>name</parameter></paramdef>
          </funcprototype>
         </funcsynopsis>
         <para>
         Cette fonction peut <20>tre utilis<69>e pour charger un plugin
         de filtrage. Le premier argument sp<73>cifie le type du filtre
         et peut prendre l'une des valeurs suivantes : 'pre', 'post'
         ou 'output'. Le second argument sp<73>cifie le nom du plugin
         de filtrage, par exemple 'trim'.
         </para>
<example>
<title>Chargement de plugins de filtrage</title>
<programlisting>
$smarty->load_filter('pre', 'trim'); // charge le filtre 'trim' de type 'pre'
$smarty->load_filter('pre', 'datefooter'); // charge un autre filtre de type 'pre' appel<65> 'datefooter'
$smarty->load_filter('output', 'compress'); // charge le filtre 'compress' de type 'output'</programlisting>
</example>
        </sect1>
		<sect1 id="api.register.block">
			<title>register_block</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>register_block</function></funcdef>
				<paramdef>string <parameter>name</parameter></paramdef>
				<paramdef>string <parameter>impl</parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
         Utilis<69>e pour d<>clarrer dynamiquement des plugins de fonction
         de blocs. Il faut passer en param<61>tre le nom de la fonction
         de blocs, suivi du nom de la fonction PHP qui l'impl<70>mente.
         </para>
<example>
<title>register_block</title>
<programlisting>
/* PHP */
$smarty->register_block("translate", "do_translation");

function do_translation ($params, $content, &$smarty) {
    if ($content) {
        $lang = $params['lang'];
        // fait de la traduction avec la variable $content
        echo $translation;
    }
}

{* template *}
{translate lang="br"}
   Hello, world!
{/translate}</programlisting>
</example>
		</sect1>
		<sect1 id="api.register.compiler.function">
			<title>register_compiler_function</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>register_compiler_function</function></funcdef>
				<paramdef>string <parameter>name</parameter></paramdef>
				<paramdef>string <parameter>impl</parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Utilis<69>e pour d<>clarer dynamiquement un plugin de fonction
			de compilation. Il faut passer en param<61>tres le nom de la fonction
			de compilation, suivi par la fonction PHP qui
			l'impl<70>mente.
			</para>
		</sect1>
		<sect1 id="api.register.function">
			<title>register_function</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>register_function</function></funcdef>
				<paramdef>string <parameter>name</parameter></paramdef>
				<paramdef>string <parameter>impl</parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Utilis<69>e pour d<>clarer dynamiquement des plugins de fonction
			de templates. Il faut passer en param<61>tres le nom de la fonction
			de templates, suivi par le nom de la fonction PHP qui l'impl<70>mente.
			</para>
<example>
<title>register_function</title>
<programlisting>
$smarty->register_function("date_now", "print_current_date");

function print_current_date ($params) {
    extract($params);
    if(empty($format))
        $format="%b %e, %Y";
    echo strftime($format,time());
}

// vous pouvez maintenant utiliser ceci dans Smarty pour afficher
// la date actuelle : {date_now} ou {date_now format="%Y/%m/%d"}
// pour la formater</programlisting>
</example>
		</sect1>
		<sect1 id="api.register.modifier">
         <title>register_modifier</title>
         <funcsynopsis>
          <funcprototype>
           <funcdef>void <function>register_modifier</function></funcdef>
           <paramdef>string <parameter>name</parameter></paramdef>
           <paramdef>string <parameter>impl</parameter></paramdef>
          </funcprototype>
         </funcsynopsis>
         <para>
         Utilis<69>e pour d<>clarer dynamiquement un plugin de modificateur.
         Il faut passer en param<61>tre le nom du modificateur de variables,
         suivi de la fonction PHP qui l'impl<70>mente.
         </para>
<example>
<title>register_modifier</title>
<programlisting>
// associons la fonction PHP stripslashes <20> un modificateur Smarty.

$smarty->register_modifier("sslash","stripslashes");

// vous pouvez maintenant utiliser {$var|sslash} pour supprimer les slash des variables</programlisting>
</example>
		</sect1>
		<sect1 id="api.register.object">
			<title>register_object</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>register_object</function></funcdef>
				<paramdef>string <parameter>object_name</parameter></paramdef>
				<paramdef>object <parameter>$object</parameter></paramdef>
				<paramdef>array <parameter>allowed methods/properties</parameter></paramdef>
				<paramdef>boolean <parameter>format</parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Utilis<69>e pour enregistrer un objet <20> utiliser dans un template.
			Reportez-vous <20> la section
         <link linkend="advanced.features.objects">objet</link> de
         ce manuel pour des exemples.
         </para>
		</sect1>
		<sect1 id="api.register.outputfilter">
			<title>register_outputfilter</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>register_outputfilter</function></funcdef>
				<paramdef>string <parameter>function_name</parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Utilis<69>e pour d<>clarer dynamiquement des filtres de sortie, pour
			agir sur la sortie d'un template avant qu'elle ne soit affich<63>e.
			Reportez-vous <20> la section <link linkend="advanced.features.outputfilters">
         filtres de sortie</link> pour plus d'information sur le sujet.
			</para>
		</sect1>
		<sect1 id="api.register.postfilter">
			<title>register_postfilter</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>register_postfilter</function></funcdef>
				<paramdef>string <parameter>function_name</parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
         Utilis<69>e pour d<>clarer dynamiquement des filtres de post-compilation pour y faire
         passer des templates une fois qu'ils ont <20>t<EFBFBD> compil<69>s. Reportez-vous
         <20> la section
          <link linkend="advanced.features.postfilters">filtres de post-compilation de templates</link>
         pour avoir plus de renseignements sur la fa<66>on de param<61>trer les fonctions
         de post-compilation.
			</para>
		</sect1>
		<sect1 id="api.register.prefilter">
			<title>register_prefilter</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>register_prefilter</function></funcdef>
				<paramdef>string <parameter>function_name</parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Utilis<69>e pour d<>clarer dynamiquement des filtres de pr<70>-compilation pour y faire
         passer des templates avant qu'ils ne soient compil<69>s. Reportez-vous
         <20> la section
          <link linkend="advanced.features.postfilters">filtres de pr<70>-compilation de templates</link>
         pour avoir plus de renseignements sur la fa<66>on de param<61>trer les fonctions
         de pr<70>-compilation.
			</para>
		</sect1>
        <sect1 id="api.register.resource">
         <title>register_resource</title>
         <funcsynopsis>
          <funcprototype>
           <funcdef>void <function>register_resource</function></funcdef>
           <paramdef>string <parameter>name</parameter></paramdef>
           <paramdef>array <parameter>resource_funcs</parameter></paramdef>
          </funcprototype>
         </funcsynopsis>
         <para>
         Utilis<69>e pour d<>clarer dynamiquement une ressource plugin
         dans Smarty. Il faut passer en param<61>tre le nom de la ressource
         et le tableau des fonctions PHP qui l'impl<70>mentent. Reportez-vous
         <20> la section <link linkend="template.resources">ressources templates</link>
         pour avoir plus d'informations sur la fa<66>on de param<61>trer une fonction
         r<>cup<75>rant des templates.
         </para>
<example>
<title>register_resource</title>
<programlisting>
$smarty->register_resource("db", array("db_get_template",
                                       "db_get_timestamp",
                                       "db_get_secure",
                                       "db_get_trusted"));</programlisting>
</example>
		</sect1>
        <sect1 id="api.trigger.error">
         <title>trigger_error</title>
         <funcsynopsis>
          <funcprototype>
           <funcdef>void <function>trigger_error</function></funcdef>
           <paramdef>string <parameter>error_msg</parameter></paramdef>
           <paramdef>[int <parameter>level</parameter>]</paramdef>
          </funcprototype>
         </funcsynopsis>
         <para>
         Cette fonction peut-<2D>tre utilis<69>e pour afficher un message d'erreur
         en utilisant Smarty. Le param<61>tre <parameter>level</parameter>
         peut prendre l'une des valeures utilis<69>es par la fonction PHP
         trigger_error, i.e. E_USER_NOTICE, E_USER_WARNING, etc. Par d<>faut
         il s'agit de E_USER_WARNING.
         </para>
        </sect1>

        <sect1 id="api.template.exists">
         <title>template_exists</title>
         <funcsynopsis>
          <funcprototype>
           <funcdef>bool <function>template_exists</function></funcdef>
           <paramdef>string <parameter>template</parameter></paramdef>
          </funcprototype>
         </funcsynopsis>
         <para>
         Cette fonction v<>rifie si le template sp<73>cifi<66> existe. Elle accepte
         soit un chemin vers le template, soit une ressource de type
         cha<68>ne de caract<63>res pr<70>cisant le nom du template.
         </para>
        </sect1>
        <sect1 id="api.unregister.block">
         <title>unregister_block</title>
         <funcsynopsis>
          <funcprototype>
           <funcdef>void <function>unregister_block</function></funcdef>
           <paramdef>string <parameter>name</parameter></paramdef>
          </funcprototype>
         </funcsynopsis>
         <para>
         Utilis<69>e pour d<>sallouer dynamiquement un plugin de fonction
         de blocs. Passez en param<61>tre le nom du bloc.
         </para>
		</sect1>
        <sect1 id="api.unregister.compiler.function">
         <title>unregister_compiler_function</title>
         <funcsynopsis>
          <funcprototype>
           <funcdef>void <function>unregister_compiler_function</function></funcdef>
           <paramdef>string <parameter>name</parameter></paramdef>
          </funcprototype>
         </funcsynopsis>
         <para>
         Utilis<69>e pour d<>sallouer dynamiquement un fonction de compilation.
         Passez en param<61>tre le nom de la fonction de compilation.
         </para>
        </sect1>
		<sect1 id="api.unregister.function">
         <title>unregister_function</title>
         <funcsynopsis>
          <funcprototype>
           <funcdef>void <function>unregister_function</function></funcdef>
           <paramdef>string <parameter>name</parameter></paramdef>
          </funcprototype>
         </funcsynopsis>
         <para>
         Utilis<69>e pour d<>sallouer dynamiquement un plugin de fonction
         de templates. Passez en param<61>tres le nom de la fonction de templates.
         </para>
<example>
<title>unregister_function</title>
<programlisting>
// nous ne voulons pas que les designers de templates aient acc<63>s
// au syst<73>me de fichiers.

$smarty->unregister_function("fetch");</programlisting>
</example>
		</sect1>
		<sect1 id="api.unregister.modifier">
         <title>unregister_modifier</title>
         <funcsynopsis>
          <funcprototype>
           <funcdef>void <function>unregister_modifier</function></funcdef>
           <paramdef>string <parameter>name</parameter></paramdef>
          </funcprototype>
         </funcsynopsis>
         <para>
         Utilis<69>e pour d<>sallouer dynamiquement un plugin modificateur de variable.
         Passez en param<61>tre le nom du modificateur de templates.
         </para>
<example>
<title>unregister_modifier</title>
<programlisting>
// nous ne voulons pas que les designers de templates
// suppriment les balises des <20>lements

$smarty->unregister_modifier("strip_tags");</programlisting>
</example>
		</sect1>
		<sect1 id="api.unregister.object">
			<title>unregister_object</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>unregister_object</function></funcdef>
				<paramdef>string <parameter>object_name</parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Utilis<69>e pour d<>sallouer un objet.
         </para>
		</sect1>
		<sect1 id="api.unregister.outputfilter">
			<title>unregister_outputfilter</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>unregister_outputfilter</function></funcdef>
				<paramdef>string <parameter>function_name</parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Utilis<69>e pour d<>sallouer dynamiquement un filtre de sortie.
			</para>
		</sect1>
		<sect1 id="api.unregister.postfilter">
			<title>unregister_postfilter</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>unregister_postfilter</function></funcdef>
				<paramdef>string <parameter>function_name</parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Utilis<69>e pour d<>sallouer dynamiquement un filtre de post-compilation.
			</para>
		</sect1>
		<sect1 id="api.unregister.prefilter">
			<title>unregister_prefilter</title>
			<funcsynopsis>
			<funcprototype>
			<funcdef>void <function>unregister_prefilter</function></funcdef>
				<paramdef>string <parameter>function_name</parameter></paramdef>
			</funcprototype>
			</funcsynopsis>
			<para>
			Utilis<69>e pour d<>sallouer dynamiquement un filtre de pr<70>-compilation.
			</para>
		</sect1>
        <sect1 id="api.unregister.resource">
         <title>unregister_resource</title>
         <funcsynopsis>
          <funcprototype>
           <funcdef>void <function>unregister_resource</function></funcdef>
           <paramdef>string <parameter>name</parameter></paramdef>
          </funcprototype>
         </funcsynopsis>
         <para>
         Utilis<69>e pour d<>sallouer dynamiquement un plugin ressource.
         Passez en param<61>tre le nom de la ressource.
         </para>
<example>
<title>unregister_resource</title>
<programlisting>
$smarty->unregister_resource("db");</programlisting>
</example>
		</sect1>
       </chapter>

  <chapter id="caching">
   <title>Cache</title>
   <para>
   Le cache est utilis<69>e pour acc<63>l<EFBFBD>rer l'appel de <link
   linkend="api.display">display()</link> ou de <link
   linkend="api.fetch">fetch()</link> en sauvegardant leur r<>sultat
   dans un fichier. Si un fichier de cache est disponible lors d'un appel,
   il sera affich<63> sans qu'il ne soit n<>cessaire de reg<65>n<EFBFBD>rer le r<>sultat.
   Le syst<73>me de cache
   peut acc<63>l<EFBFBD>rer les traitements de fa<66>on impressionnante, en particulier les
   templates dont la compilation est tr<74>s longue. Comme le r<>sultat de
   display() ou de fetch() est dans le cache, un fichier de cache peut
   <20>tre compos<6F> de plusieurs fichiers de templates, plusieurs fichiers
   de configuration, etc.
   </para>
   <para>
   Comme les templates sont dynamiques, il est important de faire attention
   <20> la fa<66>on dont les fichiers de cache sont g<>n<EFBFBD>r<EFBFBD>s, et pour combien de temps.
   Si par exemple vous affichez la page d'accueil de votre site Web dont le
   contenu ne change pas souvent, il peut <20>tre int<6E>ressant de mettre cette page
   dans le cache pour une heure ou plus. A l'inverse, si vous affichez une page
   de m<>t<EFBFBD>o mises <20> jour toutes les minutes, mettre cette page en cache
   n'a aucun sens.
   </para>
   <sect1 id="caching.setting.up">
   <title>Param<61>trer le cache</title>
   <para>
   La premi<6D>re chose <20> faire est d'activer le cache. Cela est fait en
   mettant <link linkend="variable.caching">$caching</link> = true
   (ou 1).
   </para>
    <example>
     <title>activation du cache</title>
     <programlisting>
require('Smarty.class.php');
$smarty = new Smarty;

$smarty->caching = true;

$smarty->display('index.tpl');</programlisting>
    </example>
    <para>
    Avec le cache activ<69>, 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<70>f<EFBFBD>r<EFBFBD> <20> la r<>utilisation
    du template.
    </para>
	<note>
	<title>Note technique</title>
	<para>
	Les fichiers situ<74>s dans $cache_dir sont nomm<6D>s de la m<>me fa<66>on 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>
	Tout fichier de cache <20> 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<>glage individuel de cache_lifetime</title>
     <programlisting>
require('Smarty.class.php');
$smarty = new Smarty;

$smarty->caching = 2; // r<>gler la dur<75>e de vie individuellement

// r<>gle la dur<75>e de vie du cache <20> 15 minutes pour index.tpl
$smarty->cache_lifetime = 300;
$smarty->display('index.tpl');

// r<>gle la dur<75>e de vie du cache <20> 1 heure pour home.tpl
$smarty->cache_lifetime = 3600;
$smarty->display('home.tpl');

// NOTE : le r<>glage suivant ne fonctionne pas quand $caching = 2. La dur<75>e de vie
// du fichier de cache de home.tpl a d<>j<EFBFBD> <20>t<EFBFBD> r<>gl<67>e <20> 1 heure et ne respectera
// plus la valeur de $cache_lifetime. Le cache de home.tpl expirera toujours
// dans 1 heure.
$smarty->cache_lifetime = 30; // 30 secondes
$smarty->display('home.tpl');</programlisting>
    </example>
  <para>
  Si <link linkend="variable.compile.check">$compile_check</link> est actif,
  chaque fichier de template et de configuration qui a un rapport
  avec le fichier de cache sera v<>rifi<66> pour d<>tecter une <20>ventuelle
  modification. Si l'un de ces fichiers a <20>t<EFBFBD> modifi<66> depuis que le fichier de cache a <20>t<EFBFBD>
  g<>n<EFBFBD>r<EFBFBD>, le cache est imm<6D>diatement reg<65>n<EFBFBD>r<EFBFBD>. Ce processus est co<63>teux, donc,
  pour des raisons de performances, mettez ce param<61>tre <20> false pour une application
  en production.
  </para>
    <example>
     <title>activation de $compile_check</title>
     <programlisting>
require('Smarty.class.php');
$smarty = new Smarty;

$smarty->caching = true;
$smarty->compile_check = true;

$smarty->display('index.tpl');</programlisting>
	</example>
   <para>
   Si <link linkend="variable.force.compile">$force_compile</link> est actif,
   les fichiers de cache sont toujours reg<65>n<EFBFBD>r<EFBFBD>s. Ceci revient finalement <20>
   d<>sactiver le cache. $force_compile est utilis<69> <20> 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<71>te
   <20> une base de donn<6E>es, vous pouvez utiliser cette m<>thode plut<75>t
   que $compile_check.
   </para>
    <example>
     <title>utilisation de is_cached()</title>
     <programlisting>
require('Smarty.class.php');
$smarty = new Smarty;

$smarty->caching = true;

if(!$smarty->is_cached('index.tpl')) {
   // pas de cache disponible, on assigne
	$contents = get_database_contents();
	$smarty->assign($contents);
}

$smarty->display('index.tpl');</programlisting>
    </example>
    <para>
    Vous pouvez rendre dynamiques seulement certaines parties d'une
    page avec la fonction de templates <link
    linkend="language.function.insert">insert</link>.
    Imaginons que toute une page doit <20>tre mise en cache <20> part
    une banni<6E>re en bas <20> droite. En utilisant une fonction insert pour la
    banni<6E>re, vous pouvez garder cet <20>l<EFBFBD>ment dynamique dans le contenu qui
    est en cache. Reportez-vous <20> 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 fa<66>on
	 individuelle (ou par groupe) avec la fonction <link
	 linkend="api.clear.cache">clear_cache()</link>.
    </para>
    <example>
     <title>nettoyage du cache</title>
     <programlisting>
require('Smarty.class.php');
$smarty = new Smarty;

$smarty->caching = true;

// efface tous les fichiers du cache
$smarty->clear_all_cache();

// efface le fichier de cache du template 'index.tpl'
$smarty->clear_cache('index.tpl');

$smarty->display('index.tpl');</programlisting>
    </example>
   </sect1>
   <sect1 id="caching.multiple.caches">
   <title>Caches multiples pour une seule page</title>
   <para>
   Vous pouvez avoir plusieurs fichiers de caches pour un m<>me appel
   aux fonctions display() ou fetch(). Imaginons qu'un appel <20> display('index.tpl')
   puisse avoir plusieurs r<>sultats, en fonction de certaines conditions, et que
   vous vouliez des fichiers de cache s<>par<61>s pour chacun d'eux. Vous
   pouvez faire cela en passant un identifiant de cache (cache_id) en
   deuxi<78>me param<61>tre <20> l'appel de fonction.
   </para>
    <example>
     <title>Passage d'un cache_id <20> display()</title>
     <programlisting>
require('Smarty.class.php');
$smarty = new Smarty;

$smarty->caching = true;

$my_cache_id = $_GET['article_id'];

$smarty->display('index.tpl',$my_cache_id);</programlisting>
    </example>
    <para>
    Nous passons ci-dessus la variable $my_cache_id <20> display() comme
    identifiant de cache. Pour chaque valeur distincte de $my_cache_id,
    un fichier de cache distinct va <20>tre cr<63><72>. Dans cet exemple,
    "article_id" a <20>t<EFBFBD> pass<73> dans l'URL et est utilis<69> en tant qu'identifiant
    de cache.
    </para>
 	<note>
	<title>Note technique</title>
	<para>
	Soyez prudent en passant des valeurs depuis un client (navigateur Web)
	vers Smarty (ou vers n'importe quelle application PHP). Bien que l'exemple
	ci-dessus consistant <20> utiliser article_id depuis l'URL puisse para<72>tre
	commode, le r<>sultat peut s'av<61>rer mauvais. L'identifiant
	de cache est utilis<69> pour cr<63>er un r<>pertoire sur le syst<73>me de fichiers,
	donc si l'utilisateur d<>cide de donner une tr<74>s grande valeur <20> article_id
	ou d'<27>crire un script qui envoie des article_id de fa<66>on al<61>atoire,
	cela pourra causer des probl<62>mes cot<6F> serveur. Assurez-vous de bien
	tester toute donn<6E>e pass<73>e en param<61>tre avant de l'utiliser. Dans cet
	exemple, peut-<2D>tre savez-vous que article_id a une longueur de 10
   caract<63>res, est exclusivement compos<6F> de caract<63>res alph-num<75>riques et
   doit avoir une valeur contenue dans la base de donn<6E>es. V<>rifiez-le bien !
	</para>
	</note>
	<para>
	Assurez-vous de bien passer le m<>me identifiant aux fonctions
   <link linkend="api.is.cached">is_cached()</link> et
	<link linkend="api.clear.cache">clear_cache()</link>.
	</para>
	<example>
     <title>passer un  cache_id <20> is_cached()</title>
     <programlisting>
require('Smarty.class.php');
$smarty = new Smarty;

$smarty->caching = true;

$my_cache_id = $_GET['article_id'];

if(!$smarty->is_cached('index.tpl',$my_cache_id)) {
	// pas de fichier de cache dispo, on assigne donc les variables
	$contents = get_database_contents();
	$smarty->assign($contents);
}

$smarty->display('index.tpl',$my_cache_id);</programlisting>
    </example>
    <para>
    Vous pouvez effacer tous les fichiers de cache pour un identifiant
    de cache particulier en passant null en tant que premier param<61>tre
    <20> clear_cache().
    </para>
	<example>
     <title>effacement de tous les fichiers de cache pour un identifiant de cache particulier</title>
     <programlisting>
require('Smarty.class.php');
$smarty = new Smarty;

$smarty->caching = true;

// efface tous les fichiers de cache avec "sports" comme identifiant
$smarty->clear_cache(null,"sports");

$smarty->display('index.tpl',"sports");</programlisting>
    </example>
    <para>
    De cette mani<6E>re vous pouvez "grouper" vos fichiers de cache en leur
    donnant le m<>me identifiant.
    </para>
   </sect1>
   <sect1 id="caching.groups">
    <title>groupes de fichiers de cache</title>
    <para>
    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
    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>
	<example>
     <title>groupes d'identifiants de cache</title>
     <programlisting>
require('Smarty.class.php');
$smarty = new Smarty;

$smarty->caching = true;

// efface tous les fichiers de cache avec "sports|basketball" comme premiers
// groupes d'identifiants de cache
$smarty->clear_cache(null,"sports|basketball");

// efface tous les fichiers de cache "sports" comme premier groupe d'identifiants.
// Inclue donc "sports|basketball" ou "sports|nimportequoi|nimportequoi|..."
$smarty->clear_cache(null,"sports");

$smarty->display('index.tpl',"sports|basketball");</programlisting>
    </example>
   <note>
   <title>Note technique</title>
   <para>
   Le 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>
  </chapter>

  <chapter id="advanced.features">
   <title>Fonctionnalit<69>s avanc<6E>es</title>
   <sect1 id="advanced.features.objects">
    <title>Objets</title>
    <para>
    Smarty donne l'acc<63>s aux objets PHP <20> travers les templates. Il y
    a 2 moyens d'y avoir acc<63>s. Le premier consiste <20> allouer les objets
    au template puis de les utiliser avec une syntaxe similaire <20> celles
    des fonctions personnalis<69>es. Le deuxi<78>me moyen consiste <20> allouer
    des objets aux templates et de les utiliser comme n'importe quelle
    variable. La premi<6D>re m<>thode a une syntaxe beaucoup plus sympathique.
    Elle est aussi plus s<>curis<69>e, puisqu'un objet allou<6F> ne peut avoir acc<63>s
    qu'<27> certaines m<>thodes et propri<72>t<EFBFBD>s. N<>anmoins, un objet allou<6F>
    ne peut pas avoir de lien sur lui-m<>me ou <20>tre mis dans un tableau
    d'objet, etc. Vous devez choisir la m<>thode qui correspond <20> vos
    besoins, mais t<>chez d'utiliser la premi<6D>re m<>thode autant que possible
    afin de r<>duire la syntaxe des templates au minimum.
    </para>
    <para>
    Si l'option de s<>curit<69> est activ<69>e, aucune m<>thode ou fonctions priv<69>es
    n'est accessible (commen<65>ant par "_"). S'il existe une m<>thode et une
    propri<72>t<EFBFBD> du m<>me nom, c'est la m<>thode qui sera utilis<69>e.
    </para>
    <para>
    Vous pouvez restreindre l'acc<63>s aux m<>thodes et aux propri<72>t<EFBFBD>s en
    les listant dans un tableau en tant que troisi<73>me param<61>tre
    d'allocation.
    </para>
	<para>
	Par d<>faut, les param<61>tres pass<73>s aux objets depuis le templates le sont de la
  m<>me fa<66>on que les fonctions utilisateurs les r<>cup<75>rent.
  Le premier param<61>tre correspond <20> un tableau associatif, le second <20> l'objet
  Smarty. Si vous souhaitez que les param<61>tres soient pass<73>es un <20> un, comme
  dans un appel traditionnel, d<>finissez registration, quatri<72>me param<61>tre optionnel,
  <20> false.
	</para>
    <example>
     <title>utilisation d'un objet allou<6F> ou assign<67></title>
     <programlisting>
&lt;?php
// la classe

class My_Object() {
	function meth1($params, &$smarty_obj) {
		return "this is my meth1";
	}
}

$myobj = new My_Object;
// enregistre l'objet
$smarty->register_object("foobar",$myobj);
// on restreint l'acc<63>s <20> certaines m<>thodes et propri<72>t<EFBFBD>s en les listant
$smarty->register_object("foobar",$myobj,array('meth1','meth2','prop1'));
// pour utiliser le format habituel de param<61>tre objet, passez le bool<6F>en = false
$smarty->register_object("foobar",$myobj,null,false);

// on peut aussi assigner des objets. Assignez par r<>f<EFBFBD>rence quand c'est possible
$smarty->assign_by_ref("myobj", $myobj);

$smarty->display("index.tpl");
?&gt;

TEMPLATE:

{* acc<63>s <20> notre objet enregistr<74> *}
{foobar->meth1 p1="foo" p2=$bar}

{* on peut aussi assigner la sortie *}
{foobar->meth1 p1="foo" p2=$bar assign="output"}
the output was {$output)

{* access our assigned object *}
{$myobj->meth1("foo",$bar)}</programlisting>
    </example>
  </sect1>
   <sect1 id="advanced.features.prefilters">
    <title>Filtres de pr<70>-compilation</title>
    <para>
    Les filtres de pr<70>-compilation sont des fonctions PHP que vos templates
    ex<65>cutent avant qu'ils ne soient compil<69>s. Cela peut <20>tre utile
    pour pr<70>-traiter vos templates afin d'enlever les commentaires
    inutiles, garder un oeil sur ce que les gens mettent dans leurs templates, etc.
    Les filtre de pr<70>-compilations peuvent <20>tre soit
    <link linkend="api.register.prefilter">d<>clar<61>s</link> soit charg<72>s
    <20> partir des r<>pertoires de plugins en utilisant la fonction
    <link linkend="api.load.filter">load_filter()</link> ou en r<>glant
    la variable
     <link linkend="variable.autoload.filters">$autoload_filters</link>.
     Smarty passera <20> la fonction le code source en tant que premier argument,
     et attendra en retour le code modifi<66>.
    </para>
    <example>
     <title>Utilisation un filtre de pr<70>-compilation de template</title>
     <programlisting>
&lt;?php
// mettre ceci dans votre application
function remove_dw_comments($tpl_source, &$smarty)
{
    return preg_replace("/&lt;!--#.*--&gt;/U","",$tpl_source);
}

// enregistrer le filtre de pr<70>-compilation
$smarty->register_prefilter("remove_dw_comments");
$smarty->display("index.tpl");
?&gt;

{* template Smarty index.tpl *}
&lt;!--# cette ligne va <20>tre supprim<69>e par le filtre de pr<70>-compilation --&gt;</programlisting>
    </example>
   </sect1>

   <sect1 id="advanced.features.postfilters">
    <title>Filtres de post-compilation</title>
    <para>
    Les filtres de post-compilation sont des fonctions PHP que vos templates
    ex<65>cutent apr<70>s avoir <20>t<EFBFBD> compil<69>s. Les filtres de post-compilation peuvent
    <20>tre soit <link linkend="api.register.postfilter">d<>clar<61>s</link> soit charg<72>s
    depuis les r<>pertoires des plugins en utilisant la fonction
    <link linkend="api.load.filter">load_filter()</link> ou en r<>glant
    la variable <link linkend="variable.autoload.filters">$autoload_filters</link>.
    Smarty passera le template compil<69> en tant que premier param<61>tre et attendra
    de la fonction qu'elle retourne le r<>sultat de l'ex<65>cution.
    </para>
    <example>
     <title>utilisation d'un filtre de post-compilation de templates</title>
     <programlisting>
&lt;?php
// mettez cela dans votre application
function add_header_comment($tpl_source, &$smarty)
{
    return "&lt;?php echo \"&lt;!-- Created by Smarty! --&gt;\n\" ?&gt;\n".$tpl_source;
}

// enregistre le filtre de post-compilation
$smarty->register_postfilter("add_header_comment");
$smarty->display("index.tpl");
?&gt;

{* template Smarty compil<69> index.tpl *}
&lt;!-- Created by Smarty! --&gt;
{* reste du contenu du template... *}</programlisting>
    </example>
  </sect1>

  <sect1 id="advanced.features.outputfilters">
   <title>Filtres de sortie</title>
   <para>
   Quand le template est appel<65> via les fonctions display() ou fetch(),
   sa sortie est envoy<6F>e <20> travers un ou plusieurs filtres de sorties.
   Ils diff<66>rent des filtres de post-compilation dans le sens ou ils agissent
   sur la sortie des templates, une fois ex<65>cut<75>s, et non sur les sources
   des templates.
   </para>
   <para>
   Les filtres de sortie peuvent <20>tre soit
   <link linkend="api.register.outputfilter">d<>clar<61>s</link> soit
   charg<72>s depuis les r<>pertoires des plugins en utilisant la fonction
   <link linkend="api.load.filter">load_filter()</link>
   ou en r<>glant la variable
   <link linkend="variable.autoload.filters">$autoload_filters</link>.
   Smarty passera la sortie du template en premier argument et attendra
   de la fonction qu'elle retourne le r<>sultat de l'ex<65>cution.
   </para>
   <example>
    <title>utilisation d'un filtre de sortie</title>
    <programlisting>
&lt;?php
// mettez ceci dans votre application
function protect_email($tpl_output, &$smarty)
{
    $tpl_output =
       preg_replace('!(\S+)@([a-zA-Z0-9\.\-]+\.([a-zA-Z]{2,3}|[0-9]{1,3}))!',
                    '$1%40$2', $tpl_output);
    return $tpl_output;
}

// enregistre le filtre de sortie
$smarty->register_outputfilter("protect_email");
$smarty->display("index.tpl");

// dor<6F>navant toute occurence d'un adresse email dans le r<>sultat du template
// aura un protection simple contre les robots spammers
?&gt;</programlisting>
   </example>
  </sect1>

  <sect1 id="section.template.cache.handler.func">
   <title>Fonction de gestion du cache</title>
   <para>
   Une alternative au m<>canisme de cache par d<>faut (bas<61> sur des fichiers
   de cache) consiste <20> sp<73>cifier une fonction de gestion de cache utilisateur
   qui sera utilis<69>e pour lire, <20>crire et effacer les fichiers de cache.
   </para>
   <para>
   Il suffit de cr<63>er dans votre application une fonction que Smarty
   utilisera pour la gestion du cache et d'assigner le nom de cette
   fonction <20> la variable de classe
   <link linkend="variable.cache.handler.func">$cache_handler_func</link>.
   Smarty utilisera alors cette fonction pour g<>rer les donn<6E>es du cache.
   Le premier argument est l'action, qui sera 'read', 'write' ou 'clear'.
   Le second param<61>tre est l'objet Smarty. Le troisi<73>me est le contenu
   du cache. Pour <20>crire, Smarty passe le contenu du cache dans ces param<61>tres.
   Pour lire, Smarty s'attend <20> ce que votre fonction accepte ce param<61>tre
   par r<>f<EFBFBD>rence et que vous le remplissiez avec les donn<6E>es du cache. Pour effacer,
   il suffit de passer une variable fictive car cette derni<6E>re n'est pas utilis<69>e.
   Le quatri<72>me param<61>tre est le nom du fichier de template (utile pour
   lire/<2F>crire), le cinqui<75>me param<61>tre est l'identifiant de cache (optionnel)
   et le sixi<78>me est l'identifiant de compilation.
   </para>
   <example>
    <title>exemple d'utilisation de MySQL pour la source du cache</title>
    <programlisting>
&lt;?php
/*

exemple d'usage :

include('Smarty.class.php');
include('mysql_cache_handler.php');

$smarty = new Smarty;
$smarty-&gt;cache_handler_func = 'mysql_cache_handler';

$smarty-&gt;display('index.tpl');


la base mysql est attendu dans ce format :
	
create database SMARTY_CACHE;

create table CACHE_PAGES(
CacheID char(32) PRIMARY KEY,
CacheContents MEDIUMTEXT NOT NULL
);

*/

function mysql_cache_handler($action, &$smarty_obj, &$cache_content, $tpl_file=null, $cache_id=null, $compile_id=null)
{
	// l'h<>te de la bd, l'utilisateur, et le mot de passe
	$db_host = 'localhost';
	$db_user = 'myuser';
	$db_pass = 'mypass';
	$db_name = 'SMARTY_CACHE';
	$use_gzip = false;
	
	// cr<63>e un identifiant de cache unique
	$CacheID = md5($tpl_file.$cache_id.$compile_id);
	
	if(! $link = mysql_pconnect($db_host, $db_user, $db_pass)) {
		$smarty_obj-&gt;_trigger_error_msg("cache_handler: could not connect to database");
		return false;
	}
	mysql_select_db($db_name);

	switch ($action) {
		case 'read':
			// r<>cup<75>re le cache dans la base de donn<6E>es
			$results = mysql_query("select CacheContents from CACHE_PAGES where CacheID='$CacheID'");
			if(!$results) {
				$smarty_obj-&gt;_trigger_error_msg("cache_handler: query failed.");			
			}
			$row = mysql_fetch_array($results,MYSQL_ASSOC);
			
			if($use_gzip && function_exists("gzuncompress")) {
				$cache_contents = gzuncompress($row["CacheContents"]);
			} else {
				$cache_contents = $row["CacheContents"];
			}
			$return = $results;
			break;
		case 'write':
			// sauvegarde le cache dans la base de donn<6E>es
			
			if($use_gzip && function_exists("gzcompress")) {
				// compresse le contenu pour gagner de la place
				$contents = gzcompress($cache_content);
			} else {
				$contents = $cache_content;
			}
			$results = mysql_query("replace into CACHE_PAGES values(
							'$CacheID',
							'".addslashes($contents)."')
						");
			if(!$results) {
				$smarty_obj-&gt;_trigger_error_msg("cache_handler: query failed.");			
			}
			$return = $results;
			break;
		case 'clear':
         // efface les donn<6E>es du cache
			if(empty($cache_id) && empty($compile_id) && empty($tpl_file)) {
				// les efface toutes
				$results = mysql_query("delete from CACHE_PAGES");			
			} else {
				$results = mysql_query("delete from CACHE_PAGES where CacheID='$CacheID'");			
			}
			if(!$results) {
				$smarty_obj-&gt;_trigger_error_msg("cache_handler: query failed.");			
			}
			$return = $results;
			break;
		default:
			// erreur, action inconnue
			$smarty_obj-&gt;_trigger_error_msg("cache_handler: unknown action \"$action\"");
			$return = false;
			break;
	}
	mysql_close($link);
   return $return;
	
}

?&gt;</programlisting>
    </example>
  </sect1>

  <sect1 id="template.resources">  
   <title>Ressources</title>
   <para>
   Les templates peuvent provenir d'une grande vari<72>t<EFBFBD> de ressources. Quand vous
   affichez ou r<>cup<75>rez un template, ou quand vous incluez un template
   dans un autre template, vous fournissez un type de ressource, suivi
   par le chemin appropri<72> et le nom du template.
   </para>
      <sect2 id="templates.from.template.dir">
    <title>Templates depuis $template_dir</title>
    <para>
    Les templates du r<>pertoire $template_dir n'ont pas
    besoin d'une ressource template, bien que vous puissiez utiliser
    la ressource "file" pour <20>tre coh<6F>rent. Vous n'avez qu'<27> fournir
    le chemin vers le template que vous voulez utiliser, relatif
    au r<>pertoire racine $template_dir.
    </para>    
    <example>
     <title>Utilisation de templates depuis $template_dir</title>
     <programlisting>
// le script PHP
$smarty->display("index.tpl");
$smarty->display("admin/menu.tpl");
$smarty->display("file:admin/menu.tpl"); // le m<>me que celui ci-dessus

{* le template Smarty *}
{include file="index.tpl"}
{include file="file:index.tpl"} {* le m<>me que celui ci-dessus *}</programlisting>
    </example>
   </sect2>
   <sect2 id="templates.from.any.dir">
    <title>Templates <20> partir de n'importe quel r<>pertoire</title>
    <para>
    Les templates en-dehors du r<>pertoire $template_dir n<>cessitent
    le type de ressource template, suivi du chemin absolu et du nom du
    template.
    </para>    
    <example>
     <title>utilisation d'un template depuis n'importe quel r<>pertoire</title>
     <programlisting>
// le script PHP
$smarty->display("file:/export/templates/index.tpl");
$smarty->display("file:/path/to/my/templates/menu.tpl");

{* le template Smarty *}
{include file="file:/usr/local/share/templates/navigation.tpl"}</programlisting>
    </example>

    <sect3>
     <title>Chemin de fichiers Windows</title>
     <para>
     Si vous utilisez Windows, les chemins de fichiers sont la plupart
     du temps sur un disque identifi<66> par une lettre (c:) au d<>but du chemin.
     Assurez-vous de bien mettre "file:" dans le chemin pour <20>viter des
     conflits d'espace de nommage et obtenir les r<>sultats escompt<70>s.
     </para>
     <example>
      <title>utilisation de templates avec des chemins de fichiers Windows</title>
      <programlisting>
// le script PHP
$smarty->display("file:C:/export/templates/index.tpl");
$smarty->display("file:F:/path/to/my/templates/menu.tpl");

{* le template Smarty *}
{include file="file:D:/usr/local/share/templates/navigation.tpl"}</programlisting>
     </example>
    </sect3>
   </sect2>

   <sect2 id="templates.from.elsewhere">
    <title>Templates depuis d'autres sources</title>
    <para>
    Vous pouvez r<>cup<75>rer les templates <20> partir n'importe quelle
    source <20> laquelle vous avez acc<63>s avec PHP : base de donn<6E>es,
    sockets, LDAP et ainsi de suite. Il suffit d'<27>crire les fonctions
    de ressource plugins et de les enregistrer aupr<70>s de Smarty. 
    </para>
    <para>
    Reportez-vous <20> la section <link linkend="plugins.resources">ressource plugins</link>
    pour plus d'informations sur les fonctions que vous <20>tes cens<6E> fournir.
    </para>
    <note>
     <para>
     Notez que vous ne pouvez pas <20>craser la ressource <literal>file</literal> native,
     toutefois, vous pouvez fournir une ressource qui r<>cup<75>re un template depuis
     le syst<73>me de fichier par un autre moyen en l'enregistrant sous un autre
     nom de ressource.
     </para>
    </note>
    <example>
     <title>utilisation de ressources utilisateurs</title>
     <programlisting>
// le script PHP

// mettez ces fonctions quelque part dans votre application
function db_get_template ($tpl_name, &amp;$tpl_source, &amp;$smarty_obj)
{
    // requ<71>te BD pour r<>cup<75>rer le template
    // et remplir $tpl_source
    $sql = new SQL;
    $sql->query("select tpl_source
                   from my_table
                  where tpl_name='$tpl_name'");
    if ($sql->num_rows) {
        $tpl_source = $sql->record['tpl_source'];
        return true;
    } else {
        return false;
    }
}

function db_get_timestamp($tpl_name, &amp;$tpl_timestamp, &amp;$smarty_obj)
{
    // requ<71>te BD pour remplir $tpl_timestamp
    $sql = new SQL;
    $sql->query("select tpl_timestamp
                   from my_table
                  where tpl_name='$tpl_name'");
    if ($sql->num_rows) {
        $tpl_timestamp = $sql->record['tpl_timestamp'];
        return true;
    } else {
        return false;
    }
}

function db_get_secure($tpl_name, &$smarty_obj)
{
    // on suppose que tous les templates sont s<>rs
    return true;
}

function db_get_trusted($tpl_name, &$smarty_obj)
{
    // pas utilis<69>e pour les templates dans notre cas
}

// enregistre le nom de ressource "db"
$smarty->register_resource("db", array("db_get_template",
                                       "db_get_timestamp",
                                       "db_get_secure",
                                       "db_get_trusted"));

// utilise la ressource depuis le script PHP
$smarty->display("db:index.tpl");

{* utilise la ressource depuis le template Smarty *}
{include file="db:/extras/navigation.tpl"}</programlisting>
    </example>
   </sect2>

   <sect2 id="default.template.handler.function">
    <title>Fonction de gestion de template par d<>faut</title>
    <para>
    Vous pouvez sp<73>cifier une fonction qui sera utilis<69>e pour
    r<>cup<75>rer le contenu d'un template dans le cas o<> le template
    ne peut pas <20>tre r<>cup<75>r<EFBFBD> depuis sa ressource. Une utilisation possible est
    la cr<63>ation de templates <20> la vol<6F>e.
    </para>
    <example>
     <title>utilisation de la fonction de gestion de template par d<>faut</title>
     <programlisting>
&lt;?php
// mettez cette fonction quelque part dans votre application

function make_template ($resource_type, $resource_name, &amp;$template_source, &amp;$template_timestamp, &amp;$smarty_obj)
{
	if( $resource_type == 'file' ) {
		if ( ! is_readable ( $resource_name )) {
			// cr<63>e le fichier de template et renvoie le contenu
			$template_source = "This is a new template.";
			$template_timestamp = time();
			$smarty_obj->_write_file($resource_name,$template_source);
			return true;
		}
    } else {
		// pas un fichier
		return false;
    }
}

// r<>gle la fonction par d<>faut
$smarty->default_template_handler_func = 'make_template';
?&gt;</programlisting>
    </example>
   </sect2>
  </sect1>
 </chapter>

 <chapter id="plugins">
  <title>Etendre Smarty avec des plugins</title>
  <para>
  La version 2.0 a introduit l'architecture de plugin qui est
  utilis<69>e pour pratiquement toute les fonctionnalit<69>s
  personnalisables de Smarty. Ceci comprend : 
  <itemizedlist spacing=compact>
    <listitem><simpara>les fonctions</simpara></listitem>
    <listitem><simpara>les modificateurs</simpara></listitem>
    <listitem><simpara>les fonctions de blocs</simpara></listitem>
    <listitem><simpara>les fonctions de compilation</simpara></listitem>
    <listitem><simpara>les filtres de pr<70>-compilation</simpara></listitem>
    <listitem><simpara>les filtres de post-compilation</simpara></listitem>
    <listitem><simpara>les filtres de sorties</simpara></listitem>
    <listitem><simpara>les ressources</simpara></listitem>
    <listitem><simpara>les insertions</simpara></listitem>
  </itemizedlist>
  A part pour les ressources, la compatibilit<69> avec les anciennes
  fa<66>ons d'enregistrer les fonctions de gestion avec l'API register_
  est conserv<72>e. Si vous n'avez pas utilis<69> cette API et que vous avez
  <20> la place directement modifi<66> les variables de classes 
  <literal>$custom_funcs</literal>, <literal>$custom_mods</literal> et
  d'autres, vous devez alors modifier vos scripts pour utiliser
  l'API ou convertir vos fonctionnalit<69>s personnalis<69>es en plugins.
  </para>
     
  <sect1>
   <title>Comment fonctionnent les plugins</title>
   <para>
   Les plugins sont toujours charg<72>s <20> la demande. Seuls les modificateurs
   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
   m<>me si vous avez plusieurs instances de Smarty qui tournent dans
   la m<>me requ<71>te.
   </para>
   <para>
   Les filtres de post/pr<70>-compilation et les filtres de sortie sont des cas
   un peu sp<73>ciaux.
   Comme ils ne sont pas mentionn<6E>s dans les templates, ils doivent <20>tre d<>clar<61>s
   ou charg<72>s explicitement via les fonctions de l'API avant que le template
   ne soit ex<65>cut<75>. L'ordre dans lequel les filtres multiples d'un m<>me type
   sont ex<65>cut<75>s d<>pend de l'ordre dans lequel ils sont enregistr<74>s ou charg<72>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.
   </para>   
  </sect1>

   <sect1 id="plugins.naming.conventions">
    <title>Conventions de nommage</title>
    <para>
    Les fichiers et les fonctions de plugins doivent suivre une convention
    de nommage tr<74>s sp<73>cifique pour <20>tre localis<69>s par Smarty.
    </para>
    <para>
    Les fichiers de plugins doivent <20>tre nomm<6D>s de la fa<66>on suivante :
    <blockquote>
      <para>
       <filename>
        <replaceable>type</replaceable>.<replaceable>nom</replaceable>.php
       </filename>
      </para>
     </blockquote>
    </para>
    <para>
    O<> <literal>type</literal> est l'une des valeurs suivantes :
    <itemizedlist spacing=compact>
      <listitem><simpara>function</simpara></listitem>
      <listitem><simpara>modifier</simpara></listitem>
      <listitem><simpara>block</simpara></listitem>
      <listitem><simpara>compiler</simpara></listitem>
      <listitem><simpara>prefilter</simpara></listitem>
      <listitem><simpara>postfilter</simpara></listitem>
      <listitem><simpara>outputfilter</simpara></listitem>
      <listitem><simpara>resource</simpara></listitem>
      <listitem><simpara>insert</simpara></listitem>
     </itemizedlist>
    </para>
    <para>
    Et <literal>nom</literal> doit <20>tre un identifiant valide (lettres, nombres
    et underscore seulement).
    </para>
    <para>
    Quelques exemples : <literal>function.html_select_date.php</literal>,
    <literal>resource.db.php</literal>,
    <literal>modifier.spacify.php</literal>.
    </para>
    <para>
    Les fonctions de plugins dans les fichiers de plugins doivent <20>tre
    nomm<6D>es de la fa<66>on suivante :
    <blockquote>
      <para>
       <function>smarty_<replaceable>type</replaceable>_<replaceable>nom</replaceable></function>
      </para>
     </blockquote> 
    </para>
    <para>
    Les significations de <literal>type</literal> et de <literal>nom</literal> sont les m<>mes
    que pr<70>c<EFBFBD>demment.
    </para>
    <para>
    Smarty donnera des messages d'erreur appropri<72> si le fichier de plugin
    n'est pas trouv<75>, ou si le fichier ou la fonction de plugin ne sont
    pas nomm<6D>s correctement.
    </para>
    </sect1>

   <sect1 id="plugins.writing">
    <title>Ecrire des plugins</title>
    <para>
    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
    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
    l'API.
    </para>
    <para>
    Pour les plugins qui ne sont pas enregistr<74>s pendant l'ex<65>cution, le nom
    des fonctions n'ont pas <20> suivre la convention de nommage.
    </para>
    <para>
    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
    de charger le plugin est la suivante :
    </para>
    
    <programlisting>
require_once SMARTY_DIR . 'plugins/function.html_options.php';</programlisting>
    <para>
    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 (<28> part pour les modificateurs).
    </para>    
   </sect1>

   <sect1 id="plugins.functions"><title>Les fonctions de templates</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>void <function>smarty_function_<replaceable>name</replaceable></function></funcdef>
      <paramdef>array <parameter>$params</parameter></paramdef>
      <paramdef>object <parameter>&$smarty</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
    Tous les attributs pass<73>s aux fonctions de template <20> partir du template
    sont contenus dans le tableau associatif <parameter>$params</parameter>.
    Vous pouvez acc<63>der <20> 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<74>e <20> 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<69>s fournies par Smarty, elle peut recevoir un
    objet <parameter>$smarty</parameter> pour cela.
    </para>
    <para>
     R<>f<EFBFBD>rez-vous aussi <20> :
     <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>
&lt;?php
/*
 * Smarty plugin
 * -------------------------------------------------------------
 * Fichier :  function.eightball.php
 * Type :     fonction
 * Nom :      eightball
 * R<>le :     renvoie une phrase magique au hasard
 * -------------------------------------------------------------
 */
function smarty_function_eightball($params, &amp;$smarty)
{
    $answers = array('Yes',
                     'No',
                     'No way',
                     'Outlook not so good',
                     'Ask again soon',
                     'Maybe in your reality');

    $result = array_rand($answers);
    return $answers[$result];
}
?&gt;</programlisting>
     </example>
    </para>
    <para>
     peut <20>tre utilis<69>e dans le template de la fa<66>on suivante :
    </para>
    <programlisting>
Question: Will we ever have time travel?
Answer: {eightball}.</programlisting>
    <para>
     <example>
      <title>fonction de plugin sans sortie</title>
      <programlisting>
&lt;?php
/*
 * Smarty plugin
 * -------------------------------------------------------------
 * Fichier :  function.assign.php
 * Type :     fonction
 * Nom :      assign
 * Purpose :  assigne une valeur <20> une variable de template
 * -------------------------------------------------------------
 */
function smarty_function_assign($params, &amp;$smarty)
{
    extract($params);

    if (empty($var)) {
        $smarty->trigger_error("assign: missing 'var' parameter");
        return;
    }

    if (!in_array('value', array_keys($params))) {
        $smarty->trigger_error("assign: missing 'value' parameter");
        return;
    }

    $smarty->assign($var, $value);
}
?&gt;</programlisting>
     </example>
    </para>
   </sect1>

   <sect1 id="plugins.modifiers"><title>Modificateurs</title>
    <para>
    Les modificateurs sont des petites fonctions appliqu<71>es <20> une variable
    de template avant qu'elle ne soit affich<63>e ou utilis<69>e dans un autre contexte.
    Les modificateurs peuvent <20>tre cha<68>n<EFBFBD>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<61>tre pass<73> au modificateur est la valeur
    sur laquelle le modificateur est suppos<6F> op<6F>rer. Les autres param<61>tres
    peuvent <20>tre optionnels, d<>pendant de quel genre d'op<6F>ration doit <20>tre
    effectu<74>.
    </para>
    <para>
    Le modificateur doit retourner le r<>sultat de son ex<65>cution.
    </para>
    <para>
    Regardez aussi
    <link linkend="api.register.modifier">register_modifier()</link>,
     <link linkend="api.unregister.modifier">unregister_modifier()</link>.
    </para>
    <example>
     <title>plugin modificateur simple</title>
     <para>
     Ce plugin est un alias d'une fonction PHP. Il n'a aucun param<61>tre
     suppl<70>mentaires.
     </para>
     <programlisting>
&lt;?php
/*
 * Smarty plugin
 * -------------------------------------------------------------
 * Fichier :  modifier.capitalize.php
 * Type :     modificateur
 * Name :     capitalize
 * R<>le :     met une majuscule aux mots d'une phrase
 * -------------------------------------------------------------
 */
function smarty_modifier_capitalize($string)
{
    return ucwords($string);
}
?&gt;</programlisting>
    </example>
    <para></para>
    <example>
     <title>un plugin modificateur un peu plus complexe</title>
     <programlisting>
&lt;?php
/*
 * Smarty plugin
 * -------------------------------------------------------------
 * Fichier :  modifier.truncate.php
 * Type :     modificateur
 * Name :     truncate
 * R<>le :     Tronque une cha<68>ne <20> une certaine longueur si
 *            n<>cessaire, la coupe optionnellement au milieu
 *            d'un mot et ajoute la cha<68>ne $etc 
 * -------------------------------------------------------------
 */
function smarty_modifier_truncate($string, $length = 80, $etc = '...',
                                  $break_words = false)
{
    if ($length == 0)
        return '';

    if (strlen($string) > $length) {
        $length -= strlen($etc);
        $fragment = substr($string, 0, $length+1);
        if ($break_words)
            $fragment = substr($fragment, 0, -1);
        else
            $fragment = preg_replace('/\s+(\S+)?$/', '', $fragment);
        return $fragment.$etc;
    } else
        return $string;
}
?&gt;</programlisting>
    </example>
   </sect1>

   <sect1 id="plugins.block.functions"><title>Fonctions de blocs</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>void <function>smarty_block_<replaceable>name</replaceable></function></funcdef>
      <paramdef>array <parameter>$params</parameter></paramdef>
      <paramdef>mixed <parameter>$content</parameter></paramdef>
      <paramdef>object <parameter>&$smarty</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
    Les fonctions de blocs sont des fonctions de la forme {func} .. {/func}.
    En d'autres mots, elles englobent des blocs de template et op<6F>rent sur les
    contenus de ces blocs. Les fonctions de blocs ont la priorit<69> 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<70>mentation de votre fonction est appel<65>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<73>s par le template aux fonctions de templates sont
    contenues dans le tableau associatif <parameter>$params</parameter>.
    Vous pouvez acc<63>der <20> 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<63>s aux attributs de la balise
    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
    selon si votre fonction est appel<65>e pour la balise ouvrante ou la
    balise fermante. Si c'est pour la balise ouvrante, elle sera <20>
    <literal>null</literal> et si c'est la balise fermante elle sera
    <20>gale au contenu du bloc de template. Notez que le bloc de template
    aura d<>j<EFBFBD> <20>t<EFBFBD> ex<65>cut<75> par Smarty, vous recevrez donc la sortie du
    template et non sa source.    
    </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>.
    Faites 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>.
    </para>
    <example>
     <title>fonction de bloc</title>
     <programlisting>
&lt;?php
/*
 * Smarty plugin
 * -------------------------------------------------------------
 * Fichier :  block.translate.php
 * Type :     bloc
 * Nom :      translate
 * R<>le :     traduire un bloc de texte
 * -------------------------------------------------------------
 */
function smarty_block_translate($params, $content, &amp;$smarty)
{
    if ($content) {
        $lang = $params['lang'];
        // fait une traduction de $content
        echo $translation;
    }
}</programlisting>
    </example>
   </sect1>

   <sect1 id="plugins.compiler.functions"><title>Fonctions de compilation</title>
    <para>
    Les fonctions de compilation sont appel<65>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<69>e ont le m<>me
    nom, la fonction de compilation a priorit<69>. 
    </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<61>tres : une cha<68>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<6E>es retourner le code PHP qui doit <20>tre
    inject<63> dans le template compil<69>.
    </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>
&lt;?php
/*
 * Smarty plugin
 * -------------------------------------------------------------
 * Fichier :   compiler.tplheader.php
 * Type :      compilation
 * Nom :       tplheader
 * R<>le :      Renvoie l'en-t<>te contenant le nom du fichier
 *             source et le temps de compilation.
 * -------------------------------------------------------------
 */
function smarty_compiler_tplheader($tag_arg, &$smarty)
{
    return "\necho '" . $smarty-&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 :
     </para>     
     <programlisting>
{* cette fonction n'est execut<75>e que lors de la compilation *}
{tplheader}</programlisting>
     <para>
     Le code PHP r<>sultant dans les templates compil<69>s ressemblerait <20> <20>a :
     </para>
     <programlisting>
&lt;php
echo 'index.tpl compiled at 2002-02-20 20:02';
?&gt;</programlisting>
    </example>
   </sect1>

   <sect1 id="plugins.prefilters.postfilters">
    <title>filtres de pr<70>-compilation/filtres de post-compilation</title>
    <para>
    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
    moment o<> ils sont ex<65>cut<75>s.
    </para>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>smarty_prefilter_<replaceable>name</replaceable></function></funcdef>
      <paramdef>string <parameter>$source</parameter></paramdef>
      <paramdef>object <parameter>&$smarty</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
    Les filtres de 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> <20> la fonction
    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.
    Notez que cette source n'est sauvegard<72>e nulle part, elle est seulement
    utilis<69> pour la compilation.
    </para>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>smarty_postfilter_<replaceable>name</replaceable></function></funcdef>
      <paramdef>string <parameter>$compiled</parameter></paramdef>
      <paramdef>object <parameter>&$smarty</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
    Les filtres de post-compilation sont 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
    avant que le template ne soit sauvegard<72> sur le syst<73>me de fichiers.
    Le premier param<61>tre pass<73> <20> la fonction de filtre de post-compilation est le code
    du template compil<69>, <20>ventuellement d<>j<EFBFBD> modifi<66> par d'autres filtre de post-compilations.
    Le plugin est cens<6E> retourner la version modifi<66> du code.
    </para>
    <example>
     <title>plugin de filtre de post-compilation</title>
     <programlisting>
&lt;?php
/*
 * Smarty plugin
 * -------------------------------------------------------------
 * Fichier :  prefilter.pre01.php
 * Type :     filtre de pr<70>-compilation
 * Nom :      pre01
 * R<>le :     Passe les balises HTML en minuscules.
 * -------------------------------------------------------------
 */
 function smarty_prefilter_pre01($source, &$smarty)
 {
     return preg_replace('!&lt;(\w+)[^&gt;]+&gt;!e', 'strtolower("$1")', $source);
 }
?&gt;</programlisting>
    </example>
    <para></para>
    <example>
     <title>plugin de filtre de post-compilation</title>
     <programlisting>
&lt;?php
/*
 * Smarty plugin
 * -------------------------------------------------------------
 * Fichier :  postfilter.post01.php
 * Type:      filtre de post-compilation
 * Nom :      post01
 * R<>le :     Renvoie du code qui liste toutes les variables
 *            du template.
 * -------------------------------------------------------------
 */
 function smarty_postfilter_post01($compiled, &$smarty)
 {
     $compiled = "&lt;pre&gt;\n&lt;?php print_r(\$this-&gt;get_template_vars()); ?&gt;\n&lt;/pre&gt;" . $compiled;
     return $compiled;
 }
?&gt;</programlisting>
    </example>
   </sect1>

   <sect1 id="plugins.outputfilters"><title>Filtres de sortie</title>
    <para>
    Les plugins de filtres de sortie op<6F>rent sur la sortie du template,
    apr<70>s que le template a <20>t<EFBFBD> charg<72> et ex<65>cut<75>, mais avant que
    la sortie ne soit affich<63>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<61>tre pass<73> <20> la fonction du filtre de sortie est la
    sortie du template qui doit <20>tre modifi<66>e et le second param<61>tre
    est l'instance de Smarty appelant le plugin. Le plugin est suppos<6F>
    faire un traitement et en retourner le r<>sultat.
    </para>
    <example>
     <title>plugin de filtre de sortie</title>
     <programlisting>
/*
 * Smarty plugin
 * -------------------------------------------------------------
 * Fichier :  outputfilter.protect_email.php
 * Type :     filtre de sortie
 * Nom :      protect_email
 * R<>le:     Convertie les @ en %40 pour prot<6F>ger des 
 *           robots spammers.
 * -------------------------------------------------------------
 */
 function smarty_outputfilter_protect_email($output, &$smarty)
 {
     return preg_replace('!(\S+)@([a-zA-Z0-9\.\-]+\.([a-zA-Z]{2,3}|[0-9]{1,3}))!',
                         '$1%40$2', $output);
 }
     </programlisting>
    </example>
   </sect1>

   <sect1 id="plugins.resources"><title>Ressources</title>
    <para>
    Les plugins ressources sont un moyen g<>n<EFBFBD>rique de fournir des sources
    de templates ou des composants de scripts PHP <20> Smarty. Quelques exemples
    de ressources : bases de donn<6E>es, LDAP, m<>moire partag<61>e, sockets, et ainsi
    de suite.
    </para>
    <para>
    Il y au total 4 fonctions qui ont besoin d'<27>tre enregistr<74>es pour
    chaque type de ressource. Chaque fonction re<72>oit le nom de la ressource demand<6E>e
    comme premier param<61>tre et l'objet Smarty comme dernier param<61>tre.
    Les autres param<61>tres d<>pendent de la fonction.
    </para>
    <funcsynopsis>
     <funcprototype>
      <funcdef>bool <function>smarty_resource_<replaceable>name</replaceable>_source</function></funcdef>
      <paramdef>string <parameter>$rsrc_name</parameter></paramdef>
      <paramdef>string <parameter>&$source</parameter></paramdef>
      <paramdef>object <parameter>&$smarty</parameter></paramdef>
     </funcprototype>
     <funcprototype>
      <funcdef>bool <function>smarty_resource_<replaceable>name</replaceable>_timestamp</function></funcdef>
      <paramdef>string <parameter>$rsrc_name</parameter></paramdef>
      <paramdef>int <parameter>&$timestamp</parameter></paramdef>
      <paramdef>object <parameter>&$smarty</parameter></paramdef>
     </funcprototype>
     <funcprototype>
      <funcdef>bool <function>smarty_resource_<replaceable>name</replaceable>_secure</function></funcdef>
      <paramdef>string <parameter>$rsrc_name</parameter></paramdef>
      <paramdef>object <parameter>&$smarty</parameter></paramdef>
     </funcprototype>
     <funcprototype>
      <funcdef>bool <function>smarty_resource_<replaceable>name</replaceable>_trusted</function></funcdef>
      <paramdef>string <parameter>$rsrc_name</parameter></paramdef>
      <paramdef>object <parameter>&$smarty</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>

    <para>
    La 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
    stock<63>. La fonction est suppos<6F>e retourner <literal>true</literal> si
    elle r<>ussi <20> r<>cup<75>rer la ressource et <literal>false</literal> sinon.
    </para>

    <para>
    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
    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
    a r<>ussi <20> r<>cup<75>rer la date et <literal>false</literal> sinon.
    </para>

    <para>
    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 s<>re
    ou non. La fonction est utilis<69>e seulement pour les ressources templates
    mais doit tout de m<>me <20>tre d<>finie.
    </para>

    <para>
    La quatri<72>me fonction est suppos<6F>e retourner <literal>true</literal>
    ou <literal>false</literal> selon si on peut faire confiance ou
    non <20> la ressource demand<6E>e. Cette fonction est utilis<69>e seulement
    pour les composants de scripts PHP demand<6E>s par les balises
    <command>include_php</command> ou <command>insert</command>
    ayant un attribut <structfield>src</structfield>. Quoiqu'il en soit,
    elle doit <20>tre d<>finie pour les ressources templates.
    </para>

    <para>
     Regardez aussi
     <link linkend="api.register.resource">register_resource()</link>,
     <link linkend="api.unregister.resource">unregister_resource()</link>.
    </para>
    <example>
     <title>resource plugin</title>
     <programlisting>
&lt;?php
/*
 * Smarty plugin
 * ------------------------------------------------------------- 
 * Fichier :  resource.db.php
 * Type :     ressource
 * Nom :      db
 * 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)
{
    // fait des requ<71>tes BD pour r<>cup<75>rer votre template
    // et remplir $tpl_source
    $sql = new SQL;
    $sql->query("select tpl_source
                   from my_table
                  where tpl_name='$tpl_name'");
    if ($sql->num_rows) {
        $tpl_source = $sql->record['tpl_source'];
        return true;
    } else {
        return false;
    }
}

function smarty_resource_db_timestamp($tpl_name, &amp;$tpl_timestamp, &amp;$smarty)
{
    // fait des requ<71>tes BD pour remplir $tpl_timestamp
    $sql = new SQL;
    $sql->query("select tpl_timestamp
                   from my_table
                  where tpl_name='$tpl_name'");
    if ($sql->num_rows) {
        $tpl_timestamp = $sql->record['tpl_timestamp'];
        return true;
    } else {
        return false;
    }
}

function smarty_resource_db_secure($tpl_name, &amp;$smarty)
{
    // suppose que tous les templates sont s<>rs
    return true;
}

function smarty_resource_db_trusted($tpl_name, &amp;$smarty)
{
    // inutilis<69>e pour les templates
}
?&gt;</programlisting>
    </example>
   </sect1>

   <sect1 id="plugins.inserts"><title>Insertions</title>
    <para>
    Les plugins d'insertion sont utilis<69>s pour impl<70>menter les fonctions
    qui sont appel<65>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<61>tre pass<73> <20> la fonction est une tableau associatif
    d'attributs. Vous pouvez acc<63>der <20> 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<6F>e retourner le r<>sultat qui sera
    substitu<74> <20> la balise <command>insert</command> dans le template.
    </para>    
    <example>
     <title>plugin d'insertion</title>
     <programlisting>
&lt;?php
/*
 * Smarty plugin
 * ------------------------------------------------------------- 
 * Fichier :  insert.time.php
 * Type :     temps
 * Nom :      time
 * R<>le :     Insert la date/heure courante conform<72>ment
 *            au format
 * -------------------------------------------------------------
 */
function smarty_insert_time($params, &amp;$smarty)
{
    if (empty($params['format'])) {
        $smarty->trigger_error("insert time: missing 'format' parameter");
        return;
    }

    $datetime = strftime($params['format']);
    return $datetime;
}
?&gt;</programlisting>
    </example>
   </sect1>
  </chapter>
 </part>