HTML_QuickForm
[ class tree: HTML_QuickForm ] [ index: HTML_QuickForm ] [ all elements ]

Source for file QuickHtml.php

Documentation is available at QuickHtml.php

  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
  3.  
  4. /**
  5.  * A renderer that makes it quick and easy to create customized forms.
  6.  * 
  7.  * PHP versions 4 and 5
  8.  *
  9.  * LICENSE: This source file is subject to version 3.01 of the PHP license
  10.  * that is available through the world-wide-web at the following URI:
  11.  * http://www.php.net/license/3_01.txt If you did not receive a copy of
  12.  * the PHP License and are unable to obtain it through the web, please
  13.  * send a note to license@php.net so we can mail you a copy immediately.
  14.  *
  15.  * @category    HTML
  16.  * @package     HTML_QuickForm
  17.  * @author      Jason Rust <jrust@rustyparts.com>
  18.  * @copyright   2001-2011 The PHP Group
  19.  * @license     http://www.php.net/license/3_01.txt PHP License 3.01
  20.  * @version     CVS: $Id: QuickHtml.php 317587 2011-10-01 07:55:53Z avb $
  21.  * @link        http://pear.php.net/package/HTML_QuickForm
  22.  */
  23.  
  24. /**
  25.  * A concrete renderer for HTML_QuickForm, based on QuickForm 2.x built-in one
  26.  */ 
  27. require_once 'HTML/QuickForm/Renderer/Default.php';
  28.  
  29. /**
  30.  * A renderer that makes it quick and easy to create customized forms.
  31.  *
  32.  * This renderer has three main distinctives: an easy way to create
  33.  * custom-looking forms, the ability to separate the creation of form
  34.  * elements from their display, and being able to use QuickForm in
  35.  * widget-based template systems.  See the online docs for more info.
  36.  * For a usage example see: docs/renderers/QuickHtml_example.php
  37.  * 
  38.  * @category    HTML
  39.  * @package     HTML_QuickForm
  40.  * @author      Jason Rust <jrust@rustyparts.com>
  41.  * @version     Release: 3.2.13
  42.  * @since       3.1.1
  43.  */
  44.     // {{{ properties
  45.  
  46.     /**
  47.      * The array of rendered elements
  48.      * @var array 
  49.      */
  50.     var $renderedElements = array();
  51.  
  52.     // }}}
  53.     // {{{ constructor
  54.     
  55.     /**
  56.      * Constructor
  57.      *
  58.      * @access public
  59.      * @return void 
  60.      */
  61.     {
  62.         $this->HTML_QuickForm_Renderer_Default();
  63.         // The default templates aren't used for this renderer
  64.         $this->clearAllTemplates();
  65.     // end constructor
  66.  
  67.     // }}}
  68.     // {{{ toHtml()
  69.  
  70.     /**
  71.      * returns the HTML generated for the form
  72.      *
  73.      * @param string $data (optional) Any extra data to put before the end of the form
  74.      *
  75.      * @access public
  76.      * @return string 
  77.      */
  78.     function toHtml($data '')
  79.     {
  80.         // Render any elements that haven't been rendered explicitly by elementToHtml()
  81.         foreach (array_keys($this->renderedElementsas $key{
  82.             if (!$this->renderedElements[$key]['rendered']{
  83.                 $this->renderedElements[$key]['rendered'= true;
  84.                 $data .= $this->renderedElements[$key]['html'"\n";
  85.             }
  86.         }
  87.  
  88.         // Insert the extra data and form elements at the end of the form
  89.         $this->_html str_replace('</form>'$data "\n</form>"$this->_html);
  90.         return $this->_html;
  91.     // end func toHtml
  92.  
  93.     // }}}
  94.     // {{{ elementToHtml()
  95.  
  96.     /**
  97.      * Gets the html for an element and marks it as rendered.
  98.      *
  99.      * @param string $elementName The element name
  100.      * @param string $elementValue (optional) The value of the element.  This is only useful
  101.      *                for elements that have the same name (i.e. radio and checkbox), but
  102.      *                different values
  103.      *
  104.      * @access public
  105.      * @return string The html for the QuickForm element
  106.      * @throws HTML_QuickForm_Error
  107.      */
  108.     function elementToHtml($elementName$elementValue = null)
  109.     {
  110.         $elementKey = null;
  111.         // Find the key for the element
  112.         foreach ($this->renderedElements as $key => $data{
  113.             if ($data['name'== $elementName && 
  114.                 // See if the value must match as well
  115.                 (is_null($elementValue||
  116.                  $data['value'== $elementValue)) {
  117.                 $elementKey $key;
  118.                 break;
  119.             }
  120.         }
  121.  
  122.         if (is_null($elementKey)) {
  123.             $msg is_null($elementValue? "Element $elementName does not exist." : 
  124.                 "Element $elementName with value of $elementValue does not exist.";
  125.             return PEAR::raiseError(nullQUICKFORM_UNREGISTERED_ELEMENTnullE_USER_WARNING$msg'HTML_QuickForm_Error'true);
  126.         else {
  127.             if ($this->renderedElements[$elementKey]['rendered']{
  128.                 $msg is_null($elementValue? "Element $elementName has already been rendered." : 
  129.                     "Element $elementName with value of $elementValue has already been rendered.";
  130.                 return PEAR::raiseError(nullQUICKFORM_ERRORnullE_USER_WARNING$msg'HTML_QuickForm_Error'true);
  131.             else {
  132.                 $this->renderedElements[$elementKey]['rendered'= true;
  133.                 return $this->renderedElements[$elementKey]['html'];
  134.             }
  135.         }
  136.     // end func elementToHtml
  137.  
  138.     // }}}
  139.     // {{{ renderElement()
  140.  
  141.     /**
  142.      * Gets the html for an element and adds it to the array by calling
  143.      * parent::renderElement()
  144.      *
  145.      * @param HTML_QuickForm_element    form element being visited
  146.      * @param bool                      Whether an element is required
  147.      * @param string                    An error message associated with an element
  148.      *
  149.      * @access public
  150.      * @return mixed HTML string of element if $immediateRender is set, else we just add the
  151.      *                html to the global _html string
  152.      */
  153.     function renderElement(&$element$required$error)
  154.     {
  155.         $this->_html '';
  156.         parent::renderElement($element$required$error);
  157.         if (!$this->_inGroup{
  158.             $this->renderedElements[= array(
  159.                     'name' => $element->getName()
  160.                     'value' => $element->getValue()
  161.                     'html' => $this->_html
  162.                     'rendered' => false);
  163.         }
  164.         $this->_html '';
  165.     // end func renderElement
  166.  
  167.     // }}}
  168.     // {{{ renderHidden()
  169.  
  170.     /**
  171.      * Gets the html for a hidden element and adds it to the array.
  172.      * 
  173.      * @param HTML_QuickForm_element    hidden form element being visited
  174.      * @access public
  175.      * @return void 
  176.      */
  177.     function renderHidden(&$element)
  178.     {
  179.         $this->renderedElements[= array(
  180.                 'name' => $element->getName()
  181.                 'value' => $element->getValue()
  182.                 'html' => $element->toHtml()
  183.                 'rendered' => false);
  184.     // end func renderHidden
  185.     
  186.     // }}}
  187.     // {{{ finishGroup()
  188.  
  189.     /**
  190.      * Gets the html for the group element and adds it to the array by calling
  191.      * parent::finishGroup()
  192.      *
  193.      * @param    HTML_QuickForm_group   group being visited
  194.      * @access   public
  195.      * @return   void 
  196.      */
  197.     function finishGroup(&$group)
  198.     {
  199.         $this->_html '';
  200.         parent::finishGroup($group);
  201.         $this->renderedElements[= array(
  202.                 'name' => $group->getName()
  203.                 'value' => $group->getValue()
  204.                 'html' => $this->_html
  205.                 'rendered' => false);
  206.         $this->_html '';
  207.     // end func finishGroup
  208.  
  209.     // }}}
  210. // end class HTML_QuickForm_Renderer_QuickHtml
  211. ?>

Documentation generated on Sat, 01 Oct 2011 09:00:18 +0000 by phpDocumentor 1.4.3. PEAR Logo Copyright © PHP Group 2004.