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

Source for file Array.php

Documentation is available at Array.php

  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
  3.  
  4. /**
  5.  * A concrete renderer for HTML_QuickForm, makes an array of form contents
  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      Alexey Borzov <avb@php.net>
  18.  * @author      Adam Daniel <adaniel1@eesus.jnj.com>
  19.  * @author      Bertrand Mansion <bmansion@mamasam.com>
  20.  * @author      Thomas Schulz <ths@4bconsult.de>
  21.  * @copyright   2001-2011 The PHP Group
  22.  * @license     http://www.php.net/license/3_01.txt PHP License 3.01
  23.  * @version     CVS: $Id: Array.php 317587 2011-10-01 07:55:53Z avb $
  24.  * @link        http://pear.php.net/package/HTML_QuickForm
  25.  */
  26.  
  27. /**
  28.  * An abstract base class for QuickForm renderers
  29.  */
  30. require_once 'HTML/QuickForm/Renderer.php';
  31.  
  32. /**
  33.  * A concrete renderer for HTML_QuickForm, makes an array of form contents
  34.  *
  35.  * Based on old HTML_QuickForm::toArray() code.
  36.  *
  37.  * The form array structure is the following:
  38.  * <pre>
  39.  * array(
  40.  *   'frozen'           => 'whether the form is frozen',
  41.  *   'javascript'       => 'javascript for client-side validation',
  42.  *   'attributes'       => 'attributes for <form> tag',
  43.  *   'requirednote      => 'note about the required elements',
  44.  *   // if we set the option to collect hidden elements
  45.  *   'hidden'           => 'collected html of all hidden elements',
  46.  *   // if there were some validation errors:
  47.  *   'errors' => array(
  48.  *     '1st element name' => 'Error for the 1st element',
  49.  *     ...
  50.  *     'nth element name' => 'Error for the nth element'
  51.  *   ),
  52.  *   // if there are no headers in the form:
  53.  *   'elements' => array(
  54.  *     element_1,
  55.  *     ...
  56.  *     element_N
  57.  *   )
  58.  *   // if there are headers in the form:
  59.  *   'sections' => array(
  60.  *     array(
  61.  *       'header'   => 'Header text for the first header',
  62.  *       'name'     => 'Header name for the first header',
  63.  *       'elements' => array(
  64.  *          element_1,
  65.  *          ...
  66.  *          element_K1
  67.  *       )
  68.  *     ),
  69.  *     ...
  70.  *     array(
  71.  *       'header'   => 'Header text for the Mth header',
  72.  *       'name'     => 'Header name for the Mth header',
  73.  *       'elements' => array(
  74.  *          element_1,
  75.  *          ...
  76.  *          element_KM
  77.  *       )
  78.  *     )
  79.  *   )
  80.  * );
  81.  * </pre>
  82.  *
  83.  * where element_i is an array of the form:
  84.  * <pre>
  85.  * array(
  86.  *   'name'      => 'element name',
  87.  *   'value'     => 'element value',
  88.  *   'type'      => 'type of the element',
  89.  *   'frozen'    => 'whether element is frozen',
  90.  *   'label'     => 'label for the element',
  91.  *   'required'  => 'whether element is required',
  92.  *   'error'     => 'error associated with the element',
  93.  *   'style'     => 'some information about element style (e.g. for Smarty)',
  94.  *   // if element is not a group
  95.  *   'html'      => 'HTML for the element'
  96.  *   // if element is a group
  97.  *   'separator' => 'separator for group elements',
  98.  *   'elements'  => array(
  99.  *     element_1,
  100.  *     ...
  101.  *     element_N
  102.  *   )
  103.  * );
  104.  * </pre>
  105.  *
  106.  * @category    HTML
  107.  * @package     HTML_QuickForm
  108.  * @author      Alexey Borzov <avb@php.net>
  109.  * @author      Adam Daniel <adaniel1@eesus.jnj.com>
  110.  * @author      Bertrand Mansion <bmansion@mamasam.com>
  111.  * @author      Thomas Schulz <ths@4bconsult.de>
  112.  * @version     Release: 3.2.13
  113.  * @since       3.0
  114.  */
  115. {
  116.    /**#@+
  117.     * @access private
  118.     */
  119.    /**
  120.     * An array being generated
  121.     * @var array 
  122.     */
  123.     var $_ary;
  124.  
  125.    /**
  126.     * Number of sections in the form (i.e. number of headers in it)
  127.     * @var integer 
  128.     */
  129.     var $_sectionCount;
  130.  
  131.    /**
  132.     * Current section number
  133.     * @var integer 
  134.     */
  135.     var $_currentSection;
  136.  
  137.    /**
  138.     * Array representing current group
  139.     * @var array 
  140.     */
  141.     var $_currentGroup = null;
  142.  
  143.    /**
  144.     * Additional style information for different elements
  145.     * @var array 
  146.     */
  147.     var $_elementStyles = array();
  148.  
  149.    /**
  150.     * true: collect all hidden elements into string; false: process them as usual form elements
  151.     * @var bool 
  152.     */
  153.     var $_collectHidden = false;
  154.  
  155.    /**
  156.     * true:  render an array of labels to many labels, $key 0 named 'label', the rest "label_$key"
  157.     * false: leave labels as defined
  158.     * @var bool 
  159.     */
  160.     var $_staticLabels = false;
  161.    /**#@-*/
  162.  
  163.    /**
  164.     * Constructor
  165.     *
  166.     * @param  bool    true: collect all hidden elements into string; false: process them as usual form elements
  167.     * @param  bool    true: render an array of labels to many labels, $key 0 to 'label' and the oterh to "label_$key"
  168.     * @access public
  169.     */
  170.     function HTML_QuickForm_Renderer_Array($collectHidden = false$staticLabels = false)
  171.     {
  172.         $this->HTML_QuickForm_Renderer();
  173.         $this->_collectHidden $collectHidden;
  174.         $this->_staticLabels  $staticLabels;
  175.     // end constructor
  176.  
  177.  
  178.    /**
  179.     * Returns the resultant array
  180.     *
  181.     * @access public
  182.     * @return array 
  183.     */
  184.     function toArray()
  185.     {
  186.         return $this->_ary;
  187.     }
  188.  
  189.  
  190.     function startForm(&$form)
  191.     {
  192.         $this->_ary = array(
  193.             'frozen'            => $form->isFrozen(),
  194.             'javascript'        => $form->getValidationScript(),
  195.             'attributes'        => $form->getAttributes(true),
  196.             'requirednote'      => $form->getRequiredNote(),
  197.             'errors'            => array()
  198.         );
  199.         if ($this->_collectHidden{
  200.             $this->_ary['hidden''';
  201.         }
  202.         $this->_elementIdx     = 1;
  203.         $this->_currentSection = null;
  204.         $this->_sectionCount   = 0;
  205.     // end func startForm
  206.  
  207.  
  208.     function renderHeader(&$header)
  209.     {
  210.         $this->_ary['sections'][$this->_sectionCount= array(
  211.             'header' => $header->toHtml(),
  212.             'name'   => $header->getName()
  213.         );
  214.         $this->_currentSection $this->_sectionCount++;
  215.     // end func renderHeader
  216.  
  217.  
  218.     function renderElement(&$element$required$error)
  219.     {
  220.         $elAry $this->_elementToArray($element$required$error);
  221.         if (!empty($error)) {
  222.             $this->_ary['errors'][$elAry['name']] $error;
  223.         }
  224.         $this->_storeArray($elAry);
  225.     // end func renderElement
  226.  
  227.  
  228.     function renderHidden(&$element)
  229.     {
  230.         if ($this->_collectHidden{
  231.             $this->_ary['hidden'.= $element->toHtml("\n";
  232.         else {
  233.             $this->renderElement($elementfalsenull);
  234.         }
  235.     // end func renderHidden
  236.  
  237.  
  238.     function startGroup(&$group$required$error)
  239.     {
  240.         $this->_currentGroup $this->_elementToArray($group$required$error);
  241.         if (!empty($error)) {
  242.             $this->_ary['errors'][$this->_currentGroup['name']] $error;
  243.         }
  244.     // end func startGroup
  245.  
  246.  
  247.     function finishGroup(&$group)
  248.     {
  249.         $this->_storeArray($this->_currentGroup);
  250.         $this->_currentGroup = null;
  251.     // end func finishGroup
  252.  
  253.  
  254.    /**
  255.     * Creates an array representing an element
  256.     *
  257.     * @access private
  258.     * @param  HTML_QuickForm_element    element being processed
  259.     * @param  bool                      Whether an element is required
  260.     * @param  string                    Error associated with the element
  261.     * @return array 
  262.     */
  263.     function _elementToArray(&$element$required$error)
  264.     {
  265.         $ret = array(
  266.             'name'      => $element->getName(),
  267.             'value'     => $element->getValue(),
  268.             'type'      => $element->getType(),
  269.             'frozen'    => $element->isFrozen(),
  270.             'required'  => $required,
  271.             'error'     => $error
  272.         );
  273.         // render label(s)
  274.         $labels $element->getLabel();
  275.         if (is_array($labels&& $this->_staticLabels{
  276.             foreach($labels as $key => $label{
  277.                 $key is_int($key)$key + 1: $key;
  278.                 if (1 === $key{
  279.                     $ret['label'$label;
  280.                 else {
  281.                     $ret['label_' $key$label;
  282.                 }
  283.             }
  284.         else {
  285.             $ret['label'$labels;
  286.         }
  287.  
  288.         // set the style for the element
  289.         if (isset($this->_elementStyles[$ret['name']])) {
  290.             $ret['style'$this->_elementStyles[$ret['name']];
  291.         }
  292.         if ('group' == $ret['type']{
  293.             $ret['separator'$element->_separator;
  294.             $ret['elements']  = array();
  295.         else {
  296.             $ret['html']      $element->toHtml();
  297.         }
  298.         return $ret;
  299.     }
  300.  
  301.  
  302.    /**
  303.     * Stores an array representation of an element in the form array
  304.     *
  305.     * @access private
  306.     * @param array  Array representation of an element
  307.     * @return void 
  308.     */
  309.     function _storeArray($elAry)
  310.     {
  311.         // where should we put this element...
  312.         if (is_array($this->_currentGroup&& ('group' != $elAry['type'])) {
  313.             $this->_currentGroup['elements'][$elAry;
  314.         elseif (isset($this->_currentSection)) {
  315.             $this->_ary['sections'][$this->_currentSection]['elements'][$elAry;
  316.         else {
  317.             $this->_ary['elements'][$elAry;
  318.         }
  319.     }
  320.  
  321.  
  322.    /**
  323.     * Sets a style to use for element rendering
  324.     *
  325.     * @param mixed      element name or array ('element name' => 'style name')
  326.     * @param string     style name if $elementName is not an array
  327.     * @access public
  328.     * @return void 
  329.     */
  330.     function setElementStyle($elementName$styleName = null)
  331.     {
  332.         if (is_array($elementName)) {
  333.             $this->_elementStyles array_merge($this->_elementStyles$elementName);
  334.         else {
  335.             $this->_elementStyles[$elementName$styleName;
  336.         }
  337.     }
  338. }
  339. ?>

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