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

Source for file ArraySmarty.php

Documentation is available at ArraySmarty.php

  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
  3.  
  4. /**
  5.  * A static renderer for HTML_QuickForm, makes an array of form content
  6.  * useful for a Smarty template
  7.  * 
  8.  * PHP versions 4 and 5
  9.  *
  10.  * LICENSE: This source file is subject to version 3.01 of the PHP license
  11.  * that is available through the world-wide-web at the following URI:
  12.  * http://www.php.net/license/3_01.txt If you did not receive a copy of
  13.  * the PHP License and are unable to obtain it through the web, please
  14.  * send a note to license@php.net so we can mail you a copy immediately.
  15.  *
  16.  * @category    HTML
  17.  * @package     HTML_QuickForm
  18.  * @author      Alexey Borzov <avb@php.net>
  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: ArraySmarty.php 317587 2011-10-01 07:55:53Z avb $
  24.  * @link        http://pear.php.net/package/HTML_QuickForm
  25.  */
  26.  
  27. /**
  28.  * A concrete renderer for HTML_QuickForm, makes an array of form contents
  29.  */ 
  30. require_once 'HTML/QuickForm/Renderer/Array.php';
  31.  
  32. /**
  33.  * A static renderer for HTML_QuickForm, makes an array of form content
  34.  * useful for a Smarty template
  35.  *
  36.  * Based on old HTML_QuickForm::toArray() code and ITStatic renderer.
  37.  *
  38.  * The form array structure is the following:
  39.  * <pre>
  40.  * Array (
  41.  *  [frozen]       => whether the complete form is frozen'
  42.  *  [javascript]   => javascript for client-side validation
  43.  *  [attributes]   => attributes for <form> tag
  44.  *  [hidden]       => html of all hidden elements
  45.  *  [requirednote] => note about the required elements
  46.  *  [errors] => Array
  47.  *      (
  48.  *          [1st_element_name] => Error for the 1st element
  49.  *          ...
  50.  *          [nth_element_name] => Error for the nth element
  51.  *      )
  52.  *
  53.  *  [header] => Array
  54.  *      (
  55.  *          [1st_header_name] => Header text for the 1st header
  56.  *          ...
  57.  *          [nth_header_name] => Header text for the nth header
  58.  *      )
  59.  *
  60.  *  [1st_element_name] => Array for the 1st element
  61.  *  ...
  62.  *  [nth_element_name] => Array for the nth element
  63.  * </pre>
  64.  *
  65.  * where an element array has the form:
  66.  * <pre>
  67.  *      (
  68.  *          [name]      => element name
  69.  *          [value]     => element value,
  70.  *          [type]      => type of the element
  71.  *          [frozen]    => whether element is frozen
  72.  *          [label]     => label for the element
  73.  *          [required]  => whether element is required
  74.  * // if element is not a group:
  75.  *          [html]      => HTML for the element
  76.  * // if element is a group:
  77.  *          [separator] => separator for group elements
  78.  *          [1st_gitem_name] => Array for the 1st element in group
  79.  *          ...
  80.  *          [nth_gitem_name] => Array for the nth element in group
  81.  *      )
  82.  * )
  83.  * </pre>
  84.  *
  85.  * @category    HTML
  86.  * @package     HTML_QuickForm
  87.  * @author      Alexey Borzov <avb@php.net>
  88.  * @author      Bertrand Mansion <bmansion@mamasam.com>
  89.  * @author      Thomas Schulz <ths@4bconsult.de>
  90.  * @version     Release: 3.2.13
  91.  * @since       3.0
  92.  */
  93. {
  94.    /**#@+
  95.     * @access private
  96.     */
  97.    /**
  98.     * The Smarty template engine instance
  99.     * @var object 
  100.     */
  101.     var $_tpl = null;
  102.  
  103.    /**
  104.     * Current element index
  105.     * @var integer 
  106.     */
  107.     var $_elementIdx = 0;
  108.  
  109.     /**
  110.     * The current element index inside a group
  111.     * @var integer 
  112.     */
  113.     var $_groupElementIdx = 0;
  114.  
  115.    /**
  116.     * How to handle the required tag for required fields
  117.     * @var string 
  118.     * @see      setRequiredTemplate()
  119.     */
  120.     var $_required '';
  121.  
  122.    /**
  123.     * How to handle error messages in form validation
  124.     * @var string 
  125.     * @see      setErrorTemplate()
  126.     */
  127.     var $_error '';
  128.    /**#@-*/
  129.  
  130.    /**
  131.     * Constructor
  132.     *
  133.     * @param  Smarty  reference to the Smarty template engine instance
  134.     * @param  bool    true: render an array of labels to many labels, $key 0 to 'label' and the oterh to "label_$key"
  135.     * @param  bool    true: collect all hidden elements into string; false: process them as usual form elements
  136.     * @access public
  137.     */
  138.     function HTML_QuickForm_Renderer_ArraySmarty(&$tpl$staticLabels = false$collectHidden = true)
  139.     {
  140.         $this->HTML_QuickForm_Renderer_Array($collectHidden$staticLabels);
  141.         $this->_tpl =$tpl;
  142.     // end constructor
  143.  
  144.    /**
  145.     * Called when visiting a header element
  146.     *
  147.     * @param    HTML_QuickForm_header   header element being visited
  148.     * @access   public
  149.     * @return   void 
  150.     */
  151.     function renderHeader(&$header)
  152.     {
  153.         if ($name $header->getName()) {
  154.             $this->_ary['header'][$name$header->toHtml();
  155.         else {
  156.             $this->_ary['header'][$this->_sectionCount$header->toHtml();
  157.         }
  158.         $this->_currentSection $this->_sectionCount++;
  159.     // end func renderHeader
  160.  
  161.    /**
  162.     * Called when visiting a group, before processing any group elements
  163.     *
  164.     * @param    HTML_QuickForm_group    group being visited
  165.     * @param    bool                    Whether a group is required
  166.     * @param    string                  An error message associated with a group
  167.     * @access   public
  168.     * @return   void 
  169.     */
  170.     function startGroup(&$group$required$error)
  171.     {
  172.         parent::startGroup($group$required$error);
  173.         $this->_groupElementIdx = 1;
  174.     // end func startGroup
  175.  
  176.    /**
  177.     * Creates an array representing an element containing
  178.     * the key for storing this
  179.     *
  180.     * @access private
  181.     * @param  HTML_QuickForm_element    form element being visited
  182.     * @param  bool                      Whether an element is required
  183.     * @param  string                    Error associated with the element
  184.     * @return array 
  185.     */
  186.     function _elementToArray(&$element$required$error)
  187.     {
  188.         $ret = parent::_elementToArray($element$required$error);
  189.  
  190.         if ('group' == $ret['type']{
  191.             $ret['html'$element->toHtml();
  192.             // we don't need the elements, see the array structure
  193.             unset($ret['elements']);
  194.         }
  195.         if (($required || $error&& !empty($this->_required)){
  196.             $this->_renderRequired($ret['label']$ret['html']$required$error);
  197.         }
  198.         if ($error && !empty($this->_error)) {
  199.             $this->_renderError($ret['label']$ret['html']$error);
  200.             $ret['error'$error;
  201.         }
  202.         // create keys for elements grouped by native group or name
  203.         if (strstr($ret['name']'['or $this->_currentGroup{
  204.             // Fix for bug #8123: escape backslashes and quotes to prevent errors 
  205.             // in eval(). The code below seems to handle the case where element
  206.             // name has unbalanced square brackets. Dunno whether we really
  207.             // need this after the fix for #8123, but I'm wary of making big
  208.             // changes to this code.  
  209.             preg_match('/([^]]*)\\[([^]]*)\\]/'$ret['name']$matches);
  210.             if (isset($matches[1])) {
  211.                 $sKeysSub substr_replace($ret['name']''0strlen($matches[1]));
  212.                 $sKeysSub str_replace(
  213.                     array('\\',   '\'',   '['  ,   ']''[\'\']'),
  214.                     array('\\\\''\\\'''[\'''\']''[]'    ),
  215.                     $sKeysSub
  216.                 );
  217.                 $sKeys '[\'' str_replace(array('\\''\'')array('\\\\''\\\'')$matches[1]'\']' $sKeysSub;
  218.             else {
  219.                 $sKeys '[\'' str_replace(array('\\''\'')array('\\\\''\\\'')$ret['name']'\']';
  220.             }
  221.             // special handling for elements in native groups
  222.             if ($this->_currentGroup{
  223.                 // skip unnamed group items unless radios: no name -> no static access
  224.                 // identification: have the same key string as the parent group
  225.                 if ($this->_currentGroup['keys'== $sKeys and 'radio' != $ret['type']{
  226.                     return false;
  227.                 }
  228.                 // reduce string of keys by remove leading group keys
  229.                 if (0 === strpos($sKeys$this->_currentGroup['keys'])) {
  230.                     $sKeys substr_replace($sKeys''0strlen($this->_currentGroup['keys']));
  231.                 }
  232.             }
  233.         // element without a name
  234.         elseif ($ret['name'== ''{
  235.             $sKeys '[\'element_' $this->_elementIdx '\']';
  236.         // other elements
  237.         else {
  238.             $sKeys '[\'' str_replace(array('\\''\'')array('\\\\''\\\'')$ret['name']'\']';
  239.         }
  240.         // for radios: add extra key from value
  241.         if ('radio' == $ret['type'and substr($sKeys-2!= '[]'{
  242.             $sKeys .= '[\'' str_replace(array('\\''\'')array('\\\\''\\\'')$ret['value']'\']';
  243.         }
  244.         $this->_elementIdx++;
  245.         $ret['keys'$sKeys;
  246.         return $ret;
  247.     // end func _elementToArray
  248.  
  249.    /**
  250.     * Stores an array representation of an element in the form array
  251.     *
  252.     * @access private
  253.     * @param array  Array representation of an element
  254.     * @return void 
  255.     */
  256.     function _storeArray($elAry)
  257.     {
  258.         if ($elAry{
  259.             $sKeys $elAry['keys'];
  260.             unset($elAry['keys']);
  261.             // where should we put this element...
  262.             if (is_array($this->_currentGroup&& ('group' != $elAry['type'])) {
  263.                 $toEval '$this->_currentGroup' $sKeys ' = $elAry;';
  264.             else {
  265.                 $toEval '$this->_ary' $sKeys ' = $elAry;';
  266.             }
  267.             eval($toEval);
  268.         }
  269.         return;
  270.     }
  271.  
  272.    /**
  273.     * Called when an element is required
  274.     *
  275.     * This method will add the required tag to the element label and/or the element html
  276.     * such as defined with the method setRequiredTemplate.
  277.     *
  278.     * @param    string      The element label
  279.     * @param    string      The element html rendering
  280.     * @param    boolean     The element required
  281.     * @param    string      The element error
  282.     * @see      setRequiredTemplate()
  283.     * @access   private
  284.     * @return   void 
  285.     */
  286.     function _renderRequired(&$label&$html&$required&$error)
  287.     {
  288.         $this->_tpl->assign(array(
  289.             'label'    => $label,
  290.             'html'     => $html,
  291.             'required' => $required,
  292.             'error'    => $error
  293.         ));
  294.         if (!empty($label&& strpos($this->_required$this->_tpl->left_delimiter . '$label'!== false{
  295.             $label $this->_tplFetch($this->_required);
  296.         }
  297.         if (!empty($html&& strpos($this->_required$this->_tpl->left_delimiter . '$html'!== false{
  298.             $html $this->_tplFetch($this->_required);
  299.         }
  300.         $this->_tpl->clear_assign(array('label''html''required'));
  301.     // end func _renderRequired
  302.  
  303.    /**
  304.     * Called when an element has a validation error
  305.     *
  306.     * This method will add the error message to the element label or the element html
  307.     * such as defined with the method setErrorTemplate. If the error placeholder is not found
  308.     * in the template, the error will be displayed in the form error block.
  309.     *
  310.     * @param    string      The element label
  311.     * @param    string      The element html rendering
  312.     * @param    string      The element error
  313.     * @see      setErrorTemplate()
  314.     * @access   private
  315.     * @return   void 
  316.     */
  317.     function _renderError(&$label&$html&$error)
  318.     {
  319.         $this->_tpl->assign(array('label' => '''html' => '''error' => $error));
  320.         $error $this->_tplFetch($this->_error);
  321.         $this->_tpl->assign(array('label' => $label'html'  => $html));
  322.  
  323.         if (!empty($label&& strpos($this->_error$this->_tpl->left_delimiter . '$label'!== false{
  324.             $label $this->_tplFetch($this->_error);
  325.         elseif (!empty($html&& strpos($this->_error$this->_tpl->left_delimiter . '$html'!== false{
  326.             $html $this->_tplFetch($this->_error);
  327.         }
  328.         $this->_tpl->clear_assign(array('label''html''error'));
  329.     // end func _renderError
  330.  
  331.    /**
  332.     * Process an template sourced in a string with Smarty
  333.     *
  334.     * Smarty has no core function to render    a template given as a string.
  335.     * So we use the smarty eval plugin function    to do this.
  336.     *
  337.     * @param    string      The template source
  338.     * @access   private
  339.     * @return   void 
  340.     */
  341.     function _tplFetch($tplSource)
  342.     {
  343.         if (!function_exists('smarty_function_eval')) {
  344.             require SMARTY_DIR . '/plugins/function.eval.php';
  345.         }
  346.         return smarty_function_eval(array('var' => $tplSource)$this->_tpl);
  347.     }// end func _tplFetch
  348.  
  349.    /**
  350.     * Sets the way required elements are rendered
  351.     *
  352.     * You can use {$label} or {$html} placeholders to let the renderer know where
  353.     * where the element label or the element html are positionned according to the
  354.     * required tag. They will be replaced accordingly with the right value.    You
  355.     * can use the full smarty syntax here, especially a custom modifier for I18N.
  356.     * For example:
  357.     * {if $required}<span style="color: red;">*</span>{/if}{$label|translate}
  358.     * will put a red star in front of the label if the element is required and
  359.     * translate the label.
  360.     *
  361.     *
  362.     * @param    string      The required element template
  363.     * @access   public
  364.     * @return   void 
  365.     */
  366.     function setRequiredTemplate($template)
  367.     {
  368.         $this->_required $template;
  369.     // end func setRequiredTemplate
  370.  
  371.    /**
  372.     * Sets the way elements with validation errors are rendered
  373.     *
  374.     * You can use {$label} or {$html} placeholders to let the renderer know where
  375.     * where the element label or the element html are positionned according to the
  376.     * error message. They will be replaced accordingly with the right value.
  377.     * The error message will replace the {$error} placeholder.
  378.     * For example:
  379.     * {if $error}<span style="color: red;">{$error}</span>{/if}<br />{$html}
  380.     * will put the error message in red on top of the element html.
  381.     *
  382.     * If you want all error messages to be output in the main error block, use
  383.     * the {$form.errors} part of the rendered array that collects all raw error
  384.     * messages.
  385.     *
  386.     * If you want to place all error messages manually, do not specify {$html}
  387.     * nor {$label}.
  388.     *
  389.     * Groups can have special layouts. With this kind of groups, you have to
  390.     * place the formated error message manually. In this case, use {$form.group.error}
  391.     * where you want the formated error message to appear in the form.
  392.     *
  393.     * @param    string      The element error template
  394.     * @access   public
  395.     * @return   void 
  396.     */
  397.     function setErrorTemplate($template)
  398.     {
  399.         $this->_error $template;
  400.     // end func setErrorTemplate
  401. }
  402. ?>

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