Templates

1. Zweck von Templates

Templates sind in diesem Framework ein "Abfallprodukt" der unter Klassen erläutert DOM-Struktur der GUI und dienen der Abstraktion und Trennung von Funktion und Darstellung gemäß MVC-Pattern. Sie bieten die Möglichkeit, verschiedene Teil-Elemente oder Views in XML- und HTML-Code zu definieren, mit dem anschließend ein Controller einen View erstellen kann. Im Sprachgebrauch dieses Frameworks gibt es zwei Arten von Templates. Zu einen die Template- Dateien, die zum Speichern der XML- und HTML-Fragmente, die den Inhalt eines DOM-Knotens repräsentieren, gedacht sind, zum anderen HTML-Templates innerhalb dieser Dateien, die einen wiederverwendbaren Bereich von XML- und HTML-Code definieren. Letzterer wird oft für die Darstellung von Listen benötigt, in der ein Listenelement durch beliebige Iteration im Controller zu einer Liste zusammengefügt wird.

2. Aufbau von Templates

Template-Dateien beinhalten drei Kategorien von Zeichenketten:
  • TagLibTags
  • HTML-Code
  • Einfacher Text
TagLibTags sind dabei dem Tag-Parser bekannte XML-Tags der Form <prefix:class />, wobei "prefix" und "class" durch jedes beliebige XML-konforme Präfix und jeden Klassenbezeichner des Tags ersetzbar sind. Erlaubt sind hier die Zeichen [a-z]. Jedes Tag kann eine beliebige Anzahl von Attributen und bei nicht selbstschließenden Tags einen Inhalt besitzen. Diese haben die Form attribute="value". HTML-Code und einfacher Text sind sowohl als Attribute von TagLibTags als auch als Inhalte verwendbar.


3. Typische Templates

Im Folgenden werden einige typische Templates aufgeführt und erläutert.


3.1. Template zur Darstellung dynamischer Inhalte

Ein Anwendungsbeispiel für die Darstellung dynamischer Inhalte ist das generische Befüllen von Meta-Tag-Angaben. Dazu können in einem Template mehrere <html:placeholder />- Tags eingesetzt werden. Die dynamischen Meta-Tags dieser Dokumentations-Seite haben folgende Gestalt:

APF-Template
[..] <meta name="DC.Date" content="<html:placeholder name="Date" />" /> <meta name="DC.Type" content="Text" /> <meta name="DC.Format" content="text/html" /> <meta name="DC.Identifier" content="Dipl.-Ing. (FH) Christian W. Schäfer" /> <meta name="DC.Source" content="<html:placeholder name="URI" />" /> <meta name="DC.Language" content="de" /> <meta name="DC.Relation" content="<html:placeholder name="URI" />" /> [..] <meta name="keywords" lang="de" content="PHP,Framework,Page-Controller,Front-Controller,Pattern,[..]" /> <meta name="date" content="<html:placeholder name="Date" />" /> <meta name="robots" content="index,follow" /> <meta name="revisit-after" content="5 days" /> [..]
Hier stehen nun zwei unterschiedliche Platzhalter zur Verfügung, die in einem Controller mit Inhalten gefüllt werden können. Die XML-Tags werden dann beim Transformieren der Seite durch die im Controller eingesetzten Inhalten ersetzt.


3.2. HTML-Templates

HTML-Templates dienen - wie bereits angesprochen - zur Definition von wiederverwendbaren HTML-Fragmenten zur Darstellung von Listen oder Tabellen. Hier werden zumeist je Element ein Template erstellt, das vom Controller zum Aufbau eines Views oder eines View-Elements verwendet werden kann. HTML-Templates werden nicht direkt am Platz ihrer Definition ausgegeben, sondern sind nur Struktur-Elemente die zur Generierung von Elementen genutzt werden können. Im Folgenden soll eine Template-Datei zum Aufbau einer einspaltigen Tabelle aufgeführt werden:

APF-Template
[..] <html:placeholder name="List" /> <html:template name="ListHeader"> <table cellpadding="0" cellspacing="0" border="0"> <tr> <td> <strong>ExampleList</strong> </td> </tr> <template:placeholder name="TableElements" /> </table> </html:template> <html:template name="ListItem"> <tr> <td> <template:placeholder name="ItemValue" /> </td> </tr> </html:template>
In der Template-Datei werden drei Elemente definiert:
  • HTML-Platzhalter:
    Dieser dient der Darstellung der fertigen Liste. Er wird im Controller mit dem HTML-Code der generierten Liste gefüllt.
  • HTML-Template "ListHeader":
    Dieses HTML-Template definiert den Kopf der Liste. Es beinhaltet ebenso einen Platzhalter, in den die Listenelemente eingesetzt werden können.
  • HTML-Template "ListItem":
    Dieses HTML-Template repräsentiert ein Listen-Element. Es besitzt einen Platzhalter für die Darstellung des Liste-Inhalts.
Die Implementierung des Document-Controllers würde in diesem Fall folgendem Schema genügen:

                    START
                      |
                      v
      +--------------------------------+
      | Laden der Listen-Einträge |
      +--------------------------------+
                      |
                      v
      +--------------------------------+
      |   Initialisieren Listenpuffer  |
      +--------------------------------+
                      |
                      v
      +--------------------------------+
      |       Iterieren der Liste      |
      +--------------------------------+
                      |
                      v
      +--------------------------------+
      | Einsetzen des Listenwertes in  |
      |      Template "ListItem"       |
      +--------------------------------+
                      |
                      v
      +--------------------------------+
      | Transformieren von "ListItem"  |
      |  Hinzufügen des Puffers   |
      |        zum Listenpuffer        |
      +--------------------------------+
                      |
                      v
      +--------------------------------+
      | Einsetzen des Listenpuffers in |
      |      Template "ListHeader"     |
      +--------------------------------+
                      |
                      v
      +--------------------------------+
      |   Transform. von "ListHeader"  |
      |  Einsetzen des Inhalts in den  |
      |       Platzhalter "List"       |
      +--------------------------------+
                      |
                      v
                     ENDE

Tipp: Templates, die nicht für die Generierung von Listen oder anderen mehrfach vorkommenden Strukturen eingesetzt werden, können direkt an der Stelle ausgegeben werden, an der sie in der Template-Datei definiert wurde. Hierzu muss im Document-Controller die Methode transformOnPlace() aufgerufen werden. Möchte der Entwickler das HTML-Template
APF-Template
... <html:template name="mein_template"> ... </html:template> ...
direkt ausgeben, so muss im Document-Controller folgendes notiert werden:
PHP-Code
class SampleController extends BaseDocumentController { public function transformContent(){ $template = &$this->getTemplate('mein_template'); $template->transformOnPlace(); } }

3.3. Dynamische Einbindung von Views

Zur dynamischen Einbindung von Views besitzt der <core:importdesign />-Tag ein generisches Tag-Konstrukt. Dieses bietet die Möglichkeit einen Standard-View zu definieren, der mit einem definierten URL-Parameter beeinflusst werden kann:
APF-Template
<core:importdesign namespace="[..]" template="[pagepart = start]" />
Ist der URL-Parameter "pagepart" nicht gesetzt, so wird die Template-Datei "start" eingebunden, falls der Parameter gesetzt ist, der dadurch definierte View. So ist es möglich einen Workflow mit einer Serie an Views (z.B. ein mehrseitiges Formular) abzubilden oder dieses zur Darstellung unterschiedlicher Teile eines Moduls zu nutzen. Da es bei Einbindung mehrere Module über den "pagepart"-Parameter zu Überschneidungen kommen kann, ist der URL-Parameter über das Attribut incparam manipulierbar. Die Einbindung gestaltet sich dann wie folgt:
APF-Template
<core:importdesign namespace="[..]" incparam="myurlparam" template="[myurlparam = start]" />
Ein konkretes Beispiel für die dynamischen View-Einbindung ist die Steuerung der angezeigten Perspektive der vorliegenden Seite. Je nach Wunsch des Benutzers wird einer der verhandenen Views (Normale Webseiten-Ansicht bzw. Print-Ansicht) ausgegeben. Dazu ist in der Template-Datei website.html ein <core:importdesign />-Tag mit dem Inhalt
APF-Template
<core:importdesign namespace="sites::apfdocupage::pres::templates" template="[perspective=site]" incparam="perspective" />
definiert. Damit ist es auf einfache Weise möglich eine Druck-Funktion bereitszustellen. Ein Klick auf den oben aufgeführten Print-Link demonstriert die Funktion.


3.4. Weitere Tags

Alle im Lieferumfang des Frameworks enthaltenen Tags werden auf der Seite Standard TagLibs dokumentiert. Weiterführende Template-Beispiele sind unter Objektorientierte Implementierung eines Gästebuchs und Kontakt zu finden.

Kommentare

Möchten Sie den Artikel eine Anmerkung hinzufügen, oder haben Sie ergänzende Hinweise? Dann können Sie diese hier einfügen. Die bereits verfassten Anmerkungen und Kommentare finden Sie in der untenstehenden Liste.
Für diesen Artikel liegen aktuell keine Kommentare vor.