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