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

Source for file Default.php

Documentation is available at Default.php

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

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