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