Um einen Dekorator zu konfigurieren, kann ein Array von Optionen, oder ein Zend_Config Objekt an dessen Konstruktor übergeben werden, ein Array an setOptions(), oder ein Zend_Config Objekt an setConfig().

Die Standard Optionen beinhalten:

• placement: Die Platzierung kann entweder 'append' oder 'prepend' sein (unabhängig von der Schreibweise), und definiert ob der Inhalt der render() übergeben wird, angehängt oder vorangestellt wird. Im Fall das ein Dekorator den Inhalt ersetzt wird diese Einstellung ignoriert. Der Standardwert ist anhängen.

• separator: Der Separator wird zwischen dem Inhalt der an render() übergeben wird und durch den Dekorator neu erstelltem Inhalt verwendet, oder zwischen Teilen die durch den Dekorator dargestellt werden (z.B. FormElements verwenden Seperatoren zwischen jedem dargestellten Teil). Im Fall das ein Dekoratpr den Inhalt ersetzt, wird diese Einstellung ignoriert. Der Standardwert ist PHP_EOL.

Das Dekorator Interface spezifiziert Methoden für die Interaktion mit Optionen. Diese beinhalten:

• setOption($key, $value): setzt eine einzelne Option.

• getOption($key): eine einzelne Optionswert erhalten.

• getOptions(): alle Optionen erhalten.

• removeOption($key): eine einzelne Option entfernen.

• clearOptions(): alle Optionen entfernen.

Dekoratore sollen mit den verschiedenen Zend_Form Klassentypen interagieren: Zend_Form, Zend_Form_Element, Zend_Form_DisplayGroup, und allen von Ihnen abgeleiteten Klassen. Die Methode setElement() erlaubt es das Objekt des Dekorators mit den aktuell gearbeitet wird, zu setzen und getElement() wird verwendet um es zu empfangen.

Die render() Methode jeden Dekorators akzeptiert einen String $content. Wenn der erste Dekorator aufgerufen wird, ist dieser String typischerweise leer, wärend er bei nachfolgenden Aufrufen bekannt sein wird. Basierend auf dem Typ des Dekorators und den Ihm übergebenen Optionen, wird der Dekorator entweder diesen String ersetzen, den String voranstellen oder den String anfügen; ein optionaler Separator wird in den späteren zwei Siturationen verwendet.

Zend_Form wird mit vielen Standard Dekoratoren ausgeliefert; siehe das Kapitel über Standard Dekorator für Details.

Wenn man der Meinung ist das die Notwendigkeiten der Darstellung sehr komplex sind oder starke Anpassungen benötigt, sollte man an die Erstellung eines eigenen Dekorators überlegen.

Dekoratore implementieren nur Zend_Decorator_Interface. Das Interface spezifiziert folgendes:

interface Zend_Decorator_Interface
{
    public function __construct($options = null);
    public function setElement($element);
    public function getElement();
    public function setOptions(array $options);
    public function setConfig(Zend_Config $config);
    public function setOption($key, $value);
    public function getOption($key);
    public function getOptions();
    public function removeOption($key);
    public function clearOptions();
    public function render($content);
}

        

Um das einfacher zu machen, kann man einfach Zend_Decorator_Abstract erweitern, welches alle Methoden außer render() implementiert.

Als Beispiel nehmen wir an das wir die Anzahl an verwendeten Dekoratoren verringern will, und einen "gemeinsamen" Dekorator erstellt der die Darstellung von Label, Element, jegliche Fehlermeldung, und Beschreibung in einem HTML div übernimmt. So ein 'Gemeinsamer' Dekorator kann wie folgt erstellt werden:

class My_Decorator_Composite extends Zend_Form_Decorator_Abstract
{
    public function buildLabel()
    {
        $element = $this->getElement();
        $label = $element->getLabel();
        if ($translator = $element->getTranslator()) {
            $label = $translator->translate($label);
        }
        if ($element->isRequired()) {
            $label .= '*';
        }
        $label .= ':';
        return $element->getView()
                       ->formLabel($element->getName(), $label);
    }

    public function buildInput()
    {
        $element = $this->getElement();
        $helper  = $element->helper;
        return $element->getView()->$helper(
            $element->getName(),
            $element->getValue(),
            $element->getAttribs(),
            $element->options
        );
    }

    public function buildErrors()
    {
        $element  = $this->getElement();
        $messages = $element->getMessages();
        if (empty($messages)) {
            return '';
        }
        return '<div class="errors">' .
               $element->getView()->formErrors($messages) . '</div>';
    }

    public function buildDescription()
    {
        $element = $this->getElement();
        $desc    = $element->getDescription();
        if (empty($desc)) {
            return '';
        }
        return '<div class="description">' . $desc . '</div>';
    }

    public function render($content)
    {
        $element = $this->getElement();
        if (!$element instanceof Zend_Form_Element) {
            return $content;
        }
        if (null === $element->getView()) {
            return $content;
        }

        $separator = $this->getSeparator();
        $placement = $this->getPlacement();
        $label     = $this->buildLabel();
        $input     = $this->buildInput();
        $errors    = $this->buildErrors();
        $desc      = $this->buildDescription();

        $output = '<div class="form element">'
                . $label
                . $input
                . $errors
                . $desc
                . '</div>'

        switch ($placement) {
            case (self::PREPEND):
                return $output . $separator . $content;
            case (self::APPEND):
            default:
                return $content . $separator . $output;
        }
    }
}

        

Das kann das in den Dekorator Pfad platziert werden:

// für ein Element:
$element->addPrefixPath('My_Decorator',
                        'My/Decorator/',
                        'decorator');

// für alle Elemente:
$form->addElementPrefixPath('My_Decorator',
                            'My/Decorator/',
                            'decorator');

        

Man kann dann diesen Dekorator als 'Gemeinsam' spezifizieren und diesen an ein Element anfügen:

// Überschreibe existierende Dekoratoren mit diesem einzelnen:
$element->setDecorators(array('Composite'));

        

Wärend dieses Beispiel zeigt wie ein Dekorator erstellt werden kann der komplexe Ausgaben von verschiedenen Element-Eigenschaften darstellt können auch Dekoratore erstellt werden die einzelne Aspekte eines Elements handhaben; die 'Decorator' und 'Label' Dekoratore sind exzellente Beispiele dieser Praxis. Das erlaubt es Dekotatore zu mischen und zu anzupassen um komplexe Ausgaben zu erhalten -- und auch die Überladung von einzelnen Aspekten der Dekoration für die Anpassung an eigene Bedürfnisse.

Wenn man ,zum Beispiel, eine einfache Anzeige benötigt, das ein Fehler aufgetreten ist wären ein Element überprüft wurde, aber nicht jede der individuellen Validator Fehlermeldungen angezeigt werden soll, kann ein eigener 'Errors' Dekorator erstellt werden:

class My_Decorator_Errors
{
    public function render($content = '')
    {
        $output = '<div class="errors">Der angegebene Wert war ungültig;
            bitte nochmals versuchen</div>';

        $placement = $this->getPlacement();
        $separator = $this->getSeparator();

        switch ($placement) {
            case 'PREPEND':
                return $output . $separator . $content;
            case 'APPEND':
            default:
                return $content . $separator . $output;
        }
    }
}

        

In diesem speziellen Beispiel, weil das letzte Segment, 'Errors', des Dekorators auf Zend_Form_Decorator_Errors passt wird er statt diesem Dekorator dargestellt -- was bedeutet das kein Dekorator verändert werden muß um die Ausgabe anzupassen. Durch die Benennung des Dekorators nach dem bestehenden Standard Dekorator, kann die Dekoration verändert werden ohne das der Dekorator des Elements verändert werden muß.