Programmer's Reference Guide

View Scripte

Zend_View
Referenzhandbuch für Programmierer

View Helfer

In deinen View Skripten ist es oft notwendig, bestimmte komplexe Funktionen immer wieder auszuführen, z.B. Datum formatieren, Formularelemente erstellen oder Links für Aktionen anzuzeigen. Du kannst Helferklassen verwenden, um diese Aufgaben für dich durchführen zu lassen.

Ein Helfer ist einfach eine Klasse. Nehmen wir an wir wollen einen Helfer der 'fooBar' heißt. Standardmäßig wird der Klasse 'Zend_View_Helper_' vorangestellt (Es kann ein eigener Prefix definiert werden wenn ein Pfad für die Helfer definiert wird), und das letzte Segment des Klassennamens ist der Name des Helfers; Dieses Segment sollte Titel Großgeschrieben sein; der volle Klassenname ist dann: Zend_View_Helper_FooBar. Diese Klasse sollte mindestens eine einzelne Methode enthalten, die nach dem Helfer benannt und camelCased ist: fooBar().

Hinweis: Betrachte den Fall
Namen von Helfern sind immer camelCased, bzw. beginnen Sie nie mit einem großgeschriebenen Zeichen. Der Klassenname selbst ist MixedCased, aber die Methode die aktuell ausgeführt wird ist camelCased.

Hinweis: Standard Helfer Pfad
Der Standard Helfer Pfad zeigt immer zu den View Helfern des Zend Frameworks, normalerweise 'Zend/View/Helper/'. Selbst wenn setHelperPath() ausgerufen wird um den existierenden Pfad zu überschreiben, wird dieser Pfad gesetzt um sicherzustellen das die Standard Helfer arbeiten.

Um einen Helfer in deinem View Skript zu verwenden, rufe ihn mittels $this->helperName() auf. Im Hintergrund wird Zend_View die Klasse Zend_View_Helper_HelperName laden, eine Objektinstanz der Klasse erstellen und deren Methode helperName() aufrufen. Die Objektinstanz bleibt innerhalb der Zend_View Instanz bestehen und wird bei allen weiteren Aufrufen von $this->helperName() wiederverwendet.

Vorhandene Helfer

Zend_View enthält bereits einige vorhandene Helferklassen, die sich alle auf die Erstellung von Formularelementen beziehen und die notwendige Maskierung der Ausgaben automatisch vornehmen. Zusätzlich gibt es Helfer zum Erstellen Routen-basierter URLS and HTML Listen, genauso wie für das Deklarieren von Variablen. Die aktuell gelieferten Helfer beinhalten:

declareVars(): Primär benutzt mit strictVars(), kann dieser Helfer verwendet werden um template Variablen zu deklarieren welche bereits, oder noch nicht, im View Objekt bereits gesetzt sind, sowie auch Standard Werte. Arrays welche als Argument dieser Methode übergeben werden, werden verwendet um Standard Werte zu setzen; Andernfalls, wenn die Variable nicht existiert, wird diese mit einem leeren String gesetzt.
fieldset($name, $content, $attribs): Erstellt ein XHTML Fieldset. Wenn $attribs einen 'legend' Schlüssel enthält, wird der Wert für die Fieldset Beschriftung verwendet. Das Fieldset wird $content umfassen wie vom Helfer angeboten.
form($name, $attribs, $content): Erzeugt eine XHTML Form. Alle $attribs werden als XHTML Attribute des Form Tags escaped und dargestellt. Wenn $content vorhanden und kein boolsches false ist, dann wird dieser Inhalt innerhalb der Start und End Form Tags dargestellt werden; wenn $content ein boolsches false ist (der Standard), wird nur das beginnende Formtag erzeugt.
formButton($name, $value, $attribs): Erstellt ein <button /> Element.
formCheckbox($name, $value, $attribs, $options): Erstellt ein <input type="checkbox" /> Element.

Standardmäßig, wenn kein $value angegeben und keine $options vorhanden sind, wird '0' als ungecheckter Wert, und '1' als gecheckter Wert angenommen. Wenn ein $value übergeben wird, aber keine $options vorhanden sind, wird der gecheckte Wert and der übergebene Wert angenommen.

$options sollte ein Array sein. Wenn das Array indiziert ist, ist der erste Wert der gecheckte Wert, und der zweite der ungecheckte Wert; alle anderen Werte werden ignoriert. Es kann auch ein assoziatives Array mit den Schlüsseln 'checked' und 'unChecked' übergeben werden.

Wenn $options übergeben wurden und $value mit dem gecheckten Wert übereinstimmt, dann wird das Element als gecheckt markiert. Das Element kann auch als gecheckt oder ungecheckt markiert werden indem ein boolscher Wert für das Attribut 'checked' übergeben wird.

Das obige wird möglicherweise am besten mit einigen Beispielen zusammengefasst:
```
// '1' und '0' als gecheckte/ungecheckte Optionen; nicht gecheckt
echo $this->formCheckbox('foo');

// '1' und '0' als gecheckte/ungecheckte Optionen; gecheckt
echo $this->formCheckbox('foo', null, array('checked' => true));

// 'bar' und '0' als gecheckte/ungecheckte Optionen; nicht gecheckt
echo $this->formCheckbox('foo', 'bar');

// 'bar' und '0' als gecheckte/ungecheckte Optionen; gecheckt
echo $this->formCheckbox('foo', 'bar', array('checked' => true));

// 'bar' und 'baz' als gecheckte/ungecheckte Optionen; nicht gecheckt
echo $this->formCheckbox('foo', null, null, array('bar', 'baz');

// 'bar' und 'baz' als gecheckte/ungecheckte Optionen; nicht gecheckt
echo $this->formCheckbox('foo', null, null, array(
    'checked' => 'bar',
    'unChecked' => 'baz'
));

// 'bar' und 'baz' als gecheckte/ungecheckte Optionen; gecheckt
echo $this->formCheckbox('foo', 'bar', null, array('bar', 'baz');
echo $this->formCheckbox('foo',
                         null,
                         array('checked' => true),
                         array('bar', 'baz');

// 'bar' und 'baz' als gecheckte/ungecheckte Optionen; nicht gecheckt
echo $this->formCheckbox('foo', 'baz', null, array('bar', 'baz');
echo $this->formCheckbox('foo',
                         null,
                         array('checked' => false),
                         array('bar', 'baz');
```
In allen Fällen, wird das Markup einem versteckten Element mit dem nicht gecheckten Wert vorangestellt; auf diesem Weg erhält man trotzdem einen gültigen Wert von der Form selbst wenn der Wert nicht gecheckt wird.
formErrors($errors, $options): Erzeugt eine ungeordnete XHTML Liste und zeigt Fehler an. $errors sollte ein String oder ein Array von Strings sein; $options sollte irgendein Attribut sein das im beginnenden List Tag platziert werden soll.

Es kann alternativer beginnender, schließender und seperierter Inhalt spezifiziert werden wenn Fehler dargestellt werden durch aufruf von verschiedenen Methoden auf dem Helfer:
- setElementStart($string); Standard ist '<ul class="errors"%s"><li>', wobei %s mit den in $options spezifizierten Attributen ersetzt wird.
- setElementSeparator($string); Standard ist '</li><li>'.
- setElementEnd($string); Standard ist '</li></ul>'.
formFile($name, $attribs): Erstellt ein <input type="file" /> Element.
formHidden($name, $value, $attribs): Erstellt ein <input type="hidden" /> Element.
formLabel($name, $value, $attribs): Erstellt ein <label> Element, setzt das for Attribut auf $name, und den aktuellen Labeltext auf $value. Wenn disable an attribs übergeben wird, wird nichts zurückgegeben.
formMultiCheckbox($name, $value, $attribs, $options, $listsep): Erstellt eine Liste von Checkboxen. $options sollte ein assoziatives Array sein und kann beliebig tief werden. $value kann ein einzelner Wert oder ein Array von ausgewählten Werten sein die Schlüsseln im $options Array entsprechen. $listsep ist standardmäßig ein HTML Break ("<br />"). Standardmäßig wird dieses Element als Array behandelt; alle Checkboxen teilen den gleichen Namen, und werden als Array übertragen.
formPassword($name, $value, $attribs): Erstellt ein <input type="password" /> Element.
formRadio($name, $value, $attribs, $options): Erstellt eine Reihe von <input type="radio" /> Elementen, eine für jeden der $options Elemente. Im $options Array ist der Elementschlüssel der Wert und der Elementwert die Bezeichnung des Radio-Buttons. Der $value Radiobutton wird für dich vorgewählt.
formReset($name, $value, $attribs): Erstellt ein <input type="reset" /> Element.
formSelect($name, $value, $attribs, $options): Erstellt einen <select>...</select> block mit einer <option>one für jedes $options Element. Im $options Array ist der Elementschlüssel der Optionswert und der Elementwert die Optionsbezeichnung. Die $value Optionen werden für dich vorgewählt.
formSubmit($name, $value, $attribs): Erstellt ein <input type="submit" /> Element.
formText($name, $value, $attribs): Erstellt ein <input type="text" /> Element.
formTextarea($name, $value, $attribs): Erstellt einen <textarea>...</textarea> Block.
url($urlOptions, $name, $reset): Erstelle einen URL String basierend auf dem Namen der Route. $urlOptions sollte ein assoziatives Array von Schlüßel/Werte Paaren sein, welche bon der speziellen Route verwendet wird.
htmlList($items, $ordered, $attribs, $escape): erzeugt ungeordnete und geordnete Listen welche auf den $items basieren die übergeben wurden. Wenn $items ein multidimensionales Array ist, wird eine verschachtelte Liste gebaut. Wenn das $escape Flag true ist (standard), werden individuelle Abschnitte escaped durch Verwendung des Escaping Mechanismus der im View Objekt registriert wurde; ein false Wert wird übergeben wenn Markups in den Listen gewünscht werden.

Die Verwendung dieser Helfer in deinem View Skript ist sehr einfach, hier ist ein Beispiel. Beachte, dass du diese Helfer nur aufzurufen brauchst; sie werden automatisch geladen und instanziiert, sobald sie benötigt werden.

// Innerhalb deines View Skriptes, verweist $this auf die Zend_View
// Instanz.
//
// Sagen wir, dass du bereits eine Serie von Auswahlwerten der Variable
// $countries in Form eines Arrays zugewiesen hast
// ('us' => 'United States', 'il' => 'Israel', 'de' => 'Germany')
?>
<form action="action.php" method="post">
    <p><label>Deine Email:
<?php echo $this->formText('email', 'you@example.com', array('size' => 32)) ?>
    </label></p>
    <p><label>Dein Land:
<?php echo $this->formSelect('country', 'us', null, $this->countries) ?>
    </label></p>
    <p><label>Möchtest Du hinzugefügt werden?
<?php echo $this->formCheckbox('opt_in', 'yes', null, array('yes', 'no')) ?>
    </label></p>
</form>

Die Ausgabe des View Skriptes wird in etwa so aussehen:

<form action="action.php" method="post">
    <p><label>Deine Email:
        <input type="text" name="email" value="you@example.com" size="32" />
    </label></p>
    <p><label>Dein Land:
        <select name="country">
            <option value="us" selected="selected">Amerika</option>
            <option value="il">Israel</option>
            <option value="de">Deutschland</option>
        </select>
    </label></p>
    <p><label>Möchtest Du hinzugefügt werden?
        <input type="hidden" name="opt_in" value="no" />
        <input type="checkbox" name="opt_in" value="yes" checked="checked" />
    </label></p>
</form>

Action View Helfer

Der Action View Helfer ermöglicht es View Skripten eine gegebene Kontroller Aktion auszuführen; das Ergebnis des Antwortsobjektes das der Ausführung folgt wird dann zurückgegeben. Dieses kann verwendet werden wenn eine bestimmte Aktion wiederverwendbare Inhalte oder "helfende" Inhalte erstellt.

Aktionen die zu einem _forward() oder einer Umleitung führen werden als ungültig angenommen, und als leerer String zurückgegeben.

Die API für den Action View Helfer folgt dem der meisten MVC Komponenten die Kontroller Aktionen aufrufen: action($action, $controller, $module = null, array $params = array()). $action und $controller werden benötigt; wenn kein Modul angegeben wird, dann wird das Standardmodul angenommen.

Beispiel #1 Grundsätzliche Verwendung von Action View Helfern

Als Beispiel, könnte man einen CommentController mit einer listAction() Methode haben die man in Reihenfolge ausführen will, um eine Liste von Kommentaren für die aktuelle Anfrage herauszuholen:

<div id="sidebar right">
    <div class="item">
        <?php echo $this->action('list',
                                 'comment',
                                 null,
                                 array('count' => 10)); ?>
    </div>
</div>

Cycle Helfer

Der Cycle Helfer wird verwendet um ein Set von Werte zu ändern.

Beispiel #2 Grundsätzliche Verwendung des Cycle Helfers

Um Elemente hinzuzufügen die man durchlaufen will müssen diese im Constructor spezifiziert oder die assign(array $data) Funktion verwendet werden.

<?php foreach ($this->books as $book):?>
  <tr style="background-color:<?php echo $this->cycle(array("#F0F0F0",
                                                            "#FFFFFF"))
                                              ->next()?>">
  <td><?php echo $this->escape($book['author']) ?></td>
</tr>
<?php endforeach;?>

// Rückwärts bewegen und die assign Funktion verwenden
$this->cycle()->assign(array("#F0F0F0","#FFFFFF"));
$this->cycle()->prev();
?>

Die Ausgabe

<tr style="background-color:'#F0F0F0'">
   <td>Erstes</td>
</tr>
<tr style="background-color:'#FFFFFF'">
   <td>Zweites</td>
</tr>

Beispiel #3 Mit einem oder mehreren Zyklen arbeiten

Um zwei Zyklen zu verwenden muß man den Namen des Zyklus verwenden. Einfach zwei Parameter in der cycle Methode setzen. $this->cycle(array("#F0F0F0","#FFFFFF"),'cycle2'). Man kann auch die setName($name) Funktion verwenden.

<?php foreach ($this->books as $book):?>
  <tr style="background-color:<?php echo $this->cycle(array("#F0F0F0",
                                                            "#FFFFFF"))
                                              ->next()?>">
  <td><?php echo $this->cycle(array(1,2,3),'number')->next()?></td>
  <td><?php echo $this->escape($book['author'])?></td>
</tr>
<?php endforeach;?>

Partielle Helfer

Der Partial (Partielle) View Helfer wird verwendet um ein spezielles Template innerhalb seines eigenen variablen Bereichs zu rendern. Primär wird er für wiederverwendbare Templatefragmente verwendet bei denen man keine Vorsorge wegen variablen Namenskonflikten aufpassen muß. Zusätzlich erlauben Sie es Teile von View Skripten von speziellen Modulen zu spezifizieren.

Ein Geschwisterteil zum Partial ist der PartialLoop View Helfer der es erlaubt Daten zu übergeben die durchlaufen werden können, und einen Abschnitt für jedes Teil auszugeben.

Hinweis: PartialLoop Zähler
Der PartialLoop View Helfer fügt der View eine Variable hinzu die partialCounter heißt und die die aktuelle Position des Arrays zum View Skript übergibt. Das bietet einen einfachen Weg um alternative Farbgebungen zum Bespiel bei Tabellenzeilen zu haben.

Beispiel #4 Grundsätzliche Verwendung von Partials

Die grundsätzliche Verwendung von Partials ist die Ausgabe von Templatefragmenten im eigenen Viewbereich. Es wird das folgende teilweise Skript angenommen:

<?php // partial.phtml ?>
<ul>
    <li>Von: <?php echo $this->escape($this->from) ?></li>
    <li>Subjekt: <?php echo $this->escape($this->subject) ?></li>
</ul>

Dieses würde dann vom View Skript aufgerufen indem das folgende verwendet wird:

<?php echo $this->partial('partial.phtml', array(
    'from' => 'Team Framework',
    'subject' => 'Teil der View')); ?>

Was dann das folgende ausgibt:

<ul>
    <li>From: Team Framework</li>
    <li>Subject: Teil der View</li>
</ul>

Hinweis: Was ist ein Modell?
Ein Modell das mit dem Partial View Helfer verwendet wird kann eines der folgenden sein:

Array. Wenn ein Array übergeben wird, sollte es assoziativ sein, und seine Schlüssel/Werte Paare werden der View mit dem Schlüssel als View Variable zugeordnet.

Objekt das die toArray() Methode implementiert. Wenn ein Objekt übergeben wird das eine toArray() Methode besitzt, wird das Ergebnis von toArray() dem View Objekt als View Variablen zugeordnet.

Standard Objekt. Jedes andere Objekt wird die Ergebnisse von object_get_vars() (essentiell alle öffentlichen Eigenschaften des Objektes) dem View Objekt zuordnen.

Wenn das eigene Modell ein Objekt ist, kann es gewünscht sein, es als Objekt an das Partielle Skript zu übergeben, statt es in ein Array von Variablen zu serialisieren. Das kann durch das Setzen der 'objectKey' Eigenschaft des betreffenden Helfers getan werden:
// Dem Partiellen mitteilen das ein Objekt als 'model' Variable übergeben wird
$view->partial()->setObjectKey('model');

// Dem Partiellen mitteilen das ein Objekt von partialLoop als 'model'
// Variable im letzten Partiellen View Skript übergeben wird
$view->partialLoop()->setObjectKey('model');
Diese Technik ist speziell dann sinnvoll wenn Zend_Db_Table_Rowsets an partialLoop() übergeben werden, da man dann kompletten Zugriff auf die Zeilenobjekte im View Skript hat, was es einem erlaubt Ihre Methoden auszurufen (wie das empfangen von Werten bei Eltern- oder abhängigen Zeilen).

Beispiel #5 Verwendung von PartialLoop um iterierbare Modelle darzustellen

Typischerweise, wird man Partials in einer Schleife verwenden um das selbe Inhaltsfragment, viele Male, darzustellen; auf diesem Weg können große Blöcke von wiederholenden Inhalten oder komplexe Anzeigelogik auf einen einzelnen Platz gegeben werden. Trotzdem hat das einen Geschwindigkeitsnachteil, da der partielle Helfer einmal für jede Iteration aufgerufen werden muß.

Der PartialLoop View Helfer hilft bei der Lösung dieses Problems. Er erlaubt es einen wiederholenden Teil (Array oder Objekt das einen Iterator implementiert) als Modell zu übergeben. Er iteriert dann darüber, und übergibt dessen Teile dem Partial Skript als Modell. Teil in diesem Iterator kann jedes Modell sein das der Partial View Helfer erlaubt.

Es wird das folgende teilweise View Skript angenommen:

<?php // partialLoop.phtml ?>
    <dt><?php echo $this->key ?></dt>
    <dd><?php echo $this->value ?></dd>

Und das folgende "Modell":

$model = array(
    array('key' => 'Säugetier', 'value' => 'Kamel'),
    array('key' => 'Vogel', 'value' => 'Pinguin'),
    array('key' => 'Reptil', 'value' => 'Viper'),
    array('key' => 'Fisch', 'value' => 'Flunder'),
);

Im View Skript wird dann der PartialLoop Helfer aufgerufen:

<dl>
<?php echo $this->partialLoop('partialLoop.phtml', $model) ?>
</dl>

<dl>
    <dt>Säugetier</dt>
    <dd>Kamel</dd>

    <dt>Vogel</dt>
    <dd>Pinguin</dd>

    <dt>Reptil</dt>
    <dd>Viper</dd>

    <dt>Fisch</dt>
    <dd>Flunder</dd>
</dl>

Beispiel #6 Partials in anderen Modulen darstellen

Zeitweise existiert ein Parial in einem anderen Modul. Wenn der Name des Moduls bekannt ist, kann dieses als zweites Argument entweder partial() oder partialLoop() übergeben werden, indem das $model Argument an dritte Stelle verschoben wird.

Wenn zum Beispiel, eine Teilseite existiert im 'list' Modul existiert die verwendet werden soll, kann diese wie folgt genommen werden:

<?php echo $this->partial('pager.phtml', 'list', $pagerData) ?>

Auf diesem Weg, können Teile wiederverwendet werden die speziell für andere Module erstellt wurden. Deshalb ist es besser, wiederverwendbare Teile in einen Pfad für geteilt View Skripte zu geben.

Platzhalter (PlaceHolder) Helfer

Der Placeholder View Helfer wird verwendet um Inhalte zwischen View Skripten und View Instanzen persistent zu machen. Er bietet auch einige nützliche Features wie Inhalte zu vereinigen, Inhalte von View Skripten zu erfassen und Vor- sowie Nach-Texte zu Inhalten hinzuzufügen (und eigene Separatoren für vereinigte Inhalte).

Beispiel #7 Grundsätzliche Verwendung von Platzhaltern

Die grundsätzliche Verwendung von Platzhaltern ist die persistenz von View Daten. Jeder Aufruf des Placeholder Helfers erwartet einen Platzhalter Namen; der Helfer gibt dann ein Platzhalter Container Objekt zurück das entweder manipuliert oder einfach ausgegeben werden kann.

<?php $this->placeholder('foo')->set("Ein Text für später") ?>

<?php
    echo $this->placeholder('foo');
    // Ausgabe "Ein Text für später"
?>

Beispiel #8 Platzhalter verwenden um Inhalt zu vereinigen

Inhalt über Platzhalter zu vereinigen kann zeitweise auch sehr nützlich sein. Zum Beispiel kann ein View Skript ein variables Array besitzen von dem Nachrichten empfangen werden sollen um diese später darzustellen; ein späteres View Skript kann diese dann eruieren wie diese dargestellt werden sollen.

Der Placeholder View Helfer verwendet Container die ArrayObject erweitern, und ein reichhaltiges Set von Features für die Manipulation von Arrays bieten. Zusätzlich bietet es eine Anzahl von Methoden für die Formatierung des Inhalts der im Container gespeichert ist:

setPrefix($prefix) setzt Text der dem Inhalt vorgesetzt wird. getPrefix() kann verwendet werden um jederzeit festzustellen wie die aktuellen Einstellungen sind.
setPostfix($prefix) setzt Text der dem Inhalt angehängt wird. getPostfix() kann verwendet werden um jederzeit festzustellen wie die aktuellen Einstellungen sind.
setSeparator($prefix) setzt Text mit dem zusammengefügte Inhalte seperiert werden. getSeparator() kann verwendet werden um jederzeit festzustellen wie die aktuellen Einstellungen sind.
setIndent($prefix) kann verwendet werden um einen Markierungswert für den Inhalt zu setzen. Wenn ein Integer übergeben wird, wird diese Anzahl an Leerzeichen verwendet; wenn ein String übergeben wird, wird dieser String verwendet. getIndent() kann verwendet werden um jederzeit festzustellen wie die aktuellen Einstellungen sind.

<!-- Erstes View Skript -->
<?php $this->placeholder('foo')->exchangeArray($this->data) ?>

<!-- Späteres View Skript -->
<?php
$this->placeholder('foo')->setPrefix("<ul>\n    <li>")
                         ->setSeparator("</li><li>\n")
                         ->setIndent(4)
                         ->setPostfix("</li></ul>\n");
?>

<?php
    echo $this->placeholder('foo');
    // Ausgabe als unsortierte Liste mit schöner Einrückung
?>

Weil die Placeholder Container Objekte ArrayObject erweitern, können Inhalte einem speziellen Schlüssel im Container sehr einfach zugeordnet werden, statt diese einfach an den Container anzufügen. Auf Schlüssel kann entweder als Objekt Eigenschaften oder als Array Schlüssel zugegriffen werden.

<?php $this->placeholder('foo')->bar = $this->data ?>
<?php echo $this->placeholder('foo')->bar ?>

<?php
$foo = $this->placeholder('foo');
echo $foo['bar'];
?>

Beispiel #9 Verwenden von Platzhaltern um Inhalt zu erfassen

Gelegentlich will man Inhalte für einen Platzhalter in einem View Skript haben die einfachst als Vorlage zu verwenden sind; der Placeholder View Helfer erlaubt es willkürliche Inhalte zu erfassen um diese später durch Verwendung der folgenden API darstellen zu können.

captureStart($type, $key) beginnt die Erfassung der Inhalte.

$type sollte eine der Placeholder Konstanten APPEND oder SET sein. APPEND fügt erfasste Inhalte der Liste der aktuellen Inhalte im Placeholder an; SET verwendet erfasste Inhalte als einzigen Wert für den Platzhalter (überschreibt potentiell alle vorherigen Inhalte). Standardmäßig ist $type APPEND.

$key kann verwendet werden um einen speziellen Schlüssel im Placeholder Container zu spezifizieren an dem der Inhalt erfasst werden soll.

captureStart() sperrt die Erfassung bis captureEnd() aufgerufen wurde; Erfassungen können nicht mit dem selben Placeholder Container verschachtelt werden. Das führt zu einer Ausnahme.
captureEnd() stoppt die Erfassung von Inhalten, und platziert Ihn im Container Objekt anhängig davon wie captureStart() aufgerufen wurde.

<!-- Standarderfassung: anhängen -->
<?php $this->placeholder('foo')->captureStart();
foreach ($this->data as $datum): ?>
<div class="foo">
    <h2><?php echo $datum->title ?></h2>
    <p><?php echo $datum->content ?></p>
</div>
<?php endforeach; ?>
<?php $this->placeholder('foo')->captureEnd() ?>

<?php echo $this->placeholder('foo') ?>

<!-- Erfassung zum Schlüssel -->
<?php $this->placeholder('foo')->captureStart('SET', 'data');
foreach ($this->data as $datum): ?>
<div class="foo">
    <h2><?php echo $datum->title ?></h2>
    <p><?php echo $datum->content ?></p>
</div>
<?php endforeach; ?>
<?php $this->placeholder('foo')->captureEnd() ?>

<?php echo $this->placeholder('foo')->data ?>

Konkrete Platzhalter Implementationen

Zend Framework kommt mit einer Anzahl an "konkreten" Platzhalter Implementationen. Diese sind für üblich verwendete Platzhalter: Doctype, Seitentitel, und verschiedene <head> Elemente. In allen Fällen gibt der Aufruf des Platzhalters ohne Argumente das Element selbst zurück.

Die Dokumentation für jedes Element wird separat behandelt, wie anbei beschrieben:

Doctype Helfer

Gültige HTML und XHTML Dokumente sollten eine DOCTYPE Deklaration enthalten. Neben der Schwierigkeit sich diese zu merken, können Sie auch beeinflussen wie bestimmte Elemente im Dokument dargestellt werden sollen (zum Beispiel, CDATA Kommentierung in <script> und <style> Elementen.

Der Doctype Helfer erlaubt die Spezifikation von einem der folgenden Typen:

XHTML11
XHTML1_STRICT
XHTML1_TRANSITIONAL
XHTML_BASIC1
XHTML1_FRAMESET
HTML4_STRICT
HTML4_LOOSE
HTML4_FRAMESET
HTML5

Es kann auch ein eigener DocType spezifiziert werden solange dieser richtig formatiert ist.

Der Doctype Helfer ist eine konkrete Implementation des Platzhalter Helfers.

Beispiel #10 Grundsätzliche Verwendung des Doctype Helfers

Der Doctype kann jederzeit spezifiziert werden. Trotzdem werden Helfer die vom Doctype abhängen, diesen erst erkennen wenn er gesetzt wurde, sodas der einfachste Weg darin besteht Ihn in der Bootstrap zu spezifizieren:

$doctypeHelper = new Zend_View_Helper_Doctype();
$doctypeHelper->doctype('XHTML1_STRICT');

Und Ihn dann am Beginn des Layout Scripts ausgeben:

<?php echo $this->doctype() ?>

Beispiel #11 Empfangen des Doctypes

Wenn man den Doctype wissen will, kann einfach getDoctype() auf dem Objekt aufgerufen werden, welches vom aufgerufenen Helfer zurückgegeben wird.

$doctype = $view->doctype()->getDoctype();

Typischerweise wird man einfach wissen wollen, ob der Doctype XHTML ist oder nicht; hierfür ist die isXhtml() Methode ausreichend:

if ($view->doctype()->isXhtml()) {
    // etwas anderes machen
}

HeadLink Helfer

Das HTML <link> Element wird immer mehr für das Verlinken einer Vielzahl von Ressourcen der eigenen Site verwendet: Stylesheets, Feeds, FavIcons, Trackbacks, und andere. Der HeadLink Helfer bietet ein einfaches Interface für die Erstellung und das Anhäufen dieser Elemente für das spätere Empfangen und deren Ausgabe im eigenen Layout Skript.

Der HeadLink Helfer hat spezielle Methode für das hinzufügen von Stylesheet Links zu seinem Stack:

appendStylesheet($href, $media, $conditionalStylesheet, $extras)
offsetSetStylesheet($index, $href, $media, $conditionalStylesheet, $extras)
prependStylesheet($href, $media, $conditionalStylesheet, $extras)
setStylesheet($href, $media, $conditionalStylesheet, $extras)

Der $media Wert ist standardmäßig 'screen', kann aber jeder gültige Media Wert sein. $conditionalStylesheet ist ein String oder boolsches false und wird verwendet um wärend der Darstellung zu erkennen ob spezielle Kommentare inkludiert werden sollen um das Laden dieser Stylesheets auf diversen Plattformen zu verhindern. $extras ist ein Array von extra Werten die man dem Tag hinzufügen will.

Zusätzlich hat der HeadLink Helfer eine spezielle Methode für das Hinzufügen von 'alternativen' (alternate) Links zu seinem Stack:

appendAlternate($href, $type, $title, $extras)
offsetSetAlternate($index, $href, $type, $title, $extras)
prependAlternate($href, $type, $title, $extras)
setAlternate($href, $type, $title, $extras)

Die headLink() Helfer Methode erlaubt das Spezifizieren aller Attribute die für ein <link> Element notwendig sind, und erlaubt auch die Spezifizfikation der Platzierung --- entweder ersetzt das neue Element alle anderen, wird vorangestellt (an den Beginn des Stacks) , oder angefügt (an das Ende des Stacks).

Der HeadLink Helfer ist eine konkrete Implementation des Platzhalter Helfers.

Beispiel #12 Grundsätzliche Verwendung des HeadLink Helfers

headLink kann jederzeit spezifiziert werden. Typischerweise wird ein globaler Link im eigenen Layout Skript spezifiziert, und anwendungsspezifische Links in den View Skripten der Anwendung. Im Layoutskript, in der <head> Sektion, muß das der Helfer ausgegeben werden.

<?php // Links in einem View Skript setzen:
$this->headLink()->appendStylesheet('/styles/basic.css')
                 ->headLink(array('rel' => 'favicon',
                                  'href' => '/img/favicon.ico'),
                                  'PREPEND')
                 ->prependStylesheet('/styles/moz.css',
                                     'screen',
                                     true,
                                     array('id' => 'my_stylesheet'));
?>
<?php // Darstellen der Links: ?>
<?php echo $this->headLink() ?>

HeadMeta Helfer

Das HTML Element <meta> wird verwendet um Meta Informationen über das HTML Dokument anzubieten -- typischerweise Schlüsselwörter. Dokument Zeichensätze, Cache Pragmas, usw. Meta Tags können entweder 'http-equiv' oder 'name' Typen sein, müssen ein 'content' Attribut enthalten, und können auch eines der 'lang' oder 'scheme' Modifikator Attributen enthalten.

Der HeadMeta Helfer unterstützt die folgenden Methoden für das Setzen und Hinzufügen von Meta Tags:

appendName($keyValue, $content, $conditionalName)
offsetSetName($index, $keyValue, $content, $conditionalName)
prependName($keyValue, $content, $conditionalName)
setName($keyValue, $content, $modifiers)
appendHttpEquiv($keyValue, $content, $conditionalHttpEquiv)
offsetSetHttpEquiv($index, $keyValue, $content, $conditionalHttpEquiv)
prependHttpEquiv($keyValue, $content, $conditionalHttpEquiv)
setHttpEquiv($keyValue, $content, $modifiers)

Das $keyValue Element wird verwendet um einen Wert für den 'name' oder 'http-equiv' Schlüssel zu definieren; $content ist der Wert für den 'content' Schlüssel, und $modifiers ist ein optionales assoziatives Array das Schlüssel für 'land und/oder 'scheme' enthalten kann.

Meta Tags können auch gesetzt werden indem die headMeta() Helfermethode verwendet wird, welche die folgende Signatur hat: headMeta($content, $keyValue, $keyType = 'name', $modifiers = array(), $placement = 'APPEND'). $keyValue ist der Intalt für den Schlüssel der in $keyType spezifiziert ist, und welche entweder 'name' oder 'http-equiv' sein sollte. $placement kann entweder 'SET' (überschreibt alle vorher gespeicherten Werte), 'APPEND' (fügt an das Ende des Stacks hinzu), oder 'PREPEND' (fügt an den Beginn des Stacks hinzu) sein.

HeadMeta überschreibt append(), offsetSet(), prepend(), und set() um die Verwendung der speziellen Methoden wie oben gelistet zu erzwingen. Intern wird jedes Element als stdClass Token gespeichert, welches später durch Verwendung der itemToString() Methode serialisiert wird. Das erlaubt es Prüfungen an den Elementen im Stack durchzuführen, und diese Elemente optional zu verändern indem einfach das zurückgegebene Objekt verändert wird.

Der HeadMeta Helfer ist eine konkrete Implementation des Platzhalter Helfers.

Beispiel #13 Grundsätzliche Verwendung des HeadMeta Helfers

Neue Meta Tags können jederzeit spezifiziert werden. Typischerweise werden Clientseitige Cacheregeln oder SEO Schlüsselwörter spezifiziert.

Wenn zum Beispiel ein spezielles SEO Schlüsselwort spezifiziert werden soll, kann das durch die Erstellung eines Meta Nametags, mit dem Namen 'keywords' und dem Inhalt des Schlüsselworts das mit der Seite assoziiert werden soll, geschehen:

// Meta Schlüsselwörter setzen
$this->headMeta()->appendName('keywords', 'framework php productivity');

Wenn Clientseitige Cacheregeln gesetzt werden sollen, können http-equiv Tags mit den Regeln die erzwungen werden sollen, gesetzt werden:

// Clientseitiges cachen verhindern
$this->headMeta()->appendHttpEquiv('expires',
                                   'Wed, 26 Feb 1997 08:21:57 GMT')
                 ->appendHttpEquiv('pragma', 'no-cache')
                 ->appendHttpEquiv('Cache-Control', 'no-cache');

Ein anderer populärer Verwendungszweck für Meta Tags ist das Setzen des Inhalt-Typs, Zeichensatzes, und der Sprache:

// Setzen des Inhalttyps und des Zeichensatzes
$this->headMeta()->appendHttpEquiv('Content-Type',
                                   'text/html; charset=UTF-8')
                 ->appendHttpEquiv('Content-Language', 'en-US');

Als letztes Beispiel, ein einfacher Weg um eine kurze Nachricht anzuzeigen bevor mit Hilfe eines "Meta Refreshes" weitergeleitet wird:

// Einen Meta Refresh mit 3 Sekunden zu einer neuen URL setzen:
$this->headMeta()->appendHttpEquiv('Refresh',
                                   '3;URL=http://www.some.org/some.html');

Wenn man bereit ist die Meta Tags im Layout zu platzieren, muß einfach der Helfer ausgegeben werden:

<?php echo $this->headMeta() ?>

HeadScript Helfer

Der HeadScript Helfer unterstützt die folgenden Methoden für das Setzen und Hinzufügen von Skripten:

appendFile($src, $type = 'text/javascript', $attrs = array())
offsetSetFile($index, $src, $type = 'text/javascript', $attrs = array())
prependFile($src, $type = 'text/javascript', $attrs = array())
setFile($src, $type = 'text/javascript', $attrs = array())
appendScript($script, $type = 'text/javascript', $attrs = array())
offsetSetScript($index, $script, $type = 'text/javascript', $attrs = array())
prependScript($script, $type = 'text/javascript', $attrs = array())
setScript($script, $type = 'text/javascript', $attrs = array())

Im Falle der *File() Methoden ist $src der entfernte Ort des Skriptes das geladen werden soll; das ist üblicherweise in der Form einer URL oder eines Pfades. Für die *Script() Methoden sind $script die clientseitigen Skript Direktiven die in diesem Element verwendet werden sollen.

Hinweis: Abhängige Kommentare setzen
HeadScript erlaubt es ein Script Tag in abhängige Kommentare zu setzen, das es erlaubt es vor speziellen Browsern zu verstecken. Um abhängige Tags zu setzen, muß der abhängige Wert als Teil des $attrs Parameters im Methodenaufruf übergeben werden.
Beispiel #14 Headscript mit abhängigen Kommentaren
// Scripte hinzufügen
$this->headScript()->appendFile(
    '/js/prototype.js',
    'text/javascript',
    array('conditional' => 'lt IE 7')
);

HeadScript erlaubt auch das Erfassen von Skripten; das kann nützlich sein wenn man ein Clientseitiges Skript programmtechnisch erstellen und es dann woanders platzieren will. Seine Verwendung wird in einem Beispiel anbei gezeigt.

Letztendlich kann die headScript() Methode verwendet werden um Skript Elemente schnell hinzuzufügen; die Signatur hierfür ist headScript($mode = 'FILE', $spec, $placement = 'APPEND'). Der $mode ist entweder 'FILE' oder 'SCRIPT', anhängig davon ob das Skript verlinkt oder definiert wird. $spec ist entweder die Skriptdatei die verlinkt wird, oder der Skriptcode selbst. $placement sollte entweder 'APPEND', 'PREPEND' oder 'SET' sein.

HeadScript überschreibt append(), offsetSet(), prepend(), und set() um um die Verwendung der speziellen Methoden wie vorher gezeigt zu erzwingen. Intern wird jedes Element als stdClass Token gespeichert, welches später mit Hilfe der itemToString() Methode serialisiert wird. Das erlaubt es Prüfungen an den Elementen im Stack vorzunehmen, und diese Elemente optional zu ändern, einfach durch das Modifizieren des zurückgegebenen Objektes.

Der HeadScript Helfer ist eine konkrete Implementation des Platzhalter Helfers.

Hinweis: InlineScript für HTML Body Skripte verwenden
HeadScript's Schwester Helfer, InlineScript, sollte verwendet werden wenn man Inline Skripte im HTML body inkludieren will. Die Platzierung von Skripten am Ende des Dokuments ist eine gängige Praxis für die schnellere Auslieferung von Seiten, speziell wenn 3rd Party Analyse Skripte verwendet werden.

Hinweis: Andere Attribute werden stanadrdmäßig ausgeschaltet
Standardmäßig wird HeadScript nur <script> Attribute darstellen die von W3C abgesegnet sind. Diese beinhalten 'type', 'charset', 'defer', 'language', und 'src'. Trotzdem, verwenden einige Javascript Frameworks, vorallem » Dojo, eigene Attribute um Verhalten zu ändern. Um solche Attribute zu erlauben, können diese über die setAllowArbitraryAttributes() Methode eingeschaltet werden:
$this->headScript()->setAllowArbitraryAttributes(true);

Beispiel #15 Grundsätzliche Verwendung des HeadScript Helfers

Neue Skript Tags können jederzeit spezifiziert werden. Wie vorher beschrieben können diese Links auf externe Ressourcen Dateien oder Skripte sein.

// Skripte hinzufügen
$this->headScript()->appendFile('/js/prototype.js')
                   ->appendScript($onloadScript);

Die Reihenfolge ist oft wichtig beim Clientseitigen Skripting; es kann notwendig sein sicherzustellen das Bibliotheken in einer speziellen Reihenfolge geladen werden da Sie Abhängigkeiten zueinander haben; die verschiedenen append, prepend und offsetSet Direktiven können hierbei helfen:

// Skripte in eine Reihenfolge bringen

// An einem bestimmten Offset Platzieren um Sicherzustellen
// das es als letztes geladen wird
$this->headScript()->offsetSetFile(100, '/js/myfuncs.js');

// Scriptige Effekte verwenden (append verwendet den nächsten Index, 101)
$this->headScript()->appendFile('/js/scriptaculous.js');

// Aber Basis Prototype Skripte müssen immer als erstes geladen werden
$this->headScript()->prependFile('/js/prototype.js');

Wenn man letztendlich damit fertig ist am alle Skripte im Layoutskript darzustellen, muß der Helfer einfach ausgegeben werden:

<?php echo $this->headScript() ?>

Beispiel #16 Skripte einfachen mit Hilfe des HeadScript Helfers

Manchmal mit ein Clientseitiges Skript programmtechnisch erstellt werden. Wärend man Strings zusammenhängen, Heredocs und ähnliches verwenden könnte, ist es oft einfacher nur das Skript zu erstellen und in PHP Tags einzubetten. HeadScript lässt das zu, und erfasst es in den Stack:

<?php $this->headScript()->captureStart() ?>
var action = '<?php echo $this->baseUrl ?>';
$('foo_form').action = action;
<?php $this->headScript()->captureEnd() ?>

Die folgenden Annahmen werden gemacht:

Das Skript wird an den Stack angefügt. Wenn es den Stack ersetzen soll oder an den Anfang hinzugefügt werden soll, muß 'SET' oder 'PREPEND' als erstes Argument an captureStart() übergeben werden.
Der MIME Typ des Skripts wird mit 'text/javascript' angenommen; wenn ein anderer Typ spezifiziert werden soll muß dieser als zweites Argument an captureStart() übergeben werden.
Wenn irgendwelche zusätzlichen Attribute für das <script> Tag spezifiziert werden sollen, müssen diese in einem Array als drittes Argument an captureStart() übergeben werden.

HeadStyle Helfer

Das HTML Element <style> wird verwendet um CSS Stylesheets im HTML Element <head> zu inkludieren.

Hinweis: HeadLink verwenden um CSS Dateien zu verlinken
HeadLink sollte verwendet werden um <link> Elemente zu Erstellen die externe Stylesheets enthalten. HeadScript wird verwendet wenn man Stylesheets inline definieren will.

Der HeadStyle Helfer unterstützt die folgenden Methoden für das Setzen und Hinzufügen von Stylesheet Deklarationen:

appendStyle($content, $attributes = array())
offsetSetStyle($index, $content, $attributes = array())
prependStyle($content, $attributes = array())
setStyle($content, $attributes = array())

In allen Fällen ist $content die aktuelle CSS Deklaration. $attributes sind alle zusätzlichen Attribute die das style Tag erhalten soll: lang, title, media, oder dir sind alle möglich.

Hinweis: Abhängige Kommentare setzen
HeadStyle erlaubt es ein Script Tag in abhängige Kommentare zu setzen, das es erlaubt es vor speziellen Browsern zu verstecken. Um abhängige Tags zu setzen, muß der abhängige Wert als Teil des $attrs Parameters im Methodenaufruf übergeben werden.
Beispiel #17 Headstyle mit abhängigen Kommentaren
// Skripte hinzufügen
$this->headStyle()->appendStyle($styles, array('conditional' => 'lt IE 7');

HeadStyle erlaubt auch das Erfassen von Style Deklarationen; das kann nützlich sein wenn eine Deklaration programmtechnisch erstellt werden soll und Sie dann woanders platziert wird. Die Verwendung hierfür wird in einem unten angeführten Beispiel gezeigt.

Letztendlich kann auch die headStyle() Methode verwendet werden um schnellstens Deklarationselemente hinzuzufügen; die Signatur dafür ist headStyle($content$placement = 'APPEND', $attributes = array()). $placement sollte entweder 'APPEND', 'PREPEND', oder 'SET' sein.

HeadStyle überschreibt jedes append(), offsetSet(), prepend(), und set() um die Verwendung der oben gelisteten speziellen Methoden zu forcieren. Intern wird jeder Teil als stdClass Token gespeichert, welches später serialisiert wird durch Verwendung der itemToString() Methode. Das erlaubt es die Teile im Stack zu Prüfen, und optional auch zu Ändern durch einfaches Modifizieren des zurückgegebenen Objektes.

Der HeadStyle Helfer ist eine konkrete Implementation des Platzhalter Helfers.

Beispiel #18 Grundsätzliche Verwendung des HeadStyle Helfers

Ein neues Style Tag kann jederzeit spezifiziert werden:

// Stile hinzufügen
$this->headStyle()->appendStyle($styles);

Die Reihenfolge ist in CSS sehr wichtig; es könnte sein das man sichergestellen muß das Deklarationen in einer speziellen Reihenfolge geladen werden wegen der Reihenfolge der Kaskade; die verschiedenen append, prepend und offsetSet Direktiven können für diesen Zweck verwendet werden:

// Styles in Reihenfolge bringen

// Ein spezielles Offset platzieren:
$this->headStyle()->offsetSetStyle(100, $customStyles);

// Am Ende platzieren:
$this->headStyle()->appendStyle($finalStyles);

// Am Anfang platzieren:
$this->headStyle()->prependStyle($firstStyles);

Wenn man damit fertig ist und alle Style Deklarationen im Layout Skript ausgegeben werden können kann der Helfer einfach wiederholt werden:

<?php echo $this->headStyle() ?>

Beispiel #19 Den HeadStyle Helfer verwenden um Style Deklarationen zu Erfassen

Hier und da müssen CSS Style Deklarationen programmtechnisch erstellt werden. Wärend String Kopplungen, HereDocs und ähnliches verwendet werden könnte, ist es oft einfacher das durch erstellen der Styles und deren Einfügung in PHP Tags zu machen. HeadStyle lässt das zu indem es in den Stack erfasst wird:

<?php $this->headStyle()->captureStart() ?>
body {
    background-color: <?php echo $this->bgColor ?>;
}
<?php $this->headStyle()->captureEnd() ?>

Die folgenden Annahmen werden gemacht:

Die Style Deklarationen werden dem Stack angefügt. Wenn Sie den Stack ersetzen sollen oder an den Anfang hinzugefügt werden sollten muß 'SET' oder 'PREPEND' als erstes Argument an captureStart() übergeben werden
Wenn zusätzliche Attribute für das <style> Tag spezifiziert werden sollen, dann müssen diese in einem Array als zweites Argument an captureStart() übergeben werden.

HeadTitle Helfer

Das HTML <title> Element wird verwendet um einen Titel für ein HTML Dokument anzubieten. Der HeadTitle Helfer erlaubt es Titel für späteren Empfang und Ausgabe programmtechnisch zu Erstellen und zu Speichern.

Der HeadTitle Helfer ist eine konkrete Implementation des Plaltzhalter Helfer. Er überschreibt die toString() Methode um die erstellung des <title> Elements zu erzwingen, und fgt eine headTitle() Methode für das schnelle und einfache Einstellen und Ändern von Titel Elementen hinzu. Die Signatur dieser Methode ist headTitle($title, $setType = 'APPEND'); standardmäßig, wird der Wert dem Stack angefügt (Anhäufen von Title Segmenten), aber es kann auch 'PREPEND' (Platzierung am Anfang des Stacks) oder 'SET' (Stack überschreiben) spezifiziert werden.

Beispiel #20 Grundsätzliche Verwendung des HeadTitle Helfers

Es kann jederzeit ein Titel Tag spezifiziert werden. Die typische Verwendung besteht darin das Titel Segment bei jedem Level an Tiefe in der Anwendung: Site, Kontroller, Aktion und potentiell Ressourcen.

// Setzen des Kontroller und Aktion Namens als Titel Segment:
$request = Zend_Controller_Front::getInstance()->getRequest();
$this->headTitle($request->getActionName())
     ->headTitle($request->getControllerName());

// Setzen der Site im Titel; möglicherweise das Layout Skript:
$this->headTitle('Zend Framework');

// Setzen eines Separator Strings für Segmente:
$this->headTitle()->setSeparator(' / ');

Wenn man letztendlich damit fertig ist den Titel im Layoutskript darzustellen, muß dieser einfach ausgegeben werden:

<!-- Darstellung <action> / <controller> / Zend Framework -->
<?php echo $this->headTitle() ?>

HTML Objekt Helfer

Das HTML <object> Element wird für das Einbetten von Medien wie Flash oder Quicktime in Webseiten verwendet. Der Object View Helfer übernimmt die Einbettung von Medien mit einem minimalen Aufwand.

Es gibt initial view Objekt Helfer:

formFlash Erzeugt Markup für die Einbettung von Flash Dateien.
formObject Erzeugt Markup für die Einbettung von eigenen Objekten.
formPage Erzeugt Markup für die Einbettung anderer (X)HTML Seiten.
formQuicktime Erzeugt Markup für die Einbettung von QuickTime Dateien.

Alle diese Helfer teilen sich das gleiche Interface. Aus diesem Grund enthält diese Dokumentation nur Beispiele für zwei dieser Helfer.

Beispiel #21 Flash Helfer

Die Einbettung von Flash in die eigene Seite mit Hilfe des Helfers ist recht direkt. Das einzige benötigte Argument ist die Ressource URI.

<?php echo $this->htmlFlash('/path/to/flash.swf'); ?>

Das gibt das folgende HTML aus:

<object data="/path/to/flash.swf"
        type="application/x-shockwave-flash"
        classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"
        codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab">
</object>

Zusätzlich können Attribute, Parameter und Inhalte definiert werden die mit dem <object> dargestellt werden. Das wird durch Verwendung des htmlObject Helfers demonstriert.

Beispiel #22 Anpassen des Objekts durch die Übergabe von zusätzlichen Argumenten

Das erste Argument des Objekt Helfers wird immer benötigt. Es ist die URI zu der Ressource die man einbetten will. Das zweite Argument wird nur im htmlObject Helfer benötigt. Die anderen Helfer enthalten bereits den wichtigen Wert für dieses Argument. Der dritte Parameter wird für die Übergabe von Argumenten an das Objekt Element verwendet. Es akzeptiert nur ein Array mit Schlüssel-Wert Paaren. Die classid und codebase sind Beispiel für solche Attribute. Das vierte Argument nimmt auch Schlüssel-Wert Paare und verwendet diese für die Erstellung von <param> Elementen. Sie sehen in Kürze ein Beispiel hierfür. Letztendlich, gibt es eine Option für das zur Verfügungstellen von zusätzlichen Inhalten beim Objekt. Jetzt folgt ein Beispiel welches alle Argumente verwendet.

echo $this->htmlObject(
    '/path/to/file.ext',
    'mime/type',
    array(
        'attr1' => 'aval1',
        'attr2' => 'aval2'
    ),
    array(
        'param1' => 'pval1',
        'param2' => 'pval2'
    ),
    'some content'
);

/*
Das würde folgendes ausgeben:

<object data="/path/to/file.ext" type="mime/type"
    attr1="aval1" attr2="aval2">
    <param name="param1" value="pval1" />
    <param name="param2" value="pval2" />
    some content
</object>
*/

InlineScript Helfer

Das HTML <script> Element wird verwendet um entweder Clientseitige Skriptelemente Inline zu ermöglichen oder um eine entfernte Ressource zu verlinken die Clientseitigen Skriptcode enthält. Der InlineScript Helfer erlaubt es beides zu managen. Er ist von HeadScript abgeleitet und jede Methode dieses Helfers ist vorhanden; trotzdem, sollte die inlineScript() Methode statt headScript() verwendet werden.

Hinweis: InlineScript für HTML Body Skripte verwenden
InlineScript, sollte verwendet werden wenn man Skripte im HTML body inkludieren will. Skripte am Ende des Dokuments zu platzieren ist eine gute Praxis um das Versenden von Seiten schneller zu machen, speziell wen 3rd Party Analyse Skripte verwendet werden.
Einige JS Bibliotheken müssen im HTML head; für diese Skripte sollte HeadScript verwendet werden.

JSON Helfer

Wenn Views erstellt werden die JSON zurückgeben ist es wichtig auch den entsprechenden Antwort-Header zu setzen. Der JSON View Helfer macht exakt das. Zusätzlich schaltet er, standardmäßig, Layouts aus (wenn diese aktuell eingeschaltet sind), weil Layouts generell nicht mit JSON Antworten verwendet werden.

Der JSON Helfer setzt die folgenden Header:

Content-Type: application/json

Die meisten AJAX Bibliotheken sehen nach diesem Header wenn die Antworten geparst werden um festzustellen wie der Inhalt handzuhaben ist.

Die Verwendung des JSON Helfers ist sehr geradlienig:

<?php echo $this->json($this->data) ?>

Hinweis: Layouts behalten und Encoding einschalten durch Verwendung von Zend_Json_Expr
Jede Methode im JSON Helfer akzwptiert ein zweites, optionales, Argument. Dieses zweite Argument kan ein boolsches Flag sein um Layouts ein- oder auszuschalten, oder ein Array von Optionen die an Zend_Json::encode() übergeben und intern verwendet werden um Daten zu kodieren.
Um Layouts zu behalten muß der zweite Parameter ein boolsches true sein. Wenn der zweite Parameter ein Array ist, können Layouts behalten werden indem ein keepLayouts Schlüssel mit dem boolschen Wert true eingefügt wird.
// Ein boolsches true als zweites Argument aktiviert Layouts:
echo $this->json($this->data, true);

// Oder ein boolsches true als "keepLayouts" Schlüssel:
echo $this->json($this->data, array('keepLayouts' => true));
Zend_Json::encode erlaubt es native JSON Ausdrücke zu kodieren indem Zend_Json_Expr Objekte verwendet werden. Diese Option ist standardmäßig deaktiviert. Um diese Option zu aktivieren, muß ein boolsches true an den enableJsonExprFinder Schlüssel des Options Arrays übergeben werden:
<?php echo $this->json($this->data, array(
    'enableJsonExprFinder' => true,
    'keepLayouts'          => true,
)) ?>

Navigations Helfer

Die Navigations Helfer werden von Zend_Navigation_Container für die Darstellung von Navigations Elementen verwendet.

Es gibt 2 eingebaute Helfer:

Breadcrumbs, wird für die Darstellung des Pfades der aktuell aktiven Seite verwendet.
Links, wird für die Darstellung von Navigations Header Links (z.B. <link rel="next" href="..." />) verwendet.
Menu, wird für die Darstellung von Menüs verwendet.
Sitemap, wird für die Darstellung von Sitemaps verwendet die dem » Sitemaps XML Format entsprechen.
Navigation, wird für die Weiterleitung von Aufrufen zu anderen Navigations Helfern verwendet.

Alle eingebauten Helfer erweitern Zend_View_Helper_Navigation_HelperAbstract, welches die Integration von ACL und Übersetzung hinzufügt. Die abstrakte Klasse implementiert das Interface Zend_View_Helper_Navigation_Helper welches die folgenden Methoden definiert:

{get|set}Container() empfängt/setzt den Navigations Container mit dem der Helfer standardmäßig arbeiten soll, und hasContainer() prüft ob der Helfer Container registriert hat.
{get|set}Translator() empfängt/setzt den Übersetzer der für die Übersetzung von Überschriften und Titelm verwendet wird, und {get|set}UseTranslator() kontrolliert ob der Übersetzer aktiviert werden soll. Die Methode hasTranslator() prüft ob der Helfer einen Übersetzer registriert hat.
{get|set}Acl(), {get|set}Role(), empfängt/setzt ACL (Zend_Acl) Instanzen und Rollen (string oder Zend_Acl_Role_Interface) die bei der Darstellung für das Filtern von Seiten verwendet werden, und {get|set}UseAcl() kontrolliert ob ACL aktiviert werden soll. Die Methoden hasAcl() und hasRole() prüfen ob der Helfer eine ACL Instanz oder Rolle registriert hat.
__toString(), die magische Methode stellt sicher das der Helfer, durch den direkten Aufruf von echo an der Instanz des Helfers, dargestellt werden kann.
render(), muß von konkreten Helfern implementiert werden um die Darstellung durchzuführen.

Zusätzlich zu den Methoden die vom Interface kommen, implementiert die abstrakte Klasse die folgenden Methoden:

{get|set}Indent() empfängt/setzt die Einrückung. Der Setzer akzeptiert einen string oder ein int. Im Fall eines int's verwendet der Helfer die angegebene Zahl als Leerzeichen für die Einrückung. Z.B. bedeutet setIndent(4) eine Einrückung von initial 4 Leerzeichen. Die Einrückung kann für alle Helfer außer dem Sitemap Helfer spezifiziert werden.
{get|set}MinDepth() empfängt/setzt die minimale Tiefe die eine Seite haben muß um vom Helfer eingefügt zu werden. Das Setzen von null bedeutet keine minimale Tiefe.
{get|set}MaxDepth() empfängt/setzt die maximale Tiefe die eine Seite haben muß um vom Helfer eingefügt zu werden. Das Setzen von null bedeutet keine maximale Tiefe.
__call() wird verwendet um Aufrufe zum Container, der im Helfer registriert ist, weiterzuleiten, was bedeutet das man Methoden in einem Helfer aufrufen kann wie wenn Sie im Container wären. Siehe das folgende Beispiel.
findActive($container, $minDepth, $maxDepth) wird verwendet um die tiefste aktive Seite im angegebenen Container zu finden. Wenn keine Tiefe angegeben wird, verwendet diese Methode die Werte die sie von getMinDepth() und getMaxDepth() erhält. Die tiefste aktive Seite muß zwischen $minDepth und $maxDepth inklusive liegen. Gibt ein Array zurück das Referenzen zu der gefundenen Instanz der Seite enthält, und die Tiefe bei der die Seite gefunden wurde.
htmlify() stellt ein a HTML Element von einer Zend_Navigation_Page Instanz dar.
accept() wird verwendet um zu erkennen ub eine Seite akzeptiert werden soll wenn durch Container iteriert wird. Diese Methode prüft die Sichtbarkeit der Seite und verifiziert das die Rolle des Helfers auf die Ressource/Privilegien der Seite zugreifen darf.
static setDefaultAcl() wird für das Setzen des standardmäßigen ACL Objekts verwendet, das dann von Helfern verwendet wird.
static setDefaultRole() wird für das Setzen der standardmäßigen Rolle verwendet, die dann von Helfern verwendet wird.

Wenn ein Navigations Container nicht explizit in einem Helfer durch Verwendung von $helper->setContainer($nav) gesetzt ist, schaut der Helfer in der Registry nach einer Container Instanz mit dem Schlüssel Zend_Navigation. Wenn ein Container nicht explizit gesetzt wurde, oder nicht in der Registry gefunden wird, erstellt der Helfer einen leeren Zend_Navigation Container wenn $helper->getContainer() aufgerufen wird.

Beispiel #23 Aufrufe an den Navigations Container weiterleiten

Navigations View Helfer verwenden die magisch __call() Methode um Methodenaufrufe an den Navigationscontainer weiterzuleiten der im View Helfer registriert ist.

$this->navigation()->addPage(array(
    'type' => 'uri',
    'label' => 'New page'));

Der obige Aufruf fügt eine Seite zum Container im Navigation Helfer hinzu.

Übersetzung von Labels und Titeln

Der Navigations Helfer unterstützt die Übersetzung von SeitenLabels und Überschriften. Man kann einen Übersetzer vom Typ Zend_Translate oder Zend_Translate_Adapter im Helfer setzen indem $helper->setTranslator($translator) verwendet wird, oder wie in allen anderen I18n-fähigen Komponenten; durch das Hinzufügen des Übersetzers in die Registry indem der Schlüssel Zend_Translate verwendet wird.

Wenn man die Übersetzung ausschalten will, sollte man $helper->setUseTranslator(false) verwenden.

Der Proxy Helfer injiziert seinen eigenen Übersetzer in den Helfer auf den er weiterleitet wenn der weitergeleitete Helfer nicht bereits einen Übersetzer hat.

Hinweis: Es gibt keinen Übersetzer im Sitemap Helfer, da keine SeitenLabels oder Überschriften in einer XML Sitemap enthalten sind.

Integration mit ACL

Alle navigatorischen View Helfer unterstützen ACL abgeleitet von der Zend_View_Helper_Navigation_HelperAbstract Klasse. Ein Zend_Acl Objekt kann einer Instanz eines Helfers mit $helper->setAcl($acl) hinzugefügt werden, und eine Rolle mit $helper->setRole('member') oder $helper->setRole(new Zend_Acl_Role('member')). Wenn ACL im Helfer verwendet wird, muß es der Rolle im Helfer vom ACL erlaubt sein auf die Ressourcen zuzugreifen und/oder das die Privilegien für diese Seite bei der Darstellung eingefügt werden dürfen.

Wenn eine Seite vom ACL nicht akzeptiert ist, wird auch jede untergeordnete Seite von der Darstellung ausgenommen sein. If a page is not accepted by ACL, any descendant page will also be excluded from rendering.

Der Proxy Helfer injiziert seine eigene ACL und Rolle in den Helfer zu dem er weiterleitet wenn der weitergeleitete Helfer nicht bereits einen hat.

Das Beispiel von unten zeigt wie ACL die Darstellung beeinflusst.

Setup der Navigation das in Beispielen verwendet wird

Dieses Beispiel zeigt das Setup eines Navigations Container für eine fiktive Software Firma.

Notizen zum Setup:

Die Domain der Site ist www.example.com.
Interessante Eigenschaften der Seite sind mit einem Kommentar markiert.
Solange im Beispiel nicht anders erwähnt, fragt der Benutzer nach der URL http://www.example.com/products/server/faq/, welche auf die Seite mit dem Label FAQ unter Foo Server übersetzt wird.
Das angenommene ACL und Route Setup wird unter dem Container Setup gezeigt.

/*
 * Navigations Container (config/array)

 * Jedes Element im Array wird an Zend_Navigation_Page::factory()
 * übergeben wenn der unten angezeigt Navigations Container
 * erstellt wird.
 */
$pages = array(
    array(
        'label'      => 'Home',
        'title'      => 'Geh zu Home',
        'module'     => 'default',
        'controller' => 'index',
        'action'     => 'index',
        'order'      => -100 // Sicherstellen das Home die erste Seite ist
    ),
    array(
        'label'      => 'Spezielles Angebot nur diese Woche!',
        'module'     => 'store',
        'controller' => 'offer',
        'action'     => 'amazing',
        'visible'    => false // nicht sichtbar
    ),
    array(
        'label'      => 'Produkte',
        'module'     => 'products',
        'controller' => 'index',
        'action'     => 'index',
        'pages'      => array(
            array(
                'label'      => 'Foo Server',
                'module'     => 'products',
                'controller' => 'server',
                'action'     => 'index',
                'pages'      => array(
                    array(
                        'label'      => 'FAQ',
                        'module'     => 'products',
                        'controller' => 'server',
                        'action'     => 'faq',
                        'rel'        => array(
                            'canonical' => 'http://www.example.com/?page=faq',
                            'alternate' => array(
                                'module'     => 'products',
                                'controller' => 'server',
                                'action'     => 'faq',
                                'params'     => array('format' => 'xml')
                            )
                        )
                    ),
                    array(
                        'label'      => 'Editionen',
                        'module'     => 'products',
                        'controller' => 'server',
                        'action'     => 'editions'
                    ),
                    array(
                        'label'      => 'System Anforderungen',
                        'module'     => 'products',
                        'controller' => 'server',
                        'action'     => 'requirements'
                    )
                )
            ),
            array(
                'label'      => 'Foo Studio',
                'module'     => 'products',
                'controller' => 'studio',
                'action'     => 'index',
                'pages'      => array(
                    array(
                        'label'      => 'Kunden Stories',
                        'module'     => 'products',
                        'controller' => 'studio',
                        'action'     => 'customers'
                    ),
                    array(
                        'label'      => 'Support',
                        'module'     => 'prodcts',
                        'controller' => 'studio',
                        'action'     => 'support'
                    )
                )
            )
        )
    ),
    array(
        'label'      => 'Firma',
        'title'      => 'Über uns',
        'module'     => 'company',
        'controller' => 'about',
        'action'     => 'index',
        'pages'      => array(
            array(
                'label'      => 'Investor Relations',
                'module'     => 'company',
                'controller' => 'about',
                'action'     => 'investors'
            ),
            array(
                'label'      => 'News',
                'class'      => 'rss', // Klasse
                'module'     => 'company',
                'controller' => 'news',
                'action'     => 'index',
                'pages'      => array(
                    array(
                        'label'      => 'Für die Presse',
                        'module'     => 'company',
                        'controller' => 'news',
                        'action'     => 'press'
                    ),
                    array(
                        'label'      => 'Archiv',
                        'route'      => 'archive', // Route
                        'module'     => 'company',
                        'controller' => 'news',
                        'action'     => 'archive'
                    )
                )
            )
        )
    ),
    array(
        'label'      => 'Community',
        'module'     => 'community',
        'controller' => 'index',
        'action'     => 'index',
        'pages'      => array(
            array(
                'label'      => 'Mein Account',
                'module'     => 'community',
                'controller' => 'account',
                'action'     => 'index',
                'resource'   => 'mvc:community.account' // Ressource
            ),
            array(
                'label' => 'Forum',
                'uri'   => 'http://forums.example.com/',
                'class' => 'external' // Klasse
            )
        )
    ),
    array(
        'label'      => 'Administration',
        'module'     => 'admin',
        'controller' => 'index',
        'action'     => 'index',
        'resource'   => 'mvc:admin', // Ressource
        'pages'      => array(
            array(
                'label'      => 'Neuen Artikel schreiben',
                'module'     => 'admin',
                'controller' => 'post',
                'aciton'     => 'write'
            )
        )
    )
);

// Container von einem Array erstellen
$container = new Zend_Navigation($pages);

// Den Container im Proxy Helfer speichern
$view->getHelper('navigation')->setContainer($container);

// ...oder einfach:
$view->navigation($container);

// ...oder ihn einfach in der Registry speichern:
Zend_Registry::set('Zend_Navigation', $container);

Zusätzlich zum obigen Container, wird das folgende Setup angenommen:

// Router Setup (Standardrouten und 'archive' Route):
$front = Zend_Controller_Front::getInstance();
$router = $front->getRouter();
$router->addDefaultRoutes();
$router->addRoute(
    'archive',
    new Zend_Controller_Router_Route(
        '/archive/:year',
        array(
            'module'     => 'company',
            'controller' => 'news',
            'action'     => 'archive',
            'year'       => (int) date('Y') - 1
        ),
        array('year' => '\d+')
    )
);

// ACL Setup:
$acl = new Zend_Acl();
$acl->addRole(new Zend_Acl_Role('member'));
$acl->addRole(new Zend_Acl_Role('admin'));
$acl->add(new Zend_Acl_Resource('mvc:admin'));
$acl->add(new Zend_Acl_Resource('mvc:community.account'));
$acl->allow('member', 'mvc:community.account');
$acl->allow('admin', null);

// ACL und Rolle im Proxy Helfer speichern:
$view->navigation()->setAcl($acl)->setRole('member');

// ...oder ein standard ACL und Rolle statisch setzen:
Zend_View_Helper_Navigation_HelperAbstract::setDefaultAcl($acl);
Zend_View_Helper_Navigation_HelperAbstract::setDefaultRole('member');

Breadcrumbs Helfer

Breadcrumbs werden verwendet um anzuzeigen wo in einer Sitemap ein Benutzer aktuell browst, und werden typischerweise wie folgt angezeigt: "Du bist hier: Home > Produkte > FantastischesProdukt 1.0". Der BreakCrumbs Helfer folgt den Richtlinien von » Breadcrumbs Pattern - Yahoo! Design Pattern Library, und erlaubt eine einfache Anpassung (Minimale/Maximale Tiefe, Einrückung, Trennzeichen, und ob das letzte Element verlinkt sein soll), oder die Darstellung durch Verwendung eines partiellen View Skripts.

Der Breabcrumbs Helfer funktioniert wie folgt; er findet die tiefste aktive Seite in einem Navigations Container, und stellt den aufwärtsgerichteten Pfad zum Root dar. Für MVC Seiten wird die "Aktivität" einer Seite erkannt indem das Anfrage Objekt angeschaut wird, wie im Kapitel Zend_Navigation_Page_Mvc beschrieben.

Der Helfer setzt die Eigenschaft minDepth standardmäßig auf 1, was bedeutet das Breadcrumbs nicht dargestellt werden wenn die tiefste aktive Seite eine Root Seite ist. Wenn maxDepth spezifiziert ist, beendet der Helfer die Darstellung bei der spezifizierten Tiefe (z.B. stopp bei Level 2 selbst wenn die tiefste aktive Seite auf Level 3 ist).

Methoden im Breakcrumbs Helfer sind:

{get|set}Separator() empfängt/setzt das Trennzeichen das zwischen Breakcrumbs verwendet wird. Der Standardwert ist ' > '.
{get|set}LinkLast() empfängt/setzt ob der letzte Breabcrumb als Anker dargestellt werden soll oder nicht. Der Standardwert ist false.
{get|set}Partial() empfängt/setzt ein partielles View Skript das für die Darstellung von Breadcrumbs verwendet werden soll. Wenn ein partielles View Skript gesetzt ist, verwendet die render() Methode des Helfers die renderPartial() Methode. Wenn kein partielles gesetzt ist, wird die renderStraight() Methode verwendet. Der Helfer erwartet das der partielle ein string oder ein array mit zwei Elementen ist. Wen der Partielle ein string ist, benennt er den Namen des partiellen Skripts das zu verwenden ist. Wenn er ein array ist, wird das erste Element als Name des partiellen View Skripts verwendet, und das zweite Element ist das Modul in dem das Skript zu finden ist.
renderStraight() ist die standardmäßige render Methode.
renderPartial() wird für die Darstellung verwendet wenn ein partielles View Skript verwendet wird.

Beispiel #24 Darstellung von Breadcrumbs

Dieses Beispiel zeigt wie Breadcrumbs mit Standardsettings dargestellt werden.

In einem View Skript oder Layout:
<?php echo $this->navigation()->breadcrumbs(); ?>

oder wenn Short-Tags aktiviert sind:
<?php $this->navigation()->breadcrumbs(); ?>

Die zwei obigen Aufrufe verwenden die magische __toString() Methode,
und sind identisch mit:
<?php echo $this->navigation()->breadcrumbs()->render(); ?>

Ausgabe:
<a href="/products">Produkte</a> &gt; <a href="/products/server">Foo Server</a> &gt; FAQ

Beispiel #25 Einrückung spezifizieren

Dieses Beispiel zeigt wie Breadcrumbs mit anfänglicher Einrückung dargestellt werden können.

Darstellung mit 8 Leerzeichen Einrückung:
<?php echo $this->navigation()->breadcrumbs()->setIndent(8); ?>

Ausgabe:
        <a href="/products">Products</a> &gt; <a href="/products/server">Foo Server</a> &gt; FAQ

Beispiel #26 Eigene Ausgabe für Breakcrumbs

Dieses Beispiel zeigt wie man eine eigene Breadcrumbs Ausgabe durch die Spezifizierung diverser Optionen erstellt.

In einem View Skript oder Layout:

<?php
echo $this->navigation()
          ->breadcrumbs()
          ->setLinkLast(true)                   // Letzte Seite verlinken
          ->setMaxDepth(1)                      // Bei Level 1 stoppen
          ->setSeparator(' &#9654;' . PHP_EOL); // Cooler Seperator mit Umbruch
?>

Output:
<a href="/products">Produkte</a> &#9654;
<a href="/products/server">Foo Server</a>

/////////////////////////////////////////////////////

Minimale notwendige Tiefe für die Darstellung von Breadcrumbs setzen:

<?php
$this->navigation()->breadcrumbs()->setMinDepth(10);
echo $this->navigation()->breadcrumbs();
?>

Ausgabe:
Nichts, weil die tiefste aktive Seite nicht auf Level 10 oder tiefer ist.

Beispiel #27 Darstellung von Breadcrumbs mit Verwendung eines partiellen View Skripts

Dieses Beispiel zeigt wir eigene Breakcrumbs durch Verwendung eines partiellen View Skripts dargestellt werden können. Durch den Aufruf von setPartial() kann man ein partielles View Skript spezifizieren das verwendet wird wenn die renderPartial() Methode aufgerufen wird. Diese Methode findest die tiefste aktive Seite und übergibt ein Array von Seiten die zur aktiven Seite des partiellen View Skripts weiterleitet.

Im Layout:

$partial = ;
echo $this->navigation()->breadcrumbs()
                        ->setPartial(array('breadcrumbs.phtml', 'default'));

Inhalt von application/modules/default/views/breadcrumbs.phtml:

echo implode(', ', array_map(
        create_function('$a', 'return $a->getLabel();'),
        $this->pages));

Ausgabe:

Produkte, Foo Server, FAQ

Link Helfer

Der Link Helfer wird für die Darstellung von HTML LINK Elementen verwendet. Links werden für die Beschreibung von Dokument-Beziehungen der aktuell aktiven Seite verwendet. Mehr über Links und Linktypen kann unter » Dokument-Beziehung: Das LINK Element (HTML4 W3C Rec.) und » Link Typen (HTML4 W3C Rec.) in der HMTL4 W3C Empfehlung nachgelesen werden.

Es gibt zwei Typen von Beziehungen; vorwärts und rückwärts, angezeigt durch die Schlüsselwörter 'rel' und 'rev'. Die meisten Methoden im Helfer nehmen einen $rel Parameter entgegen, welcher entweder 'rel' oder 'rev' sein muß. Die meisten Methoden nehmen auch einen $type Parameter entgegen welcher für die Spezifikation des Linktyps (z.B. alternate, start, next, prev, chapter, usw.) verwendet wird.

Beziehungen können dem Seitenobjekt manuell hinzugefügt werden, oder werden durch das Durchlaufen des Containers, der im Helfer registriert ist, gefunden. Die Methode findRelation($page, $rel, $type) versucht zuerst den gegebenen $rel von $type von der $page durch den Aufruf von $page->findRel($type) oder $page->findRel($type) zu finden. Wenn $page eine Beziehung hat die zu der Instanz einer Seite konvertiert werden kann, wird diese Beziehung verwendet. Wenn die Instanz von $page keinen $type spezifiziert hat, schaut der Helfer nach einer Methode im Helfer die search$rel$type heißt (z.B. searchRelNext() oder searchRevAlternate()). Wenn so eine Methode existiert, wird Sie für die Erkennung der Beziehung der $page verwendet indem der Container durchlaufen wird.

Nicht alle Beziehungen können durch das Durchlaufen des Containers erkannt werden. Das sind die Beziehungen die durch eine Suche gefunden werden können:

searchRelStart(), Vorwärts Beziehung 'start': Die erste Seite im Container.
searchRelNext(), Vorwärts Beziehung 'next'; findet die nächste Seite im Container, z.B. die Seite nach der aktiven Seite.
searchRelPrev(), Vorwärts Beziehung 'prev'; findet die vorhergehende Seite, z.B. die Seite vor der aktiven Seite.
searchRelChapter(), Vorwärts Beziehung 'chapter'; findet alle Seiten auf Level 0 ausser der 'start' Beziehung oder der aktiven Seite wenn diese auf Level 0 ist.
searchRelSection(), Vorwärts Beziehung 'section'; findet alle Kind-Seiten der aktiven Seite wenn die aktive Seite auf Level 0 ist (ein 'chapter').
searchRelSubsection(), Vorwärts Beziehung 'subsection'; findet alle Kind-Seiten der aktiven Seite wenn die aktive Seite auf Level 1 sind (ein 'section').
searchRevSection(), Rückwärts Beziehung 'section'; findet den Elternteil der aktiven Seite wenn die aktive Seite auf Level 1 ist (ein 'section').
searchRevSubsection(), Rückwärts Beziehung 'subsection'; findet den Elternteil der aktiven Seite wenn die aktive Seite auf Level 2 ist (ein 'subsection').

Hinweis: Wenn in der Instanz der Seite nach Beziehungen gesehen wird ( ($page->getRel($type) oder $page->getRev($type)), akzeptiert der Helfer Wert vom Typ string, array, Zend_Config, oder Zend_Navigation_Page. Wenn ein String gefunden wird, wird dieser zu einer Zend_Navigation_Page_Uri konvertiert. Wenn ein Array oder eine Config gefunden wird, wird diese in ein oder mehrere Seiteninstanzen konvertiert, und jedes Element wird an die Seiten Factory übergeben. Wenn der erste Schlüssel nicht nummerische ist, wird das Array/Config direkt an die Seiten Factory übergeben, und eine einzelne Seite wird retourniert.

Der Helfer unterstützt auch magische Methoden für das Finden von Beziehungen. Um z.B. alternative vorwärts Beziehungen zu finden muß $helper->findRelAlternate($page) aufgerufen werden, und um rückwärts gerichtete Kapitel Beziehungen zu finden $helper->findRevSection($page). Diese Aufrufe korrespondieren mit $helper->findRelation($page, 'rel', 'alternate'); und $helper->findRelation($page, 'rev', 'section');.

Um zu Steuern welche Beziehung dargestellt werden soll, verwendet der Helfer ein render Flag. Das render Flag ist ein Integer Wert, und kann in » binären und (&) Operationen mit den render Konstanten des Helfers verwendet werden um festzustellen ob die Beziehung zu der die render Konstante gehört, dargestellt werden soll.

Siehe das folgende Beispiel für weitere Informationen.

Zend_View_Helper_Navigation_Link::RENDER_ALTERNATE
Zend_View_Helper_Navigation_Link::RENDER_STYLESHEET
Zend_View_Helper_Navigation_Link::RENDER_START
Zend_View_Helper_Navigation_Link::RENDER_NEXT
Zend_View_Helper_Navigation_Link::RENDER_PREV
Zend_View_Helper_Navigation_Link::RENDER_CONTENTS
Zend_View_Helper_Navigation_Link::RENDER_INDEX
Zend_View_Helper_Navigation_Link::RENDER_GLOSSARY
Zend_View_Helper_Navigation_Link::RENDER_COPYRIGHT
Zend_View_Helper_Navigation_Link::RENDER_CHAPTER
Zend_View_Helper_Navigation_Link::RENDER_SECTION
Zend_View_Helper_Navigation_Link::RENDER_SUBSECTION
Zend_View_Helper_Navigation_Link::RENDER_APPENDIX
Zend_View_Helper_Navigation_Link::RENDER_HELP
Zend_View_Helper_Navigation_Link::RENDER_BOOKMARK
Zend_View_Helper_Navigation_Link::RENDER_CUSTOM
Zend_View_Helper_Navigation_Link::RENDER_ALL

Die Konstanten von RENDER_ALTERNATE bis RENDER_BOOKMARK stellen standardmäßige HTML Linktypen dar. RENDER_CUSTOM stellt eine nicht-standardmäßige Beziehung dar die in der Seite spezifiziert ist. RENDER_ALL stellt standardmäßige und nicht-standardmäßige Beziehungen dar.

Methoden im Link Helfer:

{get|set}RenderFlag() empfängt/setzt das render Flag. Standardwert ist RENDER_ALL. Siehe das folgende Beispiel dafür wie das render Flag zu setzen ist.
findAllRelations() findet alle Beziehungen von allen Typen einer angegebenen Seite.
findRelation() findet alle Beziehungen eines angegebenen Typs einer angegebenen Seite.
searchRel{Start|Next|Prev|Chapter|Section|Subsection}() durchsucht einen Container um vorwärtsgerichtete Beziehungen zu Startseite, nächster Seite, voriger Seite, Kapitel, Sektion und Untersektion zu finden.
searchRev{Section|Subsection}() durchsucht einen Container um rückwärtsgerichtete Beziehungen zu Sektionen oder Untersektionen zu finden.
renderLink() stellt ein einzelnes link Element dar.

Beispiel #28 Beziehungen in Seiten spezifizieren

Dieses Beispiel zeigt wir Beziehungen in Seiten spezifiziert werden können.

$container = new Zend_Navigation(array(
    array(
        'label' => 'Strings für Beziehungen verwenden',
        'rel'   => array(
            'alternate' => 'http://www.example.org/'
        ),
        'rev'   => array(
            'alternate' => 'http://www.example.net/'
        )
    ),
    array(
        'label' => 'Arrays für Beziehungen verwenden',
        'rel'   => array(
            'alternate' => array(
                'label' => 'Example.org',
                'uri'   => 'http://www.example.org/'
            )
        )
    ),
    array(
        'label' => 'Konfigurationen für Beziehungen verwenden',
        'rel'   => array(
            'alternate' => new Zend_Config(array(
                'label' => 'Example.org',
                'uri'   => 'http://www.example.org/'
            ))
        )
    ),
    array(
        'label' => 'Instanzen von Seiten für Beziehungen verwenden',
        'rel'   => array(
            'alternate' => Zend_Navigation_Page::factory(array(
                'label' => 'Example.org',
                'uri'   => 'http://www.example.org/'
            ))
        )
    )
));

Beispiel #29 Standardmäßige Darstellung von Links

Dieses Beispiel zeigt wie ein Menü von einem Container dargestellt wird, der im View Helfer registriert/gefunden wurde.

Im View Skript oder Layout:
<?php echo $this->view->navigation()->links(); ?>

Ausgabe:
<link rel="alternate" href="/products/server/faq/format/xml">
<link rel="start" href="/" title="Home">
<link rel="next" href="/products/server/editions" title="Editionen">
<link rel="prev" href="/products/server" title="Foo Server">
<link rel="chapter" href="/products" title="Produkte">
<link rel="chapter" href="/company/about" title="Firma">
<link rel="chapter" href="/community" title="Community">
<link rel="canonical" href="http://www.example.com/?page=server-faq">
<link rev="subsection" href="/products/server" title="Foo Server">

Beispiel #30 Spezifizieren welche Beziehungen dargestellt werden sollen

Dieses Beispiel zeigt wie spezifiziert werden kann, welche Beziehungen zu finden und darzustellen sind.

Nur start, next und prev darstellen:
$helper->setRenderFlag(Zend_View_Helper_Navigation_Links::RENDER_START |
                       Zend_View_Helper_Navigation_Links::RENDER_NEXT |
                       Zend_View_Helper_Navigation_Links::RENDER_PREV);

Ausgabe:
<link rel="start" href="/" title="Home">
<link rel="next" href="/products/server/editions" title="Editionen">
<link rel="prev" href="/products/server" title="Foo Server">

Nur native Linktypen darstellen:
$helper->setRenderFlag(Zend_View_Helper_Navigation_Links::RENDER_ALL ^
                       Zend_View_Helper_Navigation_Links::RENDER_CUSTOM);

Ausgabe:
<link rel="alternate" href="/products/server/faq/format/xml">
<link rel="start" href="/" title="Home">
<link rel="next" href="/products/server/editions" title="Editionen">
<link rel="prev" href="/products/server" title="Foo Server">
<link rel="chapter" href="/products" title="Produkte">
<link rel="chapter" href="/company/about" title="Firma">
<link rel="chapter" href="/community" title="Community">
<link rev="subsection" href="/products/server" title="Foo Server">

Alles ausser Kapitel darstellen:
$helper->setRenderFlag(Zend_View_Helper_Navigation_Links::RENDER_ALL ^
                       Zend_View_Helper_Navigation_Links::RENDER_CHAPTER);

Ausgabe:
<link rel="alternate" href="/products/server/faq/format/xml">
<link rel="start" href="/" title="Home">
<link rel="next" href="/products/server/editions" title="Editionen">
<link rel="prev" href="/products/server" title="Foo Server">
<link rel="canonical" href="http://www.example.com/?page=server-faq">
<link rev="subsection" href="/products/server" title="Foo Server">

Menu Helfer

Der Menu Helfer wird für die Darstellung von Menüs aus Navigations Containern verwendet. Standardmäßig wird das Menü durch Verwendung der HTML Tags UL und LI dargestellt. Der Helfer erlaubt aber auch die Verwendung eines partiellen View Skripts.

Methoden im Menu Helfer:

{get|set}UlClass() empfängt/setzt die CSS Klasse zur Verwendung in renderMenu().
{get|set}OnlyActiveBranch() empfängt/setzt ein Flag das spezifiziert ob der aktive Zweig eines Containers dargestellt werden soll.
{get|set}RenderParents() empfängt/setzt ein Flag das spezifiziert ob Eltern nur dargestellt werden sollen wenn nur der aktive Zweig eines Containers dargestellt wird. Wenn es auf false gesetzt wird, wird nur das tiefste aktive Menü dargestellt.
{get|set}Partial() empfängt/setzt ein partielles View Skript das für die Darstellung des Menüs verwendet werden soll. Wenn ein partielles Skript gesetzt ist, verwendet die render() Methode des Helfers die renderPartial() Methode. Wenn kein Partieller gesetzt ist, wird die renderMenu() Methode verwendet. Der Helfer erwartet das der Partielle ein string, oder ein array mit zwei Elementen, ist. Wenn der Partielle ein string ist bezeichnet er den Namen des partiellen Skripts das zu verwenden ist. Wenn er ein array ist wird das erste Element als Name des partiellen View Skripts verwendet, und das zweite Element ist das Modul indem das Skript gefunden wird.
htmlify() überschreibt die Methode der abstrakten Klasse damit span Elemente zurückgegeben werden wenn die Seite kein href hat.
renderMenu($container = null, $options = array()) ist eine standardmäßige render Methode, und stellt einen Container als HTML UL Liste dar.

Wenn $container nicht angegeben wird, wird der Container der im Helfer registriert ist dargestellt.

$options wird verwendet um temporär spezifizierte Optionen zu überschreiben ohne das die Werte in der Helferinstanz resetiert werden. Es ist ein assoziatives Array wobei jeder Schlüssel mit einer Option im Helfer korrespondiert.

Erkannte Optionen:
- indent; Einrückung. Erwartet einen string oder einen int Wert.
- minDepth; Minimale Tiefe. Erwartet ein int oder null (keine minimale Tiefe).
- maxDepth; Maximale Tiefe. Erwartet ein int oder null (keine maximale Tiefe).
- ulClass; CSS Klasse für das ul Element. Erwartet einen string.
- onlyActiveBranch; Ob nur der aktive Branch dargestellt werden soll. Erwartet einen boolean Wert.
- renderParents; Ob eltern dargestellt werden sollen wenn nur der aktive Branch dargestellt wird. Erwartet einen boolean Wert.
Wenn keine Option angegeben wird, werden die Werte die im Helfer gesetzt sind verwendet.
renderPartial() wird für die Darstellung des Menüs in einem partiellen View Skript verwendet.
renderSubMenu() stellt das tiefste Menü Level des aktiven Branches eines Containers dar.

Beispiel #31 Darstellung eines Menüs

Dieses Beispiel zeigt wie ein Menü von einem registrierten/im View Helfer gefundenen Container, dargestellt wird. Es ist zu beachten das Seiten basierend auf Ihrer Sichtbarkeit und ACL ausgefiltert werden.

In einem View Skript oder Layout:
<?php echo $this->navigation()->menu()->render() ?>

Oder einfach:
<?php echo $this->navigation()->menu() ?>

Oder wenn Short Tags aktiviert sind:
<?= $this->navigation()->menu() ?>

Ausgabe:
<ul class="navigation">
    <li>
        <a title="Geh zu Home" href="/">Home</a>
    </li>
    <li class="active">
        <a href="/products">Produkte</a>
        <ul>
            <li class="active">
                <a href="/products/server">Foo Server</a>
                <ul>
                    <li class="active">
                        <a href="/products/server/faq">FAQ</a>
                    </li>
                    <li>
                        <a href="/products/server/editions">Editionen</a>
                    </li>
                    <li>
                        <a href="/products/server/requirements">System Anforderungen</a>
                    </li>
                </ul>
            </li>
            <li>
                <a href="/products/studio">Foo Studio</a>
                <ul>
                    <li>
                        <a href="/products/studio/customers">Kunden Stories</a>
                    </li>
                    <li>
                        <a href="/prodcts/studio/support">Support</a>
                    </li>
                </ul>
            </li>
        </ul>
    </li>
    <li>
        <a title="About us" href="/company/about">Firma</a>
        <ul>
            <li>
                <a href="/company/about/investors">Investor Relations</a>
            </li>
            <li>
                <a class="rss" href="/company/news">News</a>
                <ul>
                    <li>
                        <a href="/company/news/press">Für die Presse</a>
                    </li>
                    <li>
                        <a href="/archive">Archiv</a>
                    </li>
                </ul>
            </li>
        </ul>
    </li>
    <li>
        <a href="/community">Community</a>
        <ul>
            <li>
                <a href="/community/account">Mein Account</a>
            </li>
            <li>
                <a class="external" href="http://forums.example.com/">Forums</a>
            </li>
        </ul>
    </li>
</ul>

Beispiel #32 renderMenu() direkt aufrufen

Dieses Beispiel zeigt wie ein Menü dargestellt werden kann das nicht im View Helfer registriert ist, indem renderMenu() direkt aufgerufen wird und ein paar wenige Optionen spezifiziert werden.

<?php
// Nur das 'Community' Menü darstellen
$community = $this->navigation()->findOneByLabel('Community');
$options = array(
    'indent'  => 16,
    'ulClass' => 'community'
);
echo $this->navigation()
          ->menu()
          ->renderMenu($community, $options);
?>
Output:
                <ul class="community">
                    <li>
                        <a href="/community/account">Mein Account</a>
                    </li>
                    <li>
                        <a class="external" href="http://forums.example.com/">Forums</a>
                    </li>
                </ul>

Beispiel #33 Das tiefste aktive Menü darstellen

Dieses Beispiel zeigt wie renderSubMenu() das tiefste Untermenü des aktiven Branches dargestellt wird.

Der Aufruf von renderSubMenu($container, $ulClass, $indent) ist identisch mit dem Aufruf von renderMenu($container, $options) mit den folgenden Optionen: array( 'ulClass' => $ulClass, 'indent' => $indent, 'minDepth' => null, 'maxDepth' => null, 'onlyActiveBranch' => true, 'renderParents' => false )

<?php
echo $this->navigation()
          ->menu()
          ->renderSubMenu(null, 'sidebar', 4);
?>

Die Ausgabe ist die gleiche wenn 'FAQ' oder 'Foo Server' aktiv sind:
    <ul class="sidebar">
        <li class="active">
            <a href="/products/server/faq">FAQ</a>
        </li>
        <li>
            <a href="/products/server/editions">Editionen</a>
        </li>
        <li>
            <a href="/products/server/requirements">System Anforderungen</a>
        </li>
    </ul>

Beispiel #34 Darstellung eines Menüs mit maximaler Tiefe

<?php
echo $this->navigation()
          ->menu()
          ->setMaxDepth(1);
?>

Ausgabe:
<ul class="navigation">
    <li>
        <a title="Geh zu Home" href="/">Home</a>
    </li>
    <li class="active">
        <a href="/products">Produkte</a>
        <ul>
            <li class="active">
                <a href="/products/server">Foo Server</a>
            </li>
            <li>
                <a href="/products/studio">Foo Studio</a>
            </li>
        </ul>
    </li>
    <li>
        <a title="About us" href="/company/about">Firma</a>
        <ul>
            <li>
                <a href="/company/about/investors">Investor Relations</a>
            </li>
            <li>
                <a class="rss" href="/company/news">News</a>
            </li>
        </ul>
    </li>
    <li>
        <a href="/community">Community</a>
        <ul>
            <li>
                <a href="/community/account">Mein Account</a>
            </li>
            <li>
                <a class="external" href="http://forums.example.com/">Forums</a>
            </li>
        </ul>
    </li>
</ul>

Beispiel #35 Darstellung eines Menüs mit minimaler Tiefe

<?php
echo $this->navigation()
          ->menu()
          ->setMinDepth(1);
?>

Ausgabe:
<ul class="navigation">
    <li class="active">
        <a href="/products/server">Foo Server</a>
        <ul>
            <li class="active">
                <a href="/products/server/faq">FAQ</a>
            </li>
            <li>
                <a href="/products/server/editions">Editionen</a>
            </li>
            <li>
                <a href="/products/server/requirements">System Anforderungen</a>
            </li>
        </ul>
    </li>
    <li>
        <a href="/products/studio">Foo Studio</a>
        <ul>
            <li>
                <a href="/products/studio/customers">Kunden Stories</a>
            </li>
            <li>
                <a href="/prodcts/studio/support">Support</a>
            </li>
        </ul>
    </li>
    <li>
        <a href="/company/about/investors">Investor Relations</a>
    </li>
    <li>
        <a class="rss" href="/company/news">News</a>
        <ul>
            <li>
                <a href="/company/news/press">Für die Presse</a>
            </li>
            <li>
                <a href="/archive">Archiv</a>
            </li>
        </ul>
    </li>
    <li>
        <a href="/community/account">Mein Account</a>
    </li>
    <li>
        <a class="external" href="http://forums.example.com/">Forums</a>
    </li>
</ul>

Beispiel #36 Nur den aktiven Branch eines Menüs darstellen

<?php
echo $this->navigation()
          ->menu()
          ->setOnlyActiveBranch(true);
?>

Ausgabe:
<ul class="navigation">
    <li class="active">
        <a href="/products">Produkte</a>
        <ul>
            <li class="active">
                <a href="/products/server">Foo Server</a>
                <ul>
                    <li class="active">
                        <a href="/products/server/faq">FAQ</a>
                    </li>
                    <li>
                        <a href="/products/server/editions">Editionen</a>
                    </li>
                    <li>
                        <a href="/products/server/requirements">System Anforderungen</a>
                    </li>
                </ul>
            </li>
        </ul>
    </li>
</ul>

Beispiel #37 Nur den aktiven Branch eines Menüs mit minimaler Tiefe darstellen

<?php
echo $this->navigation()
          ->menu()
          ->setOnlyActiveBranch(true)
          ->setMinDepth(1);
?>

Ausgabe:
<ul class="navigation">
    <li class="active">
        <a href="/products/server">Foo Server</a>
        <ul>
            <li class="active">
                <a href="/products/server/faq">FAQ</a>
            </li>
            <li>
                <a href="/products/server/editions">Editionen</a>
            </li>
            <li>
                <a href="/products/server/requirements">System Anforderungen</a>
            </li>
        </ul>
    </li>
</ul>

Beispiel #38 Nur den aktiven Branch eines Menüs mit maximaler Tiefe darstellen

<?php
echo $this->navigation()
          ->menu()
          ->setOnlyActiveBranch(true)
          ->setMaxDepth(1);
?>

Ausgabe:
<ul class="navigation">
    <li class="active">
        <a href="/products">Produkte</a>
        <ul>
            <li class="active">
                <a href="/products/server">Foo Server</a>
            </li>
            <li>
                <a href="/products/studio">Foo Studio</a>
            </li>
        </ul>
    </li>
</ul>

Beispiel #39 Nur den aktiven Branch eines Menüs mit maximaler Tiefe aber ohne Eltern darstellen

<?php
echo $this->navigation()
          ->menu()
          ->setOnlyActiveBranch(true)
          ->setRenderParents(false)
          ->setMaxDepth(1);
?>

Ausgabe:
<ul class="navigation">
    <li class="active">
        <a href="/products/server">Foo Server</a>
    </li>
    <li>
        <a href="/products/studio">Foo Studio</a>
    </li>
</ul>

Beispiel #40 Darstellen eines eigenen Menüs durch Verwendung eines partiellen View Skripts

Dieses Beispiel zeigt wie ein eigenes Menü, durch Verwendung eines partiellen View Skripts, dargestellt werden kann. Durch Aufruf von setPartial() kann ein partielles View Skript spezifiziert werden das verwendet wird wenn man render() aufruft. Wenn ein Partielles spezifiziert ist, wird die renderPartial() Methode aufgerufen. Diese Methode fügt den Container in die View ein, und verwendet hierbei den Schlüssel container.

In a layout:

$partial = array('menu.phtml', 'default');
$this->navigation()->menu()->setPartial($partial);
echo $this->navigation()->menu()->render();

In application/modules/default/views/menu.phtml:

foreach ($this->container as $page) {
    echo $this->menu()->htmlify($page), PHP_EOL;
}

Ausgabe:

<a title="Geh zu Home" href="/">Home</a>
<a href="/products">Produkte</a>
<a title="About us" href="/company/about">Firma</a>
<a href="/community">Community</a>

Sitemap Helfer

Der Sitemap Helfer wird für die Erzeugung von XML Sitemaps verwendet wie im » Sitemaps XML Format definiert. Mehr darüber kann unter » Sitemaps in Wikipedia nachgelesen werden.

Standardmäßig verwendet der Sitemap Helfer Sitemap Prüfungen um jedes Element zu prüfen das dargestellt werden soll. Das kann deaktiviert werden indem man $helper->setUseSitemapValidators(false) aufruft.

Hinweis: Wenn man die Sitemap Prüfungen deaktiviert, werden die eigenen Eigenschaften (siehe Tabelle) nicht geprüft.

Der Sitemap Helfer unterstützt auch die Pürfung von » Sitemap XSD Schemas der erzeugten Sitemap. Das ist standardmäßig deaktiviert, da es eine Anfrage auf die Schema Datei benötigt. Es kann mit $helper->setUseSchemaValidation(true) aktiviert werden.

**Sitemap XML Elemente**
Element	Beschreibung
`loc`	Absolute UTL zur Seite. Eine absolute URL wird vom Helfer erzeugt.
`lastmod`	Das Datum der letzten Änderung der Datei, im » W3C Datetime Format. Dieser Zeitabschnitt kann bei Bedarf unterdrückt, und nur YYYY-MM-DD verwendet werden. Der Helfer versucht den `lastmod` Wert von der Seiteneigenschaft `lastmod` zu erhalten wenn diese auf der Seite gesetzt ist. Wenn der Wert kein gültiges Datum ist, wird er ignoriert.
`changefreq`	Wie oft eine Seite geändert wird. Dieser Wert bietet eine generelle Information für Suchmaschinen und muß nicht exakt mit der Anzahl der Suchen auf der Seite übereinstimmen. Gültige Werte sind: always hourly daily weekly monthly yearly never Der Helfer versucht den `changefreq` Wert von der Seiteneigenschaft `changefreq` zu erhalten, wenn diese auf der Seite gesetzt ist. Wenn der Wert nicht gültig ist, wird er ignoriert.
`priority`	Die Priorität dieser URL relativ zu anderen URLs auf der eigenen Site. Der gültige Bereich für diesen Wert ist von 0.0 bis 1.0. Der Helfer versucht den `priority` Wert von der Seiteneigenschaft `priority` zu erhalten wenn dieser auf der Seite gesetzt ist. Wenn der Wert nicht gültig ist, wird er ignoriert.

Methoden im Sitemap Helfer:

{get|set}FormatOutput() empfängt/setzt ein Flag das anzeigt ob XML Ausgaben formatiert werden sollen. Das entspricht der Eigenschaft formatOutput der nativen DOMDocument Klasse. Mehr kann man unter » PHP: DOMDocument - Handbuch nachlesen. Der Standardwert ist false.
{get|set}UseXmlDeclaration() empfängt/setzt ein Flag das anzeigt ob die XML Deklaration bei der Darstellung enthalten sein soll. Der Standardwert ist true.
{get|set}UseSitemapValidators() empfängt/setzt ein Flag das anzeigt ob Sitemap Prüfungen verwendet werden sollen wenn die DOM Sitemap dargestellt werden soll. Der Standardwert ist true.
{get|set}UseSchemaValidation() empfängt/setzt ein Flag das anzeigt ob der Helfer eine XML Schema Prüfung verwenden soll wenn die DOM Sitemap erzeugt wird. Der Standardwert ist false.
{get|set}ServerUrl() empfängt/setzt die Server URL die nicht-absoluten URLs in der url() Methode vorangestellt werden. Wenn keine Server URL spezifiziert ist, wird diese vom Helfer festgestellt.
url() wird verwendet um absolute URLs zu Seiten zu erstellen.
getDomSitemap() erzeugt ein DOMDocument von einem angegebenen Container.

Beispiel #41 Eine XML Sitemap darstellen

Dieses Beispiel zeigt wie eine XML Sitemap, basierend auf dem Setup das wir vorher angegeben haben, dargestellt wird.

// In einem View Skript oder Layout:

// Ausgabeformat
$this->navigation()
      ->sitemap()
      ->setFormatOutput(true); // Standardwert ist false

// Andere mögliche Methoden:
// ->setUseXmlDeclaration(false); // Standardwert ist true
// ->setServerUrl('http://my.otherhost.com');
// Standard ist die automatische Erkennung

// Sitemap ausdrucken
echo $this->navigation()->sitemap();

Es ist zu beachten wie Seiten die unsichtbar oder Seiten mit ACL Rollen die mit dem View Helfer inkompatibel sin, ausgefiltert werden:

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>http://www.example.com/</loc>
  </url>
  <url>
    <loc>http://www.example.com/products</loc>
  </url>
  <url>
    <loc>http://www.example.com/products/server</loc>
  </url>
  <url>
    <loc>http://www.example.com/products/server/faq</loc>
  </url>
  <url>
    <loc>http://www.example.com/products/server/editions</loc>
  </url>
  <url>
    <loc>http://www.example.com/products/server/requirements</loc>
  </url>
  <url>
    <loc>http://www.example.com/products/studio</loc>
  </url>
  <url>
    <loc>http://www.example.com/products/studio/customers</loc>
  </url>
  <url>
    <loc>http://www.example.com/prodcts/studio/support</loc>
  </url>
  <url>
    <loc>http://www.example.com/company/about</loc>
  </url>
  <url>
    <loc>http://www.example.com/company/about/investors</loc>
  </url>
  <url>
    <loc>http://www.example.com/company/news</loc>
  </url>
  <url>
    <loc>http://www.example.com/company/news/press</loc>
  </url>
  <url>
    <loc>http://www.example.com/archive</loc>
  </url>
  <url>
    <loc>http://www.example.com/community</loc>
  </url>
  <url>
    <loc>http://www.example.com/community/account</loc>
  </url>
  <url>
    <loc>http://forums.example.com/</loc>
  </url>
</urlset>

Die Sitemap ohne Verwendung einer ACL Rolle darstellen (sollte /community/account ausfiltern):

echo $this->navigation()
          ->sitemap()
          ->setFormatOutput(true)
          ->setRole();

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>http://www.example.com/</loc>
  </url>
  <url>
    <loc>http://www.example.com/products</loc>
  </url>
  <url>
    <loc>http://www.example.com/products/server</loc>
  </url>
  <url>
    <loc>http://www.example.com/products/server/faq</loc>
  </url>
  <url>
    <loc>http://www.example.com/products/server/editions</loc>
  </url>
  <url>
    <loc>http://www.example.com/products/server/requirements</loc>
  </url>
  <url>
    <loc>http://www.example.com/products/studio</loc>
  </url>
  <url>
    <loc>http://www.example.com/products/studio/customers</loc>
  </url>
  <url>
    <loc>http://www.example.com/prodcts/studio/support</loc>
  </url>
  <url>
    <loc>http://www.example.com/company/about</loc>
  </url>
  <url>
    <loc>http://www.example.com/company/about/investors</loc>
  </url>
  <url>
    <loc>http://www.example.com/company/news</loc>
  </url>
  <url>
    <loc>http://www.example.com/company/news/press</loc>
  </url>
  <url>
    <loc>http://www.example.com/archive</loc>
  </url>
  <url>
    <loc>http://www.example.com/community</loc>
  </url>
  <url>
    <loc>http://forums.example.com/</loc>
  </url>
</urlset>

Darstellen der Sitemap mit Verwendung einer maximalen Tiefe von 1.

echo $this->navigation()
          ->sitemap()
          ->setFormatOutput(true)
          ->setMaxDepth(1);

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>http://www.example.com/</loc>
  </url>
  <url>
    <loc>http://www.example.com/products</loc>
  </url>
  <url>
    <loc>http://www.example.com/products/server</loc>
  </url>
  <url>
    <loc>http://www.example.com/products/studio</loc>
  </url>
  <url>
    <loc>http://www.example.com/company/about</loc>
  </url>
  <url>
    <loc>http://www.example.com/company/about/investors</loc>
  </url>
  <url>
    <loc>http://www.example.com/company/news</loc>
  </url>
  <url>
    <loc>http://www.example.com/community</loc>
  </url>
  <url>
    <loc>http://www.example.com/community/account</loc>
  </url>
  <url>
    <loc>http://forums.example.com/</loc>
  </url>
</urlset>

Navigation Helfer

Der Navigation Helfer ist ein Proxy Helfer der Aufrufe zu anderen Navigations Helfern durchführt. Er kann als Einstiegspunkt fpr alle navigations-basierenden View Tasks verwendet werden. Die vorher erwähnten Navigations Helfer sind im Namespace Zend_View_Helper_Navigation und würden es deshalb benötigen, den Pfad Zend/View/Helper/Navigation als Helfer Pfad der View hinzuzufügen. Mit dem Proxy Helfer der im Zend_View_Helper Namespace sitzt, ist er immer vorhanden, ohne das irgendein Helfer Pfad an der View hinzugefügt werden muß.

Der Navigations Helfer findet andere Helfer die das Zend_View_Helper_Navigation_Helper Interface implementieren, was bedeuet das auch auf eigene View Helfer weitergeleitet wird. Das würde trotzdem das Hinzufügen des eigenen Helfer Pfades zur View benötigen.

Wenn auf andere Helfer weitergeleitet wird, kann der Navigations Helfer seinen Container, ACL/Rolle und Übersetzer injizieren. Das bedeutet weder das man diese drei nicht explizit in allen navigatorischen Helfern setzen muß, noch das diese in Zend_Registry oder in statische Methoden injiziert werden muß.

findHelper() findet alle angegebenen Helfer, prüft das dieser ein navigatorischer Helfer ist, und injiziiert Container, ACL/Rolle und Übersetzer.
{get|set}InjectContainer() empfängt/setzt ein Flag das anzeigt ob der Container an weitergeleitete Helfer injiziiert werden soll. Der Standardwert ist true.
{get|set}InjectAcl() empfängt/setzt ein Flag das anzeigt ob die ACL/Rolle an weitergeleitete Helfer injiziiert werden soll. Der Standardwert ist true.
{get|set}InjectTranslator() empfängt/setzt ein Flag das anzeigt ob der Übersetzer an weitergeleitete Helfer injiziiert werden soll. Der Standardwert ist true.
{get|set}DefaultProxy() empfängt/setzt den Standard Proxy. Der Standardwert ist 'menu'.
render() leitet auf die render Methode des Standardproxies weiter.

Übersetzungs Helfer

Oft sind Webseiten in verschiedenen Sprachen vorhanden. Um den Inhalt einer Site zu übersetzen sollte ganz einfach Zend Translate verwendet werden, und um Zend Translate in der eigenen View zu integrieren sollte der Translate View Helfer verwendet werden.

In allen folgenden Beispielen verwenden wir den einfachen Array Übersetzungs Adapter. Natürlich kann jede Instanz von Zend_Translate und genauso jede Subklasse von Zend_Translate_Adapter verwendet werden. Es gibt verschiedene Wege den Translate View Helfer zu initiieren:

Registriert, durch eine vorher in Zend_Registry registrierte Instanz
Danach, durch das Fluent Interface
Direkt, durch Instanzierung der Klasse

Eine registrierte Instanz von Zend_Translate ist die bevorzugte Verwendung für diesen Helfer. Bevor der Adapter der Registry hinzugefügt wird, kann das zu verwendende Gebietsschema einfach ausgewählt werden.

Hinweis: Wir sprechen hier von Gebietsschemata (Locale) statt von Sprachen weil eine Sprache auch in verschiedenen Regionen vorhanden sein kann. Zum Beispiel wird Englisch in verschiedenen Dialekten gesprochen. Es könnte eine Übersetzung für Britisch und eine für Amerikanisches Englisch geben. Deswegen sagen wir Gebietsschema "locale" statt Sprache.

Beispiel #42 Registrierte Instanz

Um eine registrierte Instanz zu verwenden muß einfach eine Instanz von Zend_Translate oder Zend_Translate_Adapter erstellt werden und in Zend_Registry durch Verwendung des Schlüssels Zend_Translate registriert werden.

// unser Beispieladapter
$adapter = new Zend_Translate('array', array('simple' => 'einfach'), 'de');
Zend_Registry::set('Zend_Translate', $adapter);

// In der View
echo $this->translate('simple');
// gibt 'einfach' zurück

Wenn man mit dem Fluent Interface besser zurecht kommt, kann eine Instanz auch in der View erstellt werden und der Helfer im Nachhinein initiiert werden.

Beispiel #43 In der View

Um das Fluid Interface zu verwenden muß eine Instanz von Zend_Translate oder Zend_Translate_Adapter erstellt werden, der Helfer ohne Parameter und anschließend die setTranslator() Methode aufgerufen werden.

// in der View
$adapter = new Zend_Translate('array', array('simple' => 'einfach'), 'de');
$this->translate()->setTranslator($adapter)->translate('simple');
// das gibt 'einfach' zurück

Wenn der Helfer ohne Zend_View verwendet werden soll kann er auch direkt angesprochen werden.

Beispiel #44 Direkte Verwendung

// unser Beispieladapter
$adapter = new Zend_Translate('array', array('simple' => 'einfach'), 'de');

// den Helfer initiieren
$translate = new Zend_View_Helper_Translate($adapter);
print $translate->translate('simple'); // das gibt 'einfach' zurück

Dieser Weg kann verwendet werden wenn man nicht mit Zend_View arbeitet und übersetzte Ausgaben erzeugen muß.

Wie man bereits sehen konnte, wird die translate() Methode verwendet um die Übersetzung zurückzugeben. Sie muss nur mit der benötigten messageid des Übersetzungsadapters aufgerufen werden. Aber sie kann auch Parameter im Übersetzungsstring ersetzen. Deswegen akzeptiert Sie variable Parameter in zwei Wegen: entweder als Liste von Parametern, oder als Array von Parametern. Als Beispiel:

Beispiel #45 Einzelne Parameter

Um einen einzelnen Parameter zu verwenden muss dieser einfach der Methode angefügt werden.

// innerhalb der View
$date = "Montag";
$this->translate("Today is %1\$s", $date);
// könnte 'Heute ist Montag' zurückgeben

Hinweis: Wenn man Parameter verwendet die auch Text sind ist zu beachten das es auch nötig sein kann diese Parameter zu übersetzen.

Beispiel #46 Liste von Parametern

Oder eine Liste von Parametern verwenden und diese der Methode hinzufügen.

// innerhalb der View
$date = "Monday";
$month = "April";
$time = "11:20:55";
$this->translate("Today is %1\$s in %2\$s. Actual time: %3\$s",
                 $date,
                 $month,
                 $time);
// könnte 'Heute ist Monday in April. Aktuelle Zeit: 11:20:55' zurückgeben

Beispiel #47 Array von Parametern

Oder ein Array von Parametern verwenden und dieses der Methode hinzufügen.

// innerhalb der View
$date = array("Monday", "April", "11:20:55");
$this->translate("Today is %1\$s in %2\$s. Actual time: %3\$s", $date);
// könnte 'Heute ist Monday in April. Aktuelle Zeit: 11:20:55' zurückgeben

Manchmal ist es notwendig das Gebietsschema der Übersetzung zu Ändern. Das kann entweder dynamisch pro Übersetzung oder statisch für alle folgenden Übersetzungen durchgeführt werden. Dies kann mit beidem, einer Liste von Paramtern oder einem Array von Parametern, verwendet werden. In beiden Fällen muss das als letzter einzelner Parameter angegeben werden.

Beispiel #48 Das Gebietsschema dynamisch wechseln

// innerhalb der View
$date = array("Monday", "April", "11:20:55");
$this->translate("Today is %1\$s in %2\$s. Actual time: %3\$s", $date, 'it');

Dieses Beispiel gibt die italienische Übersetzung für die messageid zurück. Aber Sie wird nur einmal verwendet. Die nächste Übersetzung verwendet wieder das Gebietsschema des Adapters. Normalerweise wird das gewünschte Gebietsschema im Übersetzungsadapter gesetzt bevor dieser der Registry hinzugefügt wird. Das Gebietsschema kann aber auch im Helfer gesetzt werden:

Beispiel #49 Das Gebietsschema statisch wechseln

// innerhalb der View
$date = array("Monday", "April", "11:20:55");
$this->translate()->setLocale('it');
$this->translate("Today is %1\$s in %2\$s. Actual time: %3\$s", $date);

Das obige Beispiel setzt 'it' als neues standardmäßiges Gebietsschema welches für alle weiteren Übersetzungen verwendet wird.

Natürlich gibt es auch eine getLocale() Methode um das aktuell gesetzte Gebietsschema zu erhalten.

Beispiel #50 Das aktuell gesetzte Gebietsschema erhalten

// innerhalb der View
$date = array("Monday", "April", "11:20:55");

// gibt 'de' als standardmäßig gesetztes Gebietsschema
// vom obigen Beispiel zurück
$this->translate()->getLocale();

$this->translate()->setLocale('it');
$this->translate("Today is %1\$s in %2\$s. Actual time: %3\$s", $date);

// gibt 'it' als neues standardmäßig gesetztes Gebietsschema zurück
$this->translate()->getLocale();

Helfer Pfade

Wie bei den View Skripten kann der Controller für Zend_View auch einen Stapel an Pfaden festlegen, in dem nach Hilfsklassen gesucht werden soll. Standardmäßig sucht Zend_View in "Zend/View/Helper/*" nach Hilfsklassen. Du kannst Zend_View mit Hilfe der Methoden setHelperPath() und addHelperPath() mitteilen, auch in anderen Verzeichnissen zu suchen. Zusätzlich kann man einen Klassenpräfix angeben, um Helfer in dem bereit gestellten Pfad verwenden zu können, um eigene Namensräume für die Helferklassen zu verwenden. Standardmäßig wird 'Zend_View_Helper_' angenommen, wenn kein Präfix angegeben wird.

$view = new Zend_View();

// Setze den Pfad auf /path/to/more/helpers, mit dem Präfix 'My_View_Helper'
$view->setHelperPath('/path/to/more/helpers', 'My_View_Helper');

Durch Verwendung der addHelperPath() Methode können die Pfade "gestapelt" werden. Wenn du Pfade zu diesem Stapelspeicher hinzufügst, wird Zend_View im zuletzt hinzugefügten Pfad nach der angeforderten Hilfsklasse schauen. Dies erlaubt dir, zu den vorhandenen Helfern weitere hinzufügen oder diese durch eigene zu ersetzen.

$view = new Zend_View();
// Füge /path/to/some/helpers mit Klassenpräfix 'My_View_Helper' hinzu
$view->addHelperPath('/path/to/some/helpers', 'My_View_Helper');
// Füge /other/path/to/helpers mit Klassenpräfix 'Your_View_Helper' hinzu
$view->addHelperPath('/other/path/to/helpers', 'Your_View_Helper');

// wenn nun $this->helperName() aufgerufen wird, wird Zend_View zuerst nach
// "/path/to/some/helpers/HelperName" mit dem Klassennamen
// "Your_View_Helper_HelperName", dann nach
// "/other/path/to/helpers/HelperName.php" mit dem Klassennamen
// "My_View_Helper_HelperName", und zuletzt nach
// "Zend/View/Helpers/HelperName.php" mit dem Klassennamen
// "Zend_View_Helper_HelperName" schauen.

Eigene Helfer schreiben

Eigene Helfer zu schreiben ist einfach; du mußt nur diese Regeln befolgen:

Wärend das nicht strikt notwendig ist, ist es empfohlen entweder Zend_View_Helper_Interface zu implementieren oder Zend_View_Helper_Abstract zu erweitern wenn eigene Helfer erstellt werden. Eingeführt mit 1.6.0, definieren diese einfach die setView() Methode; trotzdem, in kommenden Releases, ist es geplant ein Strategy Pattern zu implementieren das vieles der Namensschemas einfacher mach wie anbei beschrieben. Wenn darauf aufgebaut wird hilft das, das der eigene Code Zukunftssicher ist.
Der Klassenname muss mindestens auf den Helfernamen unter Verwendung der MixedCaps selber enden. Wenn du z.B. einen Helfer mit Namen "specialPurpose" schreibst, muss der Klassenname mindestens "SpecialPurpose" lauten. Man kann, und sollte, dem Klassennamen einen Präfix geben und es wird empfohlen, 'View_Helper' als Teil des Präfix zu verwenden: "My_View_Helper_SpecialPurpose" (man muss den Präfix mit oder oder abschließenden Unterstrich an addHelperPath() oder setHelperPath() übergeben).
Die Klasse muss eine öffentliche Methode mit dem Namen des Helfers haben. Dies ist die Methode, welche vom View Skript durch "$this->specialPurpose()" aufgerufen wird. In unserem "specialPurpose" Beispiel, würde die notwendige Deklaration dieser Methode "public function specialPurpose()" lauten.
Im Allgemeinen sollte die Klasse keine Ausgaben durch echo(), print() oder auf andere Weise erstellen. Stattdessen sollte es die auszugebenen Werte zurückgeben. Die zurückgegebenen Werte sollten entsprechend maskiert werden.
Diese Klasse muss sich in einer Datei befinden, die nach der Helfermethode benannt ist. Bezogen auf unser "specialPurpose" Beispiel, muss der Dateiname "SpecialPurpose.php" lauten.

Platziere die Hilfsklasse irgendwo in deinem Stapelspeicher für Hilfspfade und Zend_View wird den Helfer automatisch für dich laden, instanziieren, speichern und ausführen.

Hier ist ein Beispiel für unseren SpecialPurpose Helfer:

class My_View_Helper_SpecialPurpose extends Zend_View_Helper_Abstract
{
    protected $_count = 0;
    public function specialPurpose()
    {
        $this->_count++;
        $output = "Ich habe 'The Jerk' {$this->_count} Mal(e) gesehen.";
        return htmlspecialchars($output);
    }
}

Dann rufst du in einem View Skript den SpecialPurpose Helfer so oft auf, wie du möchtest; er wird einmal instanziiert und bleibt für die Lebensdauer der Zend_View Instanz bestehen.

// denke daran, dass $this in deinem View Skript auf die
// Zend_View Instanz verweist.
echo $this->specialPurpose();
echo $this->specialPurpose();
echo $this->specialPurpose();

Die Ausgabe wird in etwa so aussehen:

Ich habe 'The Jerk' 1 Mal(e) gesehen.
Ich habe 'The Jerk' 2 Mal(e) gesehen.
Ich habe 'The Jerk' 3 Mal(e) gesehen.

Hier und da ist es notwendig das aufrufende Zend_View Objekt aufzurufen -- zum Beispiel, wenn es notwendig ist die registrierte Verschöüsselung zu verwenden, oder wenn ein anderes View Skript gerendert werden soll, als Teil des eigenen Helfers. Um Zugriff zum View Objekt zu erhalten, sollte die eigene Helfer Klasse eine setView($view) Methode wie folgt besitzen:

class My_View_Helper_ScriptPath
{
    public $view;

    public function setView(Zend_View_Interface $view)
    {
        $this->view = $view;
    }

    public function scriptPath($script)
    {
        return $this->view->getScriptPath($script);
    }
}

Wenn die Helfer Klasse eine setView() Methode hat, wird diese aufgerufen wenn die Helfer Klasse das erste Mal instanziert wird, und das aktuelle View Objekt übergeben wird. Es liegt an einem selbst das Objekt in der Klasse zu fixieren, genau so wie herauszufinden wie auf dieses zugegriffen werden sollte.

Wenn Zend_View_Helper_Abstract erweitert wird, muß diese Methode nicht selbst definiert werden da Sie schon vordefiniert ist.

View Scripte

Zend_View
Referenzhandbuch für Programmierer

Zend_View_Abstract