mirror of
https://github.com/smarty-php/smarty.git
synced 2025-08-04 10:24:26 +02:00
add german docs to dist
This commit is contained in:
mohrt
409
docs/de/appendixes.sgml
Normal file
409
docs/de/appendixes.sgml
Normal file
@@ -0,0 +1,409 @@
|
||||
<!-- Smarty German Documentation Port -->
|
||||
<!-- appendixes.sgml,v 1.5 2003/01/10 08:15:14 dexxter Exp -->
|
||||
<!-- dexxter -->
|
||||
<!-- 1.5 -->
|
||||
<part id="appendixes">
|
||||
<title>Anhänge</title>
|
||||
<chapter id="troubleshooting">
|
||||
<title>Problemlösung</title>
|
||||
<para></para>
|
||||
<sect1 id="smarty.php.errors">
|
||||
<title>Smarty/PHP Fehler</title>
|
||||
<para>
|
||||
Smarty kann verschiedene Fehler-Typen, wie fehlende Tag-Attribute oder syntaktisch falsche Variablen-Namen abfangen. Wenn dies geschieht, wird Ihnen eine Fehlermeldung ausgegeben. Beispiel:
|
||||
</para>
|
||||
|
||||
<example>
|
||||
<title>Smarty Fehler</title>
|
||||
<programlisting>
|
||||
Warning: Smarty: [in index.tpl line 4]: syntax error: unknown tag - '%blah'
|
||||
in /path/to/smarty/Smarty.class.php on line 1041
|
||||
|
||||
Fatal error: Smarty: [in index.tpl line 28]: syntax error: missing section name
|
||||
in /path/to/smarty/Smarty.class.php on line 1041</programlisting>
|
||||
</example>
|
||||
|
||||
<para>
|
||||
In der ersten Zeile zeigt Smarty den Template-Namen, die Zeilennummer
|
||||
und den Fehler an. Darauf folgt die betroffene Zeile in der Smarty Klasse welche den Fehler erzeugt hat.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Es gibt gewisse Fehlerkonditionen, die Smarty nicht abfangen kann (bsp: fehlende End-Tags). Diese Fehler
|
||||
resultieren jedoch normalerweise in einem PHP-'compile-time' Fehler.
|
||||
</para>
|
||||
|
||||
<example>
|
||||
<title>PHP Syntaxfehler</title>
|
||||
<programlisting>
|
||||
Parse error: parse error in /path/to/smarty/templates_c/index.tpl.php on line 75</programlisting>
|
||||
</example>
|
||||
|
||||
<para>
|
||||
Wenn ein PHP Syntaxfehler auftritt, wird Ihnen die Zeilennummer des
|
||||
betroffenen PHP Skriptes ausgegeben, nicht die des Templates. Normalerweise
|
||||
können Sie jedoch das Template anschauen um den Fehler zu lokalisieren.
|
||||
Schauen sie insbesondere auf Folgendes: fehlende End-Tags in einer {if}{/if} Anweisung
|
||||
oder in einer {section}{/section} und die Logik eines {if} Blocks. Falls Sie den Fehler
|
||||
so nicht finden, können Sie auch das kompilierte Skript öffnen und zu der
|
||||
betreffenden Zeilennummer springen um herauszufinden welcher Teil des Templates
|
||||
den Fehler enthält.
|
||||
</para>
|
||||
</sect1>
|
||||
</chapter>
|
||||
<chapter id="tips">
|
||||
<title>Tips & Tricks</title>
|
||||
<para>
|
||||
</para>
|
||||
<sect1 id="tips.blank.var.handling">
|
||||
<title>Handhabung unangewiesener Variablen</title>
|
||||
<para>
|
||||
Manchmal möchten Sie vielleicht, dass anstatt einer Leerstelle ein Standardwert ausgegeben wird - zum
|
||||
Beispiel um im Tabellenhintergrund "&nbsp;" auszugeben, damit er korrekt angezeigt wird. Damit dafür
|
||||
keine {if} Anweisung verwendet werden muss, gibt es in Smarty eine Abkürzung: die Verwendung des <emphasis>default</emphasis>
|
||||
Variablen-Modifikators.
|
||||
</para>
|
||||
<example>
|
||||
<title>"&nbsp;" ausgeben wenn eine Variable nicht zugewiesen ist</title>
|
||||
<programlisting>
|
||||
|
||||
{* kompliziert *}
|
||||
|
||||
{if $titel eq ""}
|
||||
&nbsp;
|
||||
{else}
|
||||
{$titel}
|
||||
{/if}
|
||||
|
||||
|
||||
{* einfach *}
|
||||
|
||||
{$titel|default:"&nbsp;"}</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
|
||||
<sect1 id="tips.default.var.handling">
|
||||
<title>Handhabung von Standardwerten</title>
|
||||
<para>
|
||||
Wenn eine Variable in einem Template häufig zum Einsatz kommt,
|
||||
kann es ein bisschen störend wirken, den 'default'-Modifikator jedes mal anzuwenden.
|
||||
Sie können dies umgehen, indem Sie der Variable mit der <link linkend="language.function.assign">assign</link> Funktion
|
||||
einen Standardwert zuweisen.
|
||||
</para>
|
||||
<example>
|
||||
<title>Zuweisen des Standardwertes einer Variable</title>
|
||||
<programlisting>
|
||||
{* schreiben sie dieses statement an den Anfang des Templates *}
|
||||
{assign var="titel" value=$titel|default:"kein Titel"}
|
||||
|
||||
{* fall 'titel' bei der Anweisung leer war, enthält es nun den Wert 'kein Titel' wenn Sie es ausgeben *}
|
||||
{$titel}
|
||||
</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<sect1 id="tips.passing.vars">
|
||||
<title>Variablen an eingebundene Templates weitergeben</title>
|
||||
<para>
|
||||
Wenn die Mehrzahl Ihrer Templates den gleichen Header und Footer verwenden,
|
||||
lagert man diese meist in eigene Templates aus und bindet diese ein. Was
|
||||
geschieht aber wenn der Header einen seitenspezifischen Titel haben soll?
|
||||
Smarty bietet die Möglichkeit, dem eingebundenen Template, Variablen
|
||||
zu übergeben.
|
||||
</para>
|
||||
<example>
|
||||
<title>Die Titel-Variable dem Header-Template zuweisen</title>
|
||||
<programlisting>
|
||||
|
||||
ersteseite.tpl
|
||||
------------
|
||||
|
||||
{include file="header.tpl" title="Erste Seite"}
|
||||
{* template body hier *}
|
||||
{include file="footer.tpl"}
|
||||
|
||||
|
||||
archiv.tpl
|
||||
------------
|
||||
|
||||
{config_load file="archiv.conf"}
|
||||
{include file="header.tpl" title=#archivSeiteTitel#}
|
||||
{* template body hier *}
|
||||
{include file="footer.tpl"}
|
||||
|
||||
|
||||
header.tpl
|
||||
----------
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<TITLE>{$title|default:"Nachrichten"}</TITLE>
|
||||
</HEAD>
|
||||
<BODY>
|
||||
|
||||
|
||||
footer.tpl
|
||||
----------
|
||||
</BODY>
|
||||
</HTML></programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Sobald die erste Seite geparsed wird, wird der Titel 'Erste Seite'
|
||||
dem header.tpl übergeben und fortan als Titel verwendet. Wenn
|
||||
die Archivseite ausgegeben wird, wird der Titel 'Archive' ausgegeben.
|
||||
Wie Sie sehen können, wird der Wert dafür aus der Datei
|
||||
'archiv.conf' geladen und nicht von einem übergebenen Wert. Der
|
||||
Standardwert 'Nachrichten' wird verwendet, wenn die '$titel' leer ist.
|
||||
Erneut wird dafür der <emphasis>default</emphasis>-Modifikator angewandt.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="tips.dates">
|
||||
<title>Zeitangaben</title>
|
||||
<para>
|
||||
Um dem Template Designer höchstmögliche Kontrolle über die Ausgabe
|
||||
von Zeitangaben/Daten zu ermöglichen, ist es empfehlenswert Daten immer
|
||||
als Timestamp zu übergeben. Der Designer kann danach die Funktion
|
||||
<link linkend="language.modifier.date.format">date_format</link> für
|
||||
die Formatierung verwenden.
|
||||
</para>
|
||||
<para>
|
||||
Bemerkung: Seit Smarty 1.4.0 ist es möglich jede Timestamp zu
|
||||
übergeben, welche mit strtotime() ausgewertet werden kann. Dazu
|
||||
gehören Unix-Timestamps und MySQL-Timestamps.
|
||||
</para>
|
||||
<example>
|
||||
<title>Die Verwendung von date_format</title>
|
||||
<programlisting>
|
||||
{$startDatum|date_format}
|
||||
|
||||
AUSGABE:
|
||||
|
||||
Jan 4, 2001
|
||||
|
||||
|
||||
{$startDatum|date_format:"%Y/%m/%d"}
|
||||
|
||||
AUSGABE:
|
||||
|
||||
2001/01/04
|
||||
|
||||
|
||||
{if $datum1 < $datum2}
|
||||
...
|
||||
{/if}</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Falls {html_select_date} in einem Template verwendet wird, hat der Programmierer
|
||||
die Möglichkeit den Wert wieder in ein Timestamp-Format zu ändern. Dies
|
||||
kann zum Beispiel wie folgt gemacht werden:
|
||||
</para>
|
||||
<example>
|
||||
<title>Formular Datum-Elemente nach Timestamp konvertieren</title>
|
||||
<programlisting>
|
||||
// hierbei wird davon ausgegangen, dass Ihre Formular Elemente wie folgt benannt sind
|
||||
// startDate_Day, startDate_Month, startDate_Year
|
||||
|
||||
$startDate = makeTimeStamp($startDate_Year,$startDate_Month,$startDate_Day);
|
||||
|
||||
function makeTimeStamp($year="",$month="",$day="")
|
||||
{
|
||||
if(empty($year))
|
||||
$year = strftime("%Y");
|
||||
if(empty($month))
|
||||
$month = strftime("%m");
|
||||
if(empty($day))
|
||||
$day = strftime("%d");
|
||||
|
||||
return mktime(0,0,0,$month,$day,$year);
|
||||
}</programlisting>
|
||||
|
||||
</example>
|
||||
</sect1>
|
||||
<sect1 id="tips.wap">
|
||||
<title>WAP/WML</title>
|
||||
<para>
|
||||
WAP/WML Templates verlangen, dass ein Content-Type Header im Template
|
||||
angegeben wird. Der einfachste Weg um dies zu tun, wäre, eine Funktion
|
||||
zu schreiben, welche den Header ausgibt. Falls sie den Caching Mechanismus
|
||||
verwenden, sollten Sie auf das 'insert'-Tag zurückgreifen ('insert'-Tags
|
||||
werden nicht gecached), um ein optimales Ergebnis zu erzielen. Achten Sie darauf,
|
||||
dass vor der Ausgabe des Headers keine Daten an den Client gesendet werden, da
|
||||
die gesendeten Header-Daten ansonsten von Client verworfen werden.
|
||||
</para>
|
||||
<example>
|
||||
<title>Die verwendung von 'insert' um einen WML Content-Type header zu senden</title>
|
||||
<programlisting>
|
||||
// stellen Sie sicher, dass Apache mit .wml Dateien umgehen kann!
|
||||
// schreiben Sie folgende Funktion in Ihrer Applikation, oder in Smarty.addons.php
|
||||
function insert_header() {
|
||||
// this function expects $content argument
|
||||
// folgende Funktion erwartet ein $inhalt argument
|
||||
extract(func_get_arg(0));
|
||||
if(empty($inhalt))
|
||||
return;
|
||||
header($inhalt);
|
||||
return;
|
||||
}
|
||||
|
||||
// Ihr Template _muss_ danach wie folgt beginnen:
|
||||
|
||||
{insert name=header inhalt="Content-Type: text/vnd.wap.wml"}
|
||||
|
||||
<?xml version="1.0"?>
|
||||
<!DOCTYPE wml PUBLIC "-//WAPFORUM//DTD WML 1.1//EN" "http://www.wapforum.org/DTD/wml_1.1.xml">
|
||||
|
||||
<!-- neues wml deck -->
|
||||
<wml>
|
||||
<!-- erste karte -->
|
||||
<card>
|
||||
<do type="accept">
|
||||
<go href="#zwei"/>
|
||||
</do>
|
||||
<p>
|
||||
Welcome to WAP with Smarty!
|
||||
Willkommen bei WAP mit Smarty!
|
||||
OK klicken um weiterzugehen...
|
||||
</p>
|
||||
</card>
|
||||
<!-- zweite karte -->
|
||||
<card id="zwei">
|
||||
<p>
|
||||
Einfach, oder?
|
||||
</p>
|
||||
</card>
|
||||
</wml></programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<sect1 id="tips.componentized.templates">
|
||||
<title>Template/Script Komponenten</title>
|
||||
<para>
|
||||
Dieser Tip ist nicht ausgiebig getestet, aber dennoch eine nette Idee. Verwendung auf eigene Gefahr. ;-)
|
||||
</para>
|
||||
<para>
|
||||
Normalerweise werden Variablen dem Template wie folgt zugewiesen:
|
||||
In Ihrer PHP-Applikation werden die Variablen zusammengestellt
|
||||
(zum Beispiel mit Datenbankabfragen). Danach kreieren Sie eine
|
||||
Instanz von Smarty, weisen die Variablen zu und geben das Template aus.
|
||||
Wenn wir also zum Beispiel einen Börsenticker in unserem
|
||||
Template haben, stellen wir die Kursinformationen in unserer Anwendung
|
||||
zusammen, weisen Sie dem Template zu und geben es aus. Wäre es jedoch nicht
|
||||
nett diesen Börsenticker einfach in ein Template einer anderen Applikation
|
||||
einbinden zu können ohne deren Programmcode zu ändern?
|
||||
</para>
|
||||
|
||||
|
||||
<para>
|
||||
Sie können PHP-Code mit {php}{/php} in Ihre Templates einbetten.
|
||||
So können Sie Templates erstellen, welche die Datenstrukturen
|
||||
zur Anweisung der eigenen Variablen enthalten. Durch die Bindung von
|
||||
Template und Logik entsteht so eine eigenständig lauffähige Komponente.
|
||||
</para>
|
||||
<example>
|
||||
<title>Template/Script Komponenten</title>
|
||||
<programlisting>
|
||||
{* Smarty *}
|
||||
|
||||
{php}
|
||||
|
||||
// unsere funktion um die börsenkurse zu holen
|
||||
function fetch_ticker($symbol,&$ticker_name,&$ticker_price) {
|
||||
// hier wird $ticker_name und $ticker_price zugewiesen
|
||||
}
|
||||
|
||||
// aufruf der funktion
|
||||
fetch_ticker("YHOO",$ticker_name,$ticker_price);
|
||||
|
||||
// zuweisung der variablen
|
||||
$this->assign("ticker_name",$ticker_name);
|
||||
$this->assign("ticker_price",$ticker_price);
|
||||
|
||||
{/php}
|
||||
|
||||
Symbol: {$ticker_name} Preis: {$ticker_price}</programlisting>
|
||||
</example>
|
||||
<para>
|
||||
Seit Smarty 1.5.0, gibt es einen noch einfacheren und auch saubereren Weg
|
||||
in dem man die Logik mit {include_php ...} einbindet. So kann man weiterhin
|
||||
die Logik vom Design getrennt halten. Mehr Informationen gibt es in der <link linkend="language.function.include.php">include_php</link> Dokumentation.
|
||||
</para>
|
||||
<example>
|
||||
<title>Template/Script Komponenten mit include_php</title>
|
||||
<programlisting>
|
||||
load_ticker.php
|
||||
---------------
|
||||
|
||||
<?php
|
||||
// unsere funktion um die börsenkurse zu holen
|
||||
function fetch_ticker($symbol,&$ticker_name,&$ticker_price) {
|
||||
// hier wird $ticker_name und $ticker_price zugewiesen
|
||||
}
|
||||
|
||||
// aufruf der funktion
|
||||
fetch_ticker("YHOO",$ticker_name,$ticker_price);
|
||||
|
||||
// zuweisung der variablen
|
||||
$this->assign("ticker_name",$ticker_name);
|
||||
$this->assign("ticker_price",$ticker_price);
|
||||
?>
|
||||
|
||||
|
||||
index.tpl
|
||||
---------
|
||||
|
||||
{* Smarty *}
|
||||
|
||||
{include_php file="load_ticker.php"}
|
||||
|
||||
Symbol: {$ticker_name} Preis: {$ticker_price}</programlisting>
|
||||
</example>
|
||||
</sect1>
|
||||
<sect1 id="tips.obfuscating.email">
|
||||
<title>Verschleierung von E-mail Adressen</title>
|
||||
<para>
|
||||
Haben Sie sich auch schon gewundert, wie Ihre E-mail Adresse auf so viele
|
||||
Spam-Mailinglisten kommt? Ein Weg, wie Spammer E-mail Adressen sammeln, ist
|
||||
über Webseiten. Um dieses Problem zu bekämpfen, können sie
|
||||
den 'mailto'-Plugin verwenden. Er ändert die Zeichenfolge mit Javascript
|
||||
so, dass sie im HTML Quellcode nicht lesbar ist, jedoch von jedem Browser
|
||||
wieder zusammengesetzt werden kann. Den 'mailto'-Plugin gibt es im Smarty-Repository
|
||||
auf http://smarty.php.net. Laden sie den Plugin herunter und speichern Sie ihn im
|
||||
'plugins' Verzeichnis.
|
||||
</para>
|
||||
<example>
|
||||
<title>Beispiel von verschleierung von E-mail Adressen</title>
|
||||
<programlisting>
|
||||
|
||||
index.tpl
|
||||
---------
|
||||
|
||||
Fragen bitte an
|
||||
{mailto address=$EmailAddress encode="javascript" subject="Hallo"}
|
||||
senden
|
||||
|
||||
</programlisting>
|
||||
</example>
|
||||
<note>
|
||||
<title>Technische Details</title>
|
||||
<para>
|
||||
Die Codierung mit Javascript ist nicht sehr sicher, da ein möglicher
|
||||
Spammer die Decodierung in sein Sammelprogramm einbauen könnte. Es wird jedoch damit
|
||||
gerechnet, dass, da Aufwand und Ertrag sich nicht decken, dies nicht oft der Fall ist.
|
||||
</para>
|
||||
</note>
|
||||
</sect1>
|
||||
</chapter>
|
||||
<chapter id="resources">
|
||||
<title>Weiterführende Informationen</title>
|
||||
<para>
|
||||
Smarty's Homepage erreicht man unter http://smarty.php.net/.
|
||||
Sie können der Smarty Mailingliste beitreten in dem
|
||||
sie ein E-mail an smarty-general-subscribe@lists.php.net senden. Das Archiv
|
||||
der Liste ist hier http://marc.theaimsgroup.com/?l=smarty&r=1&w=2 einsehbar.
|
||||
</para>
|
||||
</chapter>
|
||||
<chapter id="bugs">
|
||||
<title>BUGS</title>
|
||||
<para>
|
||||
Bitte konsultieren Sie die Datei 'BUGS' welche mit Smarty ausgeliefert wird,
|
||||
oder die Webseite.
|
||||
</para>
|
||||
</chapter>
|
||||
</part>
|
||||
46
docs/de/common.dsl
Normal file
46
docs/de/common.dsl
Normal file
@@ -0,0 +1,46 @@
|
||||
;; -*- Scheme -*-
|
||||
;;
|
||||
;; common.dsl,v 1.1.1.1 2003/01/09 09:44:46 dexxter Exp
|
||||
;;
|
||||
;; This file contains stylesheet customization common to the HTML
|
||||
;; and print versions.
|
||||
;;
|
||||
|
||||
;; Stylesheets Localization
|
||||
(define %default-language% "en")
|
||||
|
||||
(define %use-id-as-filename% #t)
|
||||
(define %gentext-nav-tblwidth% "100%")
|
||||
(define %refentry-function% #t)
|
||||
(define %refentry-generate-name% #f)
|
||||
(define %funcsynopsis-style% 'ansi)
|
||||
(define ($legalnotice-link-file$ legalnotice)
|
||||
(string-append "copyright" %html-ext%))
|
||||
(define %generate-legalnotice-link% #t)
|
||||
(define %footnotes-at-end% #t)
|
||||
(define %force-chapter-toc% #t)
|
||||
(define newline "\U-000D")
|
||||
(define %number-programlisting-lines% #f)
|
||||
(define %linenumber-mod% 1)
|
||||
(define %shade-verbatim% #t)
|
||||
|
||||
(define ($generate-book-lot-list$)
|
||||
;; REFENTRY generate-book-lot-list
|
||||
;; PURP Which Lists of Titles should be produced for Books?
|
||||
;; DESC
|
||||
;; This parameter should be a list (possibly empty) of the elements
|
||||
;; for which Lists of Titles should be produced for each 'Book'.
|
||||
;;
|
||||
;; It is meaningless to put elements that do not have titles in this
|
||||
;; list. If elements with optional titles are placed in this list, only
|
||||
;; the instances of those elements that do have titles will appear in
|
||||
;; the LOT.
|
||||
;;
|
||||
;; /DESC
|
||||
;; AUTHOR N/A
|
||||
;; /REFENTRY
|
||||
(list (normalize "table")))
|
||||
|
||||
(define (php-code code)
|
||||
(make processing-instruction
|
||||
data: (string-append "php " code "?")))
|
||||
4619
docs/de/designers.sgml
Normal file
4619
docs/de/designers.sgml
Normal file
File diff suppressed because it is too large
Load Diff
408
docs/de/getting-started.sgml
Normal file
408
docs/de/getting-started.sgml
Normal file
@@ -0,0 +1,408 @@
|
||||
<!-- Smarty German Documentation Port -->
|
||||
<!-- $Id$ -->
|
||||
<!-- $Author$ -->
|
||||
<!-- $Revision$ -->
|
||||
<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ür PHP. Genauer gesagt erlaubt es
|
||||
die einfache Trennung von Applikations-Logik und Design/Ausgabe. Dies
|
||||
ist vor allem wü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ührung,
|
||||
der Author und der Inhalt selbst enthalten keine Informationen darüber
|
||||
wie sie dargestellt werden sollen. Also werden sie von der Applikation
|
||||
an Smarty übergeben, damit der Designer in den Templates mit einer Kombination von
|
||||
HTML- und Template-Tags die Ausgabe (Tabellen, Hintergrundfarben,
|
||||
Schriftgrössen, Stylesheets, etc.) gestalten kann. Falls nun die
|
||||
Applikation eines Tages angepasst werden muss, ist dies für den
|
||||
Designer nicht von Belang, da die Inhalte immer noch genau gleich
|
||||
übergeben werden. Genauso kann der Designer die Ausgabe der
|
||||
Daten beliebig verändern, ohne dass eine Ä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<69>lich für die
|
||||
Ausgabe verwendet wird, kann sie auch im Template eingebettet werden. Ein Tip:
|
||||
versuchen Sie Applikations-Logik aus dem Template und Prä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üssen Templates nicht für jeden Seitenaufruf performance-intensiv
|
||||
neu geparst werden und jedes Template kann voll von PHP Compiler-Cache
|
||||
Lö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 übernimmt.</para></listitem>
|
||||
<listitem><para>Kein Overhead durch Template-Parsing, nur einmaliges kompilieren.</para></listitem>
|
||||
<listitem><para>Re-kompiliert nur gänderte Templates.</para></listitem>
|
||||
<listitem><para>Sie kö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önnen {}, {{}}, <!--{}-->, etc. verwenden.</para></listitem>
|
||||
<listitem><para>'if/elseif/else/endif'-Konstrukte werden direkt dem PHP-Parser übergeben. Somit können {if ...} Ausdr<64>cke sowohl sehr einfach als auch sehr komplex sein.</para></listitem>
|
||||
<listitem><para>Unbegrenzte Verschachtelung von 'section', 'if' und anderen Blöcken.</para></listitem>
|
||||
<listitem><para>Ermöglicht die direkte Einbettung von PHP-Code. (Obwohl es weder benö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ö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ür Dateien und Verzeichnisse Ihres Betriebssystems
|
||||
vertraut sind. Im Folgenden wird ein Unix-Dateisystem verwendet, stellen Sie also
|
||||
sicher, dass sie die für Ihr Betriebssystem nötigen Änderungen vornehmen.
|
||||
</para>
|
||||
<para>
|
||||
Das Beispiel geht davon aus, dass '/php/includes' in Ihrem PHP-'include_path'
|
||||
liegt. Konsultieren Sie das PHP-Manual für weiterfü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 Änderungen an den Smarty-Library Dateien vorzunehmen.
|
||||
Dies macht ein mögliches Upgrade wesentlich einfacher. Sie mü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ötigt:
|
||||
</para>
|
||||
<example>
|
||||
<title>Smarty-Library Dateiliste</title>
|
||||
<screen>
|
||||
Smarty.class.php
|
||||
Smarty_Compiler.class.php
|
||||
Config_File.class.php
|
||||
debug.tpl
|
||||
/plugins/*.php (alle Dateien!)</screen>
|
||||
</example>
|
||||
|
||||
<para>
|
||||
Sie kö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ür beide Fälle aufgezeigt.
|
||||
</para>
|
||||
<para>
|
||||
So erzeugt man eine Instanz der Smarty-Klasse im PHP-Skript:
|
||||
</para>
|
||||
|
||||
<example>
|
||||
<title>Smarty Instanz aus 'include_path' erstellen:</title>
|
||||
<screen>
|
||||
require('Smarty.class.php');
|
||||
$smarty = new Smarty;</screen>
|
||||
</example>
|
||||
|
||||
<para>
|
||||
Wenn sich die Dateien ausserhalb des PHP-'include_path' befinden,
|
||||
muss die Konstante <link linkend="constant.smarty.dir">SMARTY_DIR</link>
|
||||
auf den absoluten Pfad zeigen und mit einem '/' enden. Nehmen wir an,
|
||||
die Library-Dateien befinden sich in '/usr/local/lib/php/Smarty/':
|
||||
</para>
|
||||
|
||||
<example>
|
||||
<title>Instanz von Smarty aus SMARTY_DIR erstellen:</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ür unser Beispiel werden wir die Smarty Umgebung für eine
|
||||
Gästebuch-Applikation konfigurieren. Wir verwenden den Applikationsnamen
|
||||
nur, um die Verzeichnis-Struktur zu verdeutlichen. Sie können die selbe
|
||||
Umgebung fü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ü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ögliche Direktzugriffe zu verhindern.
|
||||
</para>
|
||||
</note>
|
||||
|
||||
<para>
|
||||
In Ihrer DocumentRoot muss mindestens eine Datei liegen, die für Browser
|
||||
zugä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ässt sich dies konfigurieren indem Sie 'index.php'
|
||||
als letzten Eintrag fü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
|
||||
|
||||
/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äten eventuell später
|
||||
genutzt werden sollen.
|
||||
</para>
|
||||
</note>
|
||||
|
||||
<para>
|
||||
Smarty benö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 'web' und
|
||||
ist in der Gruppe 'web'). Wenn Sie Apache verwenden, können Sie in der httpd.conf (gew<65>hnlich in '/usr/local/apache/conf/')
|
||||
nachsehen, unter welchem Benutzer Ihr Server läuft.
|
||||
</para>
|
||||
|
||||
<example>
|
||||
<title>Dateirechte einrichten</title>
|
||||
<screen>
|
||||
|
||||
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/</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öchten, dass auch andere Benutzer die Dateien lesen
|
||||
können (vor allem für Ihren eigenen Komfort), so erreichen Sie dies mit 775.
|
||||
</para>
|
||||
</note>
|
||||
|
||||
<para>
|
||||
Nun mü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/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ötigt,
|
||||
es ist jedoch eine gute Idee jedes Template mit einem Kommentar zu versehen.
|
||||
Dies erleichtert die Erkennbarkeit des Templates, unabhängig von der
|
||||
verwendeten Dateierweiterung. (Zum Beispiel für Editoren die Syntax-Highlighting
|
||||
unterstützen.)
|
||||
</para>
|
||||
</note>
|
||||
|
||||
<para>
|
||||
Als nä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äre dies nicht nötig. Es ist jedoch
|
||||
effizienter und weniger fehleranfällig die Pfade absolut zu setzen.
|
||||
Und es garantiert, dass Smarty die Templates aus dem geplanten Verzeichnis lädt.
|
||||
</para>
|
||||
</note>
|
||||
|
||||
<para>
|
||||
Wenn Sie 'index.php' nun in Ihrem Webbrowser öffnen, sollte 'Hallo, Ned!' ausgegeben werden.
|
||||
</para>
|
||||
<para>
|
||||
Die Basis-Installation von Smarty wäre somit beendet.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 id="installing.smarty.extended">
|
||||
<title>Erweiterte Konfiguration</title>
|
||||
|
||||
<para>
|
||||
|
||||
Dies ist eine Weiterfü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ü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önnten sensitive Informationen enthalten,
|
||||
die wir nicht zugänglich machen mö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ö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ö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>
|
||||
382
docs/de/html-common.dsl
Normal file
382
docs/de/html-common.dsl
Normal file
@@ -0,0 +1,382 @@
|
||||
;; -*- Scheme -*-
|
||||
;;
|
||||
;; html-common.dsl,v 1.1.1.1 2003/01/09 09:44:46 dexxter Exp
|
||||
;;
|
||||
|
||||
;; Returns the depth of the auto-generated TOC (table of contents) that
|
||||
;; should be made at the nd-level
|
||||
(define (toc-depth nd)
|
||||
(if (string=? (gi nd) (normalize "book"))
|
||||
3 ; the depth of the top-level TOC
|
||||
1 ; the depth of all other TOCs
|
||||
))
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
(element (funcdef function)
|
||||
($bold-seq$
|
||||
(make sequence
|
||||
(process-children)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
(define (is-true-optional nl)
|
||||
(and (equal? (gi (parent nl)) (normalize "parameter"))
|
||||
(equal? 0 (string-length (strip (data (preced nl)))))
|
||||
(equal? 0 (string-length (strip (data (follow nl)))))
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
(define (has-true-optional nl)
|
||||
(is-true-optional
|
||||
(node-list-first-element
|
||||
(select-elements
|
||||
(descendants nl)
|
||||
(normalize "optional"))
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
(define (count-true-optionals nl)
|
||||
(let loop
|
||||
((result 0)
|
||||
(nl (select-elements (descendants nl) (normalize "optional")))
|
||||
)
|
||||
(if(node-list-empty? nl)
|
||||
result
|
||||
(if(is-true-optional(node-list-first nl))
|
||||
(loop (+ result 1) (node-list-rest nl))
|
||||
(loop result (node-list-rest nl))
|
||||
)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
;; there are two different kinds of optionals
|
||||
;; optional parameters and optional parameter parts
|
||||
;; an optional parameter is identified by an optional tag
|
||||
;; with a parameter tag as its parent
|
||||
;; and only whitespace between them
|
||||
(element optional
|
||||
;;check for true optional parameter
|
||||
(if (is-true-optional (current-node))
|
||||
;; yes - handle '[...]' in paramdef
|
||||
(process-children-trim)
|
||||
;; no - do '[...]' output
|
||||
(make sequence
|
||||
(literal %arg-choice-opt-open-str%)
|
||||
(process-children-trim)
|
||||
(literal %arg-choice-opt-close-str%)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
;; now this is going to be tricky
|
||||
(element paramdef
|
||||
(make sequence
|
||||
;; special treatment for first parameter in funcsynopsis
|
||||
(if (equal? (child-number (current-node)) 1)
|
||||
;; is first ?
|
||||
(make sequence
|
||||
;; start parameter list
|
||||
(literal "(")
|
||||
;; is optional ?
|
||||
( if (has-true-optional (current-node))
|
||||
(literal %arg-choice-opt-open-str%)
|
||||
(empty-sosofo)
|
||||
)
|
||||
)
|
||||
;; not first
|
||||
(empty-sosofo)
|
||||
)
|
||||
|
||||
;;
|
||||
(process-children-trim)
|
||||
|
||||
;; special treatment for last parameter
|
||||
(if (equal? (gi (ifollow (current-node))) (normalize "paramdef"))
|
||||
;; more parameters will follow
|
||||
(make sequence
|
||||
;; next is optional ?
|
||||
( if (has-true-optional (ifollow (current-node)))
|
||||
;; optional
|
||||
(make sequence
|
||||
(literal " ")
|
||||
(literal %arg-choice-opt-open-str%)
|
||||
)
|
||||
;; not optional
|
||||
(empty-sosofo)
|
||||
)
|
||||
(literal ", " )
|
||||
)
|
||||
;; last parameter
|
||||
(make sequence
|
||||
(literal
|
||||
(let loop ((result "")(count (count-true-optionals (parent (current-node)))))
|
||||
(if (<= count 0)
|
||||
result
|
||||
(loop (string-append result %arg-choice-opt-close-str%)(- count 1))
|
||||
)
|
||||
)
|
||||
)
|
||||
( literal ")" )
|
||||
)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
(element function
|
||||
(let* ((function-name (data (current-node)))
|
||||
(linkend
|
||||
(string-append
|
||||
"function."
|
||||
(string-replace
|
||||
(string-replace function-name "_" "-")
|
||||
"::" ".")))
|
||||
(target (element-with-id linkend))
|
||||
(parent-gi (gi (parent))))
|
||||
(cond
|
||||
;; function names should be plain in FUNCDEF
|
||||
((equal? parent-gi "funcdef")
|
||||
(process-children))
|
||||
|
||||
;; if a valid ID for the target function is not found, or if the
|
||||
;; FUNCTION tag is within the definition of the same function,
|
||||
;; make it bold, add (), but don't make a link
|
||||
((or (node-list-empty? target)
|
||||
(equal? (case-fold-down
|
||||
(data (node-list-first
|
||||
(select-elements
|
||||
(node-list-first
|
||||
(children
|
||||
(select-elements
|
||||
(children
|
||||
(ancestor-member (parent) (list "refentry")))
|
||||
"refnamediv")))
|
||||
"refname"))))
|
||||
function-name))
|
||||
($bold-seq$
|
||||
(make sequence
|
||||
(process-children)
|
||||
(literal "()"))))
|
||||
|
||||
;; else make a link to the function and add ()
|
||||
(else
|
||||
(make element gi: "A"
|
||||
attributes: (list
|
||||
(list "HREF" (href-to target)))
|
||||
($bold-seq$
|
||||
(make sequence
|
||||
(process-children)
|
||||
(literal
|
||||
)
|
||||
(literal "()"))))))))
|
||||
|
||||
(element command
|
||||
(let* ((command-name (data (current-node)))
|
||||
(linkend
|
||||
(string-append
|
||||
"language.function."
|
||||
(string-replace
|
||||
(string-replace command-name "_" ".")
|
||||
"::" ".")))
|
||||
(target (element-with-id linkend))
|
||||
(parent-gi (gi (parent))))
|
||||
(cond
|
||||
;; function names should be plain in FUNCDEF
|
||||
((equal? parent-gi "funcdef")
|
||||
(process-children))
|
||||
|
||||
;; if a valid ID for the target function is not found, or if the
|
||||
;; FUNCTION tag is within the definition of the same function,
|
||||
;; make it bold, add (), but don't make a link
|
||||
((or (node-list-empty? target)
|
||||
(equal? (case-fold-down
|
||||
(data (node-list-first
|
||||
(select-elements
|
||||
(node-list-first
|
||||
(children
|
||||
(select-elements
|
||||
(children
|
||||
(ancestor-member (parent) (list "refentry")))
|
||||
"refnamediv")))
|
||||
"refname"))))
|
||||
command-name))
|
||||
($bold-seq$
|
||||
(make sequence
|
||||
(literal "{")
|
||||
(process-children)
|
||||
(literal "}"))))
|
||||
|
||||
;; else make a link to the function and add ()
|
||||
(else
|
||||
(make element gi: "A"
|
||||
attributes: (list
|
||||
(list "HREF" (href-to target)))
|
||||
($bold-seq$
|
||||
(make sequence
|
||||
(literal "{")
|
||||
(process-children)
|
||||
(literal "}"))))))))
|
||||
|
||||
(element classname
|
||||
(let* ((class-name (data (current-node)))
|
||||
(linkend
|
||||
(string-append
|
||||
"class."
|
||||
(string-replace
|
||||
(case-fold-down class-name) "_" "-")))
|
||||
(target (element-with-id linkend))
|
||||
(parent-gi (gi (parent))))
|
||||
(cond
|
||||
;; function names should be plain in SYNOPSIS
|
||||
((equal? parent-gi "synopsis")
|
||||
(process-children))
|
||||
|
||||
;; if a valid ID for the target class is not found, or if the
|
||||
;; CLASSNAME tag is within the definition of the same class,
|
||||
;; make it bold, but don't make a link
|
||||
((or (node-list-empty? target)
|
||||
(equal? (case-fold-down
|
||||
(data (node-list-first
|
||||
(select-elements
|
||||
(node-list-first
|
||||
(children
|
||||
(select-elements
|
||||
(children
|
||||
(ancestor-member (parent) (list "refentry")))
|
||||
"refnamediv")))
|
||||
"refname"))))
|
||||
class-name))
|
||||
($bold-seq$
|
||||
(process-children)))
|
||||
|
||||
;; else make a link to the function and add ()
|
||||
(else
|
||||
(make element gi: "A"
|
||||
attributes: (list
|
||||
(list "HREF" (href-to target)))
|
||||
($bold-seq$
|
||||
(process-children)))))))
|
||||
|
||||
|
||||
(element constant
|
||||
(let* ((constant-name (data (current-node)))
|
||||
(linkend
|
||||
(string-append "constant."
|
||||
(case-fold-down
|
||||
(string-replace constant-name "_" "-"))))
|
||||
(target (element-with-id linkend))
|
||||
(parent-gi (gi (parent))))
|
||||
(cond
|
||||
; ;; constant names should be plain in FUNCDEF
|
||||
; ((equal? parent-gi "funcdef")
|
||||
; (process-children))
|
||||
|
||||
;; if a valid ID for the target constant is not found, or if the
|
||||
;; CONSTANT tag is within the definition of the same constant,
|
||||
;; make it bold, add (), but don't make a link
|
||||
((or (node-list-empty? target)
|
||||
(equal? (case-fold-down
|
||||
(data (node-list-first
|
||||
(select-elements
|
||||
(node-list-first
|
||||
(children
|
||||
(select-elements
|
||||
(children
|
||||
(ancestor-member (parent) (list "refentry")))
|
||||
"refnamediv")))
|
||||
"refname"))))
|
||||
constant-name))
|
||||
($bold-mono-seq$
|
||||
(process-children)))
|
||||
|
||||
;; else make a link to the function and add ()
|
||||
(else
|
||||
(make element gi: "A"
|
||||
attributes: (list
|
||||
(list "HREF" (href-to target)))
|
||||
($bold-mono-seq$
|
||||
(process-children)))))))
|
||||
|
||||
|
||||
(element example
|
||||
(make sequence
|
||||
(make element gi: "TABLE"
|
||||
attributes: (list
|
||||
(list "WIDTH" "100%")
|
||||
(list "BORDER" "0")
|
||||
(list "CELLPADDING" "0")
|
||||
(list "CELLSPACING" "0")
|
||||
(list "CLASS" "EXAMPLE"))
|
||||
(make element gi: "TR"
|
||||
(make element gi: "TD"
|
||||
($formal-object$))))))
|
||||
|
||||
|
||||
(element (paramdef parameter)
|
||||
(make sequence
|
||||
font-posture: 'italic
|
||||
(process-children-trim)
|
||||
)
|
||||
)
|
||||
|
||||
(mode book-titlepage-recto-mode
|
||||
(element authorgroup
|
||||
(process-children))
|
||||
|
||||
(element author
|
||||
(let ((author-name (author-string))
|
||||
(author-affil (select-elements (children (current-node))
|
||||
(normalize "affiliation"))))
|
||||
(make sequence
|
||||
(make element gi: "DIV"
|
||||
attributes: (list (list "CLASS" (gi)))
|
||||
(literal author-name))
|
||||
(process-node-list author-affil))))
|
||||
)
|
||||
|
||||
(define (chunk-element-list)
|
||||
(list (normalize "preface")
|
||||
(normalize "chapter")
|
||||
(normalize "appendix")
|
||||
(normalize "article")
|
||||
(normalize "glossary")
|
||||
(normalize "bibliography")
|
||||
(normalize "index")
|
||||
(normalize "colophon")
|
||||
(normalize "setindex")
|
||||
(normalize "reference")
|
||||
(normalize "refentry")
|
||||
(normalize "part")
|
||||
(normalize "sect1")
|
||||
(normalize "sect2")
|
||||
(normalize "section")
|
||||
(normalize "book") ;; just in case nothing else matches...
|
||||
(normalize "set") ;; sets are definitely chunks...
|
||||
))
|
||||
|
||||
(define ($section-body$)
|
||||
(make element gi: "DIV"
|
||||
attributes: (list (list "CLASS" (gi)))
|
||||
($section-separator$)
|
||||
($section-title$)
|
||||
|
||||
(if (or (not (node-list-empty? (select-elements (children (current-node))
|
||||
(normalize "sect2"))))
|
||||
(not (node-list-empty? (select-elements (children (current-node))
|
||||
(normalize "sect3")))))
|
||||
(build-toc (current-node) 1)
|
||||
(empty-sosofo))
|
||||
|
||||
(process-children)))
|
||||
|
||||
21
docs/de/html.dsl
Normal file
21
docs/de/html.dsl
Normal file
@@ -0,0 +1,21 @@
|
||||
<!DOCTYPE style-sheet PUBLIC "-//James Clark//DTD DSSSL Style Sheet//EN" [
|
||||
<!ENTITY docbook.dsl SYSTEM "/usr/share/sgml/docbook/html/docbook.dsl" CDATA DSSSL>
|
||||
<!ENTITY html-common.dsl SYSTEM "html-common.dsl">
|
||||
<!ENTITY common.dsl SYSTEM "common.dsl">
|
||||
]>
|
||||
|
||||
<style-sheet>
|
||||
<style-specification id="docbook-smarty-html" use="docbook">
|
||||
<style-specification-body>
|
||||
|
||||
(define %html-ext% ".html")
|
||||
|
||||
&html-common.dsl;
|
||||
&common.dsl;
|
||||
|
||||
</style-specification-body>
|
||||
</style-specification>
|
||||
|
||||
<external-specification id="docbook" document="docbook.dsl">
|
||||
|
||||
</style-sheet>
|
||||
48
docs/de/manual.sgml
Normal file
48
docs/de/manual.sgml
Normal file
@@ -0,0 +1,48 @@
|
||||
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook V3.1//EN" [
|
||||
<!ENTITY preface SYSTEM "preface.sgml">
|
||||
<!ENTITY getting.started SYSTEM "getting-started.sgml">
|
||||
<!ENTITY smarty.for.designers SYSTEM "designers.sgml">
|
||||
<!ENTITY smarty.for.programmers SYSTEM "programmers.sgml">
|
||||
<!ENTITY appendixes SYSTEM "appendixes.sgml">
|
||||
]>
|
||||
<!-- Smarty German Documentation Port -->
|
||||
<!-- $Id$ -->
|
||||
<!-- $Author$ -->
|
||||
<!-- $Revision$ -->
|
||||
<book id="index" lang="de">
|
||||
<bookinfo id="bookinfo">
|
||||
<title>Smarty - die kompilierende PHP Template-Engine</title>
|
||||
<authorgroup id="authors">
|
||||
<author>
|
||||
<firstname>Monte</firstname><surname>Ohrt <monte@ispi.net></surname>
|
||||
</author>
|
||||
<author>
|
||||
<firstname>Andrei</firstname><surname>Zmievski <andrei@php.net></surname>
|
||||
</author>
|
||||
</authorgroup>
|
||||
|
||||
<authorgroup id="translators">
|
||||
<author>
|
||||
<firstname>Andreas</firstname><surname>Halter <smarty@andreashalter.ch> (Deutsche Übersetzung)</surname>
|
||||
</author>
|
||||
<author>
|
||||
<firstname>Thomas</firstname><surname>Schulz <ths@4bconsult.de> (Review der deutschen Übersetzung)</surname>
|
||||
</author>
|
||||
</authorgroup>
|
||||
|
||||
<edition>Version 2.0</edition>
|
||||
<copyright>
|
||||
<year>2001</year>
|
||||
<year>2002</year>
|
||||
<year>2003</year>
|
||||
<holder>ispi of Lincoln, Inc.</holder>
|
||||
</copyright>
|
||||
</bookinfo>
|
||||
|
||||
&preface;
|
||||
&getting.started;
|
||||
&smarty.for.designers;
|
||||
&smarty.for.programmers;
|
||||
&appendixes;
|
||||
|
||||
</book>
|
||||
73
docs/de/preface.sgml
Normal file
73
docs/de/preface.sgml
Normal file
@@ -0,0 +1,73 @@
|
||||
<!-- Smarty German Documentation Port -->
|
||||
<!-- $Id$ -->
|
||||
<!-- $Author$ -->
|
||||
<!-- $Revision$ -->
|
||||
|
||||
<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ä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ä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 übergibt dieses
|
||||
dem Programmierer. Der Programmierer implementiert die Geschäftslogik
|
||||
in PHP und verwendet den Interface-Prototypen zur Erstellung eines Template-Skeletts.
|
||||
Danach ü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üssen und möchte auch
|
||||
nicht, dass der Designer seinen PHP-Code verändert. Designer selbst
|
||||
benötigen Konfigurationsdateien, dynamische Blöcke und andere Interface spezifische
|
||||
Eigenheiten, möchten aber auch nicht direkt mit PHP in Berührung kommen.
|
||||
</para>
|
||||
<para>
|
||||
Die meisten Template-Engines die heutzutage angeboten werden, bieten eine
|
||||
rudimentäre Möglichkeit Variablen in einem Template zu ersetzen
|
||||
und beherschen eine eingeschränkte Funktionalität für dynamische
|
||||
Blöcke. Unsere Anforderungen forderten jedoch ein wenig mehr. Wir wollten
|
||||
erreichen, dass sich Programmierer überhaupt nicht um HTML Layouts
|
||||
kümmern müssen. Dies war aber fast unumgä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ügung stünden,
|
||||
aus denen er Variablen fü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ürde. Nach einer hitzigen Debatte darüber
|
||||
was eine Template Engine können sollte und was nicht, und nachdem wir feststellen
|
||||
mussten, dass ein paar komplizierte technische Probleme auf uns zukommen
|
||||
wü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öffentlicht). SmartTemplate
|
||||
erlaubte uns praktisch alles zu tun was wir uns vorgenommen hatten: normale
|
||||
Variablen-Ersetzung, Möglichkeiten weitere Templates einzubinden,
|
||||
Integration von Konfigurationsdateien, Einbetten von PHP-Code, limitierte 'if'-Funktionalität
|
||||
und eine sehr robuste Implementation von dynamischen Blöcken die
|
||||
mehrfach verschachtelt werden konnten. All dies wurde mit Regulären Ausdrücken
|
||||
erledigt und der Sourcecode wurde ziemlich unübersichtlich. Für grössere
|
||||
Applikationen war die Klasse auch bemerkenswert langsam, da das Parsing bei jedem
|
||||
Aufruf einer Seite durchlaufen werden musste. Das grösste Problem aber war,
|
||||
dass der Programmierer das Setup, die Templates und dynamische Blöcke in seinem
|
||||
PHP-Skript definieren musste. Die nächste Frage war: wie können wir dies
|
||||
weiter vereinfachen?
|
||||
</para>
|
||||
<para>
|
||||
Dann kam uns die Idee, aus der schlie<69>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äre also, wenn wir diese
|
||||
beiden Stärken vereinten? Smarty war geboren...
|
||||
</para>
|
||||
</preface>
|
||||
2772
docs/de/programmers.sgml
Normal file
2772
docs/de/programmers.sgml
Normal file
File diff suppressed because it is too large
Load Diff
@@ -3618,6 +3618,13 @@ OUTPUT: (both examples)
|
||||
<entry><emphasis>web server doc root</emphasis></entry>
|
||||
<entry>directory to base relative paths from</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>link</entry>
|
||||
<entry>string</entry>
|
||||
<entry>no</entry>
|
||||
<entry><emphasis>n/a</emphasis></entry>
|
||||
<entry>href value to link the image to</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
@@ -3632,6 +3639,10 @@ OUTPUT: (both examples)
|
||||
DOCUMENT_ROOT) is used as the base. If security is enabled, the
|
||||
path to the image must be within a secure directory.
|
||||
</para>
|
||||
<para>
|
||||
link is the href value to link the image to. If link is supplied, an
|
||||
<a href="LINKVALUE"><a> tag is put around the image tag.
|
||||
</para>
|
||||
<note>
|
||||
<title>Technical Note</title>
|
||||
<para>
|
||||
|
||||
Reference in New Issue
Block a user