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

Source for file Object.php

Documentation is available at Object.php

  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
  3.  
  4. /**
  5.  * A concrete renderer for HTML_QuickForm, makes an object from 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      Ron McClain <ron@humaniq.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: Object.php 317587 2011-10-01 07:55:53Z avb $
  21.  * @link        http://pear.php.net/package/HTML_QuickForm
  22.  */
  23.  
  24. /**
  25.  * An abstract base class for QuickForm renderers
  26.  */
  27. require_once 'HTML/QuickForm/Renderer.php';
  28.  
  29. /**
  30.  * A concrete renderer for HTML_QuickForm, makes an object from form contents
  31.  *
  32.  * Based on HTML_Quickform_Renderer_Array code
  33.  *
  34.  * @category    HTML
  35.  * @package     HTML_QuickForm
  36.  * @author      Ron McClain <ron@humaniq.com>
  37.  * @version     Release: 3.2.13
  38.  * @since       3.1.1
  39.  */
  40. {
  41.    /**#@+
  42.     * @access private
  43.     */
  44.     /**
  45.      * The object being generated
  46.      * @var QuickformForm 
  47.      */
  48.     var $_obj= null;
  49.  
  50.     /**
  51.      * Number of sections in the form (i.e. number of headers in it)
  52.      * @var integer $_sectionCount 
  53.      */
  54.     var $_sectionCount;
  55.  
  56.     /**
  57.     * Current section number
  58.     * @var integer $_currentSection 
  59.     */
  60.     var $_currentSection;
  61.  
  62.     /**
  63.     * Object representing current group
  64.     * @var object $_currentGroup 
  65.     */
  66.     var $_currentGroup = null;
  67.  
  68.     /**
  69.      * Class of Element Objects
  70.      * @var object $_elementType 
  71.      */
  72.     var $_elementType 'QuickFormElement';
  73.  
  74.     /**
  75.     * Additional style information for different elements
  76.     * @var array $_elementStyles 
  77.     */
  78.     var $_elementStyles = array();
  79.  
  80.     /**
  81.     * true: collect all hidden elements into string; false: process them as usual form elements
  82.     * @var bool $_collectHidden 
  83.     */
  84.     var $_collectHidden = false;
  85.    /**#@-*/
  86.  
  87.  
  88.     /**
  89.      * Constructor
  90.      *
  91.      * @param bool    true: collect all hidden elements
  92.      * @access public
  93.      */
  94.     function HTML_QuickForm_Renderer_Object($collecthidden = false
  95.     {
  96.         $this->HTML_QuickForm_Renderer();
  97.         $this->_collectHidden $collecthidden;
  98.         $this->_obj = new QuickformForm;
  99.     }
  100.  
  101.     /**
  102.      * Return the rendered Object
  103.      * @access public
  104.      */
  105.     function toObject(
  106.     {
  107.         return $this->_obj;
  108.     }
  109.  
  110.     /**
  111.      * Set the class of the form elements.  Defaults to QuickformElement.
  112.      * @param string   Name of element class
  113.      * @access public
  114.      */
  115.     function setElementType($type)
  116.     {
  117.         $this->_elementType $type;
  118.     }
  119.  
  120.     function startForm(&$form
  121.     {
  122.         $this->_obj->frozen = $form->isFrozen();
  123.         $this->_obj->javascript = $form->getValidationScript();
  124.         $this->_obj->attributes = $form->getAttributes(true);
  125.         $this->_obj->requirednote = $form->getRequiredNote();
  126.         $this->_obj->errors = new StdClass;
  127.  
  128.         if($this->_collectHidden{
  129.             $this->_obj->hidden = '';
  130.         }
  131.         $this->_elementIdx = 1;
  132.         $this->_currentSection = null;
  133.         $this->_sectionCount = 0;
  134.     // end func startForm
  135.  
  136.     function renderHeader(&$header
  137.     {
  138.         $hobj = new StdClass;
  139.         $hobj->header = $header->toHtml();
  140.         $this->_obj->sections[$this->_sectionCount$hobj;
  141.         $this->_currentSection $this->_sectionCount++;
  142.     }
  143.  
  144.     function renderElement(&$element$required$error
  145.     {
  146.         $elObj $this->_elementToObject($element$required$error);
  147.         if(!empty($error)) {
  148.             $name $elObj->name;
  149.             $this->_obj->errors->$name $error;
  150.         }
  151.         $this->_storeObject($elObj);
  152.     // end func renderElement
  153.  
  154.     function renderHidden(&$element)
  155.     {
  156.         if($this->_collectHidden{
  157.             $this->_obj->hidden .= $element->toHtml("\n";
  158.         else {
  159.             $this->renderElement($elementfalsenull);
  160.         }
  161.     //end func renderHidden
  162.  
  163.     function startGroup(&$group$required$error
  164.     {
  165.         $this->_currentGroup $this->_elementToObject($group$required$error);
  166.         if(!empty($error)) {
  167.             $name $this->_currentGroup->name;
  168.             $this->_obj->errors->$name $error;
  169.         }
  170.     // end func startGroup
  171.  
  172.     function finishGroup(&$group
  173.     {
  174.         $this->_storeObject($this->_currentGroup);
  175.         $this->_currentGroup = null;
  176.     // end func finishGroup
  177.  
  178.     /**
  179.      * Creates an object representing an element
  180.      *
  181.      * @access private
  182.      * @param HTML_QuickForm_element    form element being rendered
  183.      * @param required bool         Whether an element is required
  184.      * @param error string    Error associated with the element
  185.      * @return object 
  186.      */
  187.     function _elementToObject(&$element$required$error
  188.     {
  189.         if($this->_elementType{
  190.             $ret = new $this->_elementType;
  191.         }
  192.         $ret->name = $element->getName();
  193.         $ret->value = $element->getValue();
  194.         $ret->type = $element->getType();
  195.         $ret->frozen = $element->isFrozen();
  196.         $labels $element->getLabel();
  197.         if (is_array($labels)) {
  198.             $ret->label = array_shift($labels);
  199.             foreach ($labels as $key => $label{
  200.                 $key is_int($key)$key + 2: $key;
  201.                 $ret->{'label_' $key$label;
  202.             }
  203.         else {
  204.             $ret->label = $labels;
  205.         }
  206.         $ret->required = $required;
  207.         $ret->error = $error;
  208.  
  209.         if(isset($this->_elementStyles[$ret->name])) {
  210.             $ret->style = $this->_elementStyles[$ret->name];
  211.             $ret->styleTemplate = "styles/"$ret->style .".html";
  212.         }
  213.         if($ret->type == 'group'{
  214.             $ret->separator = $element->_separator;
  215.             $ret->elements = array();
  216.         else {
  217.             $ret->html = $element->toHtml();
  218.         }
  219.         return $ret;
  220.     }
  221.  
  222.     /** 
  223.      * Stores an object representation of an element in the form array
  224.      *
  225.      * @access private
  226.      * @param QuickformElement     Object representation of an element
  227.      * @return void 
  228.      */
  229.     function _storeObject($elObj
  230.     {
  231.         $name $elObj->name;
  232.         if(is_object($this->_currentGroup&& $elObj->type != 'group'{
  233.             $this->_currentGroup->elements[$elObj;
  234.         elseif (isset($this->_currentSection)) {
  235.             $this->_obj->sections[$this->_currentSection]->elements[$elObj;
  236.         else {
  237.             $this->_obj->elements[$elObj;
  238.         }
  239.     }
  240.  
  241.     function setElementStyle($elementName$styleName = null)
  242.     {
  243.         if(is_array($elementName)) {
  244.             $this->_elementStyles = array_merge($this->_elementStyles$elementName);
  245.         else {
  246.             $this->_elementStyles[$elementName$styleName;
  247.         }
  248.     }
  249.  
  250. // end class HTML_QuickForm_Renderer_Object
  251.  
  252.  
  253.  
  254. /**
  255.  * Convenience class for the form object passed to outputObject()
  256.  * 
  257.  * Eg.
  258.  * <pre>
  259.  * {form.outputJavaScript():h}
  260.  * {form.outputHeader():h}
  261.  *   <table>
  262.  *     <tr>
  263.  *       <td>{form.name.label:h}</td><td>{form.name.html:h}</td>
  264.  *     </tr>
  265.  *   </table>
  266.  * </form>
  267.  * </pre>
  268.  * 
  269.  * @category    HTML
  270.  * @package     HTML_QuickForm
  271.  * @author      Ron McClain <ron@humaniq.com>
  272.  * @version     Release: 3.2.13
  273.  * @since       3.1.1
  274.  */
  275. {
  276.    /**
  277.     * Whether the form has been frozen
  278.     * @var boolean $frozen 
  279.     */
  280.     var $frozen;
  281.  
  282.    /**
  283.     * Javascript for client-side validation
  284.     * @var string $javascript 
  285.     */
  286.     var $javascript;
  287.  
  288.    /**
  289.     * Attributes for form tag
  290.     * @var string $attributes 
  291.     */
  292.     var $attributes;
  293.  
  294.    /**
  295.     * Note about required elements
  296.     * @var string $requirednote 
  297.     */
  298.     var $requirednote;
  299.  
  300.    /**
  301.     * Collected html of all hidden variables
  302.     * @var string $hidden 
  303.     */
  304.     var $hidden;
  305.  
  306.    /**
  307.     * Set if there were validation errors.
  308.     * StdClass object with element names for keys and their
  309.     * error messages as values
  310.     * @var object $errors 
  311.     */
  312.     var $errors;
  313.  
  314.    /**
  315.     * Array of QuickformElementObject elements.  If there are headers in the form
  316.     * this will be empty and the elements will be in the
  317.     * separate sections
  318.     * @var array $elements 
  319.     */
  320.     var $elements;
  321.  
  322.    /**
  323.     * Array of sections contained in the document
  324.     * @var array $sections 
  325.     */
  326.     var $sections;
  327.  
  328.    /**
  329.     * Output &lt;form&gt; header
  330.     * {form.outputHeader():h}
  331.     * @return string    &lt;form attributes&gt;
  332.     */
  333.     function outputHeader()
  334.     {
  335.         return "<form " $this->attributes . ">\n";
  336.     }
  337.  
  338.    /**
  339.     * Output form javascript
  340.     * {form.outputJavaScript():h}
  341.     * @return string    Javascript
  342.     */
  343.     function outputJavaScript()
  344.     {
  345.         return $this->javascript;
  346.     }
  347. // end class QuickformForm
  348.  
  349.  
  350. /**
  351.  * Convenience class describing a form element.
  352.  *
  353.  * The properties defined here will be available from
  354.  * your flexy templates by referencing
  355.  * {form.zip.label:h}, {form.zip.html:h}, etc.
  356.  *
  357.  * @category    HTML
  358.  * @package     HTML_QuickForm
  359.  * @author      Ron McClain <ron@humaniq.com>
  360.  * @version     Release: 3.2.13
  361.  * @since       3.1.1
  362.  */
  363. {
  364.     /**
  365.      * Element name
  366.      * @var string $name 
  367.      */
  368.     var $name;
  369.  
  370.     /**
  371.      * Element value
  372.      * @var mixed $value 
  373.      */
  374.     var $value;
  375.  
  376.     /**
  377.      * Type of element
  378.      * @var string $type 
  379.      */
  380.     var $type;
  381.  
  382.     /**
  383.      * Whether the element is frozen
  384.      * @var boolean $frozen 
  385.      */
  386.     var $frozen;
  387.  
  388.     /**
  389.      * Label for the element
  390.      * @var string $label 
  391.      */
  392.     var $label;
  393.  
  394.     /**
  395.      * Whether element is required
  396.      * @var boolean $required 
  397.      */
  398.     var $required;
  399.  
  400.     /**
  401.      * Error associated with the element
  402.      * @var string $error 
  403.      */
  404.     var $error;
  405.  
  406.     /**
  407.      * Some information about element style
  408.      * @var string $style 
  409.      */
  410.     var $style;
  411.  
  412.     /**
  413.      * HTML for the element
  414.      * @var string $html 
  415.      */
  416.     var $html;
  417.  
  418.     /**
  419.      * If element is a group, the group separator
  420.      * @var mixed $separator 
  421.      */
  422.     var $separator;
  423.  
  424.     /**
  425.      * If element is a group, an array of subelements
  426.      * @var array $elements 
  427.      */
  428.     var $elements;
  429.  
  430.     function isType($type)
  431.     {
  432.         return ($this->type == $type);
  433.     }
  434.  
  435.     function notFrozen()
  436.     {
  437.         return !$this->frozen;
  438.     }
  439.  
  440.     function isButton()
  441.     {
  442.         return ($this->type == "submit" || $this->type == "reset");
  443.     }
  444.  
  445.  
  446.    /**
  447.     * XXX: why does it use Flexy when all other stuff here does not depend on it?
  448.     */
  449.     function outputStyle()
  450.     {
  451.         ob_start();
  452.         HTML_Template_Flexy::staticQuickTemplate('styles/' $this->style . '.html'$this);
  453.         $ret ob_get_contents();
  454.         ob_end_clean();
  455.         return $ret;
  456.     }
  457. // end class QuickformElement
  458. ?>

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