lib/pear/HTML/QuickForm/Renderer/Default.php

   1 <?php
   2 /* vim: set expandtab tabstop=4 shiftwidth=4: */
   3 // +----------------------------------------------------------------------+
   4 // | PHP version 4.0                                                      |
   5 // +----------------------------------------------------------------------+
   6 // | Copyright (c) 1997-2003 The PHP Group                                |
   7 // +----------------------------------------------------------------------+
   8 // | This source file is subject to version 2.0 of the PHP license,       |
   9 // | that is bundled with this package in the file LICENSE, and is        |
  10 // | available at through the world-wide-web at                           |
  11 // | http://www.php.net/license/2_02.txt.                                 |
  12 // | If you did not receive a copy of the PHP license and are unable to   |
  13 // | obtain it through the world-wide-web, please send a note to          |
  14 // | license@php.net so we can mail you a copy immediately.               |
  15 // +----------------------------------------------------------------------+
  16 // | Authors: Alexey Borzov <borz_off@cs.msu.su>                          |
  17 // |          Adam Daniel <adaniel1@eesus.jnj.com>                        |
  18 // |          Bertrand Mansion <bmansion@mamasam.com>                     |
  19 // +----------------------------------------------------------------------+
  20 //
  21 // $Id$
  22
  23 require_once('HTML/QuickForm/Renderer.php');
  24
  25 /**
  26  * A concrete renderer for HTML_QuickForm,
  27  * based on QuickForm 2.x built-in one
  28  *
  29  * @access public
  30  */
  31 class HTML_QuickForm_Renderer_Default extends HTML_QuickForm_Renderer
  32 {
  33    /**
  34     * The HTML of the form
  35     * @var      string
  36     * @access   private
  37     */
  38     var $_html;
  39
  40    /**
  41     * Header Template string
  42     * @var      string
  43     * @access   private
  44     */
  45     var $_headerTemplate =
  46         "\n\t<tr>\n\t\t<td style=\"white-space: nowrap; background-color: #CCCCCC;\" align=\"left\" valign=\"top\" colspan=\"2\"><b>{header}</b></td>\n\t</tr>";
  47
  48    /**
  49     * Element template string
  50     * @var      string
  51     * @access   private
  52     */
  53     var $_elementTemplate =
  54         "\n\t<tr>\n\t\t<td align=\"right\" valign=\"top\"><!-- BEGIN required --><span style=\"color: #ff0000\">*</span><!-- END required --><b>{label}</b></td>\n\t\t<td valign=\"top\" align=\"left\"><!-- BEGIN error --><span style=\"color: #ff0000\">{error}</span><br /><!-- END error -->\t{element}</td>\n\t</tr>";
  55
  56    /**
  57     * Form template string
  58     * @var      string
  59     * @access   private
  60     */
  61     var $_formTemplate =
  62         "\n<form{attributes}>\n<div>\n{hidden}<table border=\"0\">\n{content}\n</table>\n</div>\n</form>";
  63
  64    /**
  65     * Required Note template string
  66     * @var      string
  67     * @access   private
  68     */
  69     var $_requiredNoteTemplate =
  70         "\n\t<tr>\n\t\t<td></td>\n\t<td align=\"left\" valign=\"top\">{requiredNote}</td>\n\t</tr>";
  71
  72    /**
  73     * Array containing the templates for customised elements
  74     * @var      array
  75     * @access   private
  76     */
  77     var $_templates = array();
  78
  79    /**
  80     * Array containing the templates for group wraps.
  81     *
  82     * These templates are wrapped around group elements and groups' own
  83     * templates wrap around them. This is set by setGroupTemplate().
  84     *
  85     * @var      array
  86     * @access   private
  87     */
  88     var $_groupWraps = array();
  89
  90    /**
  91     * Array containing the templates for elements within groups
  92     * @var      array
  93     * @access   private
  94     */
  95     var $_groupTemplates = array();
  96
  97    /**
  98     * True if we are inside a group
  99     * @var      bool
 100     * @access   private
 101     */
 102     var $_inGroup = false;
 103
 104    /**
 105     * Array with HTML generated for group elements
 106     * @var      array
 107     * @access   private
 108     */
 109     var $_groupElements = array();
 110
 111    /**
 112     * Template for an element inside a group
 113     * @var      string
 114     * @access   private
 115     */
 116     var $_groupElementTemplate = '';
 117
 118    /**
 119     * HTML that wraps around the group elements
 120     * @var      string
 121     * @access   private
 122     */
 123     var $_groupWrap = '';
 124
 125    /**
 126     * HTML for the current group
 127     * @var      string
 128     * @access   private
 129     */
 130     var $_groupTemplate = '';
 131
 132    /**
 133     * Collected HTML of the hidden fields
 134     * @var      string
 135     * @access   private
 136     */
 137     var $_hiddenHtml = '';
 138
 139    /**
 140     * Constructor
 141     *
 142     * @access public
 143     */
 144     function HTML_QuickForm_Renderer_Default()
 145     {
 146         $this->HTML_QuickForm_Renderer();
 147     } // end constructor
 148
 149    /**
 150     * returns the HTML generated for the form
 151     *
 152     * @access public
 153     * @return string
 154     */
 155     function toHtml()
 156     {
 157         // _hiddenHtml is cleared in finishForm(), so this only matters when
 158         // finishForm() was not called (e.g. group::toHtml(), bug #3511)
 159         return $this->_hiddenHtml . $this->_html;
 160     } // end func toHtml
 161
 162    /**
 163     * Called when visiting a form, before processing any form elements
 164     *
 165     * @param    object      An HTML_QuickForm object being visited
 166     * @access   public
 167     * @return   void
 168     */
 169     function startForm(&$form)
 170     {
 171         $this->_html = '';
 172         $this->_hiddenHtml = '';
 173     } // end func startForm
 174
 175    /**
 176     * Called when visiting a form, after processing all form elements
 177     * Adds required note, form attributes, validation javascript and form content.
 178     *
 179     * @param    object      An HTML_QuickForm object being visited
 180     * @access   public
 181     * @return   void
 182     */
 183     function finishForm(&$form)
 184     {
 185         // add a required note, if one is needed
 186         if (!empty($form->_required) && !$form->_freezeAll) {
 187             $this->_html .= str_replace('{requiredNote}', $form->getRequiredNote(), $this->_requiredNoteTemplate);
 188         }
 189         // add form attributes and content
 190         $html = str_replace('{attributes}', $form->getAttributes(true), $this->_formTemplate);
 191         if (strpos($this->_formTemplate, '{hidden}')) {
 192             $html = str_replace('{hidden}', $this->_hiddenHtml, $html);
 193         } else {
 194             $this->_html .= $this->_hiddenHtml;
 195         }
 196         $this->_hiddenHtml = '';
 197         $this->_html = str_replace('{content}', $this->_html, $html);
 198         // add a validation script
 199         if ('' != ($script = $form->getValidationScript())) {
 200             $this->_html = $script . "\n" . $this->_html;
 201         }
 202     } // end func finishForm
 203
 204    /**
 205     * Called when visiting a header element
 206     *
 207     * @param    object     An HTML_QuickForm_header element being visited
 208     * @access   public
 209     * @return   void
 210     */
 211     function renderHeader(&$header)
 212     {
 213         $name = $header->getName();
 214         if (!empty($name) && isset($this->_templates[$name])) {
 215             $this->_html .= str_replace('{header}', $header->toHtml(), $this->_templates[$name]);
 216         } else {
 217             $this->_html .= str_replace('{header}', $header->toHtml(), $this->_headerTemplate);
 218         }
 219     } // end func renderHeader
 220
 221    /**
 222     * Helper method for renderElement
 223     *
 224     * @param    string      Element name
 225     * @param    mixed       Element label (if using an array of labels, you should set the appropriate template)
 226     * @param    bool        Whether an element is required
 227     * @param    string      Error message associated with the element
 228     * @access   private
 229     * @see      renderElement()
 230     * @return   string      Html for element
 231     */
 232     function _prepareTemplate($name, $label, $required, $error)
 233     {
 234         if (is_array($label)) {
 235             $nameLabel = array_shift($label);
 236         } else {
 237             $nameLabel = $label;
 238         }
 239         if (isset($this->_templates[$name])) {
 240             $html = str_replace('{label}', $nameLabel, $this->_templates[$name]);
 241         } else {
 242             $html = str_replace('{label}', $nameLabel, $this->_elementTemplate);
 243         }
 244         if ($required) {
 245             $html = str_replace('<!-- BEGIN required -->', '', $html);
 246             $html = str_replace('<!-- END required -->', '', $html);
 247         } else {
 248             $html = preg_replace("/([ \t\n\r]*)?<!-- BEGIN required -->(\s|\S)*<!-- END required -->([ \t\n\r]*)?/iU", '', $html);
 249         }
 250         if (isset($error)) {
 251             $html = str_replace('{error}', $error, $html);
 252             $html = str_replace('<!-- BEGIN error -->', '', $html);
 253             $html = str_replace('<!-- END error -->', '', $html);
 254         } else {
 255             $html = preg_replace("/([ \t\n\r]*)?<!-- BEGIN error -->(\s|\S)*<!-- END error -->([ \t\n\r]*)?/iU", '', $html);
 256         }
 257         if (is_array($label)) {
 258             foreach($label as $key => $text) {
 259                 $key  = is_int($key)? $key + 2: $key;
 260                 $html = str_replace("{label_{$key}}", $text, $html);
 261                 $html = str_replace("<!-- BEGIN label_{$key} -->", '', $html);
 262                 $html = str_replace("<!-- END label_{$key} -->", '', $html);
 263             }
 264         }
 265         if (strpos($html, '{label_')) {
 266             $html = preg_replace('/\s*<!-- BEGIN label_(\S+) -->.*<!-- END label_\1 -->\s*/i', '', $html);
 267         }
 268         return $html;
 269     } // end func _prepareTemplate
 270
 271    /**
 272     * Renders an element Html
 273     * Called when visiting an element
 274     *
 275     * @param object     An HTML_QuickForm_element object being visited
 276     * @param bool       Whether an element is required
 277     * @param string     An error message associated with an element
 278     * @access public
 279     * @return void
 280     */
 281     function renderElement(&$element, $required, $error)
 282     {
 283         if (!$this->_inGroup) {
 284             $html = $this->_prepareTemplate($element->getName(), $element->getLabel(), $required, $error);
 285             $this->_html .= str_replace('{element}', $element->toHtml(), $html);
 286
 287         } elseif (!empty($this->_groupElementTemplate)) {
 288             $html = str_replace('{label}', $element->getLabel(), $this->_groupElementTemplate);
 289             if ($required) {
 290                 $html = str_replace('<!-- BEGIN required -->', '', $html);
 291                 $html = str_replace('<!-- END required -->', '', $html);
 292             } else {
 293                 $html = preg_replace("/([ \t\n\r]*)?<!-- BEGIN required -->(\s|\S)*<!-- END required -->([ \t\n\r]*)?/iU", '', $html);
 294             }
 295             $this->_groupElements[] = str_replace('{element}', $element->toHtml(), $html);
 296
 297         } else {
 298             $this->_groupElements[] = $element->toHtml();
 299         }
 300     } // end func renderElement
 301
 302    /**
 303     * Renders an hidden element
 304     * Called when visiting a hidden element
 305     *
 306     * @param object     An HTML_QuickForm_hidden object being visited
 307     * @access public
 308     * @return void
 309     */
 310     function renderHidden(&$element)
 311     {
 312         $this->_hiddenHtml .= $element->toHtml() . "\n";
 313     } // end func renderHidden
 314
 315    /**
 316     * Called when visiting a raw HTML/text pseudo-element
 317     *
 318     * @param  object     An HTML_QuickForm_html element being visited
 319     * @access public
 320     * @return void
 321     */
 322     function renderHtml(&$data)
 323     {
 324         $this->_html .= $data->toHtml();
 325     } // end func renderHtml
 326
 327    /**
 328     * Called when visiting a group, before processing any group elements
 329     *
 330     * @param object     An HTML_QuickForm_group object being visited
 331     * @param bool       Whether a group is required
 332     * @param string     An error message associated with a group
 333     * @access public
 334     * @return void
 335     */
 336     function startGroup(&$group, $required, $error)
 337     {
 338         $name = $group->getName();
 339         $this->_groupTemplate        = $this->_prepareTemplate($name, $group->getLabel(), $required, $error);
 340         $this->_groupElementTemplate = empty($this->_groupTemplates[$name])? '': $this->_groupTemplates[$name];
 341         $this->_groupWrap            = empty($this->_groupWraps[$name])? '': $this->_groupWraps[$name];
 342         $this->_groupElements        = array();
 343         $this->_inGroup              = true;
 344     } // end func startGroup
 345
 346    /**
 347     * Called when visiting a group, after processing all group elements
 348     *
 349     * @param    object      An HTML_QuickForm_group object being visited
 350     * @access   public
 351     * @return   void
 352     */
 353     function finishGroup(&$group)
 354     {
 355         $separator = $group->_separator;
 356         if (is_array($separator)) {
 357             $count = count($separator);
 358             $html  = '';
 359             for ($i = 0; $i < count($this->_groupElements); $i++) {
 360                 $html .= (0 == $i? '': $separator[($i - 1) % $count]) . $this->_groupElements[$i];
 361             }
 362         } else {
 363             if (is_null($separator)) {
 364                 $separator = '&nbsp;';
 365             }
 366             $html = implode((string)$separator, $this->_groupElements);
 367         }
 368         if (!empty($this->_groupWrap)) {
 369             $html = str_replace('{content}', $html, $this->_groupWrap);
 370         }
 371         $this->_html   .= str_replace('{element}', $html, $this->_groupTemplate);
 372         $this->_inGroup = false;
 373     } // end func finishGroup
 374
 375     /**
 376      * Sets element template
 377      *
 378      * @param       string      The HTML surrounding an element
 379      * @param       string      (optional) Name of the element to apply template for
 380      * @access      public
 381      * @return      void
 382      */
 383     function setElementTemplate($html, $element = null)
 384     {
 385         if (is_null($element)) {
 386             $this->_elementTemplate = $html;
 387         } else {
 388             $this->_templates[$element] = $html;
 389         }
 390     } // end func setElementTemplate
 391
 392
 393     /**
 394      * Sets template for a group wrapper
 395      *
 396      * This template is contained within a group-as-element template
 397      * set via setTemplate() and contains group's element templates, set
 398      * via setGroupElementTemplate()
 399      *
 400      * @param       string      The HTML surrounding group elements
 401      * @param       string      Name of the group to apply template for
 402      * @access      public
 403      * @return      void
 404      */
 405     function setGroupTemplate($html, $group)
 406     {
 407         $this->_groupWraps[$group] = $html;
 408     } // end func setGroupTemplate
 409
 410     /**
 411      * Sets element template for elements within a group
 412      *
 413      * @param       string      The HTML surrounding an element
 414      * @param       string      Name of the group to apply template for
 415      * @access      public
 416      * @return      void
 417      */
 418     function setGroupElementTemplate($html, $group)
 419     {
 420         $this->_groupTemplates[$group] = $html;
 421     } // end func setGroupElementTemplate
 422
 423     /**
 424      * Sets header template
 425      *
 426      * @param       string      The HTML surrounding the header
 427      * @access      public
 428      * @return      void
 429      */
 430     function setHeaderTemplate($html)
 431     {
 432         $this->_headerTemplate = $html;
 433     } // end func setHeaderTemplate
 434
 435     /**
 436      * Sets form template
 437      *
 438      * @param     string    The HTML surrounding the form tags
 439      * @access    public
 440      * @return    void
 441      */
 442     function setFormTemplate($html)
 443     {
 444         $this->_formTemplate = $html;
 445     } // end func setFormTemplate
 446
 447     /**
 448      * Sets the note indicating required fields template
 449      *
 450      * @param       string      The HTML surrounding the required note
 451      * @access      public
 452      * @return      void
 453      */
 454     function setRequiredNoteTemplate($html)
 455     {
 456         $this->_requiredNoteTemplate = $html;
 457     } // end func setRequiredNoteTemplate
 458
 459     /**
 460      * Clears all the HTML out of the templates that surround notes, elements, etc.
 461      * Useful when you want to use addData() to create a completely custom form look
 462      *
 463      * @access  public
 464      * @return  void
 465      */
 466     function clearAllTemplates()
 467     {
 468         $this->setElementTemplate('{element}');
 469         $this->setFormTemplate("\n\t<form{attributes}>{content}\n\t</form>\n");
 470         $this->setRequiredNoteTemplate('');
 471         $this->_templates = array();
 472     } // end func clearAllTemplates
 473 } // end class HTML_QuickForm_Renderer_Default
 474 ?>