Créer un visuel personnalisé en utilisant Zend_Form_Decorator

Rendre visuellement un objet de formulaire est complètement optionnel -- il n'est pas obligatoire d'utiliser la méthode render() de Zend_Form. Cependant, si vous l'utilisez, alors des décorateurs sont utilisés pour rendre les différents objets du formulaire.

Un nombre arbitraire de décorateurs peut être attaché à chaque objet du formulaire (élément, groupe d'affichage, sous-formulaires ou encore l'objet formulaire lui-même) ; cependant seul un décorateur par type peut être attaché. Les décorateurs sont appelés dans l'ordre dans lequel ils ont été enregistrés. En fonction du décorateur en question, celui-ci peut remplacer le contenu qui lui est passé, ou alors le faire précédé ou suivre.

La configuration du décorateur est effectuée via son constructeur ou sa méthode setOptions(). Lorsque vous créez des décorateurs au travers de méthodes comme addDecorator(), alors sa configuration doit être passée en tant que tableau à ladite méthode. Ces options de configuration peuvent être utilisées pour indiquer le placement du décorateur, le séparateur inter-éléments ou toute autre option acceptable.

Avant le rendu d'un décorateur, au travers de sa méthode render(), l'objet sur lequel il agit lui est passé en argument, grâce à setElement(), et ainsi le décorateur peut piloter l'élément sur lequel il agit. Ceci permet de créer des décorateurs qui n'agissent que sur un petit paramètre de l'élément auquel ils sont rattachés, comme le label, les messages d'erreur, etc... En chaînant des décorateurs qui rendent chacun individuellement un petit morceau d'un élément, vous pouvez créer une mise en forme complexe représentant l'objet (élément) dans son intégralité.

Configuration

Pour configurer un décorateur, passez un tableau d'options ou un objet Zend_Config à son constructeur. Aussi, un tableau peut être passé à setOptions(), ou un objet Zend_Config à setConfig().

Options de base:

  • placement : le placement peut être 'append' ou 'prepend' (insensible à la casse), et indique sur le contenu passé à render() doit être ajouté après ou avant, respectivement. Dans le cas où le décorateur remplace le contenu, cette directive de placement est ignorée. La directive par défaut est 'append'.

  • separator : le séparateur est utilisé entre le contenu passé à render() et le nouveau contenu généré par le décorateur, ou encore entre les éléments rendus (par exemple FormElements utilise le séparateur entre chaque objet rendu). Dans le cas où le décorateur remplace son contenu, cette option est ignorée. Par défaut, elle vaut PHP_EOL.

L'interface des décorateurs spécifie les méthodes pour agir sur les options. Les voici :

  • setOption($key, $value) : affecte une option.

  • getOption($key) : récupère une option.

  • getOptions() : récupère toutes les options.

  • removeOption($key) : supprime une option.

  • clearOptions() : supprime toutes les options.

Les décorateurs sont destinés à agir avec tous les objets du formulaire, Zend_Form, Zend_Form_Element, Zend_Form_DisplayGroup, et toute classe en dérivant. La méthode setElement() vous permet de passer l'objet au décorateur sur lequel il travaille. getElement() vous permet de récupérer cet objet depuis le décorateur.

Chaque méthode render() des décorateurs accepte en paramètre une chaîne $content. Lorsque le premier décorateur est appelé, cette chaîne est en toute logique vide, alors que tous les appels successifs travailleront sur le contenu précédent. Selon le type de décorateur et ses options, la chaîne sera alors remplacée, précédée ou suivie du nouveau contenu décoré. Dans ces deux derniers cas, un séparateur optionnel peut être utilisé.

Décorateurs standards

Zend_Form est fourni avec quelques décorateurs de base, voyez le chapitre sur les décorateurs standards pour plus de détails.

Décorateurs personnalisés

Si vos rendus HTML sont complexes, ou si vous avez besoin de beaucoup de personnalisation, vous pouvez alors créer vos propres décorateurs.

Les décorateurs ont juste besoin d'implémenter l'interface Zend_Form_Decorator_Interface. Celle-ci spécifie les méthodes suivantes :

  1. interface Zend_Form_Decorator_Interface
  2. {
  3.     public function __construct($options = null);
  4.     public function setElement($element);
  5.     public function getElement();
  6.     public function setOptions(array $options);
  7.     public function setConfig(Zend_Config $config);
  8.     public function setOption($key, $value);
  9.     public function getOption($key);
  10.     public function getOptions();
  11.     public function removeOption($key);
  12.     public function clearOptions();
  13.     public function render($content);
  14. }

Pour vous simplifier la tâche, vous pourriez considérer le fait d'étendre Zend_Form_Decorator_Abstract, qui implémente toutes les méthodes de l'interface sauf render().

Par exemple, imaginons que vous ne souhaitiez pas vous encombrer avec un nombre important de décorateurs, et que vous vouliez afficher les principale caractéristiques d'un élément grâce à un seul décorateur (label, élément, messages d'erreur et description), le tout dans une div. Voici comment vous pourriez procéder :

  1. class My_Decorator_Composite extends Zend_Form_Decorator_Abstract
  2. {
  3.     public function buildLabel()
  4.     {
  5.         $element = $this->getElement();
  6.         $label = $element->getLabel();
  7.         if ($translator = $element->getTranslator()) {
  8.             $label = $translator->translate($label);
  9.         }
  10.         if ($element->isRequired()) {
  11.             $label .= '*';
  12.         }
  13.         $label .= ':';
  14.         return $element->getView()
  15.                        ->formLabel($element->getName(), $label);
  16.     }
  17.  
  18.     public function buildInput()
  19.     {
  20.         $element = $this->getElement();
  21.         $helper  = $element->helper;
  22.         return $element->getView()->$helper(
  23.             $element->getName(),
  24.             $element->getValue(),
  25.             $element->getAttribs(),
  26.             $element->options
  27.         );
  28.     }
  29.  
  30.     public function buildErrors()
  31.     {
  32.         $element  = $this->getElement();
  33.         $messages = $element->getMessages();
  34.         if (empty($messages)) {
  35.             return '';
  36.         }
  37.         return '<div class="errors">' .
  38.                $element->getView()->formErrors($messages) . '</div>';
  39.     }
  40.  
  41.     public function buildDescription()
  42.     {
  43.         $element = $this->getElement();
  44.         $desc    = $element->getDescription();
  45.         if (empty($desc)) {
  46.             return '';
  47.         }
  48.         return '<div class="description">' . $desc . '</div>';
  49.     }
  50.  
  51.     public function render($content)
  52.     {
  53.         $element = $this->getElement();
  54.         if (!$element instanceof Zend_Form_Element) {
  55.             return $content;
  56.         }
  57.         if (null === $element->getView()) {
  58.             return $content;
  59.         }
  60.  
  61.         $separator = $this->getSeparator();
  62.         $placement = $this->getPlacement();
  63.         $label     = $this->buildLabel();
  64.         $input     = $this->buildInput();
  65.         $errors    = $this->buildErrors();
  66.         $desc      = $this->buildDescription();
  67.  
  68.         $output = '<div class="form element">'
  69.                 . $label
  70.                 . $input
  71.                 . $errors
  72.                 . $desc
  73.                 . '</div>'
  74.  
  75.         switch ($placement) {
  76.             case (self::PREPEND):
  77.                 return $output . $separator . $content;
  78.             case (self::APPEND):
  79.             default:
  80.                 return $content . $separator . $output;
  81.         }
  82.     }
  83. }

Vous pouvez maintenant placer ce décorateur dans les chemins des décorateurs :

  1. // pour un élément:
  2. $element->addPrefixPath('My_Decorator',
  3.                         'My/Decorator/',
  4.                         'decorator');
  5.  
  6. // pour tous les éléments:
  7. $form->addElementPrefixPath('My_Decorator',
  8.                             'My/Decorator/',
  9.                             'decorator');

Dès à présent, vous pouvez indiquer que vous voulez utiliser le décorateur 'Composite', (c'est son nom de classe sans le préfixe) et l'attacher à un élément :

  1. // Ecrase les éventuels décorateurs de cet élément avec le notre:
  2. $element->setDecorators(array('Composite'));

Cet exemple vous montre comment rendre un contenu HTML complexe à partir de propriétés d'un élément, en une seule passe. Il existe des décorateurs qui ne s'occupent que d'une propriété de l'élément auquel ils sont rattachés, 'Errors' et 'Label' en sont d'excellents exemples qui permettent un placement fin.

Par exemple, si vous souhaitez simplement informer l'utilisateur d'une erreur, mais sans lui montrer les messages d'erreurs, vous pouvez créer votre propre décorateur 'Errors' :

  1. class My_Decorator_Errors
  2. {
  3.     public function render($content = '')
  4.     {
  5.         $output = '<div class="errors">La valeur est invalide, rééssayez</div>';
  6.  
  7.         $placement = $this->getPlacement();
  8.         $separator = $this->getSeparator();
  9.  
  10.         switch ($placement) {
  11.             case 'PREPEND':
  12.                 return $output . $separator . $content;
  13.             case 'APPEND':
  14.             default:
  15.                 return $content . $separator . $output;
  16.         }
  17.     }
  18. }

Dans cet exemple particulier, comme le segment final du nom de la classe, 'Errors', respecte la syntaxe de Zend_Form_Decorator_Errors, il sera alors utilisé à la place du décorateur par défaut -- ceci signifie que vous n'avez pas besoin de l'injecter dans un élément particulier. En nommant vos fins de classes de décorateurs comme celles des décorateurs standards, vous pouvez changer la décoration sans agir sur les éléments en question.

Rendre des décorateurs individuellement

Comme les décorateurs agissent souvent sur une propriété d'un élément, et en fonction de la décoration précédente, il peut être utile d'afficher juste le rendu d'un décorateur particulier, sur un élément. Ceci est possible par la surcharge des méthodes dans les classes principales de Zend_Form (formulaires, sous-formulaires, groupes d'affichage, éléments).

Pour effectuer ceci, appelez simplement render[nom-du-décorateur](), où "[nom-du-décorateur]" est le nom court de votre décorateur (sans son préfixe de classe). Il est aussi possible de lui passer optionnellement du contenu, par exemple :

  1. // rend juste le décorateur Label de cet élément:
  2. echo $element->renderLabel();
  3.  
  4. // Rend juste le décorateur Fieldset, en lui passant du contenu:
  5. echo $group->renderFieldset('fieldset content');
  6.  
  7. // rend juste le tag HTML du formulaire, avec du contenu:
  8. echo $form->renderHtmlTag('wrap this content');

Si le décorateur n'existe pas, une exception sera levée.

Ceci peut être particulièrement utile lors du rendu d'un formulaire avec le décorateur ViewScript ; là où chaque élément utilise ses décorateurs pour rendre du contenu, mais de manière très fine.

blog comments powered by Disqus