diff --git a/docs/fr/bookinfo.xml b/docs/fr/bookinfo.xml
new file mode 100755
index 00000000..bf4a24de
--- /dev/null
+++ b/docs/fr/bookinfo.xml
@@ -0,0 +1,39 @@
+
+
+
+ Smarty - the compiling PHP template engine
+
+
+ MonteOhrt <monte@ispi.net>
+
+
+ AndreiZmievski <andrei@php.net>
+
+
+ &build-date;
+
+ 2001-2004
+ ispi of Lincoln, Inc.
+
+
+
+
diff --git a/docs/fr/getting-started.xml b/docs/fr/getting-started.xml
new file mode 100644
index 00000000..44cca6be
--- /dev/null
+++ b/docs/fr/getting-started.xml
@@ -0,0 +1,427 @@
+
+ Pour commencer
+
+
+ Qu'est-ce que Smarty ?
+
+ Smarty est un moteur de template pour PHP. Plus précisément, il facilite
+ la séparation entre la logique applicative et la présentation.
+ Cela s'explique plus facilement dans une situation où le
+ programmeur et le designer de templates jouent des rôles différents, ou,
+ comme la plupart du temps, sont deux personnes distinctes.
+ Supposons par exemple que vous concevez une page Web qui affiche un
+ article de newsletter. Le titre, le sous-titre, l'auteur et le corps
+ sont des éléments de contenu, ils ne contiennent aucune information
+ concernant la présentation. Ils sont transmis à Smarty par l'application,
+ puis le designer de templates éditent les templates et utilisent une
+ combinaison de balises HTML et de balises de templates pour formater
+ la présentation de ces éléments (tableaux HTML, couleurs d'arrière-plan,
+ tailles des polices, feuilles de styles, etc.). Un beau jour le programmeur
+ a besoin de changer la façon dont le contenu de l'article
+ est récupéré (un changement dans la logique applicative). Ce
+ changement n'affecte pas le designer de templates, le contenu
+ arrivera toujours au template de la même façon. De même, si le
+ le designer de templates veut changer complétement l'apparence
+ du template, aucun changement dans la logique de l'application
+ n'est nécessaire. Ainsi le programmeur peut changer la logique
+ de l'application sans restructurer les templates, et le designer
+ de templates peut changer les templates sans briser la logique
+ applicative.
+
+
+ Et maintenant un mot rapide sur ce que Smarty NE fait PAS. Smarty n'a
+ pas pour prétention de supprimer complétement les traitements au sein des
+ templates.
+ Il est tout à fait envisageable de recontrer un traitement dans un template,
+ à condition que ce dernier ne désserve que des besoins de présentation.
+ Un conseil : laissez la logique applicative en dehors des templates et
+ la logique de présentation en dehors de l'application. A l'avenir, cela permet
+ une meilleure gestion des évènements.
+
+
+ L'un des aspects unique de Smarty est la compilation des templates.
+ Cela signifie que Smarty lit les templates et crée des scripts PHP à partir
+ de ces derniers. Une fois créés, ils sont exécutés.
+ Il n'y a donc pas d'analyse coûteuse de template à chaque requête,
+ et les templates peuvent bénéficier des solutions de cache PHP
+ comme Zend Accelerator (http://www.zend.com) ou PHP Accelerator
+ (http://www.php-accelerator.co.uk).
+
+
+ Quelques caractéristiques de Smarty :
+
+
+ Il est très rapide.
+ Il est efficace, le parser PHP s'occupe
+ du sale travail.
+ Pas d'analyse de template coûteuse, une seule compilation.
+
+ Il sait ne recompiler que les fichiers de templates
+ qui ont été modifiés.
+ Vous pouvez créer des
+ fonctions utilisateurs et des
+ modificateurs de variables personnalisés, le langage de
+ template est donc extrémement extensible.
+ Syntaxe des templates configurable, vous
+ pouvez utiliser {}, {{}}, <!--{}-->, etc comme délimiteurs.
+
+ Les instructions if/elseif/else/endif
+ sont passées au parser PHP, la syntaxe de l'expression {if...}
+ peut être aussi simple ou aussi complexe que vous
+ le désirez.
+ Imbrication illimitée de sections,
+ de 'if', etc. autorisée.
+ Il est possible d'inclure du code PHP
+ directement dans vos templates, bien que cela ne soit pas obligatoire
+ (ni conseillé), vu que le moteur est extensible.
+ Support de cache intégré.
+ Sources de templates arbitraires.
+ Fonctions de gestion de cache personnalisables.
+ Architecture de plugins
+
+
+
+
+ Installation
+
+
+ Ce dont vous avez besoin
+
+ Smarty nécessite un serveur Web utilisant PHP 4.0.6 ou supérieur.
+
+
+
+
+ Installation de base
+
+ Copiez les fichiers bibliothèques de Smarty du répertoire
+ /libs/ de la distribution à un emplacement accessible à PHP.
+ Ce sont des fichiers PHP que vous NE DEVEZ PAS
+ modifier. Ils sont partagés par toutes les applications et ne seront
+ mis à jour que lorsque vous installerez une nouvelle version de
+ Smarty.
+
+
+ fichiers de la bibliothèque SMARTY
+
+Smarty.class.php
+Smarty_Compiler.class.php
+Config_File.class.php
+debug.tpl
+/plugins/*.php (tous !)
+
+
+
+ Smarty utilise une constante PHP appelée SMARTY_DIR qui
+ représente le chemin complet de la bibliothèque Smarty. En fait,
+ si votre application trouve le fichier
+ Smarty.class.php, vous n'aurez pas
+ besoin de définir la variable SMARTY_DIR, Smarty s'en chargera pour vous.
+ En revanche, si Smarty.class.php
+ n'est pas dans votre répertoire d'inclusion ou que vous ne
+ donnez pas un chemin absolu à votre application, vous
+ devez définir SMARTY_DIR explicitement. SMARTY_DIR
+ doit avoir être terminé par un slash.
+
+
+
+ Voici comment créer une instance de Smarty dans vos scripts PHP :
+
+
+
+ créer une instance de Smarty
+
+require('Smarty.class.php');
+$smarty = new Smarty;
+
+
+
+ Essayez de lancer le script ci-dessus. Si vous obtenez une erreur indiquant
+ que le fichier Smarty.class.php n'est pas trouvé,
+ tentez l'une des choses suivantes :
+
+
+
+ fournir un chemin absolu vers la bibliothèque Smarty
+
+require('/usr/local/lib/php/Smarty/Smarty.class.php');
+$smarty = new Smarty;
+
+
+
+ Ajouter le répertoire de la bibliothèque au chemin de php_include
+
+// Editez le fichier php.ini, ajoutez le répertoire de la
+// bibliothèque Smarty au include_path et redémarrez le serveur Web.
+// Cela devrait ensuite fonctionner :
+require('Smarty.class.php');
+$smarty = new Smarty;
+
+
+
+ Définir explicitement la constante SMARTY_DIR
+
+define('SMARTY_DIR','/usr/local/lib/php/Smarty/');
+require(SMARTY_DIR.'Smarty.class.php');
+$smarty = new Smarty;
+
+
+
+ Maintenant que les fichiers de la librairie sont en place,
+ il est temps de définir les répertoires de Smarty, pour votre application.
+ Smarty a besoin de quatre répertoires qui sont (par défaut)
+ templates,
+ templates_c, configs et
+ cache. Chacun d'entre eux peut être défini
+ via les attributs $template_dir,
+ $compile_dir, $config_dir et
+ $cache_dir respectivement. Il est vivement
+ conseillé que vous régliez ces répertoires séparément pour chaque
+ application qui utilise Smarty.
+
+
+ Assurez-vous de bien connaître chemin de la racine
+ de votre arborescence Web. Dans notre exemple, la racine
+ est "/web/www.mydomain.com/docs". Seul Smarty
+ accède aux répertoires en question, et jamais le serveur Web.
+ Pour des raisons de sécurité, il est donc conseillé de
+ sortir ces répertoires dans un répertoire
+ en dehors de l'arborescence
+ Web.
+
+
+ Dans notre exemple d'installation, nous allons régler l'environnement
+ de Smarty pour une application de livre d'or. Nous avons ici choisi
+ une application principalement pour mettre en évidence une
+ convention de nommage des répertoires. Vous pouvez utiliser le même
+ environnement pour n'importe quelle autre application, il suffit de
+ remplacer "livredor" avec le nom de votre application. Nous allons
+ mettre nos répertoires Smarty dans
+ "/web/www.mydomain.com/smarty/livredor/".
+
+
+ Vous allez avoir besoin d'au moins un fichier à la racine de
+ l'arborescence Web,
+ il s'agit du script auquel l'internaute a accès. Nous allons l'appeler
+ "index.php" et le placer dans un sous-répertoire
+ appelé "/livredor/". Il est pratique de configurer le serveur Web de
+ sorte que "index.php" soit identifié comme fichier
+ par défaut de ce répertoire. Aicnsi, si l'on tape
+ "http://www.mydomain.com/livredor/", le script index.php soit
+ exécuté sans que "index.php" ne soit spécifié dans l'URL. Avec Apache
+ vous pouvez régler cela en ajoutant "index.php" à la ligne où se
+ trouve DirectoryIndex (séparez chaque entrée par un espace).
+
+
+ Jetons un coup d'oeil à la structure de fichier obtenue :
+
+
+
+ exemple de structure de fichiers
+
+/usr/local/lib/php/Smarty/Smarty.class.php
+/usr/local/lib/php/Smarty/Smarty_Compiler.class.php
+/usr/local/lib/php/Smarty/Config_File.class.php
+/usr/local/lib/php/Smarty/debug.tpl
+/usr/local/lib/php/Smarty/plugins/*.php
+
+/web/www.mydomain.com/smarty/livredor/templates/
+/web/www.mydomain.com/smarty/livredor/templates_c/
+/web/www.mydomain.com/smarty/livredor/configs/
+/web/www.mydomain.com/smarty/livredor/cache/
+
+/web/www.mydomain.com/docs/livredor/index.php
+
+
+
+ Smarty a besoin d'accéder en écriture aux répertoires
+ $compile_dir et $cache_dir,
+ assurez-vous donc que le serveur Web dispose de ces droits d'accès.
+ Il s'agit généralement de l'utilisateur "nobody" et du group
+ "nobody". Pour les utilisateurs de OS X, l'utilisateur par défaut
+ est "web" et le group "web". Si vous utilisez Apache, vous pouvez
+ parcourir le fichier httpd.conf (en général dans
+ "/usr/local/apache/conf/") pour déterminer quel est l'utilisateur
+ et le groupe auquel il appartient.
+
+
+
+
+ régler les permissions d'accès
+
+
+chown nobody:nobody /web/www.mydomain.com/smarty/templates_c/
+chmod 770 /web/www.mydomain.com/smarty/templates_c/
+
+chown nobody:nobody /web/www.mydomain.com/smarty/cache/
+chmod 770 /web/www.mydomain.com/smarty/cache/
+
+
+
+ Note technique
+
+ La commande chmod 770 est relativement bien sécurisée, elle donne
+ à l'utilisateur "nobody" et au groupe "nobody" les accès en
+ lecture/écriture aux répertoires. Si vous voulez donner le droit d'accès
+ en lecture à tout le monde (principalement pour pouvoir accéder
+ vous-même à ces fichiers), vous pouvez lui préférer chmod 775.
+
+
+
+
+ Nous devons créer le fichier index.tpl que Smarty va charger.
+ Il va se trouver dans $template_dir.
+
+
+
+ Edition de /web/www.mydomain.com/smarty/templates/index.tpl
+
+
+{* Smarty *}
+
+Hello, {$name}!
+
+
+
+
+ Note technique
+
+ {* Smarty *} est un commentaire de template. Il n'est pas
+ obligatoire mais il est bon de commencer tous vos templates
+ avec ce commentaire. Cela rend le fichier facilement
+ reconnaissable en plus de son extension. Les éditeurs
+ de texte peuvent par exemple reconnaître le fichier et
+ adapter la coloration syntaxique.
+
+
+
+
+ Maintenant passons à l'édition du fichier index.php. Nous allons
+ créer une instance de Smarty, assigner une valeur à une variable
+ de template et afficher le résultat avec index.tpl. Dans notre
+ exemple d'environnement, "/usr/local/lib/php/Smarty" est dans notre
+ include_path. Assurez-vous de faire la même chose ou d'utiliser
+ des chemins absolus.
+
+
+
+ édition de /web/www.mydomain.com/docs/livredor/index.php
+
+// charge la bibliothèque Smarty
+require('Smarty.class.php');
+
+$smarty = new Smarty;
+
+$smarty->template_dir = '/web/www.mydomain.com/smarty/livredor/templates/';
+$smarty->compile_dir = '/web/www.mydomain.com/smarty/livredor/templates_c/';
+$smarty->config_dir = '/web/www.mydomain.com/smarty/livredor/configs/';
+$smarty->cache_dir = '/web/www.mydomain.com/smarty/livredor/cache/';
+
+$smarty->assign('name','Ned');
+
+$smarty->display('index.tpl');
+
+
+
+ Note techique
+
+ Dans notre exemple, nous avons configuré les chemins absolus
+ pour chacun des répertoires Smarty. Si
+ '/web/www.mydomain.com/smarty/livredor/' est dans votre
+ include_path PHP alors ces réglages ne sont pas nécessaires.
+ Quoi qu'il en soit il est plus efficace et (par expérience)
+ moins générateur d'erreurs de les définir avec des chemins
+ absolus. Cela nous garantit que Smarty récupèrera les bons fichiers.
+
+
+
+
+ Et maintenant appelez le fichier index.php avec navigateur
+ Web. Vous devriez voir "Hello, Ned!".
+
+
+ Vous venez de terminer l'installation de base de Smarty !
+
+
+
+ Configuration avancée
+
+
+ Ceci est la suite de l'installation de base, veuillez
+ lire cette dernière avant de poursuivre.
+
+
+
+ Une manière un peu plus commode de configurer Smarty est de faire votre
+ propre classe fille et de l'initialiser selon votre environnement.
+ De la sorte, nous n'aurons plus besoin de configurer à chaques fois les
+ chemins de notre environnement. Créons un nouveau répertoire
+ "/php/includes/livredor/" et un nouveau fichier appelé "setup.php".
+ Dans notre exemple d'environnement, "/php/includes" est notre
+ include_path PHP. Assurez-vous de faire la même chose ou alors d'utiliser
+ des chemins absolus.
+
+
+
+ édition de /php/includes/livredor/setup.php
+
+
+// charge la librairie Smarty
+require('Smarty.class.php');
+
+// le fichier setup.php est un bon
+// endroit pour charger les fichiers
+// de librairies de l'application et vous pouvez
+// faire cela juste ici. Par exemple :
+// require('livredor/livredor.lib.php');
+
+class Smarty_livredor extends Smarty {
+
+ function Smarty_livredor() {
+
+ // Constructeur de la classe. Appelé automatiquement
+ // à l'instanciation de la classe.
+
+ $this->Smarty();
+
+ $this->template_dir = '/web/www.mydomain.com/smarty/livredor/templates/';
+ $this->compile_dir = '/web/www.mydomain.com/smarty/livredor/templates_c/';
+ $this->config_dir = '/web/www.mydomain.com/smarty/livredor/configs/';
+ $this->cache_dir = '/web/www.mydomain.com/smarty/livredor/cache/';
+
+ $this->caching = true;
+ $this->assign('app_name','Guest Book');
+ }
+
+}
+
+
+
+ Modifions maintenant le fichier index.php pour qu'il utilise "setup.php"
+
+
+
+ édition de /web/www.mydomain.com/docs/livredor/index.php
+
+
+require('livredor/setup.php');
+
+$smarty = new Smarty_livredor;
+
+$smarty->assign('name','Ned');
+
+$smarty->display('index.tpl');
+
+
+
+ Vous savez maintenant qu'il est facile de créer une instance de Smarty,
+ correctement configurée, en utilisant Smarty_livredor qui initialise
+ automatiquement tout ce qu'il faut pour votre application.
+
+
+
+
+
+
diff --git a/docs/fr/manual.xml b/docs/fr/manual.xml
new file mode 100644
index 00000000..144efb43
--- /dev/null
+++ b/docs/fr/manual.xml
@@ -0,0 +1,45 @@
+
+
+
+
+
+]>
+
+
+
+ Smarty - le moteur et compilateur de template PHP
+
+
+ MonteOhrt <monte@ispi.net>
+
+
+ AndreiZmievski <andrei@php.net>
+
+
+
+
+
+ ArnaudCogoluègnes <arnaud.cogoluegnes@free.fr>
+
+
+ GéraldCroës <gcroes@aston.fr>
+
+
+
+ Version 2.0
+
+ 2001
+ 2002
+ 2003
+ ispi of Lincoln, Inc.
+
+
+
+ &preface;
+ &getting.started;
+ &smarty.for.designers;
+ &smarty.for.programmers;
+ &appendixes;
+
+
diff --git a/docs/fr/preface.xml b/docs/fr/preface.xml
new file mode 100644
index 00000000..66027b6e
--- /dev/null
+++ b/docs/fr/preface.xml
@@ -0,0 +1,77 @@
+
+ Préface
+
+ "Comment rendre mes scripts PHP indépendants de la présentation ?".
+ Voici sans doute la question la plus posée sur la mailing list
+ PHP. Alors que PHP est étiqueté "langage de script
+ pour HTML", on se rend vite compte, après quelques projets qui mélangent
+ sans complexe HTML et PHP, que la séparation entre la forme et
+ le contenu est important. De plus, dans de nombreuses entreprises
+ les rôles du designer et du programmeur sont distincts. La solution template
+ coule donc de source.
+
+
+ Dans notre entreprise par exemple, le développement d'une application
+ se fait de la manière suivante : une fois le cahier des charges écrit,
+ le designer réalise une maquette, et donne ses interfaces
+ au programmeur. Le programmeur implémente les fonctionnalités applicatives
+ et utilise les maquettes pour faire des squelettes de templates. Le projet
+ est alors passé au designer HTML/responsable de la mise en page qui amène les
+ templates jusqu'au faîte de leur gloire. Il est possible que le projet fasse
+ une fois ou deux des allers/retours entre la programmation et la présentation.
+ En conséquence, il est important de disposer d'un bon système de template. Les
+ programmeurs ne veulent pas avoir à faire au HTML, et ne veulent pas non plus
+ que les designers HTML bidouillent le code PHP. Les designers ont besoin d'outils
+ comme des fichiers de configuration, des blocs dynamiques et d'autres solutions
+ pour répondre à des problématiques d'interface, mais ne veulent pas
+ nécessairement avoir à faire à toutes les subtilités de la programmation PHP.
+
+
+ Un rapide tour d'horizon des solutions type template aujourd'hui et
+ l'on s'aperçoit que la plupart d'entre elles n'offrent que des moyens
+ rudimentaires pour substituer des variables dans des templates, ainsi que des
+ fonctionnalités limitées de blocs dynamiques. Cependant nous avons
+ besoin d'un peu plus. Nous ne voulons pas que les programmeurs
+ s'occupent de la présentation HTML du TOUT, mais cela est pratiquement
+ inévitable. Par exemple, si un designer veut des couleurs d'arrière plan
+ différentes pour alterner entre différents blocs dynamiques, il est nécessaire
+ que ce dernier travaille avec le programmeur. Nous avons aussi besoin que les
+ designers soient capables de travailler avec leurs propres fichiers
+ de configuration pour y récupérer des variables, exploitables dans leurs
+ templates. Et la liste est longue.
+
+
+ Fin 1999, nous avons commencé à écrire une spécification pour un moteur de
+ template. Une fois la spécification terminée,
+ nous avons commencé à travailler sur un moteur de template écrit
+ en C qui pourrait, avec un peu de chance, être inclus à PHP.
+ Non seulement nous avons rencontré des problèmes techniques complexes,
+ mais nous avons participés à de nombreux débats sur ce que devait
+ et ce que ne devait pas faire un moteur de template. De cette expérience nous avons
+ décidé qu'un moteur de template se devait d'être écrit sous la forme d'une
+ classe PHP, afin que quiconque puisse l'utiliser à sa convenance. Nous
+ avons donc réalisé un moteur de template qui se contentait de faire cela,
+ et SmartTemplate a vu le jour (note : cette
+ classe n'a jamais été soumise au public). C'était une classe qui
+ faisait pratiquement tout ce que nous voulions : substitution de variables,
+ inclusion d'autres templates, intégration avec des fichiers de configuration,
+ intégration de code PHP, instruction 'if' basique et une gestion plus robuste
+ des blocks dynamiques imbriqués. Elle faisait tout cela avec des expressions
+ rationnelles et le code se révéla, comment dire, impénétrable. De plus, elle était
+ relativement lente pour les grosses applications à cause de l'analyse
+ et du travail sur les expressions rationnelles qu'elle devait faire à chaque
+ exécution. Le plus gros problème du point de vue du programmeur était
+ tout le travail nécessaire en amont, dans le script PHP, pour configurer
+ et exécuter les templates, et les blocs dynamiques. Comment rendre tout ceci
+ plus simple ?
+
+
+ Puis vint la vision de ce que devait devenir Smarty. Nous
+ savons combien le code PHP peut être rapide sans le coût
+ d'analyse des templates. Nous savons aussi combien fastidieux
+ et décourageant peut paraître le langage pour le designer moyen, et que
+ cela peut être remplacé par une syntaxe spécifique, beaucoup
+ plus simple. Et si nous combinions les deux forces ? Ainsi, Smarty
+ était né...
+
+