lib/pear/HTML/QuickForm/Renderer/Object.php

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