Folgende TagLib-Tags stehen zur Verfügung. In nicht selbstschließenden Tags sind alle HTML- Tags und -Formatierungen erlaubt. Die Tags können mit den üblichen HTML-Attributen ausgestattet werden, sofern diese für die Ausgabe oder Funktion relevant sind.
Der Page-Controller des APF ist nach dem HMVC-Pattern entworfen und verwaltet die einzelnen Elemente und Komponenten Ihrer Software in Dokumenten. Jedes dieser Dokumente - auch Knoten genannt - kann weitere Knoten enthalten. Ein Knoten wird im APF durch die Klasse Document und davon erbenden Klassen repräsentiert.
Der APF-Parser verarbeitet alle Tags der Form
<prefix:name />
beziehungsweise
<prefix:name></prefix:name>
inklusive der definierten Tag-Attribute innerhalb von Template-Dateien. Zur Erzeugung des DOM-Baums greift er auf die Document::$knownTags- (statisch) und Document::$knownInstanceTags-Listen (pro Instanz) zurück um die zu nutzende Implementierung zu erhalten. Möchten Sie in Ihrem Projekt einen eigenen Tag nutzen, der im Auslieferungszustand des APF noch nicht bekannt ist, können Sie den <core:addtaglib />-Tag nutzen. Dieser macht den gewünschten Tag inklusive seiner Implementierung entweder global für alle Templates oder den lokalen DOM-Knoten bekannt. In einem Template auf diese Weise bekannt gegebene Tags können unmittelbar danach genutzt werden.
Die Signatur des Tags gestaltet sich wie folgt:
<core:addtaglib
class=""
prefix=""
name=""
[scope=""]
/>
[A-Za-z0-9_\]
)
[a-z]
)
[a-z]
)
global|local
)
Die innerhalb der Klasse zu implementierenden Methoden können der API-Dokumentation oder dem Tutorial Implementierung von Tags entnommen werden. Die Bennenung der Tag-Implementierung kann frei durch das Attribut class definiert werden. Dabei ist es möglich, eine Implementierung mit unterschiedlichen Präfixen und unterschiedlichen Tag-Namen zu registrieren.
Die Implementierung von eigenen Tags wird empfohlen, wenn Funktionalitäten in mehreren Projekten wiederverwendet werden sollen oder die Funktionalität mit einem (Document-)Controller nicht mehr abgebildet werden können.
Document::addTagLib('VENDOR\..\DateDisplayTag', 'date', 'display');
Möchte der Template-Entwickler an einer definierten Stelle ein weiteres Document einfügen, so kann der Tag
<core:importdesign
namespace=""
template=""
[incparam=""]
[context=""]
/>
genutzt werden.
Beschreibung der Attribute:[A-Za-z0-9_\]
)
[A-Za-z0-9-_]
)
Wird bei der Definition des Tags ein sog. pagepart-Template definiert, kann ein Template abhängig vom URL-Parameter eingebunden werden. Standard-Parameter ist pagepart, dieser kann jedoch mit dem optionalen Attribut incparam angepasst werden. Beispiel für die Einbindung mit pagepart-Parameter:
<core:importdesign
namespace="VENDOR\pres\templates"
template="[pagepart = test]"
/>
<core:importdesign
namespace="VENDOR\pres\templates"
template="[cmsmodule = test]"
incparam="cmsmodule"
/>
Das eingebundene Template erbt automatisch die Eigenschaften des Vater-Objekts. Insbesondere Context und Sprache werden übertragen.
Um in einem Document-Controller Inhalte dynamisch füllen zu können gibt es den <html:placeholder/>-Tag.
<html:placeholder name="" />
[A-Za-z0-9-_]
)
Um einen Platzhalter mit Inhalt zu füllen kann man in einem Document-Controller folgendes einbauen:
$this->setPlaceHolder('NameDesPlatzhalters', 'InhaltDesPlatzHalters');
${NameDesPlatzhalters}
Der Tag <html:getstring/> dient dazu einen Wert aus einer sprachabhängigen Konfigurations-Datei auszulesen und anzuzeigen. So können Sie auf einfache Weise mehrsprachige Anwendungen bauen.
<html:getstring
[name=""]
namespace=""
config=""
entry="" />
[A-Za-z0-9_-]
)
[A-Za-z0-9_\]
)
[A-Za-z0-9-_]
)
[A-Za-z0-9-_.]
)
Die sprachabhängige Konfigurationsdatei muss jeweils eine Sektion pro Sprache (zweistelliger ISO-Länder-Code) und die verwendeten Konfigurationsschlüssel in den Sektionen enthalten sein. Soll der Tag
<html:getstring namespace="VENDOR\modules\guestbook" config="language.ini" entry="title" />
zur Anzeige eines sprachabhängigen Titels in einem Template genutzt werden, muss die Konfigurationsdatei
/VENDOR/config/modules/guestbook/{CONTEXT}/{ENVIRONMENT}_language.ini
mit dem Inhalt
[de]
title = "Mein Modul"
[en]
title = "My module"
gefüllt werden.
Sprachabhängige Werte lassen sich zusätzlich mit Platzhaltern versehen, die mittels (Document-)Controller zur Ausführungszeit dynamisch gefüllt werden können. Ein Platzhalter definiert sich durch seinen Namen, der durch Klammern eingefasst ist:
{user-name}
Dieser Platzhalter kann später mit dem Schlüssel user-name referenziert werden. Die nachfolgend aufgeführte Sprach-Datei definiert drei Schlüssel, die jeweils einen oder mehrere Platzhalter beinhalten:
[de]
headline = "Dies ist eine {word}"
intro.text = "Dies ist ein Text mit {count} Platzhalter."
message = "Dies ist eine Nachricht von {user-name}, die am {date} gesendet wurde."
...
Die dort definierten Werte, könnten wie folgt in einem Template genutzt werden:
<h3><html:getstring
name="headline"
namespace="..."
config="..."
entry="headline"/></h3>
<html:form name="Form">
<p>
<html:getstring
name="intro-text"
namespace="..."
config="..."
entry="intro.text"/>
</p>
...
</html:form>
<html:template name="Message">
...
<p>
<html:getstring
name="message"
namespace="..."
config="..."
entry="message"/>
</p>
</html:template>
Zur Befüllung der Platzhalter stehen nun verschiedene Möglichkeiten zur Verfügung, die im nachfolgend abgebildeten Document-Controller beschrieben sind. Diese nutzen jeweils die Methode getLabel() um die jeweilige Instanz zu beziehen. Diese bietet dann die Methode setPlaceHolder() an, die den Namen und den Wert des Platzhalters entgegen nimmt. Die Methode kann im fluid interface-Stil genutzt werden um mehrere Platzhalter zu setzen:
use APF\core\pagecontroller\BaseDocumentController;
class SampleController extends BaseDocumentController {
public function transformContent() {
// Platzhalter in einem < html:getstring /> direkt im Template füllen:
$this->getLabel('headline')->setPlaceHolder('word', 'Überschrift');
// Platzhalter in einem < html:getstring /> im Formular füllen:
$form = $this->getForm('Form');
$form->getLabel('intro-text')->setPlaceHolder('count', 'eine');
// Platzhalter in einem < html:getstring /> in einem Template füllen:
$tmpl = $this->getTemplate('Message');
$tmpl->getLabel('message')
->setPlaceHolder('user-name', 'Hans')
->setPlaceHolder('date', date('d.m.Y H:i:s'));
}
}
Um weitere Elemente für die Ausgabe-Steuerung definieren zu können gibt es so genannte Templates. Diese können innerhalb eines Document-Controllers manipuliert und verarbeitet werden. In einem Template gibt es wiederum Platzhalter, die dynamisch gesetzt werden können.
<html:template name="">
[<html:placeholder name="" />]
[<core:addtaglib class="" prefix="" name="" />]
[<html:getstring namespace="" config="" entry="" />]
</html:template>
[A-Za-z0-9-_]
)
Zugriff auf ein Template gewährt die geschützte Methode getTemplate() eines Document-Controllers. Mit Hilfe dieser Funktion kann eine Referenz auf ein Template-Objekt zurückgeliefert werden. Ein typischer Anwendungsfall sieht so aus:
Template:<@controller
class=""
@>
<html:placeholder name="Content" />
<html:template name="MyTemplate">
<html:placeholder name="MyPlaceHolder">
</html:template>
use APF\core\pagecontroller\BaseDocumentController;
class SampleController extends BaseDocumentController {
public function transformContent(){
$tmpl = $this->getTemplate('MyTemplate');
$tmpl->setPlaceHolder('MyPlaceHolder', 'MyContent');
$this->setPlaceHolder('Content', $tmpl->transformTemplate());
}
}
Hier wird in der Template-Datei ein Document-Controller, ein HTML-Platzhalter und ein Template mit zugehörigem Platzhalter definiert. Im Controller kann man nun mittels der Methoden getTemplate() eine Referenz auf das Template holen und mit setPlaceHolder() den Platzhalter im Template füllen. Anschließend wird das Template transformiert und die Ausgabe in den HTML-Platzhalter mittels setPlaceHolder() eingesetzt. Es ist möglich mehrere Templates auf einer Seite zu platzieren. Oft wird das für die Ausgabe von unterschiedlichen Meldungen bei unterschiedlichen Events eingesetzt.
Verwenden Sie ein Template um sich wiederholende Inhalte auszugeben, so gilt zu beachten, dass die Instanz des Template-Tags (TemplateTag) bei der Verwendung in Schleifen immer die selbe Instanz ist. Füllen Sie während eines Durchlaufs nur einen Teil der Platzhalter, so werden in vorherigen Durchläufen gefüllte Elemente nicht wieder entfernt. Um dies zu vermeiden können Sie nach jedem Durchlauf die Methode clear() auf der Instanz des Templates aufrufen:
use APF\core\pagecontroller\BaseDocumentController;
class SampleController extends BaseDocumentController {
public function transformContent() {
$template = $this->getTemplate('table-line');
$elements = ...;
foreach($elements as $element) {
$template->setPlaceHolder('foo', $element->getFoo());
$bar = $element->getBar();
if(!empty($bar)) {
$template->setPlaceHolder('bar', $bar);
}
$buffer .= $template->transformTemplate();
$template->clear();
}
$this->setPlaceHolder('content', $buffer);
}
}
Der Aufruf von clear() sorgt dafür, dass alle Platzhalter-Tags (Instanzen von PlaceHolderTag) zurückgesetzt - sprich der Inhalt geleert - wird.
Definieren Sie eigene Platzhalter-Tags oder haben Sie weitere Elemente, die nach einem Schleifen-Durchlauf geleert werden sollen, können Sie der Methode clear() eine eigene Implementierung des Interfaces TemplateTagClearApproach mitgeben. Die folgende Code-Box zeigt die Standard-Implementierung des APF, die die vorhandenen Platzhalter zurücksetzt und gleichzeitig im Template vorhandenen <*:getstring />-Tags zurücksetzt:
use APF\core\pagecontroller\TemplateTagClearApproach;
class DefaultTemplateTagClearApproach implements TemplateTagClearApproach {
public function clear(TemplateTag &$node) {
$node->clearPlaceHolders();
foreach ($node->getChildren() as &$child) {
if ($child instanceof LanguageLabelTag) {
$child->clearPlaceHolders();
}
}
}
}
Möchten Sie der Methode eine eigene Implementierung des Lösch-Vorgehens mitgeben, so gestaltet sich der Controller-Code wie folgt:
use APF\core\pagecontroller\BaseDocumentController;
use APF\core\pagecontroller\DefaultTemplateTagClearApproach;
class SampleController extends BaseDocumentController {
public function transformContent() {
$template = $this->getTemplate('table-line');
$elements = ...;
$clearApproach = new DefaultTemplateTagClearApproach();
foreach($elements as $element) {
$template->setPlaceHolder('foo', $element->getFoo());
$bar = $element->getBar();
if(!empty($bar)) {
$template->setPlaceHolder('bar', $bar);
}
$buffer .= $template->transformTemplate();
$template->clear($clearApproach);
}
$this->setPlaceHolder('content', $buffer);
}
}
Um einen Controller zu deklarieren muss folgender Tag am Anfang des Templates platziert werden:
<@controller
class=""
@>
[A-Za-z0-9_\]
)
Details finden Sie unter (Document-)Controller.
Der Tag <fcon:importdesign />-Tag unterstützt bei der Implementierung von FrontController-basierten Applikationen und bindet Views auf Grund von Model-Informationen im Sinne des MVC-Pattern ein. Hierzu muss eine eigene Model-Klasse für die aktuelle Applikation oder das eingebundene Modul erstellt werden, aus dem die Informationen für die Einbindung des Views bezogen werden können. Die Steuerung der View-Einbindung wird typischerweise durch eigene FrontController-Actions geregelt, die im Modus TYPE_PRE_PAGE_CREATE (siehe Front-Controller) ausgeführt wird. Diese kann in der URL enthaltene Parameter an das Model-Objekt weitergeben.
<fcon:importdesign
template-namespace=""
template-param=""
model=""
[sessionsingleton=""]
/>
[A-Za-z0-9\]
)
[A-Za-z0-9_]
)
[A-Za-z0-9_\]
)
true|false
)
Um den Tag verwenden zu können muss diese mit einem
<core:addtaglib
class="APF\tools\html\taglib\FrontControllerImportTemplateTag"
prefix="fcon"
name="importdesign"
/>
eingebunden werden.
Um unsere Webseite für Sie optimal zu gestalten und fortlaufend verbessern zu können, verwenden wir Cookies. Durch die Nutzung der Webseite stimmen Sie der Verwendung von Cookies zu. Weitere Informationen finden Sie in den Datenschutzrichtlinien.