cvs: smarty /docs/de bookinfo.xml getting-started.xml language-defs.ent preface.xml

http://cvs.php.net/co.php/smarty/docs/de/bookinfo.xml?r=1.1&p=1
Index: smarty/docs/de/bookinfo.xml
+++ smarty/docs/de/bookinfo.xml
<?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision: 1.1 $ -->
 <bookinfo id="bookinfo">
  <title>Smarty - the compiling PHP template engine</title>
  <authorgroup id="authors">
   <author>
    <firstname>Monte</firstname><surname>Ohrt &lt;[email protected]&gt;</surname>
   </author>
   <author>
    <firstname>Andrei</firstname><surname>Zmievski &lt;[email protected]&gt;</surname>
   </author>
  </authorgroup>
  <pubdate>&build-date;</pubdate>
  <copyright>
   <year>2001-2004</year>
   <holder>ispi of Lincoln, Inc.</holder>
  </copyright>
 </bookinfo>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"../../../../manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->

http://cvs.php.net/co.php/smarty/docs/de/getting-started.xml?r=1.1&p=1
Index: smarty/docs/de/getting-started.xml
+++ smarty/docs/de/getting-started.xml
<!-- Smarty German Documentation Port -->
<!-- $Id: getting-started.xml,v 1.1 2004/03/28 15:20:08 didou Exp $ -->
<!-- $Author: didou $ -->
<!-- $Revision: 1.1 $ -->
<part id="getting.started">
 <title>Erste Schritte</title>
 <chapter id="what.is.smarty">
   <title>Was ist Smarty?</title>
   <para>
	Smarty ist eine Template-Engine f&uuml;r PHP. Genauer gesagt erlaubt es
	die einfache Trennung von Applikations-Logik und Design/Ausgabe. Dies
	ist vor allem w&uuml;nschenswert, wenn der Applikationsentwickler nicht
	die selbe Person ist wie der Designer. Nehmen wir zum Beispiel eine
	Webseite die Zeitungsartikel ausgibt. Der Titel, die Einf&uuml;hrung,
	der Author und der Inhalt selbst enthalten keine Informationen dar&uuml;ber
	wie sie dargestellt werden sollen. Also werden sie von der Applikation
	an Smarty &uuml;bergeben, damit der Designer in den Templates mit einer Kombination von
	HTML- und Template-Tags die Ausgabe (Tabellen, Hintergrundfarben,
	Schriftgr&ouml;ssen, Stylesheets, etc.) gestalten kann. Falls nun die
	Applikation eines Tages angepasst werden muss, ist dies f&uuml;r den
	Designer nicht von Belang, da die Inhalte immer noch genau gleich
	&uuml;bergeben werden. Genauso kann der Designer die Ausgabe der
	Daten beliebig ver&auml;ndern, ohne dass eine &Auml;nderung der
	Applikation vorgenommen werden muss. Somit können der Programmierer
	die Applikations-Logik und der Designer die Ausgabe frei anpassen,
	ohne sich dabei in die Quere zu kommen.
	</para>
	<para>
	Was Smarty nicht kann: Smarty versucht nicht die gesamte Logik aus dem
	Template zu verbannen. Solange die verwendete Logik ausschließlich f&uuml;r die
	Ausgabe verwendet wird, kann sie auch im Template eingebettet werden. Ein Tip:
	versuchen Sie Applikations-Logik aus dem Template und Pr&auml;sentations-Logik 
    aus der Applikation herauszuhalten. Nur so bleibt die Applikation auf absehbere Zeit
    gut skalier- und wartbar.
	</para>
	<para>
	Einer der einzigartigen Aspekte von Smarty ist die Kompilierung der
	Templates. Smarty liest die Template-Dateien und generiert daraus neue
	PHP-Skripte; von da an werden nur noch diese Skripte verwendet. Deshalb
	m&uuml;ssen Templates nicht f&uuml;r jeden Seitenaufruf performance-intensiv 
    neu geparst werden und jedes Template kann voll von PHP Compiler-Cache 
    L&ouml;sungen profitieren. 
    (Zend, http://www.zend.com; PHP Accelerator, http://www.php-accelerator.co.uk)
   </para>
   <para>
    Ein paar Smarty Charakteristiken
   </para>
   <itemizedlist>
    <listitem><para>Sehr schnell.</para></listitem>
    <listitem><para>Sehr effizient, da der PHP-Parser die 'schmutzige' Arbeit &uuml;bernimmt.</para></listitem>
    <listitem><para>Kein Overhead durch Template-Parsing, nur einmaliges kompilieren.</para></listitem>
    <listitem><para>Re-kompiliert nur g&auml;nderte Templates.</para></listitem>
    <listitem><para>Sie k&ouml;nnen die Engine um <link linkend="language.custom.functions">individuelle Funktionen</link> und <link linkend="language.modifiers">Variablen-Modifikatoren</link> erweitern.</para></listitem>
    <listitem><para>Konfigurierbare Syntax für Template-Tags: Sie k&ouml;nnen {}, {{}}, &lt;!--{}--&gt;, etc. verwenden.</para></listitem>
    <listitem><para>'if/elseif/else/endif'-Konstrukte werden direkt dem PHP-Parser &uuml;bergeben. Somit k&ouml;nnen {if ...} Ausdrücke sowohl sehr einfach als auch sehr komplex sein.</para></listitem>
    <listitem><para>Unbegrenzte Verschachtelung von 'section', 'if' und anderen Bl&ouml;cken.</para></listitem>
    <listitem><para>Erm&ouml;glicht die direkte Einbettung von PHP-Code. (Obwohl es weder ben&ouml;tigt noch empfohlen wird, da die Engine einfach erweiterbar ist.)</para></listitem>
    <listitem><para>Eingebauter Caching-Support</para></listitem>
    <listitem><para>Beliebige Template-Quellen</para></listitem>
    <listitem><para>Eigene Cache-Handling Funktionen</para></listitem>
    <listitem><para>Plugin Architektur</para></listitem>
   </itemizedlist>
 </chapter>
 <chapter id="installation">
  <title>Installation</title>
  <sect1 id="installation.requirements">
   <title>Anforderungen</title>
   <para>
   Smarty ben&ouml;tigt einen Webserver mit PHP >=4.0.6.
   </para>
  </sect1>

  <sect1 id="installing.smarty.basic">
    <title>Basis Installation</title>
	<note>
	<title>Technische Bemerkung</title>
	<para>
	Dieser Leitfaden geht davon aus, dass Sie Ihr Webserver- und PHP-Setup kennen
	und mit den Namenskonventionen f&uuml;r Dateien und Verzeichnisse Ihres Betriebssystems
	vertraut sind. Im Folgenden wird ein Unix-Dateisystem verwendet, stellen Sie also
	sicher, dass sie die f&uuml;r Ihr Betriebssystem n&ouml;tigen &Auml;nderungen vornehmen.
	</para>
	<para>
	Das Beispiel geht davon aus, dass '/php/includes' in Ihrem PHP-'include_path'
	liegt. Konsultieren Sie das PHP-Manual f&uuml;r weiterf&uuml;hrende Informationen hierzu.
	</para>
	</note>
	<para>
	Installieren Sie als erstes die Smarty-Library Dateien. Diese Dateien
	sollten von Ihnen NICHT editiert und von allen Applikationen
	verwendet werden. Sie werden nur erneuert, wenn Sie eine neue Version von Smarty installieren.
	</para>
	<note>
	 <title>Technische Bemerkung</title>
	 <para>
	 Wir empfehlen keine &Auml;nderungen an den Smarty-Library Dateien vorzunehmen.
	 Dies macht ein m&ouml;gliches Upgrade wesentlich einfacher. Sie m&uuml;ssen
	 diese Dateien auch nicht anpassen, um Smarty zu konfigurieren! Benutzen Sie für
     diesen Zwecke eine Instanz der Smarty-Klasse.
	</para>
	</note>

	<para>
	Folgende Library Dateien werden mit Smarty geliefert und werden ben&ouml;tigt:
	</para>
	<example>
     <title>Smarty-Library Dateiliste</title>
     <screen>
Smarty.class.php
Smarty_Compiler.class.php
Config_File.class.php
debug.tpl
/core/*.php (alle)
/plugins/*.php (alle)</screen>
	</example>

	<para>
	Sie k&ouml;nnen diese Dateien entweder in Ihrem PHP-'include_path' oder
	auch in irgend einem anderen Verzeichnis ablegen, solange die Konstante
	<link linkend="constant.smarty.dir">SMARTY_DIR</link> auf den korrekten
	Pfad zeigt. Im Folgenden werden Beispiele f&uuml;r beide F&auml;lle aufgezeigt.
	</para>
	<para>
	So erzeugt man eine Instanz der Smarty-Klasse im PHP-Skript:
	</para>

	<example>
     <title>Smarty Instanz erstellen:</title>
     <screen>
require('Smarty.class.php');
$smarty = new Smarty;</screen>
	</example>

        <para>
	Versuchen Sie das Skript auszuf&uuml;hren. Wenn Sie eine Fehlermeldung erhalten dass
	<emphasis>Smarty.class.php</emphasis> nicht gefunden werden konnte, versuchen Sie folgendes:
        </para>

        <example>
     <title>Absoluter Pfad &uuml;bergeben</title>
     <screen>
require('/usr/local/lib/php/Smarty/Smarty.class.php');
$smarty = new Smarty;</screen>
        </example>

        <example>
     <title>Library Verzeichnis dem Include-Pfad hinzuf&uuml;gen</title>
     <screen>
// editieren Sie php.ini, f&uuml;gen Sie das Smarty
// Verzeichnis Ihrem include_path hinzu, und starten Sie den Webserver neu
// Danach sollte folgendes Funktionieren.
require('Smarty.class.php');
$smarty = new Smarty;</screen>
        </example>

        <example>
     <title>SMARTY_DIR manuell setzen</title>
     <screen>
define('SMARTY_DIR','/usr/local/lib/php/Smarty/');
require(SMARTY_DIR.'Smarty.class.php');
$smarty = new Smarty;</screen>
        </example>


	<para>
	Jetzt, wo die Library Dateien an ihrem Platz sind, wird es
	Zeit, die Smarty Verzeichnisse zu erstellen.
	</para>
	<para>
	F&uuml;r unser Beispiel werden wir die Smarty Umgebung f&uuml;r eine
	G&auml;stebuch-Applikation konfigurieren. Wir verwenden den Applikationsnamen
	nur, um die Verzeichnis-Struktur zu verdeutlichen. Sie k&ouml;nnen die selbe
	Umgebung f&uuml;r alle Ihre Applikationen verwenden indem Sie 'guestbook'
	durch dem Namen Ihrer Applikation ersetzen.
	</para>
	<para>
	Stellen Sie sicher, dass Sie die DocumentRoot Ihres Webservers kennen.
	In unserem Beispiel lautet sie '/web/www.domain.com/docs/'.
	</para>
	<para>
	Die Smarty Verzeichnisse werden in den Klassen-Variablen $template_dir,
	$compile_dir, $config_dir und $cache_dir definiert. Die Standardwerte sind:
	"templates", "templates_c", "configs" und "cache". F&uuml;r unser Beispiel
	legen wir alle diese Verzeichnisse unter '/web/www.domain.com/smarty/guestbook/' an.
	</para>

	<note>
	<title>Technische Bemerkung</title>
	<para>
	Wir empfehlen, diese Verzeichnisse ausserhalb der DocumentRoot anzulegen,
	um m&ouml;gliche Direktzugriffe zu verhindern.
	</para>
	</note>

	<para>
	In Ihrer DocumentRoot muss mindestens eine Datei liegen, die f&uuml;r Browser
	zug&auml;nglich ist. Wir nennen dieses Skript 'index.php', und legen
	es in das Verzeichnis '/guestbook/' in unserer DocumentRoot.
	</para>
	
	<note>
	<title>Technische Bemerkung</title>
	<para>
	Bequem ist es, den Webserver so zu konfigurieren, dass 'index.php' als
	Standard-Verzeichnis-Index verwendet wird. Somit kann man das Skript
	direkt mit 'http://www.domain.com/guestbook/' aufrufen. Falls Sie Apache
	verwenden, l&auml;sst sich dies konfigurieren indem Sie 'index.php'
	als letzten Eintrag f&uuml;r DirectoryIndex verwenden. (Jeder Eintrag muss
	mit einem Leerzeichen abgetrennt werden). 
    </para>
	</note>
	
	<para>
	Die Dateistruktur bis jetzt:
	</para>

	<example>
     <title>Beispiel der Dateistruktur</title>
     <screen>
/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
/usr/local/lib/php/Smarty/core/*.php

/web/www.mydomain.com/smarty/guestbook/templates/
/web/www.mydomain.com/smarty/guestbook/templates_c/
/web/www.mydomain.com/smarty/guestbook/configs/
/web/www.mydomain.com/smarty/guestbook/cache/

/web/www.mydomain.com/docs/guestbook/index.php</screen>
	</example>

	<note>
	 <title>Technische Bemerkung</title>
	 <para>
	 Falls Sie kein Caching und keine Konfigurationsdateien verwenden, ist es nicht
	 erforderlich die Verzeichnisse '$config_dir' und '$cache_dir' zu erstellen.
	 Es wird jedoch trotzdem empfohlen, da diese Funktionalit&auml;ten eventuell sp&auml;ter
	 genutzt werden sollen.
     </para>
	</note>

	<para>
	Smarty ben&ouml;tigt Schreibzugriff auf die Verzeichnisse '$compile_dir' und '$cache_dir'.
	Stellen Sie also sicher, dass der Webserver-Benutzer (normalerweise Benutzer 'nobody' und Gruppe 'nogroup')
	in diese Verzeichnisse schreiben kann. (In OS X lautet der Benutzer normalerweise 'www' und
	ist in der Gruppe 'www'). Wenn Sie Apache verwenden, k&ouml;nnen Sie in der httpd.conf (gewöhnlich in '/usr/local/apache/conf/')
	nachsehen, unter welchem Benutzer Ihr Server l&auml;uft.
	</para>

	<example>
     <title>Dateirechte einrichten</title>
     <screen>

chown nobody:nobody /web/www.mydomain.com/smarty/guestbook/templates_c/
chmod 770 /web/www.mydomain.com/smarty/guestbook/templates_c/

chown nobody:nobody /web/www.mydomain.com/smarty/guestbook/cache/
chmod 770 /web/www.mydomain.com/smarty/guestbook/cache/</screen>
	</example>

	<note>
	 <title>Technische Bemerkung</title>
	 <para>
	 'chmod 770' setzt ziemlich strenge Rechte und erlaubt nur dem Benutzer 'nobody'
	 und der Gruppe 'nobody' Lese-/Schreibzugriff auf diese Verzeichnisse. Falls Sie
	 die Rechte so setzen m&ouml;chten, dass auch andere Benutzer die Dateien lesen
	 k&ouml;nnen (vor allem f&uuml;r Ihren eigenen Komfort), so erreichen Sie dies mit 775.
     </para>
	</note>

	<para>
	Nun m&uuml;ssen wir die 'index.tpl' Datei erstellen, welche Smarty laden soll.
	Die Datei wird in Ihrem '$template_dir' abgelegt.
	</para>

	<example>
     <title>Editieren von /web/www.mydomain.com/smarty/guestbook/templates/index.tpl</title>
     <screen>

{* Smarty *}

Hallo, {$name}!</screen>
	</example>


	<note>
	<title>Technische Bemerkung</title>
	<para>
		{* Smarty *} ist ein Template-Kommentar. Der wird zwar nicht ben&ouml;tigt,
		es ist jedoch eine gute Idee jedes Template mit einem Kommentar zu versehen.
		Dies erleichtert die Erkennbarkeit des Templates, unabh&auml;ngig von der
		verwendeten Dateierweiterung. (Zum Beispiel f&uuml;r Editoren die Syntax-Highlighting
		unterst&uuml;tzen.)
	</para>
	</note>

	<para>
	Als n&auml;chstes editieren wir die Datei 'index.php'. Wir erzeugen eine
	Smarty-Instanz, weisen dem Template eine Variable zu und geben 'index.tpl' aus.
	</para>

	<example>
     <title>Editieren von /web/www.mydomain.com/docs/guestbook/index.php</title>
     <screen>

define('SMARTY_DIR','/usr/local/lib/php/Smarty/');
require(SMARTY_DIR.'Smarty.class.php');

$smarty = new Smarty;

$smarty->template_dir = '/web/www.mydomain.com/smarty/guestbook/templates/';
$smarty->compile_dir = '/web/www.mydomain.com/smarty/guestbook/templates_c/';
$smarty->config_dir = '/web/www.mydomain.com/smarty/guestbook/configs/';
$smarty->cache_dir = '/web/www.mydomain.com/smarty/guestbook/cache/';

$smarty->assign('name','Ned');

$smarty->display('index.tpl');</screen>
	</example>

	<note>
	 <title>Technische Bemerkung</title>
	 <para>
	 In unserem Beispiel verwenden wir durchwegs absolute Pfadnamen zu den
	 Smarty-Verzeichnissen. Falls '/web/www.mydomain.com/smarty/guestbook/' in
	 Ihrem PHP-'include_path' liegt, w&auml;re dies nicht n&ouml;tig. Es ist jedoch
	 effizienter und weniger fehleranf&auml;llig die Pfade absolut zu setzen.
	 Und es garantiert, dass Smarty die Templates aus dem geplanten Verzeichnis l&auml;dt.
	 </para>
	</note>

	<para>
	Wenn Sie 'index.php' nun in Ihrem Webbrowser &ouml;ffnen, sollte 'Hallo, Ned!' ausgegeben werden.
	</para>
	<para>
	Die Basis-Installation von Smarty w&auml;re somit beendet.
	</para>
   </sect1>
   <sect1 id="installing.smarty.extended">
   <title>Erweiterte Konfiguration</title>

   <para>
   
   Dies ist eine Weiterf&uuml;hrung der <link linkend="installing.smarty.basic">Basis Installation</link>, bitte lesen Sie diese zuerst!
   </para>
   <para>
   Ein flexiblerer Weg um Smarty aufzusetzen ist, die Klasse zu erweitern und
   eine eigene Smarty-Umgebung zu initialisieren. Anstatt immer wieder
   die Verzeichnisse zu definieren, kann diese Aufgabe auch in einer einzigen
   Datei erledigt werden. Beginnen wir, indem wir ein neues Verzeichnis namens '/php/includes/guestbook/'
   erstellen und eine Datei namens 'setup.php' darin anlegen.
   </para>

   <example>
    <title>Editieren von /php/includes/guestbook/setup.php</title>
    <screen>

// Smarty Library Dateien laden
define('SMARTY_DIR','/usr/local/lib/php/Smarty/');
require(SMARTY_DIR.'Smarty.class.php');

// ein guter Platz um Applikations spezifische Libraries zu laden
// require('guestbook/guestbook.lib.php');

class Smarty_GuestBook extends Smarty {

   function Smarty_GuestBook() {
   

		// Konstruktor. Diese Werte werden f&uuml;r jede Instanz automatisch gesetzt

		$this->Smarty();

		$this->template_dir = '/web/www.mydomain.com/smarty/guestbook/templates/';
		$this->compile_dir = '/web/www.mydomain.com/smarty/guestbook/templates_c/';
		$this->config_dir = '/web/www.mydomain.com/smarty/guestbook/configs/';
		$this->cache_dir = '/web/www.mydomain.com/smarty/guestbook/cache/'; 
		
		$this->caching = true;
		$this->assign('app_name','Guest Book');
   }

}</screen>
   </example>

   <note>
	<title>Technische Bemerkung</title>
	<para>
	In unserem Beispiel werden die Library Dateien ausserhalb der DocumentRoot
	abgelegt. Diese Dateien k&ouml;nnten sensitive Informationen enthalten,
	die wir nicht zug&auml;nglich machen m&ouml;chten.
	Deshalb legen wir alle Library Dateien in '/php/includes/guestbook/' ab
	und laden sie in unserem 'setup.php' Skript, wie Sie im oben gezeigten
	Beispiel sehen k&ouml;nnen.
	</para>
   </note>

  <para>
  Nun passen wir 'index.php' an, um 'setup.php' zu verwenden:
  </para>
   
   <example>
    <title>Editieren von /web/www.mydomain.com/docs/guestbook/index.php</title>
    <screen>

require('guestbook/setup.php');

$smarty = new Smarty_GuestBook;

$smarty->assign('name','Ned');

$smarty->display('index.tpl');</screen>
   </example>

  <para>
  Wie Sie sehen k&ouml;nnen, ist es sehr einfach eine Instanz von Smarty zu erstellen.
  Mit Hilfe von Smarty_GuestBook werden alle Variablen automatisch initialisiert.
  </para>
   
  </sect1>

 </chapter>
</part>

http://cvs.php.net/co.php/smarty/docs/de/language-defs.ent?r=1.1&p=1
Index: smarty/docs/de/language-defs.ent
+++ smarty/docs/de/language-defs.ent
<!-- $Revision: 1.1 $ -->

<!ENTITY SMARTYManual      "Smarty - die kompilierende PHP Template-Engine">
<!ENTITY SMARTYDesigners   "Smarty f&uuml;r Template Designer">
<!ENTITY SMARTYProgrammers "Smarty f&uuml;r Programmierer">
<!ENTITY Appendixes        "Anh&auml;nge">

http://cvs.php.net/co.php/smarty/docs/de/preface.xml?r=1.1&p=1
Index: smarty/docs/de/preface.xml
+++ smarty/docs/de/preface.xml
<!-- Smarty German Documentation Port -->
<!-- $Id: preface.xml,v 1.1 2004/03/28 15:20:08 didou Exp $ -->
<!-- $Author: didou $ -->
<!-- $Revision: 1.1 $ -->

 <preface id="preface">
  <title>Vorwort</title>
  <para>
   Die Frage, wie man die Applikations-Logik eines PHP-Scriptes vom Layout trennt, ist unzweifelhaft
   eines der am h&auml;figsten diskutierten Themen. Da PHP als
   "in HTML eingebettete Scripting-Sprache" angepriesen wird, ergibt sich
   nach einigen Projekten in denen man HTML und PHP gemischt hat schnell die Idee,
   Funktionalit&auml;t und Darstellung zu trennen. Dazu kommt, dass in vielen Firmen Applikationsentwickler
   und Designer nicht die selbe Person sind. In Konsequenz beginnt die Suche nach einer Template-Lösung.
  </para>
  <para>
   Als Beispiel: In unserer Firma funktioniert die Entwicklung einer Applikation
   wie folgt: Nachdem die Spezifikationen erstellt sind, entwickelt der
   Interface Designer einen Prototypen des Interfaces und &uuml;bergibt dieses
   dem Programmierer. Der Programmierer implementiert die Gesch&auml;ftslogik
   in PHP und verwendet den Interface-Prototypen zur Erstellung eines Template-Skeletts.
   Danach &uuml;bergibt der Programmierer die Templates dem HTML/Webseiten-Designer
   welcher ihnen den letzten Schliff verleiht. Das Projekt kann mehrfach zwischen
   dem Programmieren und dem Designer ausgetauscht werden. Deshalb ist es wichtig,
   dass die Trennung von Logik und Design klar stattfindet. Der Programmierer will
   sich normalerweise nicht mit HTML herumschlagen m&uuml;ssen und m&ouml;chte auch
   nicht, dass der Designer seinen PHP-Code ver&auml;ndert. Designer selbst
   ben&ouml;tigen Konfigurationsdateien, dynamische Bl&ouml;cke und andere Interface spezifische
   Eigenheiten, m&ouml;chten aber auch nicht direkt mit PHP in Ber&uuml;hrung kommen.
  </para>
  <para>
   Die meisten Template-Engines die heutzutage angeboten werden, bieten eine
   rudiment&auml;re M&ouml;glichkeit Variablen in einem Template zu ersetzen
   und beherschen eine eingeschr&auml;nkte Funktionalit&auml;t f&uuml;r dynamische
   Bl&ouml;cke. Unsere Anforderungen forderten jedoch ein wenig mehr. Wir wollten
   erreichen, dass sich Programmierer &uuml;berhaupt nicht um HTML Layouts
   k&uuml;mmern m&uuml;ssen. Dies war aber fast unumg&auml;nglich. Wenn ein
   Designer zum Beispiel alternierende Farben in einer Tabelle einsetzen wollte,
   musste dies vorhergehend mit dem Programmierer abgesprochen werden. Wir wollten
   weiter, dass dem Designer Konfigurationsdateien zur Verf&uuml;gung st&uuml;nden,
   aus denen er Variablen f&uuml;r seine Templates extrahieren kann. Die Liste ist endlos.
  </para>
  <para>
   Wir begannen 1999 mit der Spezifikation der Template Engine. Nachdem dies
   erledigt war, fingen wir an eine Engine in C zu schreiben, die - so hofften
   wir - in PHP eingebaut w&uuml;rde. Nach einer hitzigen Debatte dar&uuml;ber
   was eine Template Engine k&ouml;nnen sollte und was nicht, und nachdem wir feststellen
   mussten, dass ein paar komplizierte technische Probleme auf uns zukommen
   w&uuml;rden, entschlossen wir uns die Template Engine in PHP als Klasse
   zu realisieren, damit sie von jederman verwendet und angepasst werden kann.
   So schrieben wir also eine Engine, die wir <productname>SmartTemplate</productname>
   nannten (anm: diese Klasse wurde nie ver&ouml;ffentlicht). SmartTemplate
   erlaubte uns praktisch alles zu tun was wir uns vorgenommen hatten: normale
   Variablen-Ersetzung, M&ouml;glichkeiten weitere Templates einzubinden,
   Integration von Konfigurationsdateien, Einbetten von PHP-Code, limitierte 'if'-Funktionalit&auml;t
   und eine sehr robuste Implementation von dynamischen Bl&ouml;cken die
   mehrfach verschachtelt werden konnten. All dies wurde mit Regul&auml;ren Ausdr&uuml;cken
   erledigt und der Sourcecode wurde ziemlich un&uuml;bersichtlich. F&uuml;r gr&ouml;ssere
   Applikationen war die Klasse auch bemerkenswert langsam, da das Parsing bei jedem
   Aufruf einer Seite durchlaufen werden musste. Das gr&ouml;sste Problem aber war,
   dass der Programmierer das Setup, die Templates und dynamische Bl&ouml;cke in seinem
   PHP-Skript definieren musste. Die n&auml;chste Frage war: wie k&ouml;nnen wir dies
   weiter vereinfachen?
  </para>
  <para>
   Dann kam uns die Idee, aus der schließlich Smarty wurde. Wir wussten
   wie schnell PHP-Code ohne den Overhead des Template-Parsing ist. Wir wussten
   ebenfalls wie pedantisch PHP aus Sicht eines durchschnittlichen
   Designers ist und dass dies mit einer einfacheren Template-Syntax
   verborgen werden kann. Was w&auml;re also, wenn wir diese
   beiden St&auml;rken vereinten? Smarty war geboren...
  </para>
 </preface>