Configure the dmca form site on ridley
authorTom Hughes <tom@compton.nu>
Wed, 29 Aug 2018 18:40:50 +0000 (19:40 +0100)
committerTom Hughes <tom@compton.nu>
Wed, 29 Aug 2018 19:22:12 +0000 (20:22 +0100)
55 files changed:
cookbooks/dmca/.foodcritic [new file with mode: 0644]
cookbooks/dmca/README.md [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/Common.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/DHTMLRulesTableless.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/PageDHTMLRulesTableless.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/Array.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/ArraySmarty.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/Default.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/ITDynamic.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/ITStatic.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/Object.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/ObjectFlexy.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/QuickHtml.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/Tableless.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Rule.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Callback.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Compare.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Email.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Range.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Regex.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Required.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/RuleRegistry.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/advcheckbox.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/autocomplete.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/button.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/checkbox.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/date.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/element.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/file.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/group.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/header.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/hidden.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/hiddenselect.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/hierselect.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/html.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/image.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/input.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/link.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/password.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/radio.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/reset.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/select.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/static.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/submit.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/text.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/textarea.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/utils.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/HTML/QuickForm/xbutton.php [new file with mode: 0644]
cookbooks/dmca/files/default/html/index.php [new file with mode: 0644]
cookbooks/dmca/metadata.rb [new file with mode: 0644]
cookbooks/dmca/recipes/default.rb [new file with mode: 0644]
cookbooks/dmca/templates/default/apache.erb [new file with mode: 0644]
roles/ridley.rb

diff --git a/cookbooks/dmca/.foodcritic b/cookbooks/dmca/.foodcritic
new file mode 100644 (file)
index 0000000..0c118ec
--- /dev/null
@@ -0,0 +1,5 @@
+~FC001
+~FC064
+~FC065
+~FC066
+~FC071
diff --git a/cookbooks/dmca/README.md b/cookbooks/dmca/README.md
new file mode 100644 (file)
index 0000000..319bcca
--- /dev/null
@@ -0,0 +1,3 @@
+# DMCA Cookbook
+
+This cookbook configures the DMCA form available at https://dmca.openstreetmap.org
diff --git a/cookbooks/dmca/files/default/html/HTML/Common.php b/cookbooks/dmca/files/default/html/HTML/Common.php
new file mode 100644 (file)
index 0000000..8823ea4
--- /dev/null
@@ -0,0 +1,465 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * Base class for all HTML classes
+ *
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ * 
+ * @category    HTML
+ * @package     HTML_Common
+ * @author      Adam Daniel <adaniel1@eesus.jnj.com>
+ * @copyright   2001-2009 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id: Common.php,v 1.15 2009/04/03 15:26:22 avb Exp $
+ * @link        http://pear.php.net/package/HTML_Common/
+ */ 
+
+/**
+ * Base class for all HTML classes
+ *
+ * @category    HTML
+ * @package     HTML_Common
+ * @author      Adam Daniel <adaniel1@eesus.jnj.com>
+ * @version     Release: 1.2.5
+ * @abstract
+ */
+class HTML_Common
+{
+    /**
+     * Associative array of attributes
+     * @var     array
+     * @access  private
+     */
+    var $_attributes = array();
+
+    /**
+     * Tab offset of the tag
+     * @var     int
+     * @access  private
+     */
+    var $_tabOffset = 0;
+
+    /**
+     * Tab string
+     * @var       string
+     * @since     1.7
+     * @access    private
+     */
+    var $_tab = "\11";
+
+    /**
+     * Contains the line end string
+     * @var       string
+     * @since     1.7
+     * @access    private
+     */
+    var $_lineEnd = "\12";
+
+    /**
+     * HTML comment on the object
+     * @var       string
+     * @since     1.5
+     * @access    private
+     */
+    var $_comment = '';
+
+    /**
+     * Class constructor
+     * @param    mixed   $attributes     Associative array of table tag attributes
+     *                                   or HTML attributes name="value" pairs
+     * @param    int     $tabOffset      Indent offset in tabs
+     * @access   public
+     */
+    function HTML_Common($attributes = null, $tabOffset = 0)
+    {
+        $this->setAttributes($attributes);
+        $this->setTabOffset($tabOffset);
+    } // end constructor
+
+    /**
+     * Returns the current API version
+     * @access   public
+     * @returns  double
+     */
+    function apiVersion()
+    {
+        return 1.7;
+    } // end func apiVersion
+
+    /**
+     * Returns the lineEnd
+     *
+     * @since     1.7
+     * @access    private
+     * @return    string
+     */
+    function _getLineEnd()
+    {
+        return $this->_lineEnd;
+    } // end func getLineEnd
+
+    /**
+     * Returns a string containing the unit for indenting HTML
+     *
+     * @since     1.7
+     * @access    private
+     * @return    string
+     */
+    function _getTab()
+    {
+        return $this->_tab;
+    } // end func _getTab
+
+    /**
+     * Returns a string containing the offset for the whole HTML code
+     *
+     * @return    string
+     * @access   private
+     */
+    function _getTabs()
+    {
+        return str_repeat($this->_getTab(), $this->_tabOffset);
+    } // end func _getTabs
+
+    /**
+     * Returns an HTML formatted attribute string
+     * @param    array   $attributes
+     * @return   string
+     * @access   private
+     */
+    function _getAttrString($attributes)
+    {
+        $strAttr = '';
+
+        if (is_array($attributes)) {
+            $charset = HTML_Common::charset();
+            foreach ($attributes as $key => $value) {
+                $strAttr .= ' ' . $key . '="' . htmlspecialchars($value, ENT_COMPAT, $charset) . '"';
+            }
+        }
+        return $strAttr;
+    } // end func _getAttrString
+
+    /**
+     * Returns a valid atrributes array from either a string or array
+     * @param    mixed   $attributes     Either a typical HTML attribute string or an associative array
+     * @access   private
+     * @return   array
+     */
+    function _parseAttributes($attributes)
+    {
+        if (is_array($attributes)) {
+            $ret = array();
+            foreach ($attributes as $key => $value) {
+                if (is_int($key)) {
+                    $key = $value = strtolower($value);
+                } else {
+                    $key = strtolower($key);
+                }
+                $ret[$key] = $value;
+            }
+            return $ret;
+
+        } elseif (is_string($attributes)) {
+            $preg = "/(([A-Za-z_:]|[^\\x00-\\x7F])([A-Za-z0-9_:.-]|[^\\x00-\\x7F])*)" .
+                "([ \\n\\t\\r]+)?(=([ \\n\\t\\r]+)?(\"[^\"]*\"|'[^']*'|[^ \\n\\t\\r]*))?/";
+            if (preg_match_all($preg, $attributes, $regs)) {
+                for ($counter=0; $counter<count($regs[1]); $counter++) {
+                    $name  = $regs[1][$counter];
+                    $check = $regs[0][$counter];
+                    $value = $regs[7][$counter];
+                    if (trim($name) == trim($check)) {
+                        $arrAttr[strtolower(trim($name))] = strtolower(trim($name));
+                    } else {
+                        if (substr($value, 0, 1) == "\"" || substr($value, 0, 1) == "'") {
+                            $arrAttr[strtolower(trim($name))] = substr($value, 1, -1);
+                        } else {
+                            $arrAttr[strtolower(trim($name))] = trim($value);
+                        }
+                    }
+                }
+                return $arrAttr;
+            }
+        }
+    } // end func _parseAttributes
+
+    /**
+     * Returns the array key for the given non-name-value pair attribute
+     *
+     * @param     string    $attr         Attribute
+     * @param     array     $attributes   Array of attribute
+     * @since     1.0
+     * @access    private
+     * @return    bool
+     */
+    function _getAttrKey($attr, $attributes)
+    {
+        if (isset($attributes[strtolower($attr)])) {
+            return true;
+        } else {
+            return null;
+        }
+    } //end func _getAttrKey
+
+    /**
+     * Updates the attributes in $attr1 with the values in $attr2 without changing the other existing attributes
+     * @param    array   $attr1      Original attributes array
+     * @param    array   $attr2      New attributes array
+     * @access   private
+     */
+    function _updateAttrArray(&$attr1, $attr2)
+    {
+        if (!is_array($attr2)) {
+            return false;
+        }
+        foreach ($attr2 as $key => $value) {
+            $attr1[$key] = $value;
+        }
+    } // end func _updateAtrrArray
+
+    /**
+     * Removes the given attribute from the given array
+     *
+     * @param     string    $attr           Attribute name
+     * @param     array     $attributes     Attribute array
+     * @since     1.4
+     * @access    private
+     * @return    void
+     */
+    function _removeAttr($attr, &$attributes)
+    {
+        $attr = strtolower($attr);
+        if (isset($attributes[$attr])) {
+            unset($attributes[$attr]);
+        }
+    } //end func _removeAttr
+
+    /**
+     * Returns the value of the given attribute
+     *
+     * @param     string    $attr   Attribute name
+     * @since     1.5
+     * @access    public
+     * @return    string|null   returns null if an attribute does not exist
+     */
+    function getAttribute($attr)
+    {
+        $attr = strtolower($attr);
+        if (isset($this->_attributes[$attr])) {
+            return $this->_attributes[$attr];
+        }
+        return null;
+    } //end func getAttribute
+
+    /**
+     * Sets the value of the attribute
+     *
+     * @param   string  Attribute name
+     * @param   string  Attribute value (will be set to $name if omitted)
+     * @access  public
+     */
+    function setAttribute($name, $value = null)
+    {
+        $name = strtolower($name);
+        if (is_null($value)) {
+            $value = $name;
+        }
+        $this->_attributes[$name] = $value;
+    } // end func setAttribute
+
+    /**
+     * Sets the HTML attributes
+     * @param    mixed   $attributes     Either a typical HTML attribute string or an associative array
+     * @access   public
+     */
+    function setAttributes($attributes)
+    {
+        $this->_attributes = $this->_parseAttributes($attributes);
+    } // end func setAttributes
+
+    /**
+     * Returns the assoc array (default) or string of attributes
+     *
+     * @param     bool    Whether to return the attributes as string
+     * @since     1.6
+     * @access    public
+     * @return    mixed   attributes
+     */
+    function getAttributes($asString = false)
+    {
+        if ($asString) {
+            return $this->_getAttrString($this->_attributes);
+        } else {
+            return $this->_attributes;
+        }
+    } //end func getAttributes
+
+    /**
+     * Updates the passed attributes without changing the other existing attributes
+     * @param    mixed   $attributes     Either a typical HTML attribute string or an associative array
+     * @access   public
+     */
+    function updateAttributes($attributes)
+    {
+        $this->_updateAttrArray($this->_attributes, $this->_parseAttributes($attributes));
+    } // end func updateAttributes
+
+    /**
+     * Removes an attribute
+     *
+     * @param     string    $attr   Attribute name
+     * @since     1.4
+     * @access    public
+     * @return    void
+     */
+    function removeAttribute($attr)
+    {
+        $this->_removeAttr($attr, $this->_attributes);
+    } //end func removeAttribute
+
+    /**
+     * Sets the line end style to Windows, Mac, Unix or a custom string.
+     *
+     * @param   string  $style  "win", "mac", "unix" or custom string.
+     * @since   1.7
+     * @access  public
+     * @return  void
+     */
+    function setLineEnd($style)
+    {
+        switch ($style) {
+            case 'win':
+                $this->_lineEnd = "\15\12";
+                break;
+            case 'unix':
+                $this->_lineEnd = "\12";
+                break;
+            case 'mac':
+                $this->_lineEnd = "\15";
+                break;
+            default:
+                $this->_lineEnd = $style;
+        }
+    } // end func setLineEnd
+
+    /**
+     * Sets the tab offset
+     *
+     * @param    int     $offset
+     * @access   public
+     */
+    function setTabOffset($offset)
+    {
+        $this->_tabOffset = $offset;
+    } // end func setTabOffset
+
+    /**
+     * Returns the tabOffset
+     *
+     * @since     1.5
+     * @access    public
+     * @return    int
+     */
+    function getTabOffset()
+    {
+        return $this->_tabOffset;
+    } //end func getTabOffset
+
+    /**
+     * Sets the string used to indent HTML
+     *
+     * @since     1.7
+     * @param     string    $string     String used to indent ("\11", "\t", '  ', etc.).
+     * @access    public
+     * @return    void
+     */
+    function setTab($string)
+    {
+        $this->_tab = $string;
+    } // end func setTab
+
+    /**
+     * Sets the HTML comment to be displayed at the beginning of the HTML string
+     *
+     * @param     string
+     * @since     1.4
+     * @access    public
+     * @return    void
+     */
+    function setComment($comment)
+    {
+        $this->_comment = $comment;
+    } // end func setHtmlComment
+
+    /**
+     * Returns the HTML comment
+     *
+     * @since     1.5
+     * @access    public
+     * @return    string
+     */
+    function getComment()
+    {
+        return $this->_comment;
+    } //end func getComment
+
+    /**
+     * Abstract method.  Must be extended to return the objects HTML
+     *
+     * @access    public
+     * @return    string
+     * @abstract
+     */
+    function toHtml()
+    {
+        return '';
+    } // end func toHtml
+
+    /**
+     * Displays the HTML to the screen
+     *
+     * @access    public
+     */
+    function display()
+    {
+        print $this->toHtml();
+    } // end func display
+
+    /**
+     * Sets the charset to use by htmlspecialchars() function
+     *
+     * Since this parameter is expected to be global, the function is designed
+     * to be called statically:
+     * <code>
+     * HTML_Common::charset('utf-8');
+     * </code>
+     * or
+     * <code>
+     * $charset = HTML_Common::charset();
+     * </code>
+     *
+     * @param   string  New charset to use. Omit if just getting the 
+     *                  current value. Consult the htmlspecialchars() docs 
+     *                  for a list of supported character sets.
+     * @return  string  Current charset
+     * @access  public
+     * @static
+     */
+    function charset($newCharset = null)
+    {
+        static $charset = 'ISO-8859-1';
+
+        if (!is_null($newCharset)) {
+            $charset = $newCharset;
+        }
+        return $charset;
+    } // end func charset
+} // end class HTML_Common
+?>
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm.php b/cookbooks/dmca/files/default/html/HTML/QuickForm.php
new file mode 100644 (file)
index 0000000..f769b1f
--- /dev/null
@@ -0,0 +1,2073 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * Create, validate and process HTML forms
+ *
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @author      Alexey Borzov <avb@php.net>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * PEAR and PEAR_Error classes, for error handling
+ */
+require_once 'PEAR.php';
+/**
+ * Base class for all HTML classes
+ */
+require_once 'HTML/Common.php';
+/**
+ * Static utility methods
+ */
+require_once 'HTML/QuickForm/utils.php';
+
+/**
+ * Element types known to HTML_QuickForm
+ * @see HTML_QuickForm::registerElementType(), HTML_QuickForm::getRegisteredTypes(),
+ *      HTML_QuickForm::isTypeRegistered()
+ * @global array $GLOBALS['HTML_QUICKFORM_ELEMENT_TYPES']
+ */
+$GLOBALS['HTML_QUICKFORM_ELEMENT_TYPES'] =
+        array(
+            'group'         =>array('HTML/QuickForm/group.php','HTML_QuickForm_group'),
+            'hidden'        =>array('HTML/QuickForm/hidden.php','HTML_QuickForm_hidden'),
+            'reset'         =>array('HTML/QuickForm/reset.php','HTML_QuickForm_reset'),
+            'checkbox'      =>array('HTML/QuickForm/checkbox.php','HTML_QuickForm_checkbox'),
+            'file'          =>array('HTML/QuickForm/file.php','HTML_QuickForm_file'),
+            'image'         =>array('HTML/QuickForm/image.php','HTML_QuickForm_image'),
+            'password'      =>array('HTML/QuickForm/password.php','HTML_QuickForm_password'),
+            'radio'         =>array('HTML/QuickForm/radio.php','HTML_QuickForm_radio'),
+            'button'        =>array('HTML/QuickForm/button.php','HTML_QuickForm_button'),
+            'submit'        =>array('HTML/QuickForm/submit.php','HTML_QuickForm_submit'),
+            'select'        =>array('HTML/QuickForm/select.php','HTML_QuickForm_select'),
+            'hiddenselect'  =>array('HTML/QuickForm/hiddenselect.php','HTML_QuickForm_hiddenselect'),
+            'text'          =>array('HTML/QuickForm/text.php','HTML_QuickForm_text'),
+            'textarea'      =>array('HTML/QuickForm/textarea.php','HTML_QuickForm_textarea'),
+            'link'          =>array('HTML/QuickForm/link.php','HTML_QuickForm_link'),
+            'advcheckbox'   =>array('HTML/QuickForm/advcheckbox.php','HTML_QuickForm_advcheckbox'),
+            'date'          =>array('HTML/QuickForm/date.php','HTML_QuickForm_date'),
+            'static'        =>array('HTML/QuickForm/static.php','HTML_QuickForm_static'),
+            'header'        =>array('HTML/QuickForm/header.php', 'HTML_QuickForm_header'),
+            'html'          =>array('HTML/QuickForm/html.php', 'HTML_QuickForm_html'),
+            'hierselect'    =>array('HTML/QuickForm/hierselect.php', 'HTML_QuickForm_hierselect'),
+            'autocomplete'  =>array('HTML/QuickForm/autocomplete.php', 'HTML_QuickForm_autocomplete'),
+            'xbutton'       =>array('HTML/QuickForm/xbutton.php','HTML_QuickForm_xbutton')
+        );
+
+/**
+ * Validation rules known to HTML_QuickForm
+ * @see HTML_QuickForm::registerRule(), HTML_QuickForm::getRegisteredRules(),
+ *      HTML_QuickForm::isRuleRegistered()
+ * @global array $GLOBALS['_HTML_QuickForm_registered_rules']
+ */
+$GLOBALS['_HTML_QuickForm_registered_rules'] = array(
+    'required'      => array('html_quickform_rule_required', 'HTML/QuickForm/Rule/Required.php'),
+    'maxlength'     => array('html_quickform_rule_range',    'HTML/QuickForm/Rule/Range.php'),
+    'minlength'     => array('html_quickform_rule_range',    'HTML/QuickForm/Rule/Range.php'),
+    'rangelength'   => array('html_quickform_rule_range',    'HTML/QuickForm/Rule/Range.php'),
+    'email'         => array('html_quickform_rule_email',    'HTML/QuickForm/Rule/Email.php'),
+    'regex'         => array('html_quickform_rule_regex',    'HTML/QuickForm/Rule/Regex.php'),
+    'lettersonly'   => array('html_quickform_rule_regex',    'HTML/QuickForm/Rule/Regex.php'),
+    'alphanumeric'  => array('html_quickform_rule_regex',    'HTML/QuickForm/Rule/Regex.php'),
+    'numeric'       => array('html_quickform_rule_regex',    'HTML/QuickForm/Rule/Regex.php'),
+    'nopunctuation' => array('html_quickform_rule_regex',    'HTML/QuickForm/Rule/Regex.php'),
+    'nonzero'       => array('html_quickform_rule_regex',    'HTML/QuickForm/Rule/Regex.php'),
+    'callback'      => array('html_quickform_rule_callback', 'HTML/QuickForm/Rule/Callback.php'),
+    'compare'       => array('html_quickform_rule_compare',  'HTML/QuickForm/Rule/Compare.php')
+);
+
+// {{{ error codes
+
+/**#@+
+ * Error codes for HTML_QuickForm
+ *
+ * Codes are mapped to textual messages by errorMessage() method, if you add a
+ * new code be sure to add a new message for it to errorMessage()
+ *
+ * @see HTML_QuickForm::errorMessage()
+ */
+define('QUICKFORM_OK',                      1);
+define('QUICKFORM_ERROR',                  -1);
+define('QUICKFORM_INVALID_RULE',           -2);
+define('QUICKFORM_NONEXIST_ELEMENT',       -3);
+define('QUICKFORM_INVALID_FILTER',         -4);
+define('QUICKFORM_UNREGISTERED_ELEMENT',   -5);
+define('QUICKFORM_INVALID_ELEMENT_NAME',   -6);
+define('QUICKFORM_INVALID_PROCESS',        -7);
+define('QUICKFORM_DEPRECATED',             -8);
+define('QUICKFORM_INVALID_DATASOURCE',     -9);
+/**#@-*/
+
+// }}}
+
+/**
+ * Create, validate and process HTML forms
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @author      Alexey Borzov <avb@php.net>
+ * @version     Release: 3.2.16
+ */
+class HTML_QuickForm extends HTML_Common
+{
+    // {{{ properties
+
+    /**
+     * Array containing the form fields
+     * @since     1.0
+     * @var  array
+     * @access   private
+     */
+    var $_elements = array();
+
+    /**
+     * Array containing element name to index map
+     * @since     1.1
+     * @var  array
+     * @access   private
+     */
+    var $_elementIndex = array();
+
+    /**
+     * Array containing indexes of duplicate elements
+     * @since     2.10
+     * @var  array
+     * @access   private
+     */
+    var $_duplicateIndex = array();
+
+    /**
+     * Array containing required field IDs
+     * @since     1.0
+     * @var  array
+     * @access   private
+     */
+    var $_required = array();
+
+    /**
+     * Prefix message in javascript alert if error
+     * @since     1.0
+     * @var  string
+     * @access   public
+     */
+    var $_jsPrefix = 'Invalid information entered.';
+
+    /**
+     * Postfix message in javascript alert if error
+     * @since     1.0
+     * @var  string
+     * @access   public
+     */
+    var $_jsPostfix = 'Please correct these fields.';
+
+    /**
+     * Datasource object implementing the informal
+     * datasource protocol
+     * @since     3.3
+     * @var  object
+     * @access   private
+     */
+    var $_datasource;
+
+    /**
+     * Array of default form values
+     * @since     2.0
+     * @var  array
+     * @access   private
+     */
+    var $_defaultValues = array();
+
+    /**
+     * Array of constant form values
+     * @since     2.0
+     * @var  array
+     * @access   private
+     */
+    var $_constantValues = array();
+
+    /**
+     * Array of submitted form values
+     * @since     1.0
+     * @var  array
+     * @access   private
+     */
+    var $_submitValues = array();
+
+    /**
+     * Array of submitted form files
+     * @since     1.0
+     * @var  integer
+     * @access   public
+     */
+    var $_submitFiles = array();
+
+    /**
+     * Value for maxfilesize hidden element if form contains file input
+     * @since     1.0
+     * @var  integer
+     * @access   public
+     */
+    var $_maxFileSize = 1048576; // 1 Mb = 1048576
+
+    /**
+     * Flag to know if all fields are frozen
+     * @since     1.0
+     * @var  boolean
+     * @access   private
+     */
+    var $_freezeAll = false;
+
+    /**
+     * Array containing the form rules
+     * @since     1.0
+     * @var  array
+     * @access   private
+     */
+    var $_rules = array();
+
+    /**
+     * Form rules, global variety
+     * @var     array
+     * @access  private
+     */
+    var $_formRules = array();
+
+    /**
+     * Array containing the validation errors
+     * @since     1.0
+     * @var  array
+     * @access   private
+     */
+    var $_errors = array();
+
+    /**
+     * Note for required fields in the form
+     * @var       string
+     * @since     1.0
+     * @access    private
+     */
+    var $_requiredNote = '<span style="font-size:80%; color:#ff0000;">*</span><span style="font-size:80%;"> denotes required field</span>';
+
+    /**
+     * Whether the form was submitted
+     * @var       boolean
+     * @access    private
+     */
+    var $_flagSubmitted = false;
+
+    // }}}
+    // {{{ constructor
+
+    /**
+     * Class constructor
+     * @param    string      $formName          Form's name.
+     * @param    string      $method            (optional)Form's method defaults to 'POST'
+     * @param    string      $action            (optional)Form's action
+     * @param    string      $target            (optional)Form's target defaults to '_self'
+     * @param    mixed       $attributes        (optional)Extra attributes for <form> tag
+     * @param    bool        $trackSubmit       (optional)Whether to track if the form was submitted by adding a special hidden field
+     * @access   public
+     */
+    function HTML_QuickForm($formName='', $method='post', $action='', $target='', $attributes=null, $trackSubmit = false)
+    {
+        HTML_Common::HTML_Common($attributes);
+        $method = (strtoupper($method) == 'GET') ? 'get' : 'post';
+        $action = ($action == '') ? $_SERVER['PHP_SELF'] : $action;
+        $target = empty($target) ? array() : array('target' => $target);
+        $attributes = array('action'=>$action, 'method'=>$method, 'name'=>$formName, 'id'=>$formName) + $target;
+        $this->updateAttributes($attributes);
+        if (!$trackSubmit || isset($_REQUEST['_qf__' . $formName])) {
+            if (1 == get_magic_quotes_gpc()) {
+                $this->_submitValues = $this->_recursiveFilter('stripslashes', 'get' == $method? $_GET: $_POST);
+                foreach ($_FILES as $keyFirst => $valFirst) {
+                    foreach ($valFirst as $keySecond => $valSecond) {
+                        if ('name' == $keySecond) {
+                            $this->_submitFiles[$keyFirst][$keySecond] = $this->_recursiveFilter('stripslashes', $valSecond);
+                        } else {
+                            $this->_submitFiles[$keyFirst][$keySecond] = $valSecond;
+                        }
+                    }
+                }
+            } else {
+                $this->_submitValues = 'get' == $method? $_GET: $_POST;
+                $this->_submitFiles  = $_FILES;
+            }
+            $this->_flagSubmitted = count($this->_submitValues) > 0 || count($this->_submitFiles) > 0;
+        }
+        if ($trackSubmit) {
+            unset($this->_submitValues['_qf__' . $formName]);
+            $this->addElement('hidden', '_qf__' . $formName, null);
+        }
+        if (preg_match('/^([0-9]+)([a-zA-Z]*)$/', ini_get('upload_max_filesize'), $matches)) {
+            // see http://www.php.net/manual/en/faq.using.php#faq.using.shorthandbytes
+            switch (strtoupper($matches['2'])) {
+                case 'G':
+                    $this->_maxFileSize = $matches['1'] * 1073741824;
+                    break;
+                case 'M':
+                    $this->_maxFileSize = $matches['1'] * 1048576;
+                    break;
+                case 'K':
+                    $this->_maxFileSize = $matches['1'] * 1024;
+                    break;
+                default:
+                    $this->_maxFileSize = $matches['1'];
+            }
+        }
+    } // end constructor
+
+    // }}}
+    // {{{ apiVersion()
+
+    /**
+     * Returns the current API version
+     *
+     * @since     1.0
+     * @access    public
+     * @return    float
+     */
+    function apiVersion()
+    {
+        return 3.2;
+    } // end func apiVersion
+
+    // }}}
+    // {{{ registerElementType()
+
+    /**
+     * Registers a new element type
+     *
+     * @param     string    $typeName   Name of element type
+     * @param     string    $include    Include path for element type
+     * @param     string    $className  Element class name
+     * @since     1.0
+     * @access    public
+     * @return    void
+     */
+    function registerElementType($typeName, $include, $className)
+    {
+        $GLOBALS['HTML_QUICKFORM_ELEMENT_TYPES'][strtolower($typeName)] = array($include, $className);
+    } // end func registerElementType
+
+    // }}}
+    // {{{ registerRule()
+
+    /**
+     * Registers a new validation rule
+     *
+     * @param     string    $ruleName   Name of validation rule
+     * @param     string    $type       Either: 'regex', 'function' or 'rule' for an HTML_QuickForm_Rule object
+     * @param     string    $data1      Name of function, regular expression or HTML_QuickForm_Rule classname
+     * @param     string    $data2      Object parent of above function or HTML_QuickForm_Rule file path
+     * @since     1.0
+     * @access    public
+     * @return    void
+     */
+    function registerRule($ruleName, $type, $data1, $data2 = null)
+    {
+        include_once('HTML/QuickForm/RuleRegistry.php');
+        $registry =& HTML_QuickForm_RuleRegistry::singleton();
+        $registry->registerRule($ruleName, $type, $data1, $data2);
+    } // end func registerRule
+
+    // }}}
+    // {{{ elementExists()
+
+    /**
+     * Returns true if element is in the form
+     *
+     * @param     string   $element         form name of element to check
+     * @since     1.0
+     * @access    public
+     * @return    boolean
+     */
+    function elementExists($element=null)
+    {
+        return isset($this->_elementIndex[$element]);
+    } // end func elementExists
+
+    // }}}
+    // {{{ setDatasource()
+
+    /**
+     * Sets a datasource object for this form object
+     *
+     * Datasource default and constant values will feed the QuickForm object if
+     * the datasource implements defaultValues() and constantValues() methods.
+     *
+     * @param     object   $datasource          datasource object implementing the informal datasource protocol
+     * @param     mixed    $defaultsFilter      string or array of filter(s) to apply to default values
+     * @param     mixed    $constantsFilter     string or array of filter(s) to apply to constants values
+     * @since     3.3
+     * @access    public
+     * @return    void
+     * @throws    HTML_QuickForm_Error
+     */
+    function setDatasource(&$datasource, $defaultsFilter = null, $constantsFilter = null)
+    {
+        if (is_object($datasource)) {
+            $this->_datasource =& $datasource;
+            if (is_callable(array($datasource, 'defaultValues'))) {
+                $this->setDefaults($datasource->defaultValues($this), $defaultsFilter);
+            }
+            if (is_callable(array($datasource, 'constantValues'))) {
+                $this->setConstants($datasource->constantValues($this), $constantsFilter);
+            }
+        } else {
+            return PEAR::raiseError(null, QUICKFORM_INVALID_DATASOURCE, null, E_USER_WARNING, "Datasource is not an object in QuickForm::setDatasource()", 'HTML_QuickForm_Error', true);
+        }
+    } // end func setDatasource
+
+    // }}}
+    // {{{ setDefaults()
+
+    /**
+     * Initializes default form values
+     *
+     * @param     array    $defaultValues       values used to fill the form
+     * @param     mixed    $filter              (optional) filter(s) to apply to all default values
+     * @since     1.0
+     * @access    public
+     * @return    void
+     * @throws    HTML_QuickForm_Error
+     */
+    function setDefaults($defaultValues = null, $filter = null)
+    {
+        if (is_array($defaultValues)) {
+            if (isset($filter)) {
+                if (is_array($filter) && (2 != count($filter) || !is_callable($filter))) {
+                    foreach ($filter as $val) {
+                        if (!is_callable($val)) {
+                            return PEAR::raiseError(null, QUICKFORM_INVALID_FILTER, null, E_USER_WARNING, "Callback function does not exist in QuickForm::setDefaults()", 'HTML_QuickForm_Error', true);
+                        } else {
+                            $defaultValues = $this->_recursiveFilter($val, $defaultValues);
+                        }
+                    }
+                } elseif (!is_callable($filter)) {
+                    return PEAR::raiseError(null, QUICKFORM_INVALID_FILTER, null, E_USER_WARNING, "Callback function does not exist in QuickForm::setDefaults()", 'HTML_QuickForm_Error', true);
+                } else {
+                    $defaultValues = $this->_recursiveFilter($filter, $defaultValues);
+                }
+            }
+            $this->_defaultValues = HTML_QuickForm::arrayMerge($this->_defaultValues, $defaultValues);
+            foreach (array_keys($this->_elements) as $key) {
+                $this->_elements[$key]->onQuickFormEvent('updateValue', null, $this);
+            }
+        }
+    } // end func setDefaults
+
+    // }}}
+    // {{{ setConstants()
+
+    /**
+     * Initializes constant form values.
+     * These values won't get overridden by POST or GET vars
+     *
+     * @param     array   $constantValues        values used to fill the form
+     * @param     mixed    $filter              (optional) filter(s) to apply to all default values
+     *
+     * @since     2.0
+     * @access    public
+     * @return    void
+     * @throws    HTML_QuickForm_Error
+     */
+    function setConstants($constantValues = null, $filter = null)
+    {
+        if (is_array($constantValues)) {
+            if (isset($filter)) {
+                if (is_array($filter) && (2 != count($filter) || !is_callable($filter))) {
+                    foreach ($filter as $val) {
+                        if (!is_callable($val)) {
+                            return PEAR::raiseError(null, QUICKFORM_INVALID_FILTER, null, E_USER_WARNING, "Callback function does not exist in QuickForm::setConstants()", 'HTML_QuickForm_Error', true);
+                        } else {
+                            $constantValues = $this->_recursiveFilter($val, $constantValues);
+                        }
+                    }
+                } elseif (!is_callable($filter)) {
+                    return PEAR::raiseError(null, QUICKFORM_INVALID_FILTER, null, E_USER_WARNING, "Callback function does not exist in QuickForm::setConstants()", 'HTML_QuickForm_Error', true);
+                } else {
+                    $constantValues = $this->_recursiveFilter($filter, $constantValues);
+                }
+            }
+            $this->_constantValues = HTML_QuickForm::arrayMerge($this->_constantValues, $constantValues);
+            foreach (array_keys($this->_elements) as $key) {
+                $this->_elements[$key]->onQuickFormEvent('updateValue', null, $this);
+            }
+        }
+    } // end func setConstants
+
+    // }}}
+    // {{{ setMaxFileSize()
+
+    /**
+     * Sets the value of MAX_FILE_SIZE hidden element
+     *
+     * @param     int    $bytes    Size in bytes
+     * @since     3.0
+     * @access    public
+     * @return    void
+     */
+    function setMaxFileSize($bytes = 0)
+    {
+        if ($bytes > 0) {
+            $this->_maxFileSize = $bytes;
+        }
+        if (!$this->elementExists('MAX_FILE_SIZE')) {
+            $this->addElement('hidden', 'MAX_FILE_SIZE', $this->_maxFileSize);
+        } else {
+            $el =& $this->getElement('MAX_FILE_SIZE');
+            $el->updateAttributes(array('value' => $this->_maxFileSize));
+        }
+    } // end func setMaxFileSize
+
+    // }}}
+    // {{{ getMaxFileSize()
+
+    /**
+     * Returns the value of MAX_FILE_SIZE hidden element
+     *
+     * @since     3.0
+     * @access    public
+     * @return    int   max file size in bytes
+     */
+    function getMaxFileSize()
+    {
+        return $this->_maxFileSize;
+    } // end func getMaxFileSize
+
+    // }}}
+    // {{{ &createElement()
+
+    /**
+     * Creates a new form element of the given type.
+     *
+     * This method accepts variable number of parameters, their
+     * meaning and count depending on $elementType
+     *
+     * @param     string     $elementType    type of element to add (text, textarea, file...)
+     * @since     1.0
+     * @access    public
+     * @return    HTML_QuickForm_Element
+     * @throws    HTML_QuickForm_Error
+     */
+    function &createElement($elementType)
+    {
+        $args    =  func_get_args();
+        $element =& HTML_QuickForm::_loadElement('createElement', $elementType, array_slice($args, 1), null);
+        return $element;
+    } // end func createElement
+
+    // }}}
+    // {{{ _loadElement()
+
+    /**
+     * Returns a form element of the given type
+     *
+     * @param     string   $event   event to send to newly created element ('createElement' or 'addElement')
+     * @param     string   $type    element type
+     * @param     array    $args    arguments for event
+     * @since     2.0
+     * @access    private
+     * @return    HTML_QuickForm_Element
+     * @throws    HTML_QuickForm_Error
+     */
+    function &_loadElement($event, $type, $args, $form)
+    {
+        $type = strtolower($type);
+        if (!HTML_QuickForm::isTypeRegistered($type)) {
+            $error = PEAR::raiseError(null, QUICKFORM_UNREGISTERED_ELEMENT, null, E_USER_WARNING, "Element '$type' does not exist in HTML_QuickForm::_loadElement()", 'HTML_QuickForm_Error', true);
+            return $error;
+        }
+        $className = $GLOBALS['HTML_QUICKFORM_ELEMENT_TYPES'][$type][1];
+        $includeFile = $GLOBALS['HTML_QUICKFORM_ELEMENT_TYPES'][$type][0];
+        include_once($includeFile);
+        $elementObject = new $className();
+        for ($i = 0; $i < 5; $i++) {
+            if (!isset($args[$i])) {
+                $args[$i] = null;
+            }
+        }
+        $err = $elementObject->onQuickFormEvent($event, $args, $form);
+        if ($err !== true) {
+            return $err;
+        }
+        return $elementObject;
+    } // end func _loadElement
+
+    // }}}
+    // {{{ addElement()
+
+    /**
+     * Adds an element into the form
+     *
+     * If $element is a string representing element type, then this
+     * method accepts variable number of parameters, their meaning
+     * and count depending on $element
+     *
+     * @param    mixed      $element        element object or type of element to add (text, textarea, file...)
+     * @since    1.0
+     * @return   HTML_QuickForm_Element     a reference to newly added element
+     * @access   public
+     * @throws   HTML_QuickForm_Error
+     */
+    function &addElement($element)
+    {
+        if (is_object($element) && is_subclass_of($element, 'html_quickform_element')) {
+           $elementObject = &$element;
+           $elementObject->onQuickFormEvent('updateValue', null, $this);
+        } else {
+            $args = func_get_args();
+            $elementObject =& $this->_loadElement('addElement', $element, array_slice($args, 1), $this);
+            if (PEAR::isError($elementObject)) {
+                return $elementObject;
+            }
+        }
+        $elementName = $elementObject->getName();
+
+        // Add the element if it is not an incompatible duplicate
+        if (!empty($elementName) && isset($this->_elementIndex[$elementName])) {
+            if ($this->_elements[$this->_elementIndex[$elementName]]->getType() ==
+                $elementObject->getType()) {
+                $this->_elements[] =& $elementObject;
+                $elKeys = array_keys($this->_elements);
+                $this->_duplicateIndex[$elementName][] = end($elKeys);
+            } else {
+                $error = PEAR::raiseError(null, QUICKFORM_INVALID_ELEMENT_NAME, null, E_USER_WARNING, "Element '$elementName' already exists in HTML_QuickForm::addElement()", 'HTML_QuickForm_Error', true);
+                return $error;
+            }
+        } else {
+            $this->_elements[] =& $elementObject;
+            $elKeys = array_keys($this->_elements);
+            $this->_elementIndex[$elementName] = end($elKeys);
+        }
+        if ($this->_freezeAll) {
+            $elementObject->freeze();
+        }
+
+        return $elementObject;
+    } // end func addElement
+
+    // }}}
+    // {{{ insertElementBefore()
+
+   /**
+    * Inserts a new element right before the other element
+    *
+    * Warning: it is not possible to check whether the $element is already
+    * added to the form, therefore if you want to move the existing form
+    * element to a new position, you'll have to use removeElement():
+    * $form->insertElementBefore($form->removeElement('foo', false), 'bar');
+    *
+    * @access   public
+    * @since    3.2.4
+    * @param    HTML_QuickForm_element  Element to insert
+    * @param    string                  Name of the element before which the new
+    *                                   one is inserted
+    * @return   HTML_QuickForm_element  reference to inserted element
+    * @throws   HTML_QuickForm_Error
+    */
+    function &insertElementBefore(&$element, $nameAfter)
+    {
+        if (!empty($this->_duplicateIndex[$nameAfter])) {
+            $error = PEAR::raiseError(null, QUICKFORM_INVALID_ELEMENT_NAME, null, E_USER_WARNING, 'Several elements named "' . $nameAfter . '" exist in HTML_QuickForm::insertElementBefore().', 'HTML_QuickForm_Error', true);
+            return $error;
+        } elseif (!$this->elementExists($nameAfter)) {
+            $error = PEAR::raiseError(null, QUICKFORM_NONEXIST_ELEMENT, null, E_USER_WARNING, "Element '$nameAfter' does not exist in HTML_QuickForm::insertElementBefore()", 'HTML_QuickForm_Error', true);
+            return $error;
+        }
+        $elementName = $element->getName();
+        $targetIdx   = $this->_elementIndex[$nameAfter];
+        $duplicate   = false;
+        // Like in addElement(), check that it's not an incompatible duplicate
+        if (!empty($elementName) && isset($this->_elementIndex[$elementName])) {
+            if ($this->_elements[$this->_elementIndex[$elementName]]->getType() != $element->getType()) {
+                $error = PEAR::raiseError(null, QUICKFORM_INVALID_ELEMENT_NAME, null, E_USER_WARNING, "Element '$elementName' already exists in HTML_QuickForm::insertElementBefore()", 'HTML_QuickForm_Error', true);
+                return $error;
+            }
+            $duplicate = true;
+        }
+        // Move all the elements after added back one place, reindex _elementIndex and/or _duplicateIndex
+        $elKeys = array_keys($this->_elements);
+        for ($i = end($elKeys); $i >= $targetIdx; $i--) {
+            if (isset($this->_elements[$i])) {
+                $currentName = $this->_elements[$i]->getName();
+                $this->_elements[$i + 1] =& $this->_elements[$i];
+                if ($this->_elementIndex[$currentName] == $i) {
+                    $this->_elementIndex[$currentName] = $i + 1;
+                } else {
+                    $dupIdx = array_search($i, $this->_duplicateIndex[$currentName]);
+                    $this->_duplicateIndex[$currentName][$dupIdx] = $i + 1;
+                }
+                unset($this->_elements[$i]);
+            }
+        }
+        // Put the element in place finally
+        $this->_elements[$targetIdx] =& $element;
+        if (!$duplicate) {
+            $this->_elementIndex[$elementName] = $targetIdx;
+        } else {
+            $this->_duplicateIndex[$elementName][] = $targetIdx;
+        }
+        $element->onQuickFormEvent('updateValue', null, $this);
+        if ($this->_freezeAll) {
+            $element->freeze();
+        }
+        // If not done, the elements will appear in reverse order
+        ksort($this->_elements);
+        return $element;
+    }
+
+    // }}}
+    // {{{ addGroup()
+
+    /**
+     * Adds an element group
+     * @param    array      $elements       array of elements composing the group
+     * @param    string     $name           (optional)group name
+     * @param    string     $groupLabel     (optional)group label
+     * @param    string     $separator      (optional)string to separate elements
+     * @param    string     $appendName     (optional)specify whether the group name should be
+     *                                      used in the form element name ex: group[element]
+     * @return   HTML_QuickForm_group       reference to a newly added group
+     * @since    2.8
+     * @access   public
+     * @throws   HTML_QuickForm_Error
+     */
+    function &addGroup($elements, $name=null, $groupLabel='', $separator=null, $appendName = true)
+    {
+        static $anonGroups = 1;
+
+        if (0 == strlen($name)) {
+            $name       = 'qf_group_' . $anonGroups++;
+            $appendName = false;
+        }
+        $group =& $this->addElement('group', $name, $groupLabel, $elements, $separator, $appendName);
+        return $group;
+    } // end func addGroup
+
+    // }}}
+    // {{{ &getElement()
+
+    /**
+     * Returns a reference to the element
+     *
+     * @param     string     $element    Element name
+     * @since     2.0
+     * @access    public
+     * @return    HTML_QuickForm_element    reference to element
+     * @throws    HTML_QuickForm_Error
+     */
+    function &getElement($element)
+    {
+        if (isset($this->_elementIndex[$element])) {
+            return $this->_elements[$this->_elementIndex[$element]];
+        } else {
+            $error = PEAR::raiseError(null, QUICKFORM_NONEXIST_ELEMENT, null, E_USER_WARNING, "Element '$element' does not exist in HTML_QuickForm::getElement()", 'HTML_QuickForm_Error', true);
+            return $error;
+        }
+    } // end func getElement
+
+    // }}}
+    // {{{ &getElementValue()
+
+    /**
+     * Returns the element's raw value
+     *
+     * This returns the value as submitted by the form (not filtered)
+     * or set via setDefaults() or setConstants()
+     *
+     * @param     string     $element    Element name
+     * @since     2.0
+     * @access    public
+     * @return    mixed     element value
+     * @throws    HTML_QuickForm_Error
+     */
+    function &getElementValue($element)
+    {
+        if (!isset($this->_elementIndex[$element])) {
+            $error = PEAR::raiseError(null, QUICKFORM_NONEXIST_ELEMENT, null, E_USER_WARNING, "Element '$element' does not exist in HTML_QuickForm::getElementValue()", 'HTML_QuickForm_Error', true);
+            return $error;
+        }
+        $value = $this->_elements[$this->_elementIndex[$element]]->getValue();
+        if (isset($this->_duplicateIndex[$element])) {
+            foreach ($this->_duplicateIndex[$element] as $index) {
+                if (null !== ($v = $this->_elements[$index]->getValue())) {
+                    if (is_array($value)) {
+                        $value[] = $v;
+                    } else {
+                        $value = (null === $value)? $v: array($value, $v);
+                    }
+                }
+            }
+        }
+        return $value;
+    } // end func getElementValue
+
+    // }}}
+    // {{{ getSubmitValue()
+
+    /**
+     * Returns the elements value after submit and filter
+     *
+     * @param     string     Element name
+     * @since     2.0
+     * @access    public
+     * @return    mixed     submitted element value or null if not set
+     */
+    function getSubmitValue($elementName)
+    {
+        $value = null;
+        if (isset($this->_submitValues[$elementName]) || isset($this->_submitFiles[$elementName])) {
+            $value = isset($this->_submitValues[$elementName])? $this->_submitValues[$elementName]: array();
+            if (is_array($value) && isset($this->_submitFiles[$elementName])) {
+                foreach ($this->_submitFiles[$elementName] as $k => $v) {
+                    $value = HTML_QuickForm::arrayMerge($value, $this->_reindexFiles($this->_submitFiles[$elementName][$k], $k));
+                }
+            }
+
+        } elseif ('file' == $this->getElementType($elementName)) {
+            return $this->getElementValue($elementName);
+
+        } elseif (false !== ($pos = strpos($elementName, '['))) {
+            $base = str_replace(
+                        array('\\', '\''), array('\\\\', '\\\''),
+                        substr($elementName, 0, $pos)
+                    );
+
+            $keys = str_replace(
+                array('\\', '\'', ']', '['), array('\\\\', '\\\'', '', "']['"),
+                substr($elementName, $pos + 1, -1)
+                );
+            $idx  = "['" . $keys . "']";
+            $keyArray = explode("']['", $keys);
+
+            if (isset($this->_submitValues[$base])) {
+                $value = HTML_QuickForm_utils::recursiveValue($this->_submitValues[$base], $keyArray, NULL);
+            }
+
+            if ((is_array($value) || null === $value) && isset($this->_submitFiles[$base])) {
+                $props = array('name', 'type', 'size', 'tmp_name', 'error');
+                $code  = "if (!isset(\$this->_submitFiles['{$base}']['name']{$idx})) {\n" .
+                         "    return null;\n" .
+                         "} else {\n" .
+                         "    \$v = array();\n";
+                foreach ($props as $prop) {
+                    $code .= "    \$v = HTML_QuickForm::arrayMerge(\$v, \$this->_reindexFiles(\$this->_submitFiles['{$base}']['{$prop}']{$idx}, '{$prop}'));\n";
+                }
+                $fileValue = eval($code . "    return \$v;\n}\n");
+                if (null !== $fileValue) {
+                    $value = null === $value? $fileValue: HTML_QuickForm::arrayMerge($value, $fileValue);
+                }
+            }
+        }
+
+        // This is only supposed to work for groups with appendName = false
+        if (null === $value && 'group' == $this->getElementType($elementName)) {
+            $group    =& $this->getElement($elementName);
+            $elements =& $group->getElements();
+            foreach (array_keys($elements) as $key) {
+                $name = $group->getElementName($key);
+                // prevent endless recursion in case of radios and such
+                if ($name != $elementName) {
+                    if (null !== ($v = $this->getSubmitValue($name))) {
+                        $value[$name] = $v;
+                    }
+                }
+            }
+        }
+        return $value;
+    } // end func getSubmitValue
+
+    // }}}
+    // {{{ _reindexFiles()
+
+   /**
+    * A helper function to change the indexes in $_FILES array
+    *
+    * @param  mixed   Some value from the $_FILES array
+    * @param  string  The key from the $_FILES array that should be appended
+    * @return array
+    */
+    function _reindexFiles($value, $key)
+    {
+        if (!is_array($value)) {
+            return array($key => $value);
+        } else {
+            $ret = array();
+            foreach ($value as $k => $v) {
+                $ret[$k] = $this->_reindexFiles($v, $key);
+            }
+            return $ret;
+        }
+    }
+
+    // }}}
+    // {{{ getElementError()
+
+    /**
+     * Returns error corresponding to validated element
+     *
+     * @param     string    $element        Name of form element to check
+     * @since     1.0
+     * @access    public
+     * @return    string    error message corresponding to checked element
+     */
+    function getElementError($element)
+    {
+        if (isset($this->_errors[$element])) {
+            return $this->_errors[$element];
+        }
+    } // end func getElementError
+
+    // }}}
+    // {{{ setElementError()
+
+    /**
+     * Set error message for a form element
+     *
+     * @param     string    $element    Name of form element to set error for
+     * @param     string    $message    Error message, if empty then removes the current error message
+     * @since     1.0
+     * @access    public
+     * @return    void
+     */
+    function setElementError($element, $message = null)
+    {
+        if (!empty($message)) {
+            $this->_errors[$element] = $message;
+        } else {
+            unset($this->_errors[$element]);
+        }
+    } // end func setElementError
+
+     // }}}
+     // {{{ getElementType()
+
+     /**
+      * Returns the type of the given element
+      *
+      * @param      string    $element    Name of form element
+      * @since      1.1
+      * @access     public
+      * @return     string    Type of the element, false if the element is not found
+      */
+     function getElementType($element)
+     {
+         if (isset($this->_elementIndex[$element])) {
+             return $this->_elements[$this->_elementIndex[$element]]->getType();
+         }
+         return false;
+     } // end func getElementType
+
+     // }}}
+     // {{{ updateElementAttr()
+
+    /**
+     * Updates Attributes for one or more elements
+     *
+     * @param      mixed    $elements   Array of element names/objects or string of elements to be updated
+     * @param      mixed    $attrs      Array or sting of html attributes
+     * @since      2.10
+     * @access     public
+     * @return     void
+     */
+    function updateElementAttr($elements, $attrs)
+    {
+        if (is_string($elements)) {
+            $elements = preg_split('/[ ]?,[ ]?/', $elements);
+        }
+        foreach (array_keys($elements) as $key) {
+            if (is_object($elements[$key]) && is_a($elements[$key], 'HTML_QuickForm_element')) {
+                $elements[$key]->updateAttributes($attrs);
+            } elseif (isset($this->_elementIndex[$elements[$key]])) {
+                $this->_elements[$this->_elementIndex[$elements[$key]]]->updateAttributes($attrs);
+                if (isset($this->_duplicateIndex[$elements[$key]])) {
+                    foreach ($this->_duplicateIndex[$elements[$key]] as $index) {
+                        $this->_elements[$index]->updateAttributes($attrs);
+                    }
+                }
+            }
+        }
+    } // end func updateElementAttr
+
+    // }}}
+    // {{{ removeElement()
+
+    /**
+     * Removes an element
+     *
+     * The method "unlinks" an element from the form, returning the reference
+     * to the element object. If several elements named $elementName exist,
+     * it removes the first one, leaving the others intact.
+     *
+     * @param string    $elementName The element name
+     * @param boolean   $removeRules True if rules for this element are to be removed too
+     * @access public
+     * @since 2.0
+     * @return HTML_QuickForm_element    a reference to the removed element
+     * @throws HTML_QuickForm_Error
+     */
+    function &removeElement($elementName, $removeRules = true)
+    {
+        if (!isset($this->_elementIndex[$elementName])) {
+            $error = PEAR::raiseError(null, QUICKFORM_NONEXIST_ELEMENT, null, E_USER_WARNING, "Element '$elementName' does not exist in HTML_QuickForm::removeElement()", 'HTML_QuickForm_Error', true);
+            return $error;
+        }
+        $el =& $this->_elements[$this->_elementIndex[$elementName]];
+        unset($this->_elements[$this->_elementIndex[$elementName]]);
+        if (empty($this->_duplicateIndex[$elementName])) {
+            unset($this->_elementIndex[$elementName]);
+        } else {
+            $this->_elementIndex[$elementName] = array_shift($this->_duplicateIndex[$elementName]);
+        }
+        if ($removeRules) {
+            $this->_required = array_diff($this->_required, array($elementName));
+            unset($this->_rules[$elementName], $this->_errors[$elementName]);
+            if ('group' == $el->getType()) {
+                foreach (array_keys($el->getElements()) as $key) {
+                    unset($this->_rules[$el->getElementName($key)]);
+                }
+            }
+        }
+        return $el;
+    } // end func removeElement
+
+    // }}}
+    // {{{ addRule()
+
+    /**
+     * Adds a validation rule for the given field
+     *
+     * If the element is in fact a group, it will be considered as a whole.
+     * To validate grouped elements as separated entities,
+     * use addGroupRule instead of addRule.
+     *
+     * @param    string     $element       Form element name
+     * @param    string     $message       Message to display for invalid data
+     * @param    string     $type          Rule type, use getRegisteredRules() to get types
+     * @param    string     $format        (optional)Required for extra rule data
+     * @param    string     $validation    (optional)Where to perform validation: "server", "client"
+     * @param    boolean    $reset         Client-side validation: reset the form element to its original value if there is an error?
+     * @param    boolean    $force         Force the rule to be applied, even if the target form element does not exist
+     * @since    1.0
+     * @access   public
+     * @throws   HTML_QuickForm_Error
+     */
+    function addRule($element, $message, $type, $format=null, $validation='server', $reset = false, $force = false)
+    {
+        if (!$force) {
+            if (!is_array($element) && !$this->elementExists($element)) {
+                return PEAR::raiseError(null, QUICKFORM_NONEXIST_ELEMENT, null, E_USER_WARNING, "Element '$element' does not exist in HTML_QuickForm::addRule()", 'HTML_QuickForm_Error', true);
+            } elseif (is_array($element)) {
+                foreach ($element as $el) {
+                    if (!$this->elementExists($el)) {
+                        return PEAR::raiseError(null, QUICKFORM_NONEXIST_ELEMENT, null, E_USER_WARNING, "Element '$el' does not exist in HTML_QuickForm::addRule()", 'HTML_QuickForm_Error', true);
+                    }
+                }
+            }
+        }
+        if (false === ($newName = $this->isRuleRegistered($type, true))) {
+            return PEAR::raiseError(null, QUICKFORM_INVALID_RULE, null, E_USER_WARNING, "Rule '$type' is not registered in HTML_QuickForm::addRule()", 'HTML_QuickForm_Error', true);
+        } elseif (is_string($newName)) {
+            $type = $newName;
+        }
+        if (is_array($element)) {
+            $dependent = $element;
+            $element   = array_shift($dependent);
+        } else {
+            $dependent = null;
+        }
+        if ($type == 'required' || $type == 'uploadedfile') {
+            $this->_required[] = $element;
+        }
+        if (!isset($this->_rules[$element])) {
+            $this->_rules[$element] = array();
+        }
+        if ($validation == 'client') {
+            $this->updateAttributes(array('onsubmit' => 'try { var myValidator = validate_' . $this->_attributes['id'] . '; } catch(e) { return true; } return myValidator(this);'));
+        }
+        $this->_rules[$element][] = array(
+            'type'        => $type,
+            'format'      => $format,
+            'message'     => $message,
+            'validation'  => $validation,
+            'reset'       => $reset,
+            'dependent'   => $dependent
+        );
+    } // end func addRule
+
+    // }}}
+    // {{{ addGroupRule()
+
+    /**
+     * Adds a validation rule for the given group of elements
+     *
+     * Only groups with a name can be assigned a validation rule
+     * Use addGroupRule when you need to validate elements inside the group.
+     * Use addRule if you need to validate the group as a whole. In this case,
+     * the same rule will be applied to all elements in the group.
+     * Use addRule if you need to validate the group against a function.
+     *
+     * @param    string     $group         Form group name
+     * @param    mixed      $arg1          Array for multiple elements or error message string for one element
+     * @param    string     $type          (optional)Rule type use getRegisteredRules() to get types
+     * @param    string     $format        (optional)Required for extra rule data
+     * @param    int        $howmany       (optional)How many valid elements should be in the group
+     * @param    string     $validation    (optional)Where to perform validation: "server", "client"
+     * @param    bool       $reset         Client-side: whether to reset the element's value to its original state if validation failed.
+     * @since    2.5
+     * @access   public
+     * @throws   HTML_QuickForm_Error
+     */
+    function addGroupRule($group, $arg1, $type='', $format=null, $howmany=0, $validation = 'server', $reset = false)
+    {
+        if (!$this->elementExists($group)) {
+            return PEAR::raiseError(null, QUICKFORM_NONEXIST_ELEMENT, null, E_USER_WARNING, "Group '$group' does not exist in HTML_QuickForm::addGroupRule()", 'HTML_QuickForm_Error', true);
+        }
+
+        $groupObj =& $this->getElement($group);
+        if (is_array($arg1)) {
+            $required = 0;
+            foreach ($arg1 as $elementIndex => $rules) {
+                $elementName = $groupObj->getElementName($elementIndex);
+                foreach ($rules as $rule) {
+                    $format = (isset($rule[2])) ? $rule[2] : null;
+                    $validation = (isset($rule[3]) && 'client' == $rule[3])? 'client': 'server';
+                    $reset = isset($rule[4]) && $rule[4];
+                    $type = $rule[1];
+                    if (false === ($newName = $this->isRuleRegistered($type, true))) {
+                        return PEAR::raiseError(null, QUICKFORM_INVALID_RULE, null, E_USER_WARNING, "Rule '$type' is not registered in HTML_QuickForm::addGroupRule()", 'HTML_QuickForm_Error', true);
+                    } elseif (is_string($newName)) {
+                        $type = $newName;
+                    }
+
+                    $this->_rules[$elementName][] = array(
+                                                        'type'        => $type,
+                                                        'format'      => $format,
+                                                        'message'     => $rule[0],
+                                                        'validation'  => $validation,
+                                                        'reset'       => $reset,
+                                                        'group'       => $group);
+
+                    if ('required' == $type || 'uploadedfile' == $type) {
+                        $groupObj->_required[] = $elementName;
+                        $this->_required[] = $elementName;
+                        $required++;
+                    }
+                    if ('client' == $validation) {
+                        $this->updateAttributes(array('onsubmit' => 'try { var myValidator = validate_' . $this->_attributes['id'] . '; } catch(e) { return true; } return myValidator(this);'));
+                    }
+                }
+            }
+            if ($required > 0 && count($groupObj->getElements()) == $required) {
+                $this->_required[] = $group;
+            }
+        } elseif (is_string($arg1)) {
+            if (false === ($newName = $this->isRuleRegistered($type, true))) {
+                return PEAR::raiseError(null, QUICKFORM_INVALID_RULE, null, E_USER_WARNING, "Rule '$type' is not registered in HTML_QuickForm::addGroupRule()", 'HTML_QuickForm_Error', true);
+            } elseif (is_string($newName)) {
+                $type = $newName;
+            }
+
+            // addGroupRule() should also handle <select multiple>
+            if (is_a($groupObj, 'html_quickform_group')) {
+                // Radios need to be handled differently when required
+                if ($type == 'required' && $groupObj->getGroupType() == 'radio') {
+                    $howmany = ($howmany == 0) ? 1 : $howmany;
+                } else {
+                    $howmany = ($howmany == 0) ? count($groupObj->getElements()) : $howmany;
+                }
+            }
+
+            $this->_rules[$group][] = array('type'       => $type,
+                                            'format'     => $format,
+                                            'message'    => $arg1,
+                                            'validation' => $validation,
+                                            'howmany'    => $howmany,
+                                            'reset'      => $reset);
+            if ($type == 'required') {
+                $this->_required[] = $group;
+            }
+            if ($validation == 'client') {
+                $this->updateAttributes(array('onsubmit' => 'try { var myValidator = validate_' . $this->_attributes['id'] . '; } catch(e) { return true; } return myValidator(this);'));
+            }
+        }
+    } // end func addGroupRule
+
+    // }}}
+    // {{{ addFormRule()
+
+   /**
+    * Adds a global validation rule
+    *
+    * This should be used when for a rule involving several fields or if
+    * you want to use some completely custom validation for your form.
+    * The rule function/method should return true in case of successful
+    * validation and array('element name' => 'error') when there were errors.
+    *
+    * @access   public
+    * @param    mixed   Callback, either function name or array(&$object, 'method')
+    * @throws   HTML_QuickForm_Error
+    */
+    function addFormRule($rule)
+    {
+        if (!is_callable($rule)) {
+            return PEAR::raiseError(null, QUICKFORM_INVALID_RULE, null, E_USER_WARNING, 'Callback function does not exist in HTML_QuickForm::addFormRule()', 'HTML_QuickForm_Error', true);
+        }
+        $this->_formRules[] = $rule;
+    }
+
+    // }}}
+    // {{{ applyFilter()
+
+    /**
+     * Applies a data filter for the given field(s)
+     *
+     * @param    mixed     $element       Form element name or array of such names
+     * @param    mixed     $filter        Callback, either function name or array(&$object, 'method')
+     * @since    2.0
+     * @access   public
+     * @throws   HTML_QuickForm_Error
+     */
+    function applyFilter($element, $filter)
+    {
+        if (!is_callable($filter)) {
+            return PEAR::raiseError(null, QUICKFORM_INVALID_FILTER, null, E_USER_WARNING, "Callback function does not exist in QuickForm::applyFilter()", 'HTML_QuickForm_Error', true);
+        }
+        if ($element == '__ALL__') {
+            $this->_submitValues = $this->_recursiveFilter($filter, $this->_submitValues);
+        } else {
+            if (!is_array($element)) {
+                $element = array($element);
+            }
+            foreach ($element as $elName) {
+                $value = $this->getSubmitValue($elName);
+                if (null !== $value) {
+                    if (false === strpos($elName, '[')) {
+                        $this->_submitValues[$elName] = $this->_recursiveFilter($filter, $value);
+                    } else {
+                        $idx  = "['" . str_replace(
+                                    array('\\', '\'', ']', '['), array('\\\\', '\\\'', '', "']['"),
+                                    $elName
+                                ) . "']";
+                        eval("\$this->_submitValues{$idx} = \$this->_recursiveFilter(\$filter, \$value);");
+                    }
+                }
+            }
+        }
+    } // end func applyFilter
+
+    // }}}
+    // {{{ _recursiveFilter()
+
+    /**
+     * Recursively apply a filter function
+     *
+     * @param     string   $filter    filter to apply
+     * @param     mixed    $value     submitted values
+     * @since     2.0
+     * @access    private
+     * @return    cleaned values
+     */
+    function _recursiveFilter($filter, $value)
+    {
+        if (is_array($value)) {
+            $cleanValues = array();
+            foreach ($value as $k => $v) {
+                $cleanValues[$k] = $this->_recursiveFilter($filter, $v);
+            }
+            return $cleanValues;
+        } else {
+            return call_user_func($filter, $value);
+        }
+    } // end func _recursiveFilter
+
+    // }}}
+    // {{{ arrayMerge()
+
+   /**
+    * Merges two arrays
+    *
+    * Merges two array like the PHP function array_merge but recursively.
+    * The main difference is that existing keys will not be renumbered
+    * if they are integers.
+    *
+    * @access   public
+    * @param    array   $a  original array
+    * @param    array   $b  array which will be merged into first one
+    * @return   array   merged array
+    */
+    function arrayMerge($a, $b)
+    {
+        foreach ($b as $k => $v) {
+            if (is_array($v)) {
+                if (isset($a[$k]) && !is_array($a[$k])) {
+                    $a[$k] = $v;
+                } else {
+                    if (!isset($a[$k])) {
+                        $a[$k] = array();
+                    }
+                    $a[$k] = HTML_QuickForm::arrayMerge($a[$k], $v);
+                }
+            } else {
+                $a[$k] = $v;
+            }
+        }
+        return $a;
+    } // end func arrayMerge
+
+    // }}}
+    // {{{ isTypeRegistered()
+
+    /**
+     * Returns whether or not the form element type is supported
+     *
+     * @param     string   $type     Form element type
+     * @since     1.0
+     * @access    public
+     * @return    boolean
+     */
+    function isTypeRegistered($type)
+    {
+        return isset($GLOBALS['HTML_QUICKFORM_ELEMENT_TYPES'][strtolower($type)]);
+    } // end func isTypeRegistered
+
+    // }}}
+    // {{{ getRegisteredTypes()
+
+    /**
+     * Returns an array of registered element types
+     *
+     * @since     1.0
+     * @access    public
+     * @return    array
+     */
+    function getRegisteredTypes()
+    {
+        return array_keys($GLOBALS['HTML_QUICKFORM_ELEMENT_TYPES']);
+    } // end func getRegisteredTypes
+
+    // }}}
+    // {{{ isRuleRegistered()
+
+    /**
+     * Returns whether or not the given rule is supported
+     *
+     * @param     string   $name    Validation rule name
+     * @param     bool     Whether to automatically register subclasses of HTML_QuickForm_Rule
+     * @since     1.0
+     * @access    public
+     * @return    mixed    true if previously registered, false if not, new rule name if auto-registering worked
+     */
+    function isRuleRegistered($name, $autoRegister = false)
+    {
+        if (is_scalar($name) && isset($GLOBALS['_HTML_QuickForm_registered_rules'][$name])) {
+            return true;
+        } elseif (!$autoRegister) {
+            return false;
+        }
+        // automatically register the rule if requested
+        include_once 'HTML/QuickForm/RuleRegistry.php';
+        $ruleName = false;
+        if (is_object($name) && is_a($name, 'html_quickform_rule')) {
+            $ruleName = !empty($name->name)? $name->name: strtolower(get_class($name));
+        } elseif (is_string($name) && class_exists($name)) {
+            $parent = strtolower($name);
+            do {
+                if ('html_quickform_rule' == strtolower($parent)) {
+                    $ruleName = strtolower($name);
+                    break;
+                }
+            } while ($parent = get_parent_class($parent));
+        }
+        if ($ruleName) {
+            $registry =& HTML_QuickForm_RuleRegistry::singleton();
+            $registry->registerRule($ruleName, null, $name);
+        }
+        return $ruleName;
+    } // end func isRuleRegistered
+
+    // }}}
+    // {{{ getRegisteredRules()
+
+    /**
+     * Returns an array of registered validation rules
+     *
+     * @since     1.0
+     * @access    public
+     * @return    array
+     */
+    function getRegisteredRules()
+    {
+        return array_keys($GLOBALS['_HTML_QuickForm_registered_rules']);
+    } // end func getRegisteredRules
+
+    // }}}
+    // {{{ isElementRequired()
+
+    /**
+     * Returns whether or not the form element is required
+     *
+     * @param     string   $element     Form element name
+     * @since     1.0
+     * @access    public
+     * @return    boolean
+     */
+    function isElementRequired($element)
+    {
+        return in_array($element, $this->_required, true);
+    } // end func isElementRequired
+
+    // }}}
+    // {{{ isElementFrozen()
+
+    /**
+     * Returns whether or not the form element is frozen
+     *
+     * @param     string   $element     Form element name
+     * @since     1.0
+     * @access    public
+     * @return    boolean
+     */
+    function isElementFrozen($element)
+    {
+         if (isset($this->_elementIndex[$element])) {
+             return $this->_elements[$this->_elementIndex[$element]]->isFrozen();
+         }
+         return false;
+    } // end func isElementFrozen
+
+    // }}}
+    // {{{ setJsWarnings()
+
+    /**
+     * Sets JavaScript warning messages
+     *
+     * @param     string   $pref        Prefix warning
+     * @param     string   $post        Postfix warning
+     * @since     1.1
+     * @access    public
+     * @return    void
+     */
+    function setJsWarnings($pref, $post)
+    {
+        $this->_jsPrefix = $pref;
+        $this->_jsPostfix = $post;
+    } // end func setJsWarnings
+
+    // }}}
+    // {{{ setRequiredNote()
+
+    /**
+     * Sets required-note
+     *
+     * @param     string   $note        Message indicating some elements are required
+     * @since     1.1
+     * @access    public
+     * @return    void
+     */
+    function setRequiredNote($note)
+    {
+        $this->_requiredNote = $note;
+    } // end func setRequiredNote
+
+    // }}}
+    // {{{ getRequiredNote()
+
+    /**
+     * Returns the required note
+     *
+     * @since     2.0
+     * @access    public
+     * @return    string
+     */
+    function getRequiredNote()
+    {
+        return $this->_requiredNote;
+    } // end func getRequiredNote
+
+    // }}}
+    // {{{ validate()
+
+    /**
+     * Performs the server side validation
+     * @access    public
+     * @since     1.0
+     * @return    boolean   true if no error found
+     * @throws    HTML_QuickForm_Error
+     */
+    function validate()
+    {
+        if (count($this->_rules) == 0 && count($this->_formRules) == 0 &&
+            $this->isSubmitted()) {
+            return (0 == count($this->_errors));
+        } elseif (!$this->isSubmitted()) {
+            return false;
+        }
+
+        include_once('HTML/QuickForm/RuleRegistry.php');
+        $registry =& HTML_QuickForm_RuleRegistry::singleton();
+
+        foreach ($this->_rules as $target => $rules) {
+            $submitValue = $this->getSubmitValue($target);
+
+            foreach ($rules as $rule) {
+                if ((isset($rule['group']) && isset($this->_errors[$rule['group']])) ||
+                     isset($this->_errors[$target])) {
+                    continue 2;
+                }
+                // If element is not required and is empty, we shouldn't validate it
+                if (!$this->isElementRequired($target)) {
+                    if (!isset($submitValue) || '' == $submitValue) {
+                        continue 2;
+                    // Fix for bug #3501: we shouldn't validate not uploaded files, either.
+                    // Unfortunately, we can't just use $element->isUploadedFile() since
+                    // the element in question can be buried in group. Thus this hack.
+                    // See also bug #12014, we should only consider a file that has
+                    // status UPLOAD_ERR_NO_FILE as not uploaded, in all other cases
+                    // validation should be performed, so that e.g. 'maxfilesize' rule
+                    // will display an error if status is UPLOAD_ERR_INI_SIZE
+                    // or UPLOAD_ERR_FORM_SIZE
+                    } elseif (is_array($submitValue)) {
+                        if (false === ($pos = strpos($target, '['))) {
+                            $isUpload = !empty($this->_submitFiles[$target]);
+                        } else {
+                            $base = str_replace(
+                                        array('\\', '\''), array('\\\\', '\\\''),
+                                        substr($target, 0, $pos)
+                                    );
+                            $idx  = "['" . str_replace(
+                                        array('\\', '\'', ']', '['), array('\\\\', '\\\'', '', "']['"),
+                                        substr($target, $pos + 1, -1)
+                                    ) . "']";
+                            eval("\$isUpload = isset(\$this->_submitFiles['{$base}']['name']{$idx});");
+                        }
+                        if ($isUpload && (!isset($submitValue['error']) || UPLOAD_ERR_NO_FILE == $submitValue['error'])) {
+                            continue 2;
+                        }
+                    }
+                }
+                if (isset($rule['dependent']) && is_array($rule['dependent'])) {
+                    $values = array($submitValue);
+                    foreach ($rule['dependent'] as $elName) {
+                        $values[] = $this->getSubmitValue($elName);
+                    }
+                    $result = $registry->validate($rule['type'], $values, $rule['format'], true);
+                } elseif (is_array($submitValue) && !isset($rule['howmany'])) {
+                    $result = $registry->validate($rule['type'], $submitValue, $rule['format'], true);
+                } else {
+                    $result = $registry->validate($rule['type'], $submitValue, $rule['format'], false);
+                }
+
+                if (!$result || (!empty($rule['howmany']) && $rule['howmany'] > (int)$result)) {
+                    if (isset($rule['group'])) {
+                        $this->_errors[$rule['group']] = $rule['message'];
+                    } else {
+                        $this->_errors[$target] = $rule['message'];
+                    }
+                }
+            }
+        }
+
+        // process the global rules now
+        foreach ($this->_formRules as $rule) {
+            if (true !== ($res = call_user_func($rule, $this->_submitValues, $this->_submitFiles))) {
+                if (is_array($res)) {
+                    $this->_errors += $res;
+                } else {
+                    return PEAR::raiseError(null, QUICKFORM_ERROR, null, E_USER_WARNING, 'Form rule callback returned invalid value in HTML_QuickForm::validate()', 'HTML_QuickForm_Error', true);
+                }
+            }
+        }
+
+        return (0 == count($this->_errors));
+    } // end func validate
+
+    // }}}
+    // {{{ freeze()
+
+    /**
+     * Displays elements without HTML input tags
+     *
+     * @param    mixed   $elementList       array or string of element(s) to be frozen
+     * @since     1.0
+     * @access   public
+     * @throws   HTML_QuickForm_Error
+     */
+    function freeze($elementList=null)
+    {
+        if (!isset($elementList)) {
+            $this->_freezeAll = true;
+            $elementList = array();
+        } else {
+            if (!is_array($elementList)) {
+                $elementList = preg_split('/[ ]*,[ ]*/', $elementList);
+            }
+            $elementList = array_flip($elementList);
+        }
+
+        foreach (array_keys($this->_elements) as $key) {
+            $name = $this->_elements[$key]->getName();
+            if ($this->_freezeAll || isset($elementList[$name])) {
+                $this->_elements[$key]->freeze();
+                unset($elementList[$name]);
+            }
+        }
+
+        if (!empty($elementList)) {
+            return PEAR::raiseError(null, QUICKFORM_NONEXIST_ELEMENT, null, E_USER_WARNING, "Nonexistant element(s): '" . implode("', '", array_keys($elementList)) . "' in HTML_QuickForm::freeze()", 'HTML_QuickForm_Error', true);
+        }
+        return true;
+    } // end func freeze
+
+    // }}}
+    // {{{ isFrozen()
+
+    /**
+     * Returns whether or not the whole form is frozen
+     *
+     * @since     3.0
+     * @access    public
+     * @return    boolean
+     */
+    function isFrozen()
+    {
+         return $this->_freezeAll;
+    } // end func isFrozen
+
+    // }}}
+    // {{{ process()
+
+    /**
+     * Performs the form data processing
+     *
+     * @param    mixed     $callback        Callback, either function name or array(&$object, 'method')
+     * @param    bool      $mergeFiles      Whether uploaded files should be processed too
+     * @since    1.0
+     * @access   public
+     * @throws   HTML_QuickForm_Error
+     * @return   mixed     Whatever value the $callback function returns
+     */
+    function process($callback, $mergeFiles = true)
+    {
+        if (!is_callable($callback)) {
+            return PEAR::raiseError(null, QUICKFORM_INVALID_PROCESS, null, E_USER_WARNING, "Callback function does not exist in QuickForm::process()", 'HTML_QuickForm_Error', true);
+        }
+        $values = ($mergeFiles === true) ? HTML_QuickForm::arrayMerge($this->_submitValues, $this->_submitFiles) : $this->_submitValues;
+        return call_user_func($callback, $values);
+    } // end func process
+
+    // }}}
+    // {{{ accept()
+
+   /**
+    * Accepts a renderer
+    *
+    * @param object     An HTML_QuickForm_Renderer object
+    * @since 3.0
+    * @access public
+    * @return void
+    */
+    function accept(&$renderer)
+    {
+        $renderer->startForm($this);
+        foreach (array_keys($this->_elements) as $key) {
+            $element =& $this->_elements[$key];
+            $elementName = $element->getName();
+            $required    = ($this->isElementRequired($elementName) && !$element->isFrozen());
+            $error       = $this->getElementError($elementName);
+            $element->accept($renderer, $required, $error);
+        }
+        $renderer->finishForm($this);
+    } // end func accept
+
+    // }}}
+    // {{{ defaultRenderer()
+
+   /**
+    * Returns a reference to default renderer object
+    *
+    * @access public
+    * @since 3.0
+    * @return object a default renderer object
+    */
+    function &defaultRenderer()
+    {
+        if (!isset($GLOBALS['_HTML_QuickForm_default_renderer'])) {
+            include_once('HTML/QuickForm/Renderer/Default.php');
+            $GLOBALS['_HTML_QuickForm_default_renderer'] = new HTML_QuickForm_Renderer_Default();
+        }
+        return $GLOBALS['_HTML_QuickForm_default_renderer'];
+    } // end func defaultRenderer
+
+    // }}}
+    // {{{ toHtml ()
+
+    /**
+     * Returns an HTML version of the form
+     *
+     * @param string $in_data (optional) Any extra data to insert right
+     *               before form is rendered.  Useful when using templates.
+     *
+     * @return   string     Html version of the form
+     * @since     1.0
+     * @access   public
+     */
+    function toHtml ($in_data = null)
+    {
+        if (!is_null($in_data)) {
+            $this->addElement('html', $in_data);
+        }
+        $renderer =& $this->defaultRenderer();
+        $this->accept($renderer);
+        return $renderer->toHtml();
+    } // end func toHtml
+
+    // }}}
+    // {{{ getValidationScript()
+
+    /**
+     * Returns the client side validation script
+     *
+     * @since     2.0
+     * @access    public
+     * @return    string    Javascript to perform validation, empty string if no 'client' rules were added
+     */
+    function getValidationScript()
+    {
+        if (empty($this->_rules) || empty($this->_attributes['onsubmit'])) {
+            return '';
+        }
+
+        include_once('HTML/QuickForm/RuleRegistry.php');
+        $registry =& HTML_QuickForm_RuleRegistry::singleton();
+        $test = array();
+        $js_escape = array(
+            "\r"    => '\r',
+            "\n"    => '\n',
+            "\t"    => '\t',
+            "'"     => "\\'",
+            '"'     => '\"',
+            '\\'    => '\\\\'
+        );
+
+        foreach ($this->_rules as $elementName => $rules) {
+            foreach ($rules as $rule) {
+                if ('client' == $rule['validation']) {
+                    unset($element);
+
+                    $dependent  = isset($rule['dependent']) && is_array($rule['dependent']);
+                    $rule['message'] = strtr($rule['message'], $js_escape);
+
+                    if (isset($rule['group'])) {
+                        $group    =& $this->getElement($rule['group']);
+                        // No JavaScript validation for frozen elements
+                        if ($group->isFrozen()) {
+                            continue 2;
+                        }
+                        $elements =& $group->getElements();
+                        foreach (array_keys($elements) as $key) {
+                            if ($elementName == $group->getElementName($key)) {
+                                $element =& $elements[$key];
+                                break;
+                            }
+                        }
+                    } elseif ($dependent) {
+                        $element   =  array();
+                        $element[] =& $this->getElement($elementName);
+                        foreach ($rule['dependent'] as $elName) {
+                            $element[] =& $this->getElement($elName);
+                        }
+                    } else {
+                        $element =& $this->getElement($elementName);
+                    }
+                    // No JavaScript validation for frozen elements
+                    if (is_object($element) && $element->isFrozen()) {
+                        continue 2;
+                    } elseif (is_array($element)) {
+                        foreach (array_keys($element) as $key) {
+                            if ($element[$key]->isFrozen()) {
+                                continue 3;
+                            }
+                        }
+                    }
+
+                    $test[] = $registry->getValidationScript($element, $elementName, $rule);
+                }
+            }
+        }
+        if (count($test) > 0) {
+            return
+                "\n<script type=\"text/javascript\">\n" .
+                "//<![CDATA[\n" .
+                "function validate_" . $this->_attributes['id'] . "(frm) {\n" .
+                "  var value = '';\n" .
+                "  var errFlag = new Array();\n" .
+                "  var _qfGroups = {};\n" .
+                "  _qfMsg = '';\n\n" .
+                join("\n", $test) .
+                "\n  if (_qfMsg != '') {\n" .
+                "    _qfMsg = '" . strtr($this->_jsPrefix, $js_escape) . "' + _qfMsg;\n" .
+                "    _qfMsg = _qfMsg + '\\n" . strtr($this->_jsPostfix, $js_escape) . "';\n" .
+                "    alert(_qfMsg);\n" .
+                "    return false;\n" .
+                "  }\n" .
+                "  return true;\n" .
+                "}\n" .
+                "//]]>\n" .
+                "</script>";
+        }
+        return '';
+    } // end func getValidationScript
+
+    // }}}
+    // {{{ getSubmitValues()
+
+    /**
+     * Returns the values submitted by the form
+     *
+     * @since     2.0
+     * @access    public
+     * @param     bool      Whether uploaded files should be returned too
+     * @return    array
+     */
+    function getSubmitValues($mergeFiles = false)
+    {
+        return $mergeFiles? HTML_QuickForm::arrayMerge($this->_submitValues, $this->_submitFiles): $this->_submitValues;
+    } // end func getSubmitValues
+
+    // }}}
+    // {{{ toArray()
+
+    /**
+     * Returns the form's contents in an array.
+     *
+     * The description of the array structure is in HTML_QuickForm_Renderer_Array docs
+     *
+     * @since     2.0
+     * @access    public
+     * @param     bool      Whether to collect hidden elements (passed to the Renderer's constructor)
+     * @return    array of form contents
+     */
+    function toArray($collectHidden = false)
+    {
+        include_once 'HTML/QuickForm/Renderer/Array.php';
+        $renderer = new HTML_QuickForm_Renderer_Array($collectHidden);
+        $this->accept($renderer);
+        return $renderer->toArray();
+     } // end func toArray
+
+    // }}}
+    // {{{ exportValue()
+
+    /**
+     * Returns a 'safe' element's value
+     *
+     * This method first tries to find a cleaned-up submitted value,
+     * it will return a value set by setValue()/setDefaults()/setConstants()
+     * if submitted value does not exist for the given element.
+     *
+     * @param  string   Name of an element
+     * @access public
+     * @return mixed
+     * @throws HTML_QuickForm_Error
+     */
+    function exportValue($element)
+    {
+        if (!isset($this->_elementIndex[$element])) {
+            return PEAR::raiseError(null, QUICKFORM_NONEXIST_ELEMENT, null, E_USER_WARNING, "Element '$element' does not exist in HTML_QuickForm::getElementValue()", 'HTML_QuickForm_Error', true);
+        }
+        $value = $this->_elements[$this->_elementIndex[$element]]->exportValue($this->_submitValues, false);
+        if (isset($this->_duplicateIndex[$element])) {
+            foreach ($this->_duplicateIndex[$element] as $index) {
+                if (null !== ($v = $this->_elements[$index]->exportValue($this->_submitValues, false))) {
+                    if (is_array($value)) {
+                        $value[] = $v;
+                    } else {
+                        $value = (null === $value)? $v: array($value, $v);
+                    }
+                }
+            }
+        }
+        return $value;
+    }
+
+    // }}}
+    // {{{ exportValues()
+
+    /**
+     * Returns 'safe' elements' values
+     *
+     * Unlike getSubmitValues(), this will return only the values
+     * corresponding to the elements present in the form.
+     *
+     * @param   mixed   Array/string of element names, whose values we want. If not set then return all elements.
+     * @access  public
+     * @return  array   An assoc array of elements' values
+     * @throws  HTML_QuickForm_Error
+     */
+    function exportValues($elementList = null)
+    {
+        $values = array();
+        if (null === $elementList) {
+            // iterate over all elements, calling their exportValue() methods
+            foreach (array_keys($this->_elements) as $key) {
+                $value = $this->_elements[$key]->exportValue($this->_submitValues, true);
+                if (is_array($value)) {
+                    // This shit throws a bogus warning in PHP 4.3.x
+                    $values = HTML_QuickForm::arrayMerge($values, $value);
+                }
+            }
+        } else {
+            if (!is_array($elementList)) {
+                $elementList = array_map('trim', explode(',', $elementList));
+            }
+            foreach ($elementList as $elementName) {
+                $value = $this->exportValue($elementName);
+                if (PEAR::isError($value)) {
+                    return $value;
+                }
+                $values[$elementName] = $value;
+            }
+        }
+        return $values;
+    }
+
+    // }}}
+    // {{{ isSubmitted()
+
+   /**
+    * Tells whether the form was already submitted
+    *
+    * This is useful since the _submitFiles and _submitValues arrays
+    * may be completely empty after the trackSubmit value is removed.
+    *
+    * @access public
+    * @return bool
+    */
+    function isSubmitted()
+    {
+        return $this->_flagSubmitted;
+    }
+
+
+    // }}}
+    // {{{ isError()
+
+    /**
+     * Tell whether a result from a QuickForm method is an error (an instance of HTML_QuickForm_Error)
+     *
+     * @access public
+     * @param mixed     result code
+     * @return bool     whether $value is an error
+     * @static
+     */
+    function isError($value)
+    {
+        return (is_object($value) && is_a($value, 'html_quickform_error'));
+    } // end func isError
+
+    // }}}
+    // {{{ errorMessage()
+
+    /**
+     * Return a textual error message for an QuickForm error code
+     *
+     * @access  public
+     * @param   int     error code
+     * @return  string  error message
+     * @static
+     */
+    function errorMessage($value)
+    {
+        // make the variable static so that it only has to do the defining on the first call
+        static $errorMessages;
+
+        // define the varies error messages
+        if (!isset($errorMessages)) {
+            $errorMessages = array(
+                QUICKFORM_OK                    => 'no error',
+                QUICKFORM_ERROR                 => 'unknown error',
+                QUICKFORM_INVALID_RULE          => 'the rule does not exist as a registered rule',
+                QUICKFORM_NONEXIST_ELEMENT      => 'nonexistent html element',
+                QUICKFORM_INVALID_FILTER        => 'invalid filter',
+                QUICKFORM_UNREGISTERED_ELEMENT  => 'unregistered element',
+                QUICKFORM_INVALID_ELEMENT_NAME  => 'element already exists',
+                QUICKFORM_INVALID_PROCESS       => 'process callback does not exist',
+                QUICKFORM_DEPRECATED            => 'method is deprecated',
+                QUICKFORM_INVALID_DATASOURCE    => 'datasource is not an object'
+            );
+        }
+
+        // If this is an error object, then grab the corresponding error code
+        if (HTML_QuickForm::isError($value)) {
+            $value = $value->getCode();
+        }
+
+        // return the textual error message corresponding to the code
+        return isset($errorMessages[$value]) ? $errorMessages[$value] : $errorMessages[QUICKFORM_ERROR];
+    } // end func errorMessage
+
+    // }}}
+} // end class HTML_QuickForm
+
+/**
+ * Class for errors thrown by HTML_QuickForm package
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @version     Release: 3.2.16
+ */
+class HTML_QuickForm_Error extends PEAR_Error {
+
+    // {{{ properties
+
+    /**
+    * Prefix for all error messages
+    * @var string
+    */
+    var $error_message_prefix = 'QuickForm Error: ';
+
+    // }}}
+    // {{{ constructor
+
+    /**
+    * Creates a quickform error object, extending the PEAR_Error class
+    *
+    * @param int   $code the error code
+    * @param int   $mode the reaction to the error, either return, die or trigger/callback
+    * @param int   $level intensity of the error (PHP error code)
+    * @param mixed $debuginfo any information that can inform user as to nature of the error
+    */
+    function HTML_QuickForm_Error($code = QUICKFORM_ERROR, $mode = PEAR_ERROR_RETURN,
+                         $level = E_USER_NOTICE, $debuginfo = null)
+    {
+        if (is_int($code)) {
+            $this->PEAR_Error(HTML_QuickForm::errorMessage($code), $code, $mode, $level, $debuginfo);
+        } else {
+            $this->PEAR_Error("Invalid error code: $code", QUICKFORM_ERROR, $mode, $level, $debuginfo);
+        }
+    }
+
+    // }}}
+} // end class HTML_QuickForm_Error
+?>
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/DHTMLRulesTableless.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/DHTMLRulesTableless.php
new file mode 100644 (file)
index 0000000..e0a8823
--- /dev/null
@@ -0,0 +1,284 @@
+<?php
+/**
+ * DHTML replacement for the standard JavaScript alert window for client-side
+ * validation
+ *
+ * LICENSE:
+ * 
+ * Copyright (c) 2005-2007, Mark Wiesemann <wiesemann@php.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above copyright
+ *      notice, this list of conditions and the following disclaimer in the 
+ *      documentation and/or other materials provided with the distribution.
+ *    * The names of the authors may not be used to endorse or promote products 
+ *      derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @category   HTML
+ * @package    HTML_QuickForm_DHTMLRulesTableless
+ * @author     Alexey Borzov <borz_off@cs.msu.su>
+ * @author     Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author     Bertrand Mansion <bmansion@mamasam.com>
+ * @author     Justin Patrin <papercrane@gmail.com>
+ * @author     Mark Wiesemann <wiesemann@php.net>
+ * @license    http://www.opensource.org/licenses/bsd-license.php New BSD License
+ * @version    CVS: $Id: DHTMLRulesTableless.php,v 1.10 2007/10/24 20:36:11 wiesemann Exp $
+ * @link       http://pear.php.net/package/HTML_QuickForm_DHTMLRulesTableless
+ */
+
+require_once 'HTML/QuickForm.php';
+
+/**
+ * This is a DHTML replacement for the standard JavaScript alert window for
+ * client-side validation of forms built with HTML_QuickForm
+ *
+ * @category   HTML
+ * @package    HTML_QuickForm_DHTMLRulesTableless
+ * @author     Alexey Borzov <borz_off@cs.msu.su>
+ * @author     Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author     Bertrand Mansion <bmansion@mamasam.com>
+ * @author     Justin Patrin <papercrane@gmail.com>
+ * @author     Mark Wiesemann <wiesemann@php.net>
+ * @license    http://www.opensource.org/licenses/bsd-license.php New BSD License
+ * @version    Release: 0.3.3
+ * @link       http://pear.php.net/package/HTML_QuickForm_DHTMLRulesTableless
+ */
+class HTML_QuickForm_DHTMLRulesTableless extends HTML_QuickForm {
+    // {{{ getValidationScript()
+
+    /**
+     * Returns the client side validation script
+     *
+     * The code here was copied from HTML_QuickForm and slightly modified to run rules per-element
+     *
+     * @access    public
+     * @return    string    Javascript to perform validation, empty string if no 'client' rules were added
+     */
+    function getValidationScript()
+    {
+        if (empty($this->_rules) || empty($this->_attributes['onsubmit'])) {
+            return '';
+        }
+
+        include_once('HTML/QuickForm/RuleRegistry.php');
+        $registry =& HTML_QuickForm_RuleRegistry::singleton();
+        $test = array();
+        $js_escape = array(
+            "\r"    => '\r',
+            "\n"    => '\n',
+            "\t"    => '\t',
+            "'"     => "\\'",
+            '"'     => '\"',
+            '\\'    => '\\\\'
+        );
+
+        foreach ($this->_rules as $elementName => $rules) {
+            foreach ($rules as $rule) {
+                if ('client' == $rule['validation']) {
+                    unset($element);
+
+                    $dependent  = isset($rule['dependent']) && is_array($rule['dependent']);
+                    $rule['message'] = strtr($rule['message'], $js_escape);
+
+                    if (isset($rule['group'])) {
+                        $group    =& $this->getElement($rule['group']);
+                        // No JavaScript validation for frozen elements
+                        if ($group->isFrozen()) {
+                            continue 2;
+                        }
+                        $elements =& $group->getElements();
+                        foreach (array_keys($elements) as $key) {
+                            if ($elementName == $group->getElementName($key)) {
+                                $element =& $elements[$key];
+                                break;
+                            }
+                        }
+                    } elseif ($dependent) {
+                        $element   =  array();
+                        $element[] =& $this->getElement($elementName);
+                        foreach ($rule['dependent'] as $idx => $elName) {
+                            $element[] =& $this->getElement($elName);
+                        }
+                    } else {
+                        $element =& $this->getElement($elementName);
+                    }
+                    // No JavaScript validation for frozen elements
+                    if (is_object($element) && $element->isFrozen()) {
+                        continue 2;
+                    } elseif (is_array($element)) {
+                        foreach (array_keys($element) as $key) {
+                            if ($element[$key]->isFrozen()) {
+                                continue 3;
+                            }
+                        }
+                    }
+
+                    $test[$elementName][] = $registry->getValidationScript($element, $elementName, $rule);
+                }
+            }
+        }
+        $js = '
+<script type="text/javascript"><!--//--><![CDATA[//><!--
+qf_errorHandler = function(element, _qfMsg) {
+  div = element.parentNode;
+  var elementName = element.name.replace(/\[/, "_____");
+  var elementName = elementName.replace(/\]/, "_____");
+  if (_qfMsg != \'\') {
+    span = document.createElement("span");
+    span.className = "error";
+    _qfMsg = _qfMsg.substring(4);
+    span.appendChild(document.createTextNode(_qfMsg));
+    br = document.createElement("br");
+
+    var errorDiv = document.getElementById(elementName + \'_errorDiv\');
+    if (!errorDiv) {
+      errorDiv = document.createElement("div");
+      errorDiv.id = elementName + \'_errorDiv\';
+    } else {
+      if (   div.firstChild.textContent == \'\'
+          || _qfMsg == div.firstChild.textContent
+         ) {
+        return false;
+      }
+    }
+    while (errorDiv.firstChild) {
+      errorDiv.removeChild(errorDiv.firstChild);
+    }
+
+    errorDiv.insertBefore(br, errorDiv.firstChild);
+    errorDiv.insertBefore(span, errorDiv.firstChild);
+
+    errorDivInserted = false;
+    for (var i = element.parentNode.childNodes.length - 1; i >= 0; i--) {
+      j = i - 1;
+      if (j >= 0 && element.parentNode.childNodes[j].nodeName == "DIV") {
+        element.parentNode.insertBefore(errorDiv, element.parentNode.childNodes[i]);
+        errorDivInserted = true;
+        break;
+      }
+    }
+    if (!errorDivInserted) {
+      element.parentNode.insertBefore(errorDiv, element.parentNode.firstChild);
+    }
+
+    if (div.className.substr(div.className.length - 6, 6) != " error"
+        && div.className != "error") {
+      div.className += " error";
+    }
+
+    return false;
+  } else {
+    var errorDiv = document.getElementById(elementName + \'_errorDiv\');
+    if (errorDiv) {
+      errorDiv.parentNode.removeChild(errorDiv);
+    }
+    
+    // do not remove the error style from the div tag if there is still an error
+    // message
+    if (div.firstChild.innerHTML != "") {
+      return true;
+    }
+
+    if (div.className.substr(div.className.length - 6, 6) == " error") {
+      div.className = div.className.substr(0, div.className.length - 6);
+    } else if (div.className == "error") {
+      div.className = "";
+    }
+
+    return true;
+  }
+}';
+        $validateJS = '';
+        foreach ($test as $elementName => $jsArr) {
+            // remove group element part of the element name to avoid JS errors
+            $singleElementName = $elementName;
+            $shortNameForJS = str_replace(array('[', ']'), '__', $elementName);
+            $bracketPos = strpos($elementName, '[');
+            if ($bracketPos !== false) {
+                $singleElementName = substr($elementName, 0, $bracketPos);
+                $groupElementName = substr($elementName, $bracketPos + 1, -1);
+            }
+            if ($bracketPos === false || !$this->elementExists($singleElementName)) {
+                $groupElementName = $elementName;
+                $singleElementName = $elementName;
+            }
+            $id = str_replace('-', '_', $this->_attributes['id']);
+            $js .= '
+validate_' . $id . '_' . $shortNameForJS . ' = function(element) {
+  var value = \'\';
+  var errFlag = new Array();
+  var _qfGroups = {};
+  var _qfMsg = \'\';
+  var frm = element.parentNode;
+  while (frm && frm.nodeName != "FORM") {
+    frm = frm.parentNode;
+  }
+' . join("\n", $jsArr) . '
+  return qf_errorHandler(element, _qfMsg);
+}
+';
+            unset($element);
+            $element =& $this->getElement($singleElementName);
+            $elementNameForJS = 'frm.elements[\'' . $elementName . '\']';
+            if ($element->getType() === 'group' && $singleElementName === $elementName) {
+                $elementNameForJS = 'document.getElementById(\'' . $element->_elements[0]->getAttribute('id') . '\')';
+            }
+            $validateJS .= '
+  ret = validate_' . $id . '_' . $shortNameForJS . '('. $elementNameForJS . ') && ret;';
+            if ($element->getType() !== 'group') {  // not a group
+                $valFunc = 'validate_' . $id . '_' . $shortNameForJS . '(this)';
+                $onBlur = $element->getAttribute('onBlur');
+                $onChange = $element->getAttribute('onChange');
+                $element->updateAttributes(array('onBlur' => $onBlur . $valFunc,
+                                                 'onChange' => $onChange . $valFunc));
+            } else {  // group
+                $elements =& $element->getElements();
+                for ($i = 0; $i < count($elements); $i++) {
+                    // $groupElementName is a substring of attribute name of the element
+                    if (strpos($elements[$i]->getAttribute('name'), $groupElementName) === 0) {
+                        $valFunc = 'validate_' . $id . '_' . $shortNameForJS . '(this)';
+                        $onBlur = $elements[$i]->getAttribute('onBlur');
+                        $onChange = $elements[$i]->getAttribute('onChange');
+                        $elements[$i]->updateAttributes(array('onBlur'   => $onBlur . $valFunc,
+                                                              'onChange' => $onChange . $valFunc));
+                    }
+                }
+            }
+        }
+        $js .= '
+validate_' . $id . ' = function(frm) {
+  var ret = true;
+' . $validateJS . ';
+  return ret;
+}
+//--><!]]></script>';
+        return $js;
+    } // end func getValidationScript
+
+    // }}}
+
+    function display() {
+        $this->getValidationScript();
+        return parent::display();
+    }
+}
+
+?>
\ No newline at end of file
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/PageDHTMLRulesTableless.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/PageDHTMLRulesTableless.php
new file mode 100644 (file)
index 0000000..6d42150
--- /dev/null
@@ -0,0 +1,296 @@
+<?php
+/**
+ * DHTML replacement for the standard JavaScript alert window for client-side
+ * validation
+ *
+ * LICENSE:
+ * 
+ * Copyright (c) 2005-2007, Mark Wiesemann <wiesemann@php.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above copyright
+ *      notice, this list of conditions and the following disclaimer in the 
+ *      documentation and/or other materials provided with the distribution.
+ *    * The names of the authors may not be used to endorse or promote products 
+ *      derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @category   HTML
+ * @package    HTML_QuickForm_DHTMLRulesTableless
+ * @author     Alexey Borzov <borz_off@cs.msu.su>
+ * @author     Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author     Bertrand Mansion <bmansion@mamasam.com>
+ * @author     Justin Patrin <papercrane@gmail.com>
+ * @author     Mark Wiesemann <wiesemann@php.net>
+ * @license    http://www.opensource.org/licenses/bsd-license.php New BSD License
+ * @version    CVS: $Id: PageDHTMLRulesTableless.php,v 1.3 2007/10/24 20:36:11 wiesemann Exp $
+ * @link       http://pear.php.net/package/HTML_QuickForm_DHTMLRulesTableless
+ */
+
+require_once 'HTML/QuickForm/Page.php';
+
+/**
+ * This is a DHTML replacement for the standard JavaScript alert window for
+ * client-side validation of forms built with HTML_QuickForm
+ *
+ * @category   HTML
+ * @package    HTML_QuickForm_DHTMLRulesTableless
+ * @author     Alexey Borzov <borz_off@cs.msu.su>
+ * @author     Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author     Bertrand Mansion <bmansion@mamasam.com>
+ * @author     Justin Patrin <papercrane@gmail.com>
+ * @author     Mark Wiesemann <wiesemann@php.net>
+ * @license    http://www.opensource.org/licenses/bsd-license.php New BSD License
+ * @version    Release: 0.3.3
+ * @link       http://pear.php.net/package/HTML_QuickForm_DHTMLRulesTableless
+ */
+class HTML_QuickForm_PageDHTMLRulesTableless extends HTML_QuickForm_Page
+{
+   /**
+    * Class constructor
+    * 
+    * @access public
+    */
+    function HTML_QuickForm_PageDHTMLRulesTableless($formName, $method = 'post',
+        $target = '', $attributes = null)
+    {
+        $this->HTML_QuickForm_Page($formName, $method, '', $target, $attributes);
+    }
+
+    // {{{ getValidationScript()
+
+    /**
+     * Returns the client side validation script
+     *
+     * The code here was copied from HTML_QuickForm and slightly modified to run rules per-element
+     *
+     * @access    public
+     * @return    string    Javascript to perform validation, empty string if no 'client' rules were added
+     */
+    function getValidationScript()
+    {
+        if (empty($this->_rules) || empty($this->_attributes['onsubmit'])) {
+            return '';
+        }
+
+        include_once('HTML/QuickForm/RuleRegistry.php');
+        $registry =& HTML_QuickForm_RuleRegistry::singleton();
+        $test = array();
+        $js_escape = array(
+            "\r"    => '\r',
+            "\n"    => '\n',
+            "\t"    => '\t',
+            "'"     => "\\'",
+            '"'     => '\"',
+            '\\'    => '\\\\'
+        );
+
+        foreach ($this->_rules as $elementName => $rules) {
+            foreach ($rules as $rule) {
+                if ('client' == $rule['validation']) {
+                    unset($element);
+
+                    $dependent  = isset($rule['dependent']) && is_array($rule['dependent']);
+                    $rule['message'] = strtr($rule['message'], $js_escape);
+
+                    if (isset($rule['group'])) {
+                        $group    =& $this->getElement($rule['group']);
+                        // No JavaScript validation for frozen elements
+                        if ($group->isFrozen()) {
+                            continue 2;
+                        }
+                        $elements =& $group->getElements();
+                        foreach (array_keys($elements) as $key) {
+                            if ($elementName == $group->getElementName($key)) {
+                                $element =& $elements[$key];
+                                break;
+                            }
+                        }
+                    } elseif ($dependent) {
+                        $element   =  array();
+                        $element[] =& $this->getElement($elementName);
+                        foreach ($rule['dependent'] as $idx => $elName) {
+                            $element[] =& $this->getElement($elName);
+                        }
+                    } else {
+                        $element =& $this->getElement($elementName);
+                    }
+                    // No JavaScript validation for frozen elements
+                    if (is_object($element) && $element->isFrozen()) {
+                        continue 2;
+                    } elseif (is_array($element)) {
+                        foreach (array_keys($element) as $key) {
+                            if ($element[$key]->isFrozen()) {
+                                continue 3;
+                            }
+                        }
+                    }
+
+                    $test[$elementName][] = $registry->getValidationScript($element, $elementName, $rule);
+                }
+            }
+        }
+        $js = '
+<script type="text/javascript"><!--//--><![CDATA[//><!--
+qf_errorHandler = function(element, _qfMsg) {
+  div = element.parentNode;
+  var elementName = element.name.replace(/\[/, "_____");
+  var elementName = elementName.replace(/\]/, "_____");
+  if (_qfMsg != \'\') {
+    span = document.createElement("span");
+    span.className = "error";
+    _qfMsg = _qfMsg.substring(4);
+    span.appendChild(document.createTextNode(_qfMsg));
+    br = document.createElement("br");
+
+    var errorDiv = document.getElementById(elementName + \'_errorDiv\');
+    if (!errorDiv) {
+      errorDiv = document.createElement("div");
+      errorDiv.id = elementName + \'_errorDiv\';
+    } else {
+      if (   div.firstChild.textContent == \'\'
+          || _qfMsg == div.firstChild.textContent
+         ) {
+        return false;
+      }
+    }
+    while (errorDiv.firstChild) {
+      errorDiv.removeChild(errorDiv.firstChild);
+    }
+
+    errorDiv.insertBefore(br, errorDiv.firstChild);
+    errorDiv.insertBefore(span, errorDiv.firstChild);
+
+    errorDivInserted = false;
+    for (var i = element.parentNode.childNodes.length - 1; i >= 0; i--) {
+      j = i - 1;
+      if (j >= 0 && element.parentNode.childNodes[j].nodeName == "DIV") {
+        element.parentNode.insertBefore(errorDiv, element.parentNode.childNodes[i]);
+        errorDivInserted = true;
+        break;
+      }
+    }
+    if (!errorDivInserted) {
+      element.parentNode.insertBefore(errorDiv, element.parentNode.firstChild);
+    }
+
+    if (div.className.substr(div.className.length - 6, 6) != " error"
+        && div.className != "error") {
+      div.className += " error";
+    }
+
+    return false;
+  } else {
+    var errorDiv = document.getElementById(elementName + \'_errorDiv\');
+    if (errorDiv) {
+      errorDiv.parentNode.removeChild(errorDiv);
+    }
+    
+    // do not remove the error style from the div tag if there is still an error
+    // message
+    if (div.firstChild.innerHTML != "") {
+      return true;
+    }
+
+    if (div.className.substr(div.className.length - 6, 6) == " error") {
+      div.className = div.className.substr(0, div.className.length - 6);
+    } else if (div.className == "error") {
+      div.className = "";
+    }
+
+    return true;
+  }
+}';
+        $validateJS = '';
+        foreach ($test as $elementName => $jsArr) {
+            // remove group element part of the element name to avoid JS errors
+            $singleElementName = $elementName;
+            $shortNameForJS = str_replace(array('[', ']'), '__', $elementName);
+            $bracketPos = strpos($elementName, '[');
+            if ($bracketPos !== false) {
+                $singleElementName = substr($elementName, 0, $bracketPos);
+                $groupElementName = substr($elementName, $bracketPos + 1, -1);
+            }
+            if ($bracketPos === false || !$this->elementExists($singleElementName)) {
+                $groupElementName = $elementName;
+                $singleElementName = $elementName;
+            }
+            $id = str_replace('-', '_', $this->_attributes['id']);
+            $js .= '
+validate_' . $id . '_' . $shortNameForJS . ' = function(element) {
+  var value = \'\';
+  var errFlag = new Array();
+  var _qfGroups = {};
+  var _qfMsg = \'\';
+  var frm = element.parentNode;
+  while (frm && frm.nodeName != "FORM") {
+    frm = frm.parentNode;
+  }
+' . join("\n", $jsArr) . '
+  return qf_errorHandler(element, _qfMsg);
+}
+';
+            unset($element);
+            $element =& $this->getElement($singleElementName);
+            $elementNameForJS = 'frm.elements[\'' . $elementName . '\']';
+            if ($element->getType() === 'group' && $singleElementName === $elementName) {
+                $elementNameForJS = 'document.getElementById(\'' . $element->_elements[0]->getAttribute('id') . '\')';
+            }
+            $validateJS .= '
+  ret = validate_' . $id . '_' . $shortNameForJS . '('. $elementNameForJS . ') && ret;';
+            if ($element->getType() !== 'group') {  // not a group
+                $valFunc = 'validate_' . $id . '_' . $shortNameForJS . '(this)';
+                $onBlur = $element->getAttribute('onBlur');
+                $onChange = $element->getAttribute('onChange');
+                $element->updateAttributes(array('onBlur' => $onBlur . $valFunc,
+                                                 'onChange' => $onChange . $valFunc));
+            } else {  // group
+                $elements =& $element->getElements();
+                for ($i = 0; $i < count($elements); $i++) {
+                    // $groupElementName is a substring of attribute name of the element
+                    if (strpos($elements[$i]->getAttribute('name'), $groupElementName) === 0) {
+                        $valFunc = 'validate_' . $id . '_' . $shortNameForJS . '(this)';
+                        $onBlur = $elements[$i]->getAttribute('onBlur');
+                        $onChange = $elements[$i]->getAttribute('onChange');
+                        $elements[$i]->updateAttributes(array('onBlur'   => $onBlur . $valFunc,
+                                                              'onChange' => $onChange . $valFunc));
+                    }
+                }
+            }
+        }
+        $js .= '
+validate_' . $id . ' = function (frm) {
+  var ret = true;
+' . $validateJS . ';
+  return ret;
+}
+//--><!]]></script>';
+        return $js;
+    } // end func getValidationScript
+
+    // }}}
+
+    function display() {
+        $this->getValidationScript();
+        return parent::display();
+    }
+}
+
+?>
\ No newline at end of file
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer.php
new file mode 100644 (file)
index 0000000..3a20504
--- /dev/null
@@ -0,0 +1,158 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * An abstract base class for QuickForm renderers
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Alexey Borzov <avb@php.net>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * An abstract base class for QuickForm renderers
+ * 
+ * The class implements a Visitor design pattern
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Alexey Borzov <avb@php.net>
+ * @version     Release: 3.2.16
+ * @since       3.0
+ * @abstract
+ */
+class HTML_QuickForm_Renderer
+{
+   /**
+    * Constructor
+    *
+    * @access public
+    */
+    function HTML_QuickForm_Renderer()
+    {
+    } // end constructor
+
+   /**
+    * Called when visiting a form, before processing any form elements
+    *
+    * @param    HTML_QuickForm  a form being visited
+    * @access   public
+    * @return   void 
+    * @abstract
+    */
+    function startForm(&$form)
+    {
+        return;
+    } // end func startForm
+
+   /**
+    * Called when visiting a form, after processing all form elements
+    * 
+    * @param    HTML_QuickForm  a form being visited
+    * @access   public
+    * @return   void 
+    * @abstract
+    */
+    function finishForm(&$form)
+    {
+        return;
+    } // end func finishForm
+
+   /**
+    * Called when visiting a header element
+    *
+    * @param    HTML_QuickForm_header   a header element being visited
+    * @access   public
+    * @return   void 
+    * @abstract
+    */
+    function renderHeader(&$header)
+    {
+        return;
+    } // end func renderHeader
+
+   /**
+    * Called when visiting an element
+    *
+    * @param    HTML_QuickForm_element  form element being visited
+    * @param    bool                    Whether an element is required
+    * @param    string                  An error message associated with an element
+    * @access   public
+    * @return   void 
+    * @abstract
+    */
+    function renderElement(&$element, $required, $error)
+    {
+        return;
+    } // end func renderElement
+
+   /**
+    * Called when visiting a hidden element
+    * 
+    * @param    HTML_QuickForm_element  a hidden element being visited
+    * @access   public
+    * @return   void
+    * @abstract 
+    */
+    function renderHidden(&$element)
+    {
+        return;
+    } // end func renderHidden
+
+   /**
+    * Called when visiting a raw HTML/text pseudo-element
+    * 
+    * Only implemented in Default renderer. Usage of 'html' elements is 
+    * discouraged, templates should be used instead.
+    *
+    * @param    HTML_QuickForm_html     a 'raw html' element being visited
+    * @access   public
+    * @return   void 
+    * @abstract
+    */
+    function renderHtml(&$data)
+    {
+        return;
+    } // end func renderHtml
+
+   /**
+    * Called when visiting a group, before processing any group elements
+    *
+    * @param    HTML_QuickForm_group    A group being visited
+    * @param    bool                    Whether a group is required
+    * @param    string                  An error message associated with a group
+    * @access   public
+    * @return   void 
+    * @abstract
+    */
+    function startGroup(&$group, $required, $error)
+    {
+        return;
+    } // end func startGroup
+
+   /**
+    * Called when visiting a group, after processing all group elements
+    *
+    * @param    HTML_QuickForm_group    A group being visited
+    * @access   public
+    * @return   void 
+    * @abstract
+    */
+    function finishGroup(&$group)
+    {
+        return;
+    } // end func finishGroup
+} // end class HTML_QuickForm_Renderer
+?>
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/Array.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/Array.php
new file mode 100644 (file)
index 0000000..81c62e1
--- /dev/null
@@ -0,0 +1,340 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * A concrete renderer for HTML_QuickForm, makes an array of form contents
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Alexey Borzov <avb@php.net>
+ * @author      Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @author      Thomas Schulz <ths@4bconsult.de>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * An abstract base class for QuickForm renderers
+ */
+require_once 'HTML/QuickForm/Renderer.php';
+
+/**
+ * A concrete renderer for HTML_QuickForm, makes an array of form contents
+ *
+ * Based on old HTML_QuickForm::toArray() code.
+ *
+ * The form array structure is the following:
+ * <pre>
+ * array(
+ *   'frozen'           => 'whether the form is frozen',
+ *   'javascript'       => 'javascript for client-side validation',
+ *   'attributes'       => 'attributes for <form> tag',
+ *   'requirednote      => 'note about the required elements',
+ *   // if we set the option to collect hidden elements
+ *   'hidden'           => 'collected html of all hidden elements',
+ *   // if there were some validation errors:
+ *   'errors' => array(
+ *     '1st element name' => 'Error for the 1st element',
+ *     ...
+ *     'nth element name' => 'Error for the nth element'
+ *   ),
+ *   // if there are no headers in the form:
+ *   'elements' => array(
+ *     element_1,
+ *     ...
+ *     element_N
+ *   )
+ *   // if there are headers in the form:
+ *   'sections' => array(
+ *     array(
+ *       'header'   => 'Header text for the first header',
+ *       'name'     => 'Header name for the first header',
+ *       'elements' => array(
+ *          element_1,
+ *          ...
+ *          element_K1
+ *       )
+ *     ),
+ *     ...
+ *     array(
+ *       'header'   => 'Header text for the Mth header',
+ *       'name'     => 'Header name for the Mth header',
+ *       'elements' => array(
+ *          element_1,
+ *          ...
+ *          element_KM
+ *       )
+ *     )
+ *   )
+ * );
+ * </pre>
+ *
+ * where element_i is an array of the form:
+ * <pre>
+ * array(
+ *   'name'      => 'element name',
+ *   'value'     => 'element value',
+ *   'type'      => 'type of the element',
+ *   'frozen'    => 'whether element is frozen',
+ *   'label'     => 'label for the element',
+ *   'required'  => 'whether element is required',
+ *   'error'     => 'error associated with the element',
+ *   'style'     => 'some information about element style (e.g. for Smarty)',
+ *   // if element is not a group
+ *   'html'      => 'HTML for the element'
+ *   // if element is a group
+ *   'separator' => 'separator for group elements',
+ *   'elements'  => array(
+ *     element_1,
+ *     ...
+ *     element_N
+ *   )
+ * );
+ * </pre>
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Alexey Borzov <avb@php.net>
+ * @author      Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @author      Thomas Schulz <ths@4bconsult.de>
+ * @version     Release: 3.2.16
+ * @since       3.0
+ */
+class HTML_QuickForm_Renderer_Array extends HTML_QuickForm_Renderer
+{
+   /**#@+
+    * @access private
+    */
+   /**
+    * An array being generated
+    * @var array
+    */
+    var $_ary;
+
+   /**
+    * Number of sections in the form (i.e. number of headers in it)
+    * @var integer
+    */
+    var $_sectionCount;
+
+   /**
+    * Current section number
+    * @var integer
+    */
+    var $_currentSection;
+
+   /**
+    * Array representing current group
+    * @var array
+    */
+    var $_currentGroup = null;
+
+   /**
+    * Additional style information for different elements
+    * @var array
+    */
+    var $_elementStyles = array();
+
+   /**
+    * true: collect all hidden elements into string; false: process them as usual form elements
+    * @var bool
+    */
+    var $_collectHidden = false;
+
+   /**
+    * true:  render an array of labels to many labels, $key 0 named 'label', the rest "label_$key"
+    * false: leave labels as defined
+    * @var bool
+    */
+    var $_staticLabels = false;
+   /**#@-*/
+
+   /**
+    * Constructor
+    *
+    * @param  bool    true: collect all hidden elements into string; false: process them as usual form elements
+    * @param  bool    true: render an array of labels to many labels, $key 0 to 'label' and the oterh to "label_$key"
+    * @access public
+    */
+    function HTML_QuickForm_Renderer_Array($collectHidden = false, $staticLabels = false)
+    {
+        $this->HTML_QuickForm_Renderer();
+        $this->_collectHidden = $collectHidden;
+        $this->_staticLabels  = $staticLabels;
+    } // end constructor
+
+
+   /**
+    * Returns the resultant array
+    *
+    * @access public
+    * @return array
+    */
+    function toArray()
+    {
+        return $this->_ary;
+    }
+
+
+    function startForm(&$form)
+    {
+        $this->_ary = array(
+            'frozen'            => $form->isFrozen(),
+            'javascript'        => $form->getValidationScript(),
+            'attributes'        => $form->getAttributes(true),
+            'requirednote'      => $form->getRequiredNote(),
+            'errors'            => array()
+        );
+        if ($this->_collectHidden) {
+            $this->_ary['hidden'] = '';
+        }
+        $this->_elementIdx     = 1;
+        $this->_currentSection = null;
+        $this->_sectionCount   = 0;
+    } // end func startForm
+
+
+    function renderHeader(&$header)
+    {
+        $this->_ary['sections'][$this->_sectionCount] = array(
+            'header' => $header->toHtml(),
+            'name'   => $header->getName()
+        );
+        $this->_currentSection = $this->_sectionCount++;
+    } // end func renderHeader
+
+
+    function renderElement(&$element, $required, $error)
+    {
+        $elAry = $this->_elementToArray($element, $required, $error);
+        if (!empty($error)) {
+            $this->_ary['errors'][$elAry['name']] = $error;
+        }
+        $this->_storeArray($elAry);
+    } // end func renderElement
+
+
+    function renderHidden(&$element)
+    {
+        if ($this->_collectHidden) {
+            $this->_ary['hidden'] .= $element->toHtml() . "\n";
+        } else {
+            $this->renderElement($element, false, null);
+        }
+    } // end func renderHidden
+
+
+    function startGroup(&$group, $required, $error)
+    {
+        $this->_currentGroup = $this->_elementToArray($group, $required, $error);
+        if (!empty($error)) {
+            $this->_ary['errors'][$this->_currentGroup['name']] = $error;
+        }
+    } // end func startGroup
+
+
+    function finishGroup(&$group)
+    {
+        $this->_storeArray($this->_currentGroup);
+        $this->_currentGroup = null;
+    } // end func finishGroup
+
+
+   /**
+    * Creates an array representing an element
+    *
+    * @access private
+    * @param  HTML_QuickForm_element    element being processed
+    * @param  bool                      Whether an element is required
+    * @param  string                    Error associated with the element
+    * @return array
+    */
+    function _elementToArray(&$element, $required, $error)
+    {
+        $ret = array(
+            'name'      => $element->getName(),
+            'value'     => $element->getValue(),
+            'type'      => $element->getType(),
+            'frozen'    => $element->isFrozen(),
+            'required'  => $required,
+            'error'     => $error
+        );
+        // render label(s)
+        $labels = $element->getLabel();
+        if (is_array($labels) && $this->_staticLabels) {
+            foreach($labels as $key => $label) {
+                $key = is_int($key)? $key + 1: $key;
+                if (1 === $key) {
+                    $ret['label'] = $label;
+                } else {
+                    $ret['label_' . $key] = $label;
+                }
+            }
+        } else {
+            $ret['label'] = $labels;
+        }
+
+        // set the style for the element
+        if (isset($this->_elementStyles[$ret['name']])) {
+            $ret['style'] = $this->_elementStyles[$ret['name']];
+        }
+        if ('group' == $ret['type']) {
+            $ret['separator'] = $element->_separator;
+            $ret['elements']  = array();
+        } else {
+            $ret['html']      = $element->toHtml();
+        }
+        return $ret;
+    }
+
+
+   /**
+    * Stores an array representation of an element in the form array
+    *
+    * @access private
+    * @param array  Array representation of an element
+    * @return void
+    */
+    function _storeArray($elAry)
+    {
+        // where should we put this element...
+        if (is_array($this->_currentGroup) && ('group' != $elAry['type'])) {
+            $this->_currentGroup['elements'][] = $elAry;
+        } elseif (isset($this->_currentSection)) {
+            $this->_ary['sections'][$this->_currentSection]['elements'][] = $elAry;
+        } else {
+            $this->_ary['elements'][] = $elAry;
+        }
+    }
+
+
+   /**
+    * Sets a style to use for element rendering
+    *
+    * @param mixed      element name or array ('element name' => 'style name')
+    * @param string     style name if $elementName is not an array
+    * @access public
+    * @return void
+    */
+    function setElementStyle($elementName, $styleName = null)
+    {
+        if (is_array($elementName)) {
+            $this->_elementStyles = array_merge($this->_elementStyles, $elementName);
+        } else {
+            $this->_elementStyles[$elementName] = $styleName;
+        }
+    }
+}
+?>
\ No newline at end of file
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/ArraySmarty.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/ArraySmarty.php
new file mode 100644 (file)
index 0000000..d1e20f1
--- /dev/null
@@ -0,0 +1,403 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * A static renderer for HTML_QuickForm, makes an array of form content
+ * useful for a Smarty template
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Alexey Borzov <avb@php.net>
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @author      Thomas Schulz <ths@4bconsult.de>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * A concrete renderer for HTML_QuickForm, makes an array of form contents
+ */ 
+require_once 'HTML/QuickForm/Renderer/Array.php';
+
+/**
+ * A static renderer for HTML_QuickForm, makes an array of form content
+ * useful for a Smarty template
+ *
+ * Based on old HTML_QuickForm::toArray() code and ITStatic renderer.
+ *
+ * The form array structure is the following:
+ * <pre>
+ * Array (
+ *  [frozen]       => whether the complete form is frozen'
+ *  [javascript]   => javascript for client-side validation
+ *  [attributes]   => attributes for <form> tag
+ *  [hidden]       => html of all hidden elements
+ *  [requirednote] => note about the required elements
+ *  [errors] => Array
+ *      (
+ *          [1st_element_name] => Error for the 1st element
+ *          ...
+ *          [nth_element_name] => Error for the nth element
+ *      )
+ *
+ *  [header] => Array
+ *      (
+ *          [1st_header_name] => Header text for the 1st header
+ *          ...
+ *          [nth_header_name] => Header text for the nth header
+ *      )
+ *
+ *  [1st_element_name] => Array for the 1st element
+ *  ...
+ *  [nth_element_name] => Array for the nth element
+ * </pre>
+ *
+ * where an element array has the form:
+ * <pre>
+ *      (
+ *          [name]      => element name
+ *          [value]     => element value,
+ *          [type]      => type of the element
+ *          [frozen]    => whether element is frozen
+ *          [label]     => label for the element
+ *          [required]  => whether element is required
+ * // if element is not a group:
+ *          [html]      => HTML for the element
+ * // if element is a group:
+ *          [separator] => separator for group elements
+ *          [1st_gitem_name] => Array for the 1st element in group
+ *          ...
+ *          [nth_gitem_name] => Array for the nth element in group
+ *      )
+ * )
+ * </pre>
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Alexey Borzov <avb@php.net>
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @author      Thomas Schulz <ths@4bconsult.de>
+ * @version     Release: 3.2.16
+ * @since       3.0
+ */
+class HTML_QuickForm_Renderer_ArraySmarty extends HTML_QuickForm_Renderer_Array
+{
+   /**#@+
+    * @access private
+    */
+   /**
+    * The Smarty template engine instance
+    * @var object
+    */
+    var $_tpl = null;
+
+   /**
+    * Current element index
+    * @var integer
+    */
+    var $_elementIdx = 0;
+
+    /**
+    * The current element index inside a group
+    * @var integer
+    */
+    var $_groupElementIdx = 0;
+
+   /**
+    * How to handle the required tag for required fields
+    * @var string
+    * @see      setRequiredTemplate()
+    */
+    var $_required = '';
+
+   /**
+    * How to handle error messages in form validation
+    * @var string
+    * @see      setErrorTemplate()
+    */
+    var $_error = '';
+   /**#@-*/
+
+   /**
+    * Constructor
+    *
+    * @param  Smarty  reference to the Smarty template engine instance
+    * @param  bool    true: render an array of labels to many labels, $key 0 to 'label' and the oterh to "label_$key"
+    * @param  bool    true: collect all hidden elements into string; false: process them as usual form elements
+    * @access public
+    */
+    function HTML_QuickForm_Renderer_ArraySmarty(&$tpl, $staticLabels = false, $collectHidden = true)
+    {
+        $this->HTML_QuickForm_Renderer_Array($collectHidden, $staticLabels);
+        $this->_tpl =& $tpl;
+    } // end constructor
+
+   /**
+    * Called when visiting a header element
+    *
+    * @param    HTML_QuickForm_header   header element being visited
+    * @access   public
+    * @return   void
+    */
+    function renderHeader(&$header)
+    {
+        if ($name = $header->getName()) {
+            $this->_ary['header'][$name] = $header->toHtml();
+        } else {
+            $this->_ary['header'][$this->_sectionCount] = $header->toHtml();
+        }
+        $this->_currentSection = $this->_sectionCount++;
+    } // end func renderHeader
+
+   /**
+    * Called when visiting a group, before processing any group elements
+    *
+    * @param    HTML_QuickForm_group    group being visited
+    * @param    bool                    Whether a group is required
+    * @param    string                  An error message associated with a group
+    * @access   public
+    * @return   void
+    */
+    function startGroup(&$group, $required, $error)
+    {
+        parent::startGroup($group, $required, $error);
+        $this->_groupElementIdx = 1;
+    } // end func startGroup
+
+   /**
+    * Creates an array representing an element containing
+    * the key for storing this
+    *
+    * @access private
+    * @param  HTML_QuickForm_element    form element being visited
+    * @param  bool                      Whether an element is required
+    * @param  string                    Error associated with the element
+    * @return array
+    */
+    function _elementToArray(&$element, $required, $error)
+    {
+        $ret = parent::_elementToArray($element, $required, $error);
+
+        if ('group' == $ret['type']) {
+            $ret['html'] = $element->toHtml();
+            // we don't need the elements, see the array structure
+            unset($ret['elements']);
+        }
+        if (($required || $error) && !empty($this->_required)){
+            $this->_renderRequired($ret['label'], $ret['html'], $required, $error);
+        }
+        if ($error && !empty($this->_error)) {
+            $this->_renderError($ret['label'], $ret['html'], $error);
+            $ret['error'] = $error;
+        }
+        // create keys for elements grouped by native group or name
+        if (strstr($ret['name'], '[') or $this->_currentGroup) {
+            // Fix for bug #8123: escape backslashes and quotes to prevent errors 
+            // in eval(). The code below seems to handle the case where element
+            // name has unbalanced square brackets. Dunno whether we really
+            // need this after the fix for #8123, but I'm wary of making big
+            // changes to this code.  
+            preg_match('/([^]]*)\\[([^]]*)\\]/', $ret['name'], $matches);
+            if (isset($matches[1])) {
+                $sKeysSub = substr_replace($ret['name'], '', 0, strlen($matches[1]));
+                $sKeysSub = str_replace(
+                    array('\\',   '\'',   '['  ,   ']', '[\'\']'),
+                    array('\\\\', '\\\'', '[\'', '\']', '[]'    ),
+                    $sKeysSub
+                );
+                $sKeys = '[\'' . str_replace(array('\\', '\''), array('\\\\', '\\\''), $matches[1]) . '\']' . $sKeysSub;
+            } else {
+                $sKeys = '[\'' . str_replace(array('\\', '\''), array('\\\\', '\\\''), $ret['name']) . '\']';
+            }
+            // special handling for elements in native groups
+            if ($this->_currentGroup) {
+                // skip unnamed group items unless radios: no name -> no static access
+                // identification: have the same key string as the parent group
+                if ($this->_currentGroup['keys'] == $sKeys and 'radio' != $ret['type']) {
+                    return false;
+                }
+                // reduce string of keys by remove leading group keys
+                if (0 === strpos($sKeys, $this->_currentGroup['keys'])) {
+                    $sKeys = substr_replace($sKeys, '', 0, strlen($this->_currentGroup['keys']));
+                }
+            }
+        // element without a name
+        } elseif ($ret['name'] == '') {
+            $sKeys = '[\'element_' . $this->_elementIdx . '\']';
+        // other elements
+        } else {
+            $sKeys = '[\'' . str_replace(array('\\', '\''), array('\\\\', '\\\''), $ret['name']) . '\']';
+        }
+        // for radios: add extra key from value
+        if ('radio' == $ret['type'] and substr($sKeys, -2) != '[]') {
+            $sKeys .= '[\'' . str_replace(array('\\', '\''), array('\\\\', '\\\''), $ret['value']) . '\']';
+        }
+        $this->_elementIdx++;
+        $ret['keys'] = $sKeys;
+        return $ret;
+    } // end func _elementToArray
+
+   /**
+    * Stores an array representation of an element in the form array
+    *
+    * @access private
+    * @param array  Array representation of an element
+    * @return void
+    */
+    function _storeArray($elAry)
+    {
+        if ($elAry) {
+            $sKeys = $elAry['keys'];
+            unset($elAry['keys']);
+            // where should we put this element...
+            if (is_array($this->_currentGroup) && ('group' != $elAry['type'])) {
+                $toEval = '$this->_currentGroup' . $sKeys . ' = $elAry;';
+            } else {
+                $toEval = '$this->_ary' . $sKeys . ' = $elAry;';
+            }
+            eval($toEval);
+        }
+        return;
+    }
+
+   /**
+    * Called when an element is required
+    *
+    * This method will add the required tag to the element label and/or the element html
+    * such as defined with the method setRequiredTemplate.
+    *
+    * @param    string      The element label
+    * @param    string      The element html rendering
+    * @param    boolean     The element required
+    * @param    string      The element error
+    * @see      setRequiredTemplate()
+    * @access   private
+    * @return   void
+    */
+    function _renderRequired(&$label, &$html, &$required, &$error)
+    {
+        $this->_tpl->assign(array(
+            'label'    => $label,
+            'html'     => $html,
+            'required' => $required,
+            'error'    => $error
+        ));
+        if (!empty($label) && strpos($this->_required, $this->_tpl->left_delimiter . '$label') !== false) {
+            $label = $this->_tplFetch($this->_required);
+        }
+        if (!empty($html) && strpos($this->_required, $this->_tpl->left_delimiter . '$html') !== false) {
+            $html = $this->_tplFetch($this->_required);
+        }
+        $this->_tpl->clear_assign(array('label', 'html', 'required'));
+    } // end func _renderRequired
+
+   /**
+    * Called when an element has a validation error
+    *
+    * This method will add the error message to the element label or the element html
+    * such as defined with the method setErrorTemplate. If the error placeholder is not found
+    * in the template, the error will be displayed in the form error block.
+    *
+    * @param    string      The element label
+    * @param    string      The element html rendering
+    * @param    string      The element error
+    * @see      setErrorTemplate()
+    * @access   private
+    * @return   void
+    */
+    function _renderError(&$label, &$html, &$error)
+    {
+        $this->_tpl->assign(array('label' => '', 'html' => '', 'error' => $error));
+        $error = $this->_tplFetch($this->_error);
+        $this->_tpl->assign(array('label' => $label, 'html'  => $html));
+
+        if (!empty($label) && strpos($this->_error, $this->_tpl->left_delimiter . '$label') !== false) {
+            $label = $this->_tplFetch($this->_error);
+        } elseif (!empty($html) && strpos($this->_error, $this->_tpl->left_delimiter . '$html') !== false) {
+            $html = $this->_tplFetch($this->_error);
+        }
+        $this->_tpl->clear_assign(array('label', 'html', 'error'));
+    } // end func _renderError
+
+   /**
+    * Process an template sourced in a string with Smarty
+    *
+    * Smarty has no core function to render    a template given as a string.
+    * So we use the smarty eval plugin function        to do this.
+    *
+    * @param    string      The template source
+    * @access   private
+    * @return   void
+    */
+    function _tplFetch($tplSource)
+    {
+        if (!function_exists('smarty_function_eval')) {
+            require SMARTY_DIR . '/plugins/function.eval.php';
+        }
+        return smarty_function_eval(array('var' => $tplSource), $this->_tpl);
+    }// end func _tplFetch
+
+   /**
+    * Sets the way required elements are rendered
+    *
+    * You can use {$label} or {$html} placeholders to let the renderer know where
+    * where the element label or the element html are positionned according to the
+    * required tag. They will be replaced accordingly with the right value.    You
+    * can use the full smarty syntax here, especially a custom modifier for I18N.
+    * For example:
+    * {if $required}<span style="color: red;">*</span>{/if}{$label|translate}
+    * will put a red star in front of the label if the element is required and
+    * translate the label.
+    *
+    *
+    * @param    string      The required element template
+    * @access   public
+    * @return   void
+    */
+    function setRequiredTemplate($template)
+    {
+        $this->_required = $template;
+    } // end func setRequiredTemplate
+
+   /**
+    * Sets the way elements with validation errors are rendered
+    *
+    * You can use {$label} or {$html} placeholders to let the renderer know where
+    * where the element label or the element html are positionned according to the
+    * error message. They will be replaced accordingly with the right value.
+    * The error message will replace the {$error} placeholder.
+    * For example:
+    * {if $error}<span style="color: red;">{$error}</span>{/if}<br />{$html}
+    * will put the error message in red on top of the element html.
+    *
+    * If you want all error messages to be output in the main error block, use
+    * the {$form.errors} part of the rendered array that collects all raw error
+    * messages.
+    *
+    * If you want to place all error messages manually, do not specify {$html}
+    * nor {$label}.
+    *
+    * Groups can have special layouts. With this kind of groups, you have to
+    * place the formated error message manually. In this case, use {$form.group.error}
+    * where you want the formated error message to appear in the form.
+    *
+    * @param    string      The element error template
+    * @access   public
+    * @return   void
+    */
+    function setErrorTemplate($template)
+    {
+        $this->_error = $template;
+    } // end func setErrorTemplate
+}
+?>
\ No newline at end of file
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/Default.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/Default.php
new file mode 100644 (file)
index 0000000..74c5ce1
--- /dev/null
@@ -0,0 +1,485 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * A concrete renderer for HTML_QuickForm, based on QuickForm 2.x built-in one
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Alexey Borzov <avb@php.net>
+ * @author      Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * An abstract base class for QuickForm renderers
+ */
+require_once 'HTML/QuickForm/Renderer.php';
+
+/**
+ * A concrete renderer for HTML_QuickForm, based on QuickForm 2.x built-in one
+ * 
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Alexey Borzov <avb@php.net>
+ * @author      Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @version     Release: 3.2.16
+ * @since       3.0
+ */
+class HTML_QuickForm_Renderer_Default extends HTML_QuickForm_Renderer
+{
+   /**
+    * The HTML of the form  
+    * @var      string
+    * @access   private
+    */
+    var $_html;
+
+   /**
+    * Header Template string
+    * @var      string
+    * @access   private
+    */
+    var $_headerTemplate = 
+        "\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>";
+
+   /**
+    * Element template string
+    * @var      string
+    * @access   private
+    */
+    var $_elementTemplate = 
+        "\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>";
+
+   /**
+    * Form template string
+    * @var      string
+    * @access   private
+    */
+    var $_formTemplate = 
+        "\n<form{attributes}>\n<div>\n{hidden}<table border=\"0\">\n{content}\n</table>\n</div>\n</form>";
+
+   /**
+    * Required Note template string
+    * @var      string
+    * @access   private
+    */
+    var $_requiredNoteTemplate = 
+        "\n\t<tr>\n\t\t<td></td>\n\t<td align=\"left\" valign=\"top\">{requiredNote}</td>\n\t</tr>";
+
+   /**
+    * Array containing the templates for customised elements
+    * @var      array
+    * @access   private
+    */
+    var $_templates = array();
+
+   /**
+    * Array containing the templates for group wraps.
+    * 
+    * These templates are wrapped around group elements and groups' own
+    * templates wrap around them. This is set by setGroupTemplate().
+    * 
+    * @var      array
+    * @access   private
+    */
+    var $_groupWraps = array();
+
+   /**
+    * Array containing the templates for elements within groups
+    * @var      array
+    * @access   private
+    */
+    var $_groupTemplates = array();
+
+   /**
+    * True if we are inside a group 
+    * @var      bool
+    * @access   private
+    */
+    var $_inGroup = false;
+
+   /**
+    * Array with HTML generated for group elements
+    * @var      array
+    * @access   private
+    */
+    var $_groupElements = array();
+
+   /**
+    * Template for an element inside a group
+    * @var      string
+    * @access   private
+    */
+    var $_groupElementTemplate = '';
+
+   /**
+    * HTML that wraps around the group elements
+    * @var      string
+    * @access   private
+    */
+    var $_groupWrap = '';
+
+   /**
+    * HTML for the current group
+    * @var      string
+    * @access   private
+    */
+    var $_groupTemplate = '';
+    
+   /**
+    * Collected HTML of the hidden fields
+    * @var      string
+    * @access   private
+    */
+    var $_hiddenHtml = '';
+
+   /**
+    * Constructor
+    *
+    * @access public
+    */
+    function HTML_QuickForm_Renderer_Default()
+    {
+        $this->HTML_QuickForm_Renderer();
+    } // end constructor
+
+   /**
+    * returns the HTML generated for the form
+    *
+    * @access public
+    * @return string
+    */
+    function toHtml()
+    {
+        // _hiddenHtml is cleared in finishForm(), so this only matters when
+        // finishForm() was not called (e.g. group::toHtml(), bug #3511)
+        return $this->_hiddenHtml . $this->_html;
+    } // end func toHtml
+    
+   /**
+    * Called when visiting a form, before processing any form elements
+    *
+    * @param    HTML_QuickForm  form object being visited
+    * @access   public
+    * @return   void
+    */
+    function startForm(&$form)
+    {
+        $this->_html = '';
+        $this->_hiddenHtml = '';
+    } // end func startForm
+
+   /**
+    * Called when visiting a form, after processing all form elements
+    * Adds required note, form attributes, validation javascript and form content.
+    * 
+    * @param    HTML_QuickForm  form object being visited
+    * @access   public
+    * @return   void
+    */
+    function finishForm(&$form)
+    {
+        // add a required note, if one is needed
+        if (!empty($form->_required) && !$form->_freezeAll) {
+            $this->_html .= str_replace('{requiredNote}', $form->getRequiredNote(), $this->_requiredNoteTemplate);
+        }
+        // add form attributes and content
+        $html = str_replace('{attributes}', $form->getAttributes(true), $this->_formTemplate);
+        if (strpos($this->_formTemplate, '{hidden}')) {
+            $html = str_replace('{hidden}', $this->_hiddenHtml, $html);
+        } else {
+            $this->_html .= $this->_hiddenHtml;
+        }
+        $this->_hiddenHtml = '';
+        $this->_html = str_replace('{content}', $this->_html, $html);
+        // add a validation script
+        if ('' != ($script = $form->getValidationScript())) {
+            $this->_html = $script . "\n" . $this->_html;
+        }
+    } // end func finishForm
+      
+   /**
+    * Called when visiting a header element
+    *
+    * @param    HTML_QuickForm_header   header element being visited
+    * @access   public
+    * @return   void
+    */
+    function renderHeader(&$header)
+    {
+        $name = $header->getName();
+        if (!empty($name) && isset($this->_templates[$name])) {
+            $this->_html .= str_replace('{header}', $header->toHtml(), $this->_templates[$name]);
+        } else {
+            $this->_html .= str_replace('{header}', $header->toHtml(), $this->_headerTemplate);
+        }
+    } // end func renderHeader
+
+   /**
+    * Helper method for renderElement
+    *
+    * @param    string      Element name
+    * @param    mixed       Element label (if using an array of labels, you should set the appropriate template)
+    * @param    bool        Whether an element is required
+    * @param    string      Error message associated with the element
+    * @access   private
+    * @see      renderElement()
+    * @return   string      Html for element
+    */
+    function _prepareTemplate($name, $label, $required, $error)
+    {
+        if (is_array($label)) {
+            $nameLabel = array_shift($label);
+        } else {
+            $nameLabel = $label;
+        }
+        if (isset($this->_templates[$name])) {
+            $html = str_replace('{label}', $nameLabel, $this->_templates[$name]);
+        } else {
+            $html = str_replace('{label}', $nameLabel, $this->_elementTemplate);
+        }
+        if ($required) {
+            $html = str_replace('<!-- BEGIN required -->', '', $html);
+            $html = str_replace('<!-- END required -->', '', $html);
+        } else {
+            $html = preg_replace("/([ \t\n\r]*)?<!-- BEGIN required -->.*<!-- END required -->([ \t\n\r]*)?/isU", '', $html);
+        }
+        if (isset($error)) {
+            $html = str_replace('{error}', $error, $html);
+            $html = str_replace('<!-- BEGIN error -->', '', $html);
+            $html = str_replace('<!-- END error -->', '', $html);
+        } else {
+            $html = preg_replace("/([ \t\n\r]*)?<!-- BEGIN error -->.*<!-- END error -->([ \t\n\r]*)?/isU", '', $html);
+        }
+        if (is_array($label)) {
+            foreach($label as $key => $text) {
+                $key  = is_int($key)? $key + 2: $key;
+                $html = str_replace("{label_{$key}}", $text, $html);
+                $html = str_replace("<!-- BEGIN label_{$key} -->", '', $html);
+                $html = str_replace("<!-- END label_{$key} -->", '', $html);
+            }
+        }
+        if (strpos($html, '{label_')) {
+            $html = preg_replace('/\s*<!-- BEGIN label_(\S+) -->.*<!-- END label_\1 -->\s*/is', '', $html);
+        }
+        return $html;
+    } // end func _prepareTemplate
+
+   /**
+    * Renders an element Html
+    * Called when visiting an element
+    *
+    * @param HTML_QuickForm_element form element being visited
+    * @param bool                   Whether an element is required
+    * @param string                 An error message associated with an element
+    * @access public
+    * @return void
+    */
+    function renderElement(&$element, $required, $error)
+    {
+        if (!$this->_inGroup) {
+            $html = $this->_prepareTemplate($element->getName(), $element->getLabel(), $required, $error);
+            $this->_html .= str_replace('{element}', $element->toHtml(), $html);
+
+        } elseif (!empty($this->_groupElementTemplate)) {
+            $html = str_replace('{label}', $element->getLabel(), $this->_groupElementTemplate);
+            if ($required) {
+                $html = str_replace('<!-- BEGIN required -->', '', $html);
+                $html = str_replace('<!-- END required -->', '', $html);
+            } else {
+                $html = preg_replace("/([ \t\n\r]*)?<!-- BEGIN required -->.*<!-- END required -->([ \t\n\r]*)?/isU", '', $html);
+            }
+            $this->_groupElements[] = str_replace('{element}', $element->toHtml(), $html);
+
+        } else {
+            $this->_groupElements[] = $element->toHtml();
+        }
+    } // end func renderElement
+   
+   /**
+    * Renders an hidden element
+    * Called when visiting a hidden element
+    * 
+    * @param HTML_QuickForm_element     form element being visited
+    * @access public
+    * @return void
+    */
+    function renderHidden(&$element)
+    {
+        $this->_hiddenHtml .= $element->toHtml() . "\n";
+    } // end func renderHidden
+
+   /**
+    * Called when visiting a raw HTML/text pseudo-element
+    * 
+    * @param  HTML_QuickForm_html   element being visited
+    * @access public
+    * @return void
+    */
+    function renderHtml(&$data)
+    {
+        $this->_html .= $data->toHtml();
+    } // end func renderHtml
+
+   /**
+    * Called when visiting a group, before processing any group elements
+    *
+    * @param HTML_QuickForm_group   group being visited
+    * @param bool       Whether a group is required
+    * @param string     An error message associated with a group
+    * @access public
+    * @return void
+    */
+    function startGroup(&$group, $required, $error)
+    {
+        $name = $group->getName();
+        $this->_groupTemplate        = $this->_prepareTemplate($name, $group->getLabel(), $required, $error);
+        $this->_groupElementTemplate = empty($this->_groupTemplates[$name])? '': $this->_groupTemplates[$name];
+        $this->_groupWrap            = empty($this->_groupWraps[$name])? '': $this->_groupWraps[$name];
+        $this->_groupElements        = array();
+        $this->_inGroup              = true;
+    } // end func startGroup
+
+   /**
+    * Called when visiting a group, after processing all group elements
+    *
+    * @param    HTML_QuickForm_group    group being visited
+    * @access   public
+    * @return   void
+    */
+    function finishGroup(&$group)
+    {
+        $separator = $group->_separator;
+        if (is_array($separator)) {
+            $count = count($separator);
+            $html  = '';
+            for ($i = 0; $i < count($this->_groupElements); $i++) {
+                $html .= (0 == $i? '': $separator[($i - 1) % $count]) . $this->_groupElements[$i];
+            }
+        } else {
+            if (is_null($separator)) {
+                $separator = '&nbsp;';
+            }
+            $html = implode((string)$separator, $this->_groupElements);
+        }
+        if (!empty($this->_groupWrap)) {
+            $html = str_replace('{content}', $html, $this->_groupWrap);
+        }
+        $this->_html   .= str_replace('{element}', $html, $this->_groupTemplate);
+        $this->_inGroup = false;
+    } // end func finishGroup
+
+    /**
+     * Sets element template 
+     *
+     * @param       string      The HTML surrounding an element 
+     * @param       string      (optional) Name of the element to apply template for
+     * @access      public
+     * @return      void
+     */
+    function setElementTemplate($html, $element = null)
+    {
+        if (is_null($element)) {
+            $this->_elementTemplate = $html;
+        } else {
+            $this->_templates[$element] = $html;
+        }
+    } // end func setElementTemplate
+
+
+    /**
+     * Sets template for a group wrapper 
+     * 
+     * This template is contained within a group-as-element template 
+     * set via setTemplate() and contains group's element templates, set
+     * via setGroupElementTemplate()
+     *
+     * @param       string      The HTML surrounding group elements
+     * @param       string      Name of the group to apply template for
+     * @access      public
+     * @return      void
+     */
+    function setGroupTemplate($html, $group)
+    {
+        $this->_groupWraps[$group] = $html;
+    } // end func setGroupTemplate
+
+    /**
+     * Sets element template for elements within a group
+     *
+     * @param       string      The HTML surrounding an element 
+     * @param       string      Name of the group to apply template for
+     * @access      public
+     * @return      void
+     */
+    function setGroupElementTemplate($html, $group)
+    {
+        $this->_groupTemplates[$group] = $html;
+    } // end func setGroupElementTemplate
+
+    /**
+     * Sets header template
+     *
+     * @param       string      The HTML surrounding the header 
+     * @access      public
+     * @return      void
+     */
+    function setHeaderTemplate($html)
+    {
+        $this->_headerTemplate = $html;
+    } // end func setHeaderTemplate
+
+    /**
+     * Sets form template 
+     *
+     * @param     string    The HTML surrounding the form tags 
+     * @access    public
+     * @return    void
+     */
+    function setFormTemplate($html)
+    {
+        $this->_formTemplate = $html;
+    } // end func setFormTemplate
+
+    /**
+     * Sets the note indicating required fields template
+     *
+     * @param       string      The HTML surrounding the required note 
+     * @access      public
+     * @return      void
+     */
+    function setRequiredNoteTemplate($html)
+    {
+        $this->_requiredNoteTemplate = $html;
+    } // end func setRequiredNoteTemplate
+
+    /**
+     * Clears all the HTML out of the templates that surround notes, elements, etc.
+     * Useful when you want to use addData() to create a completely custom form look
+     *
+     * @access  public
+     * @return  void
+     */
+    function clearAllTemplates()
+    {
+        $this->setElementTemplate('{element}');
+        $this->setFormTemplate("\n\t<form{attributes}>{content}\n\t</form>\n");
+        $this->setRequiredNoteTemplate('');
+        $this->_templates = array();
+    } // end func clearAllTemplates
+} // end class HTML_QuickForm_Renderer_Default
+?>
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/ITDynamic.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/ITDynamic.php
new file mode 100644 (file)
index 0000000..02a0d35
--- /dev/null
@@ -0,0 +1,300 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * A concrete renderer for HTML_QuickForm, using Integrated Templates.
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Alexey Borzov <avb@php.net>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * An abstract base class for QuickForm renderers
+ */
+require_once 'HTML/QuickForm/Renderer.php';
+
+/**
+ * A concrete renderer for HTML_QuickForm, using Integrated Templates.
+ * 
+ * This is a "dynamic" renderer, which means that concrete form look 
+ * is defined at runtime. This also means that you can define 
+ * <b>one</b> template file for <b>all</b> your forms. That template
+ * should contain a block for every element 'look' appearing in your 
+ * forms and also some special blocks (consult the examples). If a
+ * special block is not set for an element, the renderer falls back to
+ * a default one.
+ * 
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Alexey Borzov <avb@php.net>
+ * @version     Release: 3.2.16
+ * @since       3.0
+ */
+class HTML_QuickForm_Renderer_ITDynamic extends HTML_QuickForm_Renderer
+{
+   /**#@+
+    * @access private
+    */
+   /**
+    * A template class (HTML_Template_ITX or HTML_Template_Sigma) instance
+    * @var HTML_Template_ITX|HTML_Template_Sigma
+    */
+    var $_tpl = null;
+
+   /**
+    * The errors that were not shown near concrete fields go here
+    * @var array
+    */
+    var $_errors = array();
+
+   /**
+    * Show the block with required note?
+    * @var bool
+    */
+    var $_showRequired = false;
+
+   /**
+    * A separator for group elements
+    * @var mixed
+    */
+    var $_groupSeparator = null;
+
+   /**
+    * The current element index inside a group
+    * @var integer
+    */
+    var $_groupElementIdx = 0;
+
+   /**
+    * Blocks to use for different elements  
+    * @var array
+    */
+    var $_elementBlocks = array();
+
+   /**
+    * Block to use for headers
+    * @var string
+    */
+    var $_headerBlock = null;
+   /**#@-*/
+
+
+   /**
+    * Constructor
+    *
+    * @param HTML_Template_ITX|HTML_Template_Sigma     Template object to use
+    */
+    function HTML_QuickForm_Renderer_ITDynamic(&$tpl)
+    {
+        $this->HTML_QuickForm_Renderer();
+        $this->_tpl =& $tpl;
+        $this->_tpl->setCurrentBlock('qf_main_loop');
+    }
+
+
+    function finishForm(&$form)
+    {
+        // display errors above form
+        if (!empty($this->_errors) && $this->_tpl->blockExists('qf_error_loop')) {
+            foreach ($this->_errors as $error) {
+                $this->_tpl->setVariable('qf_error', $error);
+                $this->_tpl->parse('qf_error_loop');
+            }
+        }
+        // show required note
+        if ($this->_showRequired) {
+            $this->_tpl->setVariable('qf_required_note', $form->getRequiredNote());
+        }
+        // assign form attributes
+        $this->_tpl->setVariable('qf_attributes', $form->getAttributes(true));
+        // assign javascript validation rules
+        $this->_tpl->setVariable('qf_javascript', $form->getValidationScript());
+    }
+      
+
+    function renderHeader(&$header)
+    {
+        $blockName = $this->_matchBlock($header);
+        if ('qf_header' == $blockName && isset($this->_headerBlock)) {
+            $blockName = $this->_headerBlock;
+        }
+        $this->_tpl->setVariable('qf_header', $header->toHtml());
+        $this->_tpl->parse($blockName);
+        $this->_tpl->parse('qf_main_loop');
+    }
+
+
+    function renderElement(&$element, $required, $error)
+    {
+        $blockName = $this->_matchBlock($element);
+        // are we inside a group?
+        if ('qf_main_loop' != $this->_tpl->currentBlock) {
+            if (0 != $this->_groupElementIdx && $this->_tpl->placeholderExists('qf_separator', $blockName)) {
+                if (is_array($this->_groupSeparator)) {
+                    $this->_tpl->setVariable('qf_separator', $this->_groupSeparator[($this->_groupElementIdx - 1) % count($this->_groupSeparator)]);
+                } else {
+                    $this->_tpl->setVariable('qf_separator', (string)$this->_groupSeparator);
+                }
+            }
+            $this->_groupElementIdx++;
+
+        } elseif(!empty($error)) {
+            // show the error message or keep it for later use
+            if ($this->_tpl->blockExists($blockName . '_error')) {
+                $this->_tpl->setVariable('qf_error', $error);
+            } else {
+                $this->_errors[] = $error;
+            }
+        }
+        // show an '*' near the required element
+        if ($required) {
+            $this->_showRequired = true;
+            if ($this->_tpl->blockExists($blockName . '_required')) {
+                $this->_tpl->touchBlock($blockName . '_required');
+            }
+        }
+        // Prepare multiple labels
+        $labels = $element->getLabel();
+        if (is_array($labels)) {
+            $mainLabel = array_shift($labels);
+        } else {
+            $mainLabel = $labels;
+        }
+        // render the element itself with its main label
+        $this->_tpl->setVariable('qf_element', $element->toHtml());
+        if ($this->_tpl->placeholderExists('qf_label', $blockName)) {
+            $this->_tpl->setVariable('qf_label', $mainLabel);
+        }
+        // render extra labels, if any
+        if (is_array($labels)) {
+            foreach($labels as $key => $label) {
+                $key = is_int($key)? $key + 2: $key;
+                if ($this->_tpl->blockExists($blockName . '_label_' . $key)) {
+                    $this->_tpl->setVariable('qf_label_' . $key, $label);
+                }
+            }
+        }
+        $this->_tpl->parse($blockName);
+        $this->_tpl->parseCurrentBlock();
+    }
+   
+
+    function renderHidden(&$element)
+    {
+        $this->_tpl->setVariable('qf_hidden', $element->toHtml());
+        $this->_tpl->parse('qf_hidden_loop');
+    }
+
+
+    function startGroup(&$group, $required, $error)
+    {
+        $blockName = $this->_matchBlock($group);
+        $this->_tpl->setCurrentBlock($blockName . '_loop');
+        $this->_groupElementIdx = 0;
+        $this->_groupSeparator  = is_null($group->_separator)? '&nbsp;': $group->_separator;
+        // show an '*' near the required element
+        if ($required) {
+            $this->_showRequired = true;
+            if ($this->_tpl->blockExists($blockName . '_required')) {
+                $this->_tpl->touchBlock($blockName . '_required');
+            }
+        }
+        // show the error message or keep it for later use
+        if (!empty($error)) {
+            if ($this->_tpl->blockExists($blockName . '_error')) {
+                $this->_tpl->setVariable('qf_error', $error);
+            } else {
+                $this->_errors[] = $error;
+            }
+        }
+        $this->_tpl->setVariable('qf_group_label', $group->getLabel());
+    }
+
+
+    function finishGroup(&$group)
+    {
+        $this->_tpl->parse($this->_matchBlock($group));
+        $this->_tpl->setCurrentBlock('qf_main_loop');
+        $this->_tpl->parseCurrentBlock();
+    }
+
+
+   /**
+    * Returns the name of a block to use for element rendering
+    * 
+    * If a name was not explicitly set via setElementBlock(), it tries
+    * the names '{prefix}_{element type}' and '{prefix}_{element}', where
+    * prefix is either 'qf' or the name of the current group's block
+    * 
+    * @param HTML_QuickForm_element     form element being rendered
+    * @access private
+    * @return string    block name
+    */
+    function _matchBlock(&$element)
+    {
+        $name = $element->getName();
+        $type = $element->getType();
+        if (isset($this->_elementBlocks[$name]) && $this->_tpl->blockExists($this->_elementBlocks[$name])) {
+            if (('group' == $type) || ($this->_elementBlocks[$name] . '_loop' != $this->_tpl->currentBlock)) {
+                return $this->_elementBlocks[$name];
+            }
+        }
+        if ('group' != $type && 'qf_main_loop' != $this->_tpl->currentBlock) {
+            $prefix = substr($this->_tpl->currentBlock, 0, -5); // omit '_loop' postfix
+        } else {
+            $prefix = 'qf';
+        }
+        if ($this->_tpl->blockExists($prefix . '_' . $type)) {
+            return $prefix . '_' . $type;
+        } elseif ($this->_tpl->blockExists($prefix . '_' . $name)) {
+            return $prefix . '_' . $name;
+        } else {
+            return $prefix . '_element';
+        }
+    }
+
+
+   /**
+    * Sets the block to use for element rendering
+    * 
+    * @param mixed      element name or array ('element name' => 'block name')
+    * @param string     block name if $elementName is not an array
+    * @access public
+    * @return void
+    */
+    function setElementBlock($elementName, $blockName = null)
+    {
+        if (is_array($elementName)) {
+            $this->_elementBlocks = array_merge($this->_elementBlocks, $elementName);
+        } else {
+            $this->_elementBlocks[$elementName] = $blockName;
+        }
+    }
+
+
+   /**
+    * Sets the name of a block to use for header rendering
+    *
+    * @param string     block name
+    * @access public
+    * @return void
+    */
+    function setHeaderBlock($blockName)
+    {
+        $this->_headerBlock = $blockName;
+    }
+}
+?>
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/ITStatic.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/ITStatic.php
new file mode 100644 (file)
index 0000000..e699707
--- /dev/null
@@ -0,0 +1,504 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * A static renderer for HTML_QuickForm compatible 
+ * with HTML_Template_IT and HTML_Template_Sigma.
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * An abstract base class for QuickForm renderers
+ */
+require_once 'HTML/QuickForm/Renderer.php';
+
+/**
+ * A static renderer for HTML_QuickForm compatible 
+ * with HTML_Template_IT and HTML_Template_Sigma.
+ *
+ * As opposed to the dynamic renderer, this renderer needs
+ * every elements and labels in the form to be specified by
+ * placeholders at the position you want them to be displayed.
+ * 
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @version     Release: 3.2.16
+ * @since       3.0
+ */
+class HTML_QuickForm_Renderer_ITStatic extends HTML_QuickForm_Renderer
+{
+   /**#@+
+    * @access private
+    */
+   /**
+    * An HTML_Template_IT or some other API compatible Template instance
+    * @var object
+    */
+    var $_tpl = null;
+
+   /**
+    * Rendered form name
+    * @var string
+    */
+    var $_formName = 'form';
+
+   /**
+    * The errors that were not shown near concrete fields go here
+    * @var array
+    */
+    var $_errors = array();
+
+   /**
+    * Show the block with required note?
+    * @var bool
+    */
+    var $_showRequired = false;
+
+   /**
+    * Which group are we currently parsing ?
+    * @var string
+    */
+    var $_inGroup;
+
+   /**
+    * Index of the element in its group
+    * @var int
+    */
+    var $_elementIndex = 0;
+
+   /**
+    * If elements have been added with the same name
+    * @var array
+    */
+    var $_duplicateElements = array();
+
+   /**
+    * How to handle the required tag for required fields
+    * @var string
+    */
+    var $_required = '{label}<font size="1" color="red">*</font>';
+
+   /**
+    * How to handle error messages in form validation
+    * @var string
+    */
+    var $_error = '<font color="red">{error}</font><br />{html}';
+
+   /**
+    * Collected HTML for hidden elements, if needed  
+    * @var string
+    */
+    var $_hidden = '';
+   /**#@-*/
+
+   /**
+    * Constructor
+    *
+    * @param HTML_Template_IT|HTML_Template_Sigma   Template object to use
+    */
+    function HTML_QuickForm_Renderer_ITStatic(&$tpl)
+    {
+        $this->HTML_QuickForm_Renderer();
+        $this->_tpl =& $tpl;
+    } // end constructor
+
+   /**
+    * Called when visiting a form, before processing any form elements
+    *
+    * @param    HTML_QuickForm  form object being visited
+    * @access   public
+    * @return   void
+    */
+    function startForm(&$form)
+    {
+        $this->_formName = $form->getAttribute('id');
+
+        if (count($form->_duplicateIndex) > 0) {
+            // Take care of duplicate elements
+            foreach ($form->_duplicateIndex as $elementName => $indexes) {
+                $this->_duplicateElements[$elementName] = 0;
+            }
+        }
+    } // end func startForm
+
+   /**
+    * Called when visiting a form, after processing all form elements
+    * 
+    * @param    HTML_QuickForm  form object being visited
+    * @access   public
+    * @return   void
+    */
+    function finishForm(&$form)
+    {
+        // display errors above form
+        if (!empty($this->_errors) && $this->_tpl->blockExists($this->_formName.'_error_loop')) {
+            foreach ($this->_errors as $error) {
+                $this->_tpl->setVariable($this->_formName.'_error', $error);
+                $this->_tpl->parse($this->_formName.'_error_loop');
+            }
+        }
+        // show required note
+        if ($this->_showRequired) {
+            $this->_tpl->setVariable($this->_formName.'_required_note', $form->getRequiredNote());
+        }
+        // add hidden elements, if collected
+        if (!empty($this->_hidden)) {
+            $this->_tpl->setVariable($this->_formName . '_hidden', $this->_hidden);
+        }
+        // assign form attributes
+        $this->_tpl->setVariable($this->_formName.'_attributes', $form->getAttributes(true));
+        // assign javascript validation rules
+        $this->_tpl->setVariable($this->_formName.'_javascript', $form->getValidationScript());
+    } // end func finishForm
+
+   /**
+    * Called when visiting a header element
+    *
+    * @param    HTML_QuickForm_header   header element being visited
+    * @access   public
+    * @return   void
+    */
+    function renderHeader(&$header)
+    {
+        $name = $header->getName();
+        $varName = $this->_formName.'_header';
+
+        // Find placeHolder
+        if (!empty($name) && $this->_tpl->placeHolderExists($this->_formName.'_header_'.$name)) {
+            $varName = $this->_formName.'_header_'.$name;
+        }
+        $this->_tpl->setVariable($varName, $header->toHtml());
+    } // end func renderHeader
+
+   /**
+    * Called when visiting an element
+    *
+    * @param    HTML_QuickForm_element  form element being visited
+    * @param    bool                    Whether an element is required
+    * @param    string                  An error message associated with an element
+    * @access   public
+    * @return   void
+    */
+    function renderElement(&$element, $required, $error)
+    {
+        $name = $element->getName();
+
+        // are we inside a group?
+        if (!empty($this->_inGroup)) {
+            $varName = $this->_formName.'_'.str_replace(array('[', ']'), '_', $name);
+            if (substr($varName, -2) == '__') {
+                // element name is of type : group[]
+                $varName = $this->_inGroup.'_'.$this->_elementIndex.'_';
+                $this->_elementIndex++;
+            }
+            if ($varName != $this->_inGroup) {
+                $varName .= '_' == substr($varName, -1)? '': '_';
+                // element name is of type : group[name]
+                $label = $element->getLabel();
+                $html = $element->toHtml();
+
+                if ($required && !$element->isFrozen()) {
+                    $this->_renderRequired($label, $html);
+                    $this->_showRequired = true;
+                }
+                if (!empty($label)) {
+                    if (is_array($label)) {
+                        foreach ($label as $key => $value) {
+                            $this->_tpl->setVariable($varName.'label_'.$key, $value);
+                        }
+                    } else {
+                        $this->_tpl->setVariable($varName.'label', $label);
+                    }
+                }
+                $this->_tpl->setVariable($varName.'html', $html);
+            }
+
+        } else {
+
+            $name = str_replace(array('[', ']'), array('_', ''), $name);
+
+            if (isset($this->_duplicateElements[$name])) {
+                // Element is a duplicate
+                $varName = $this->_formName.'_'.$name.'_'.$this->_duplicateElements[$name];
+                $this->_duplicateElements[$name]++;
+            } else {
+                $varName = $this->_formName.'_'.$name;
+            }
+
+            $label = $element->getLabel();
+            $html = $element->toHtml();
+
+            if ($required) {
+                $this->_showRequired = true;
+                $this->_renderRequired($label, $html);
+            }
+            if (!empty($error)) {
+                $this->_renderError($label, $html, $error);
+            }
+            if (is_array($label)) {
+                foreach ($label as $key => $value) {
+                    $this->_tpl->setVariable($varName.'_label_'.$key, $value);
+                }
+            } else {
+                $this->_tpl->setVariable($varName.'_label', $label);
+            }
+            $this->_tpl->setVariable($varName.'_html', $html);
+        }
+    } // end func renderElement
+
+   /**
+    * Called when visiting a hidden element
+    * 
+    * @param    HTML_QuickForm_element  hidden element being visited
+    * @access   public
+    * @return   void
+    */
+    function renderHidden(&$element)
+    {
+        if ($this->_tpl->placeholderExists($this->_formName . '_hidden')) {
+            $this->_hidden .= $element->toHtml();
+        } else {
+            $name = $element->getName();
+            $name = str_replace(array('[', ']'), array('_', ''), $name);
+            $this->_tpl->setVariable($this->_formName.'_'.$name.'_html', $element->toHtml());
+        }
+    } // end func renderHidden
+
+   /**
+    * Called when visiting a group, before processing any group elements
+    *
+    * @param    HTML_QuickForm_group    group being visited
+    * @param    bool                    Whether a group is required
+    * @param    string                  An error message associated with a group
+    * @access   public
+    * @return   void
+    */
+    function startGroup(&$group, $required, $error)
+    {
+        $name = $group->getName();
+        $varName = $this->_formName.'_'.$name;
+
+        $this->_elementIndex = 0;
+
+        $html = $this->_tpl->placeholderExists($varName.'_html') ? $group->toHtml() : '';
+        $label = $group->getLabel();
+
+        if ($required) {
+            $this->_renderRequired($label, $html);
+        }
+        if (!empty($error)) {
+            $this->_renderError($label, $html, $error);
+        }
+        if (!empty($html)) {
+            $this->_tpl->setVariable($varName.'_html', $html);
+        } else {
+            // Uses error blocks to set the special groups layout error
+            // <!-- BEGIN form_group_error -->{form_group_error}<!-- END form_group_error -->
+            if (!empty($error)) {
+                if ($this->_tpl->placeholderExists($varName.'_error')) {
+                    if ($this->_tpl->blockExists($this->_formName . '_error_block')) {
+                        $this->_tpl->setVariable($this->_formName . '_error', $error);
+                        $error = $this->_getTplBlock($this->_formName . '_error_block');
+                    } elseif (strpos($this->_error, '{html}') !== false || strpos($this->_error, '{label}') !== false) {
+                        $error = str_replace('{error}', $error, $this->_error);
+                    }
+                }
+                $this->_tpl->setVariable($varName . '_error', $error);
+                array_pop($this->_errors);
+            }
+        }
+        if (is_array($label)) {
+            foreach ($label as $key => $value) {
+                $this->_tpl->setVariable($varName.'_label_'.$key, $value);
+            }
+        } else {
+            $this->_tpl->setVariable($varName.'_label', $label);
+        }
+        $this->_inGroup = $varName;
+    } // end func startGroup
+
+   /**
+    * Called when visiting a group, after processing all group elements
+    *
+    * @param    HTML_QuickForm_group    group being visited
+    * @access   public
+    * @return   void
+    */
+    function finishGroup(&$group)
+    {
+        $this->_inGroup = '';
+    } // end func finishGroup
+
+   /**
+    * Sets the way required elements are rendered
+    *
+    * You can use {label} or {html} placeholders to let the renderer know where
+    * where the element label or the element html are positionned according to the
+    * required tag. They will be replaced accordingly with the right value.
+    * For example:
+    * <font color="red">*</font>{label}
+    * will put a red star in front of the label if the element is required.
+    *
+    * @param    string      The required element template
+    * @access   public
+    * @return   void
+    */
+    function setRequiredTemplate($template)
+    {
+        $this->_required = $template;
+    } // end func setRequiredTemplate
+
+   /**
+    * Sets the way elements with validation errors are rendered
+    *
+    * You can use {label} or {html} placeholders to let the renderer know where
+    * where the element label or the element html are positionned according to the
+    * error message. They will be replaced accordingly with the right value.
+    * The error message will replace the {error} place holder.
+    * For example:
+    * <font color="red">{error}</font><br />{html}
+    * will put the error message in red on top of the element html.
+    *
+    * If you want all error messages to be output in the main error block, do not specify
+    * {html} nor {label}.
+    *
+    * Groups can have special layouts. With this kind of groups, the renderer will need
+    * to know where to place the error message. In this case, use error blocks like:
+    * <!-- BEGIN form_group_error -->{form_group_error}<!-- END form_group_error -->
+    * where you want the error message to appear in the form.
+    *
+    * @param    string      The element error template
+    * @access   public
+    * @return   void
+    */
+    function setErrorTemplate($template)
+    {
+        $this->_error = $template;
+    } // end func setErrorTemplate
+
+   /**
+    * Called when an element is required
+    *
+    * This method will add the required tag to the element label and/or the element html
+    * such as defined with the method setRequiredTemplate
+    *
+    * @param    string      The element label
+    * @param    string      The element html rendering
+    * @see      setRequiredTemplate()
+    * @access   private
+    * @return   void
+    */
+    function _renderRequired(&$label, &$html)
+    {
+        if ($this->_tpl->blockExists($tplBlock = $this->_formName . '_required_block')) {
+            if (!empty($label) && $this->_tpl->placeholderExists($this->_formName . '_label', $tplBlock)) {
+                $this->_tpl->setVariable($this->_formName . '_label', is_array($label)? $label[0]: $label);
+                if (is_array($label)) {
+                    $label[0] = $this->_getTplBlock($tplBlock);
+                } else {
+                    $label    = $this->_getTplBlock($tplBlock);
+                }
+            }
+            if (!empty($html) && $this->_tpl->placeholderExists($this->_formName . '_html', $tplBlock)) {
+                $this->_tpl->setVariable($this->_formName . '_html', $html);
+                $html = $this->_getTplBlock($tplBlock);
+            }
+        } else {
+            if (!empty($label) && strpos($this->_required, '{label}') !== false) {
+                if (is_array($label)) {
+                    $label[0] = str_replace('{label}', $label[0], $this->_required);
+                } else {
+                    $label = str_replace('{label}', $label, $this->_required);
+                }
+            }
+            if (!empty($html) && strpos($this->_required, '{html}') !== false) {
+                $html = str_replace('{html}', $html, $this->_required);
+            }
+        }
+    } // end func _renderRequired
+
+   /**
+    * Called when an element has a validation error
+    *
+    * This method will add the error message to the element label or the element html
+    * such as defined with the method setErrorTemplate. If the error placeholder is not found
+    * in the template, the error will be displayed in the form error block.
+    *
+    * @param    string      The element label
+    * @param    string      The element html rendering
+    * @param    string      The element error
+    * @see      setErrorTemplate()
+    * @access   private
+    * @return   void
+    */
+    function _renderError(&$label, &$html, $error)
+    {
+        if ($this->_tpl->blockExists($tplBlock = $this->_formName . '_error_block')) {
+            $this->_tpl->setVariable($this->_formName . '_error', $error);
+            if (!empty($label) && $this->_tpl->placeholderExists($this->_formName . '_label', $tplBlock)) {
+                $this->_tpl->setVariable($this->_formName . '_label', is_array($label)? $label[0]: $label);
+                if (is_array($label)) {
+                    $label[0] = $this->_getTplBlock($tplBlock);
+                } else {
+                    $label    = $this->_getTplBlock($tplBlock);
+                }
+            } elseif (!empty($html) && $this->_tpl->placeholderExists($this->_formName . '_html', $tplBlock)) {
+                $this->_tpl->setVariable($this->_formName . '_html', $html);
+                $html = $this->_getTplBlock($tplBlock);
+            }
+            // clean up after ourselves
+            $this->_tpl->setVariable($this->_formName . '_error', null);
+        } elseif (!empty($label) && strpos($this->_error, '{label}') !== false) {
+            if (is_array($label)) {
+                $label[0] = str_replace(array('{label}', '{error}'), array($label[0], $error), $this->_error);
+            } else {
+                $label = str_replace(array('{label}', '{error}'), array($label, $error), $this->_error);
+            }
+        } elseif (!empty($html) && strpos($this->_error, '{html}') !== false) {
+            $html = str_replace(array('{html}', '{error}'), array($html, $error), $this->_error);
+        } else {
+            $this->_errors[] = $error;
+        }
+    }// end func _renderError
+
+
+   /**
+    * Returns the block's contents
+    *
+    * The method is needed because ITX and Sigma implement clearing
+    * the block contents on get() a bit differently
+    *
+    * @param    string  Block name
+    * @return   string  Block contents
+    */
+    function _getTplBlock($block)
+    {
+        $this->_tpl->parse($block);
+        if (is_a($this->_tpl, 'html_template_sigma')) {
+            $ret = $this->_tpl->get($block, true);
+        } else {
+            $oldClear = $this->_tpl->clearCache;
+            $this->_tpl->clearCache = true;
+            $ret = $this->_tpl->get($block);
+            $this->_tpl->clearCache = $oldClear;
+        }
+        return $ret;
+    }
+} // end class HTML_QuickForm_Renderer_ITStatic
+?>
\ No newline at end of file
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/Object.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/Object.php
new file mode 100644 (file)
index 0000000..afd3aa6
--- /dev/null
@@ -0,0 +1,461 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * A concrete renderer for HTML_QuickForm, makes an object from form contents
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Ron McClain <ron@humaniq.com>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * An abstract base class for QuickForm renderers
+ */
+require_once 'HTML/QuickForm/Renderer.php';
+
+/**
+ * A concrete renderer for HTML_QuickForm, makes an object from form contents
+ *
+ * Based on HTML_Quickform_Renderer_Array code
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Ron McClain <ron@humaniq.com>
+ * @version     Release: 3.2.16
+ * @since       3.1.1
+ */
+class HTML_QuickForm_Renderer_Object extends HTML_QuickForm_Renderer
+{
+   /**#@+
+    * @access private
+    */
+    /**
+     * The object being generated
+     * @var QuickformForm
+     */
+    var $_obj= null;
+
+    /**
+     * Number of sections in the form (i.e. number of headers in it)
+     * @var integer $_sectionCount
+     */
+    var $_sectionCount;
+
+    /**
+    * Current section number
+    * @var integer $_currentSection
+    */
+    var $_currentSection;
+
+    /**
+    * Object representing current group
+    * @var object $_currentGroup
+    */
+    var $_currentGroup = null;
+
+    /**
+     * Class of Element Objects
+     * @var object $_elementType
+     */
+    var $_elementType = 'QuickFormElement';
+
+    /**
+    * Additional style information for different elements  
+    * @var array $_elementStyles
+    */
+    var $_elementStyles = array();
+
+    /**
+    * true: collect all hidden elements into string; false: process them as usual form elements
+    * @var bool $_collectHidden
+    */
+    var $_collectHidden = false;
+   /**#@-*/
+
+
+    /**
+     * Constructor
+     *
+     * @param bool    true: collect all hidden elements
+     * @access public
+     */
+    function HTML_QuickForm_Renderer_Object($collecthidden = false) 
+    {
+        $this->HTML_QuickForm_Renderer();
+        $this->_collectHidden = $collecthidden;
+        $this->_obj = new QuickformForm;
+    }
+
+    /**
+     * Return the rendered Object
+     * @access public
+     */
+    function toObject() 
+    {
+        return $this->_obj;
+    }
+
+    /**
+     * Set the class of the form elements.  Defaults to QuickformElement.
+     * @param string   Name of element class
+     * @access public
+     */
+    function setElementType($type)
+    {
+        $this->_elementType = $type;
+    }
+
+    function startForm(&$form) 
+    {
+        $this->_obj->frozen = $form->isFrozen();
+        $this->_obj->javascript = $form->getValidationScript();
+        $this->_obj->attributes = $form->getAttributes(true);
+        $this->_obj->requirednote = $form->getRequiredNote();
+        $this->_obj->errors = new StdClass;
+
+        if($this->_collectHidden) {
+            $this->_obj->hidden = '';
+        }
+        $this->_elementIdx = 1;
+        $this->_currentSection = null;
+        $this->_sectionCount = 0;
+    } // end func startForm
+
+    function renderHeader(&$header) 
+    {
+        $hobj = new StdClass;
+        $hobj->header = $header->toHtml();
+        $this->_obj->sections[$this->_sectionCount] = $hobj;
+        $this->_currentSection = $this->_sectionCount++;
+    }
+
+    function renderElement(&$element, $required, $error) 
+    {
+        $elObj = $this->_elementToObject($element, $required, $error);
+        if(!empty($error)) {
+            $name = $elObj->name;
+            $this->_obj->errors->$name = $error;
+        }
+        $this->_storeObject($elObj);
+    } // end func renderElement
+
+    function renderHidden(&$element)
+    {
+        if($this->_collectHidden) {
+            $this->_obj->hidden .= $element->toHtml() . "\n";
+        } else {
+            $this->renderElement($element, false, null);
+        }
+    } //end func renderHidden
+
+    function startGroup(&$group, $required, $error) 
+    {
+        $this->_currentGroup = $this->_elementToObject($group, $required, $error);
+        if(!empty($error)) {
+            $name = $this->_currentGroup->name;
+            $this->_obj->errors->$name = $error;
+        }
+    } // end func startGroup
+
+    function finishGroup(&$group) 
+    {
+        $this->_storeObject($this->_currentGroup);
+        $this->_currentGroup = null;
+    } // end func finishGroup
+
+    /**
+     * Creates an object representing an element
+     *
+     * @access private
+     * @param HTML_QuickForm_element    form element being rendered
+     * @param required bool         Whether an element is required
+     * @param error string    Error associated with the element
+     * @return object
+     */
+    function _elementToObject(&$element, $required, $error) 
+    {
+        if($this->_elementType) {
+            $ret = new $this->_elementType;
+        }
+        $ret->name = $element->getName();
+        $ret->value = $element->getValue();
+        $ret->type = $element->getType();
+        $ret->frozen = $element->isFrozen();
+        $labels = $element->getLabel();
+        if (is_array($labels)) {
+            $ret->label = array_shift($labels);
+            foreach ($labels as $key => $label) {
+                $key = is_int($key)? $key + 2: $key;
+                $ret->{'label_' . $key} = $label;
+            }
+        } else {
+            $ret->label = $labels;
+        }
+        $ret->required = $required;
+        $ret->error = $error;
+
+        if(isset($this->_elementStyles[$ret->name])) {
+            $ret->style = $this->_elementStyles[$ret->name];
+            $ret->styleTemplate = "styles/". $ret->style .".html";
+        }
+        if($ret->type == 'group') {
+            $ret->separator = $element->_separator;
+            $ret->elements = array();
+        } else {
+            $ret->html = $element->toHtml();
+        }
+        return $ret;
+    }
+
+    /** 
+     * Stores an object representation of an element in the form array
+     *
+     * @access private
+     * @param QuickformElement     Object representation of an element
+     * @return void
+     */
+    function _storeObject($elObj) 
+    {
+        $name = $elObj->name;
+        if(is_object($this->_currentGroup) && $elObj->type != 'group') {
+            $this->_currentGroup->elements[] = $elObj;
+        } elseif (isset($this->_currentSection)) {
+            $this->_obj->sections[$this->_currentSection]->elements[] = $elObj;
+        } else {
+            $this->_obj->elements[] = $elObj;
+        }
+    }
+
+    function setElementStyle($elementName, $styleName = null)
+    {
+        if(is_array($elementName)) {
+            $this->_elementStyles = array_merge($this->_elementStyles, $elementName);
+        } else {
+            $this->_elementStyles[$elementName] = $styleName;
+        }
+    }
+
+} // end class HTML_QuickForm_Renderer_Object
+
+
+
+/**
+ * Convenience class for the form object passed to outputObject()
+ * 
+ * Eg.
+ * <pre>  
+ * {form.outputJavaScript():h}
+ * {form.outputHeader():h}
+ *   <table>
+ *     <tr>
+ *       <td>{form.name.label:h}</td><td>{form.name.html:h}</td>
+ *     </tr>
+ *   </table>
+ * </form>
+ * </pre>
+ * 
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Ron McClain <ron@humaniq.com>
+ * @version     Release: 3.2.16
+ * @since       3.1.1
+ */
+class QuickformForm
+{
+   /**
+    * Whether the form has been frozen
+    * @var boolean $frozen
+    */
+    var $frozen;
+
+   /**
+    * Javascript for client-side validation
+    * @var string $javascript
+    */
+    var $javascript;
+
+   /**
+    * Attributes for form tag
+    * @var string $attributes
+    */
+    var $attributes;
+
+   /**
+    * Note about required elements
+    * @var string $requirednote
+    */
+    var $requirednote;
+
+   /**
+    * Collected html of all hidden variables
+    * @var string $hidden
+    */
+    var $hidden;
+
+   /**
+    * Set if there were validation errors.  
+    * StdClass object with element names for keys and their
+    * error messages as values
+    * @var object $errors
+    */
+    var $errors;
+
+   /**
+    * Array of QuickformElementObject elements.  If there are headers in the form
+    * this will be empty and the elements will be in the 
+    * separate sections
+    * @var array $elements
+    */
+    var $elements;
+
+   /**
+    * Array of sections contained in the document
+    * @var array $sections
+    */
+    var $sections;
+
+   /**
+    * Output &lt;form&gt; header
+    * {form.outputHeader():h} 
+    * @return string    &lt;form attributes&gt;
+    */
+    function outputHeader()
+    {
+        return "<form " . $this->attributes . ">\n";
+    }
+
+   /**
+    * Output form javascript
+    * {form.outputJavaScript():h}
+    * @return string    Javascript
+    */
+    function outputJavaScript()
+    {
+        return $this->javascript;
+    }
+} // end class QuickformForm
+
+
+/**
+ * Convenience class describing a form element.
+ *
+ * The properties defined here will be available from 
+ * your flexy templates by referencing
+ * {form.zip.label:h}, {form.zip.html:h}, etc.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Ron McClain <ron@humaniq.com>
+ * @version     Release: 3.2.16
+ * @since       3.1.1
+ */
+class QuickformElement
+{
+    /**
+     * Element name
+     * @var string $name
+     */
+    var $name;
+
+    /**
+     * Element value
+     * @var mixed $value
+     */
+    var $value;
+
+    /**
+     * Type of element
+     * @var string $type
+     */
+    var $type;
+
+    /**
+     * Whether the element is frozen
+     * @var boolean $frozen
+     */
+    var $frozen;
+
+    /**
+     * Label for the element
+     * @var string $label
+     */
+    var $label;
+
+    /**
+     * Whether element is required
+     * @var boolean $required
+     */
+    var $required;
+
+    /**
+     * Error associated with the element
+     * @var string $error
+     */
+    var $error;
+
+    /**
+     * Some information about element style
+     * @var string $style
+     */
+    var $style;
+
+    /**
+     * HTML for the element
+     * @var string $html
+     */
+    var $html;
+
+    /**
+     * If element is a group, the group separator
+     * @var mixed $separator
+     */
+    var $separator;
+
+    /**
+     * If element is a group, an array of subelements
+     * @var array $elements
+     */
+    var $elements;
+
+    function isType($type)
+    {
+        return ($this->type == $type);
+    }
+
+    function notFrozen()
+    {
+        return !$this->frozen;
+    }
+
+    function isButton()
+    {
+        return ($this->type == "submit" || $this->type == "reset");
+    }
+
+
+   /**
+    * XXX: why does it use Flexy when all other stuff here does not depend on it?
+    */
+    function outputStyle()
+    {
+        ob_start();
+        HTML_Template_Flexy::staticQuickTemplate('styles/' . $this->style . '.html', $this);
+        $ret = ob_get_contents();
+        ob_end_clean();
+        return $ret;
+    }
+} // end class QuickformElement
+?>
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/ObjectFlexy.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/ObjectFlexy.php
new file mode 100644 (file)
index 0000000..048e556
--- /dev/null
@@ -0,0 +1,291 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * QuickForm renderer for Flexy template engine, static version.
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Ron McClain <ron@humaniq.com>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * A concrete renderer for HTML_QuickForm, makes an object from form contents
+ */ 
+require_once 'HTML/QuickForm/Renderer/Object.php';
+
+/**
+ * QuickForm renderer for Flexy template engine, static version.
+ * 
+ * A static renderer for HTML_Quickform.  Makes a QuickFormFlexyObject
+ * from the form content suitable for use with a Flexy template
+ *
+ * Usage:
+ * <code>
+ * $form =& new HTML_QuickForm('form', 'POST');
+ * $template =& new HTML_Template_Flexy();
+ * $renderer =& new HTML_QuickForm_Renderer_ObjectFlexy(&$template);
+ * $renderer->setHtmlTemplate("html.html");
+ * $renderer->setLabelTemplate("label.html");
+ * $form->accept($renderer);
+ * $view = new StdClass;
+ * $view->form = $renderer->toObject();
+ * $template->compile("mytemplate.html");
+ * </code>
+ *
+ * Based on the code for HTML_QuickForm_Renderer_ArraySmarty
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Ron McClain <ron@humaniq.com>
+ * @version     Release: 3.2.16
+ * @since       3.1.1
+ */
+class HTML_QuickForm_Renderer_ObjectFlexy extends HTML_QuickForm_Renderer_Object
+{
+   /**#@+
+    * @access private
+    */
+    /**
+     * HTML_Template_Flexy instance
+     * @var object $_flexy
+     */
+    var $_flexy;
+
+    /**
+     * Current element index
+     * @var integer $_elementIdx
+     */
+    var $_elementIdx;
+
+    /**
+     * The current element index inside a group
+     * @var integer $_groupElementIdx
+     */
+    var $_groupElementIdx = 0;
+
+    /**
+     * Name of template file for form html
+     * @var string $_html
+     * @see     setRequiredTemplate()
+     */
+    var $_html = '';
+
+    /**
+     * Name of template file for form labels
+     * @var string $label
+     * @see        setErrorTemplate()
+     */
+    var $label = '';
+
+    /**
+     * Class of the element objects, so you can add your own
+     * element methods
+     * @var string $_elementType
+     */
+    var $_elementType = 'QuickformFlexyElement';
+   /**#@-*/
+
+    /**
+     * Constructor
+     *
+     * @param HTML_Template_Flexy   template object to use
+     * @public
+     */
+    function HTML_QuickForm_Renderer_ObjectFlexy(&$flexy)
+    {
+        $this->HTML_QuickForm_Renderer_Object(true);
+        $this->_obj = new QuickformFlexyForm();
+        $this->_flexy =& $flexy;
+    } // end constructor
+
+    function renderHeader(&$header)
+    {
+        if($name = $header->getName()) {
+            $this->_obj->header->$name = $header->toHtml();
+        } else {
+            $this->_obj->header[$this->_sectionCount] = $header->toHtml();
+        }
+        $this->_currentSection = $this->_sectionCount++;
+    } // end func renderHeader
+
+    function startGroup(&$group, $required, $error)
+    {
+        parent::startGroup($group, $required, $error);
+        $this->_groupElementIdx = 1;
+    } //end func startGroup
+
+    /**
+     * Creates an object representing an element containing
+     * the key for storing this
+     *
+     * @access private
+     * @param HTML_QuickForm_element    form element being rendered
+     * @param bool        Whether an element is required
+     * @param string    Error associated with the element
+     * @return object
+     */
+    function _elementToObject(&$element, $required, $error)
+    {
+        $ret = parent::_elementToObject($element, $required, $error);
+        if($ret->type == 'group') {
+            $ret->html = $element->toHtml();
+            unset($ret->elements);
+        }
+        if(!empty($this->_label)) {
+            $this->_renderLabel($ret);
+        }
+
+        if(!empty($this->_html)) {
+            $this->_renderHtml($ret);
+            $ret->error = $error;
+        }
+
+        // Create an element key from the name
+        if (false !== ($pos = strpos($ret->name, '[')) || is_object($this->_currentGroup)) {
+            if (!$pos) {
+                $keys = '->{\'' . str_replace(array('\\', '\''), array('\\\\', '\\\''), $ret->name) . '\'}';
+            } else {
+                $keys = '->{\'' . str_replace(
+                            array('\\', '\'', '[', ']'), array('\\\\', '\\\'', '\'}->{\'', ''), 
+                            $ret->name
+                        ) . '\'}';
+            }
+            // special handling for elements in native groups
+            if (is_object($this->_currentGroup)) {
+                // skip unnamed group items unless radios: no name -> no static access
+                // identification: have the same key string as the parent group
+                if ($this->_currentGroup->keys == $keys && 'radio' != $ret->type) {
+                    return false;
+                }
+                // reduce string of keys by remove leading group keys
+                if (0 === strpos($keys, $this->_currentGroup->keys)) {
+                    $keys = substr_replace($keys, '', 0, strlen($this->_currentGroup->keys));
+                }
+            }
+        } elseif (0 == strlen($ret->name)) {
+            $keys = '->{\'element_' . $this->_elementIdx . '\'}';
+        } else {
+            $keys = '->{\'' . str_replace(array('\\', '\''), array('\\\\', '\\\''), $ret->name) . '\'}';
+        }
+        // for radios: add extra key from value
+        if ('radio' == $ret->type && '[]' != substr($keys, -2)) {
+            $keys .= '->{\'' . str_replace(array('\\', '\''), array('\\\\', '\\\''), $ret->value) . '\'}';
+        }
+        $ret->keys = $keys;
+        $this->_elementIdx++;
+        return $ret;
+    }
+
+    /**
+     * Stores an object representation of an element in the 
+     * QuickformFormObject instance
+     *
+     * @access private
+     * @param QuickformElement  Object representation of an element
+     * @return void
+     */
+    function _storeObject($elObj) 
+    {
+        if ($elObj) {
+            $keys = $elObj->keys;
+            unset($elObj->keys);
+            if(is_object($this->_currentGroup) && ('group' != $elObj->type)) {
+                $code = '$this->_currentGroup' . $keys . ' = $elObj;';
+            } else {
+                $code = '$this->_obj' . $keys . ' = $elObj;';
+            }
+            eval($code);
+        }
+    }
+
+    /**
+     * Set the filename of the template to render html elements.
+     * In your template, {html} is replaced by the unmodified html.
+     * If the element is required, {required} will be true.
+     * Eg.
+     * <pre>
+     * {if:error}
+     *   <font color="red" size="1">{error:h}</font><br />
+     * {end:}
+     * {html:h}
+     * </pre>
+     *
+     * @access public
+     * @param string   Filename of template
+     * @return void
+     */
+    function setHtmlTemplate($template)
+    {
+        $this->_html = $template;
+    } 
+
+    /**
+     * Set the filename of the template to render form labels
+     * In your template, {label} is replaced by the unmodified label.
+     * {error} will be set to the error, if any.  {required} will
+     * be true if this is a required field
+     * Eg.
+     * <pre>
+     * {if:required}
+     * <font color="orange" size="1">*</font>
+     * {end:}
+     * {label:h}
+     * </pre>
+     *
+     * @access public
+     * @param string   Filename of template
+     * @return void
+     */
+    function setLabelTemplate($template) 
+    {
+        $this->_label = $template;
+    }
+
+    function _renderLabel(&$ret)
+    {
+        $this->_flexy->compile($this->_label);
+        $ret->label = $this->_flexy->bufferedOutputObject($ret);
+    }
+
+    function _renderHtml(&$ret)
+    {
+        $this->_flexy->compile($this->_html);
+        $ret->html = $this->_flexy->bufferedOutputObject($ret);
+    }
+} // end class HTML_QuickForm_Renderer_ObjectFlexy
+
+/**
+ * Adds nothing to QuickformForm, left for backwards compatibility
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @ignore
+ */
+class QuickformFlexyForm extends QuickformForm
+{
+}
+
+/**
+ * Adds nothing to QuickformElement, left for backwards compatibility
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @ignore
+ */
+class QuickformFlexyElement extends QuickformElement
+{
+}
+?>
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/QuickHtml.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/QuickHtml.php
new file mode 100644 (file)
index 0000000..13a0c4e
--- /dev/null
@@ -0,0 +1,213 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * A renderer that makes it quick and easy to create customized forms.
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Jason Rust <jrust@rustyparts.com>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * A concrete renderer for HTML_QuickForm, based on QuickForm 2.x built-in one
+ */ 
+require_once 'HTML/QuickForm/Renderer/Default.php';
+
+/**
+ * A renderer that makes it quick and easy to create customized forms.
+ *
+ * This renderer has three main distinctives: an easy way to create
+ * custom-looking forms, the ability to separate the creation of form
+ * elements from their display, and being able to use QuickForm in
+ * widget-based template systems.  See the online docs for more info.
+ * For a usage example see: docs/renderers/QuickHtml_example.php
+ * 
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Jason Rust <jrust@rustyparts.com>
+ * @version     Release: 3.2.16
+ * @since       3.1.1
+ */
+class HTML_QuickForm_Renderer_QuickHtml extends HTML_QuickForm_Renderer_Default {
+    // {{{ properties
+
+    /**
+     * The array of rendered elements
+     * @var array
+     */
+    var $renderedElements = array();
+
+    // }}}
+    // {{{ constructor
+    
+    /**
+     * Constructor
+     *
+     * @access public
+     * @return void
+     */
+    function HTML_QuickForm_Renderer_QuickHtml()
+    {
+        $this->HTML_QuickForm_Renderer_Default();
+        // The default templates aren't used for this renderer
+        $this->clearAllTemplates();
+    } // end constructor
+
+    // }}}
+    // {{{ toHtml()
+
+    /**
+     * returns the HTML generated for the form
+     *
+     * @param string $data (optional) Any extra data to put before the end of the form
+     *
+     * @access public
+     * @return string
+     */
+    function toHtml($data = '')
+    {
+        // Render any elements that haven't been rendered explicitly by elementToHtml()
+        foreach (array_keys($this->renderedElements) as $key) {
+            if (!$this->renderedElements[$key]['rendered']) {
+                $this->renderedElements[$key]['rendered'] = true;
+                $data .= $this->renderedElements[$key]['html'] . "\n";
+            }
+        }
+
+        // Insert the extra data and form elements at the end of the form
+        $this->_html = str_replace('</form>', $data . "\n</form>", $this->_html);
+        return $this->_html;
+    } // end func toHtml
+
+    // }}}
+    // {{{ elementToHtml()
+
+    /**
+     * Gets the html for an element and marks it as rendered.
+     *
+     * @param string $elementName The element name
+     * @param string $elementValue (optional) The value of the element.  This is only useful
+     *               for elements that have the same name (i.e. radio and checkbox), but
+     *               different values
+     *
+     * @access public
+     * @return string The html for the QuickForm element
+     * @throws HTML_QuickForm_Error
+     */
+    function elementToHtml($elementName, $elementValue = null)
+    {
+        $elementKey = null;
+        // Find the key for the element
+        foreach ($this->renderedElements as $key => $data) {
+            if ($data['name'] == $elementName && 
+                // See if the value must match as well
+                (is_null($elementValue) ||
+                 $data['value'] == $elementValue)) {
+                $elementKey = $key;
+                break;
+            }
+        }
+
+        if (is_null($elementKey)) {
+            $msg = is_null($elementValue) ? "Element $elementName does not exist." : 
+                "Element $elementName with value of $elementValue does not exist.";
+            return PEAR::raiseError(null, QUICKFORM_UNREGISTERED_ELEMENT, null, E_USER_WARNING, $msg, 'HTML_QuickForm_Error', true);
+        } else {
+            if ($this->renderedElements[$elementKey]['rendered']) {
+                $msg = is_null($elementValue) ? "Element $elementName has already been rendered." : 
+                    "Element $elementName with value of $elementValue has already been rendered.";
+                return PEAR::raiseError(null, QUICKFORM_ERROR, null, E_USER_WARNING, $msg, 'HTML_QuickForm_Error', true);
+            } else {
+                $this->renderedElements[$elementKey]['rendered'] = true;
+                return $this->renderedElements[$elementKey]['html'];
+            }
+        }
+    } // end func elementToHtml
+
+    // }}}
+    // {{{ renderElement()
+
+    /**
+     * Gets the html for an element and adds it to the array by calling
+     * parent::renderElement()
+     *
+     * @param HTML_QuickForm_element    form element being visited
+     * @param bool                      Whether an element is required
+     * @param string                    An error message associated with an element
+     *
+     * @access public
+     * @return mixed HTML string of element if $immediateRender is set, else we just add the
+     *               html to the global _html string 
+     */
+    function renderElement(&$element, $required, $error)
+    {
+        $this->_html = '';
+        parent::renderElement($element, $required, $error);
+        if (!$this->_inGroup) {
+            $this->renderedElements[] = array(
+                    'name' => $element->getName(), 
+                    'value' => $element->getValue(), 
+                    'html' => $this->_html, 
+                    'rendered' => false);
+        }
+        $this->_html = '';
+    } // end func renderElement
+
+    // }}}
+    // {{{ renderHidden()
+
+    /**
+     * Gets the html for a hidden element and adds it to the array.
+     * 
+     * @param HTML_QuickForm_element    hidden form element being visited
+     * @access public
+     * @return void
+     */
+    function renderHidden(&$element)
+    {
+        $this->renderedElements[] = array(
+                'name' => $element->getName(), 
+                'value' => $element->getValue(), 
+                'html' => $element->toHtml(), 
+                'rendered' => false);
+    } // end func renderHidden
+    
+    // }}}
+    // {{{ finishGroup()
+
+    /**
+     * Gets the html for the group element and adds it to the array by calling
+     * parent::finishGroup()
+     *
+     * @param    HTML_QuickForm_group   group being visited
+     * @access   public
+     * @return   void
+     */
+    function finishGroup(&$group)
+    {
+        $this->_html = '';
+        parent::finishGroup($group);
+        $this->renderedElements[] = array(
+                'name' => $group->getName(), 
+                'value' => $group->getValue(), 
+                'html' => $this->_html, 
+                'rendered' => false);
+        $this->_html = '';
+    } // end func finishGroup
+
+    // }}}
+} // end class HTML_QuickForm_Renderer_QuickHtml
+?>
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/Tableless.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Renderer/Tableless.php
new file mode 100644 (file)
index 0000000..92cb7bb
--- /dev/null
@@ -0,0 +1,506 @@
+<?php
+/**
+ * Replacement for the default renderer of HTML_QuickForm that uses only XHTML
+ * and CSS but no table tags, and generates fully valid XHTML output
+ *
+ * PHP versions 4 and 5
+ *
+ * LICENSE:
+ *
+ * Copyright (c) 2005-2007, Mark Wiesemann <wiesemann@php.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above copyright
+ *      notice, this list of conditions and the following disclaimer in the
+ *      documentation and/or other materials provided with the distribution.
+ *    * The names of the authors may not be used to endorse or promote products
+ *      derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @category   HTML
+ * @package    HTML_QuickForm_Renderer_Tableless
+ * @author     Alexey Borzov <borz_off@cs.msu.su>
+ * @author     Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author     Bertrand Mansion <bmansion@mamasam.com>
+ * @author     Mark Wiesemann <wiesemann@php.net>
+ * @license    http://www.opensource.org/licenses/bsd-license.php New BSD License
+ * @version    CVS: $Id: Tableless.php 271939 2008-12-26 20:22:30Z wiesemann $
+ * @link       http://pear.php.net/package/HTML_QuickForm_Renderer_Tableless
+ */
+
+require_once 'HTML/QuickForm/Renderer/Default.php';
+
+/**
+ * Replacement for the default renderer of HTML_QuickForm that uses only XHTML
+ * and CSS but no table tags, and generates fully valid XHTML output
+ *
+ * You need to specify a stylesheet like the one that you find in
+ * data/stylesheet.css to make this work.
+ *
+ * @category   HTML
+ * @package    HTML_QuickForm_Renderer_Tableless
+ * @author     Alexey Borzov <borz_off@cs.msu.su>
+ * @author     Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author     Bertrand Mansion <bmansion@mamasam.com>
+ * @author     Mark Wiesemann <wiesemann@php.net>
+ * @license    http://www.opensource.org/licenses/bsd-license.php New BSD License
+ * @version    Release: 0.6.2
+ * @link       http://pear.php.net/package/HTML_QuickForm_Renderer_Tableless
+ */
+class HTML_QuickForm_Renderer_Tableless extends HTML_QuickForm_Renderer_Default
+{
+   /**
+    * Header Template string
+    * @var      string
+    * @access   private
+    */
+    var $_headerTemplate = "\n\t\t<legend>{header}</legend>\n\t\t<ol>";
+
+   /**
+    * Element template string
+    * @var      string
+    * @access   private
+    */
+    var $_elementTemplate =
+        "\n\t\t\t<li><label class=\"element\"><!-- BEGIN required --><span class=\"required\">*</span><!-- END required -->{label}</label><div class=\"element<!-- BEGIN error --> error<!-- END error -->\"><!-- BEGIN error --><span class=\"error\">{error}</span><br /><!-- END error -->{element}</div></li>";
+
+   /**
+    * Form template string
+    * @var      string
+    * @access   private
+    */
+    var $_formTemplate =
+        "\n<form{attributes}>\n\t<div style=\"display: none;\">\n{hidden}\t</div>\n{content}\n</form>";
+
+   /**
+    * Template used when opening a fieldset
+    * @var      string
+    * @access   private
+    */
+    var $_openFieldsetTemplate = "\n\t<fieldset{id}{attributes}>";
+
+   /**
+    * Template used when opening a hidden fieldset
+    * (i.e. a fieldset that is opened when there is no header element)
+    * @var      string
+    * @access   private
+    */
+    var $_openHiddenFieldsetTemplate = "\n\t<fieldset class=\"hidden{class}\">\n\t\t<ol>";
+
+   /**
+    * Template used when closing a fieldset
+    * @var      string
+    * @access   private
+    */
+    var $_closeFieldsetTemplate = "\n\t\t</ol>\n\t</fieldset>";
+
+   /**
+    * Required Note template string
+    * @var      string
+    * @access   private
+    */
+    var $_requiredNoteTemplate =
+        "\n\t\t\t<li class=\"reqnote\"><label class=\"element\">&nbsp;</label>{requiredNote}</li>";
+
+   /**
+    * How many fieldsets are open
+    * @var      integer
+    * @access   private
+    */
+   var $_fieldsetsOpen = 0;
+
+   /**
+    * Array of element names that indicate the end of a fieldset
+    * (a new one will be opened when the next header element occurs)
+    * @var      array
+    * @access   private
+    */
+    var $_stopFieldsetElements = array();
+
+   /**
+    * Name of the currently active group
+    * @var      string
+    * @access   private
+    */
+    var $_currentGroupName = '';
+
+   /**
+    * Constructor
+    *
+    * @access public
+    */
+    function HTML_QuickForm_Renderer_Tableless()
+    {
+        $this->HTML_QuickForm_Renderer_Default();
+    } // end constructor
+
+   /**
+    * Called when visiting a header element
+    *
+    * @param    object     An HTML_QuickForm_header element being visited
+    * @access   public
+    * @return   void
+    */
+    function renderHeader(&$header)
+    {
+        $name = $header->getName();
+        $id = empty($name) ? '' : ' id="' . $name . '"';
+        if (!empty($name) && isset($this->_templates[$name])) {
+            $header_html = str_replace('{header}', $header->toHtml(), $this->_templates[$name]);
+        } else {
+            $header_html = str_replace('{header}', $header->toHtml(), $this->_headerTemplate);
+        }
+        $attributes = $header->getAttributes();
+        $strAttr = '';
+        if (is_array($attributes)) {
+            $charset = HTML_Common::charset();
+            foreach ($attributes as $key => $value) {
+                if ($key == 'name') {
+                    continue;
+                }
+                $strAttr .= ' ' . $key . '="' . htmlspecialchars($value, ENT_COMPAT, $charset) . '"';
+            }
+        }
+        if ($this->_fieldsetsOpen > 0) {
+            $this->_html .= $this->_closeFieldsetTemplate;
+            $this->_fieldsetsOpen--;
+        }
+        $openFieldsetTemplate = str_replace('{id}', $id, $this->_openFieldsetTemplate);
+        $openFieldsetTemplate = str_replace('{attributes}',
+                                            $strAttr,
+                                            $openFieldsetTemplate);
+        $this->_html .= $openFieldsetTemplate . $header_html;
+        $this->_fieldsetsOpen++;
+    } // end func renderHeader
+
+   /**
+    * Renders an element Html
+    * Called when visiting an element
+    *
+    * @param object     An HTML_QuickForm_element object being visited
+    * @param bool       Whether an element is required
+    * @param string     An error message associated with an element
+    * @access public
+    * @return void
+    */
+    function renderElement(&$element, $required, $error)
+    {
+        $this->_handleStopFieldsetElements($element->getName());
+        if (!$this->_inGroup) {
+            $html = $this->_prepareTemplate($element->getName(), $element->getLabel(), $required, $error);
+            // the following lines (until the "elseif") were changed / added
+            // compared to the default renderer
+            $element_html = $element->toHtml();
+            if (!is_null($element->getAttribute('id'))) {
+                $id = $element->getAttribute('id');
+            } else {
+                $id = $element->getName();
+            }
+            if ($element->getType() != 'static' && !empty($id)) {
+                $html = str_replace('<label', '<label for="' . $id . '"', $html);
+                $element_html = preg_replace(preg_quote('#name="' . $id . '#'),
+                                             'id="' . $id . '" name="' . $id,
+                                             $element_html,
+                                             1);
+            }
+            $this->_html .= str_replace('{element}', $element_html, $html);
+        } elseif (!empty($this->_groupElementTemplate)) {
+            $html = str_replace('{label}', $element->getLabel(), $this->_groupElementTemplate);
+            if ($required) {
+                $html = str_replace('<!-- BEGIN required -->', '', $html);
+                $html = str_replace('<!-- END required -->', '', $html);
+            } else {
+                $html = preg_replace("/([ \t\n\r]*)?<!-- BEGIN required -->(\s|\S)*<!-- END required -->([ \t\n\r]*)?/i", '', $html);
+            }
+            $this->_groupElements[] = str_replace('{element}', $element->toHtml(), $html);
+
+        } else {
+            $element_html = $element->toHtml();
+            // add "id" attribute to first element of the group
+            if (count($this->_groupElements) === 0) {
+                if (!is_null($element->getAttribute('id'))) {
+                    $id = $element->getAttribute('id');
+                } else {
+                    $id = $element->getName();
+                }
+                $groupId = $this->_currentGroupName;
+                if ($element->getType() != 'static' && !empty($id)) {
+                    $element_html = preg_replace(preg_quote('#name="' . $id . '#'),
+                                                 'id="' . $groupId . '" name="' . $id,
+                                                 $element_html,
+                                                 1);
+                }
+            }
+            $this->_groupElements[] = $element_html;
+        }
+    } // end func renderElement
+
+   /**
+    * Renders an hidden element
+    * Called when visiting a hidden element
+    *
+    * @param object     An HTML_QuickForm_hidden object being visited
+    * @access public
+    * @return void
+    */
+    function renderHidden(&$element)
+    {
+        if (!is_null($element->getAttribute('id'))) {
+            $id = $element->getAttribute('id');
+        } else {
+            $id = $element->getName();
+        }
+        $html = $element->toHtml();
+        if (!empty($id)) {
+            $html = str_replace('name="' . $id,
+                                'id="' . $id . '" name="' . $id,
+                                $html);
+        }
+        $this->_hiddenHtml .= $html . "\n";
+    } // end func renderHidden
+
+   /**
+    * Called when visiting a group, before processing any group elements
+    *
+    * @param object     An HTML_QuickForm_group object being visited
+    * @param bool       Whether a group is required
+    * @param string     An error message associated with a group
+    * @access public
+    * @return void
+    */
+    function startGroup(&$group, $required, $error)
+    {
+        $this->_handleStopFieldsetElements($group->getName());
+        $name = $group->getName();
+        $this->_groupTemplate        = $this->_prepareTemplate($name, $group->getLabel(), $required, $error);
+        $this->_groupTemplate        = str_replace('<label', '<label for="' . $name . '"', $this->_groupTemplate);
+        $this->_groupElementTemplate = empty($this->_groupTemplates[$name])? '': $this->_groupTemplates[$name];
+        $this->_groupWrap            = empty($this->_groupWraps[$name])? '': $this->_groupWraps[$name];
+        $this->_groupElements        = array();
+        $this->_inGroup              = true;
+        $this->_currentGroupName     = $name;
+    } // end func startGroup
+
+    /**
+    * Called when visiting a group, after processing all group elements
+    *
+    * @param    object      An HTML_QuickForm_group object being visited
+    * @access   public
+    * @return   void
+    */
+    function finishGroup(&$group)
+    {
+        $separator = $group->_separator;
+        if (is_array($separator)) {
+            $count = count($separator);
+            $html  = '';
+            for ($i = 0; $i < count($this->_groupElements); $i++) {
+                $html .= (0 == $i? '': $separator[($i - 1) % $count]) . $this->_groupElements[$i];
+            }
+        } else {
+            if (is_null($separator)) {
+                $separator = '&nbsp;';
+            }
+            $html = implode((string)$separator, $this->_groupElements);
+        }
+        if (!empty($this->_groupWrap)) {
+            $html = str_replace('{content}', $html, $this->_groupWrap);
+        }
+        if (!is_null($group->getAttribute('id'))) {
+            $id = $group->getAttribute('id');
+        } else {
+            $id = $group->getName();
+        }
+        $groupTemplate = $this->_groupTemplate;
+
+        $this->_html   .= str_replace('{element}', $html, $groupTemplate);
+        $this->_inGroup = false;
+    } // end func finishGroup
+
+    /**
+    * Called when visiting a form, before processing any form elements
+    *
+    * @param    object      An HTML_QuickForm object being visited
+    * @access   public
+    * @return   void
+    */
+    function startForm(&$form)
+    {
+        $this->_fieldsetsOpen = 0;
+        parent::startForm($form);
+    } // end func startForm
+
+   /**
+    * Called when visiting a form, after processing all form elements
+    * Adds required note, form attributes, validation javascript and form content.
+    *
+    * @param    object      An HTML_QuickForm object being visited
+    * @access   public
+    * @return   void
+    */
+    function finishForm(&$form)
+    {
+        // add a required note, if one is needed
+        if (!empty($form->_required) && !$form->_freezeAll) {
+            $requiredNote = $form->getRequiredNote();
+            // replace default required note by DOM/XHTML optimized note
+            if ($requiredNote == '<span style="font-size:80%; color:#ff0000;">*</span><span style="font-size:80%;"> denotes required field</span>') {
+                $requiredNote = '<span class="required">*</span> denotes required field';
+            }
+            $this->_html .= str_replace('{requiredNote}', $requiredNote, $this->_requiredNoteTemplate);
+        }
+        // close the open fieldset
+        if ($this->_fieldsetsOpen > 0) {
+            $this->_html .= $this->_closeFieldsetTemplate;
+            $this->_fieldsetsOpen--;
+        }
+        // add form attributes and content
+        $html = str_replace('{attributes}', $form->getAttributes(true), $this->_formTemplate);
+        if (strpos($this->_formTemplate, '{hidden}')) {
+            $html = str_replace('{hidden}', $this->_hiddenHtml, $html);
+        } else {
+            $this->_html .= $this->_hiddenHtml;
+        }
+        $this->_hiddenHtml = '';
+        $this->_html = str_replace('{content}', $this->_html, $html);
+        $this->_html = str_replace('></label>', '>&nbsp;</label>', $this->_html);
+        // add a validation script
+        if ('' != ($script = $form->getValidationScript())) {
+            $this->_html = $script . "\n" . $this->_html;
+        }
+    } // end func finishForm
+
+    /**
+     * Sets the template used when opening a fieldset
+     *
+     * @param       string      The HTML used when opening a fieldset
+     * @access      public
+     * @return      void
+     */
+    function setOpenFieldsetTemplate($html)
+    {
+        $this->_openFieldsetTemplate = $html;
+    } // end func setOpenFieldsetTemplate
+
+    /**
+     * Sets the template used when opening a hidden fieldset
+     * (i.e. a fieldset that is opened when there is no header element)
+     *
+     * @param       string      The HTML used when opening a hidden fieldset
+     * @access      public
+     * @return      void
+     */
+    function setOpenHiddenFieldsetTemplate($html)
+    {
+        $this->_openHiddenFieldsetTemplate = $html;
+    } // end func setOpenHiddenFieldsetTemplate
+
+    /**
+     * Sets the template used when closing a fieldset
+     *
+     * @param       string      The HTML used when closing a fieldset
+     * @access      public
+     * @return      void
+     */
+    function setCloseFieldsetTemplate($html)
+    {
+        $this->_closeFieldsetTemplate = $html;
+    } // end func setCloseFieldsetTemplate
+
+    /**
+     * Adds one or more element names that indicate the end of a fieldset
+     * (a new one will be opened when a the next header element occurs)
+     *
+     * @param       mixed      Element name(s) (as array or string)
+     * @param       string     (optional) Class name for the fieldset(s)
+     * @access      public
+     * @return      void
+     */
+    function addStopFieldsetElements($element, $class = '')
+    {
+        if (is_array($element)) {
+            $elements = array();
+            foreach ($element as $name) {
+                $elements[$name] = $class;
+            }
+            $this->_stopFieldsetElements = array_merge($this->_stopFieldsetElements,
+                                                       $elements);
+        } else {
+            $this->_stopFieldsetElements[$element] = $class;
+        }
+    } // end func addStopFieldsetElements
+
+    /**
+     * Handle element/group names that indicate the end of a group
+     *
+     * @param string     The name of the element or group
+     * @access private
+     * @return void
+     */
+    function _handleStopFieldsetElements($element)
+    {
+        // if the element/group name indicates the end of a fieldset, close
+        // the fieldset
+        if (   array_key_exists($element, $this->_stopFieldsetElements)
+            && $this->_fieldsetsOpen > 0
+           ) {
+            $this->_html .= $this->_closeFieldsetTemplate;
+            $this->_fieldsetsOpen--;
+        }
+        // if no fieldset was opened, we need to open a hidden one here to get
+        // XHTML validity
+        if ($this->_fieldsetsOpen === 0) {
+            $replace = '';
+            if (   array_key_exists($element, $this->_stopFieldsetElements)
+                && $this->_stopFieldsetElements[$element] != ''
+               ) {
+                $replace = ' ' . $this->_stopFieldsetElements[$element];
+            }
+            $this->_html .= str_replace('{class}', $replace,
+                                        $this->_openHiddenFieldsetTemplate);
+            $this->_fieldsetsOpen++;
+        }
+    } // end func _handleStopFieldsetElements
+
+    /**
+     * Sets element template
+     *
+     * @param   string    The HTML surrounding an element
+     * @param   mixed     (optional) Name(s) of the element to apply template
+     *                    for (either single element name as string or multiple
+     *                    element names as an array)
+     * @access  public
+     * @return  void
+     */
+    function setElementTemplate($html, $element = null)
+    {
+        if (is_null($element)) {
+            $this->_elementTemplate = $html;
+        } elseif (is_array($element)) {
+            foreach ($element as $name) {
+                $this->_templates[$name] = $html;
+            }
+        } else {
+            $this->_templates[$element] = $html;
+        }
+    } // end func setElementTemplate
+
+} // end class HTML_QuickForm_Renderer_Default
+?>
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Rule.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Rule.php
new file mode 100644 (file)
index 0000000..9d95020
--- /dev/null
@@ -0,0 +1,82 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * Abstract base class for QuickForm validation rules 
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * Abstract base class for QuickForm validation rules 
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @version     Release: 3.2.16
+ * @since       3.2
+ * @abstract
+ */
+class HTML_QuickForm_Rule
+{
+   /**
+    * Name of the rule to use in validate method
+    *
+    * This property is used in more global rules like Callback and Regex
+    * to determine which callback and which regex is to be used for validation
+    *
+    * @var  string
+    * @access   public
+    */
+    var $name;
+
+   /**
+    * Validates a value
+    * 
+    * @access public
+    * @abstract
+    */
+    function validate($value)
+    {
+        return true;
+    }
+
+   /**
+    * Sets the rule name
+    *
+    * @param  string    rule name
+    * @access public
+    */
+    function setName($ruleName)
+    {
+        $this->name = $ruleName;
+    }
+
+    /**
+     * Returns the javascript test (the test should return true if the value is INVALID)
+     *
+     * @param     mixed     Options for the rule
+     * @access    public
+     * @return    array     first element is code to setup validation, second is the check itself
+     * @abstract
+     */
+    function getValidationScript($options = null)
+    {
+        return array('', '');
+    }
+}
+?>
\ No newline at end of file
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Callback.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Callback.php
new file mode 100644 (file)
index 0000000..1557506
--- /dev/null
@@ -0,0 +1,124 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * Validates values using callback functions or methods
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * Abstract base class for QuickForm validation rules 
+ */
+require_once 'HTML/QuickForm/Rule.php';
+
+/**
+ * Validates values using callback functions or methods
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @version     Release: 3.2.16
+ * @since       3.2
+ */
+class HTML_QuickForm_Rule_Callback extends HTML_QuickForm_Rule
+{
+    /**
+     * Array of callbacks
+     *
+     * Array is in the format:
+     * $_data['rulename'] = array('functionname', 'classname');
+     * If the callback is not a method, then the class name is not set.
+     *
+     * @var     array
+     * @access  private
+     */
+    var $_data = array();
+
+   /**
+    * Whether to use BC mode for specific rules
+    * 
+    * Previous versions of QF passed element's name as a first parameter
+    * to validation functions, but not to validation methods. This behaviour
+    * is emulated if you are using 'function' as rule type when registering.
+    * 
+    * @var array
+    * @access private
+    */
+    var $_BCMode = array();
+
+    /**
+     * Validates a value using a callback
+     *
+     * @param     string    $value      Value to be checked
+     * @param     mixed     $options    Options for callback
+     * @access    public
+     * @return    boolean   true if value is valid
+     */
+    function validate($value, $options = null)
+    {
+        if (isset($this->_data[$this->name])) {
+            $callback = $this->_data[$this->name];
+            if (isset($callback[1])) {
+                return call_user_func(array($callback[1], $callback[0]), $value, $options);
+            } elseif ($this->_BCMode[$this->name]) {
+                return $callback[0]('', $value, $options);
+            } else {
+                return $callback[0]($value, $options);
+            }
+        } elseif (is_callable($options)) {
+            return call_user_func($options, $value);
+        } else {
+            return true;
+        }
+    } // end func validate
+
+    /**
+     * Adds new callbacks to the callbacks list
+     *
+     * @param     string    $name       Name of rule
+     * @param     string    $callback   Name of function or method
+     * @param     string    $class      Name of class containing the method
+     * @param     bool      $BCMode     Backwards compatibility mode 
+     * @access    public
+     */
+    function addData($name, $callback, $class = null, $BCMode = false)
+    {
+        if (!empty($class)) {
+            $this->_data[$name] = array($callback, $class);
+        } else {
+            $this->_data[$name] = array($callback);
+        }
+        $this->_BCMode[$name] = $BCMode;
+    } // end func addData
+
+
+    function getValidationScript($options = null)
+    {
+        if (isset($this->_data[$this->name])) {
+            $callback = $this->_data[$this->name][0];
+            $params   = ($this->_BCMode[$this->name]? "'', {jsVar}": '{jsVar}') .
+                        (isset($options)? ", '{$options}'": '');
+        } else {
+            $callback = is_array($options)? $options[1]: $options;
+            $params   = '{jsVar}';
+        }
+        return array('', "{jsVar} != '' && !{$callback}({$params})");
+    } // end func getValidationScript
+
+} // end class HTML_QuickForm_Rule_Callback
+?>
\ No newline at end of file
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Compare.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Compare.php
new file mode 100644 (file)
index 0000000..82d38c7
--- /dev/null
@@ -0,0 +1,105 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * Rule to compare two form fields
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Alexey Borzov <avb@php.net>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * Abstract base class for QuickForm validation rules 
+ */
+require_once 'HTML/QuickForm/Rule.php';
+
+/**
+ * Rule to compare two form fields
+ * 
+ * The most common usage for this is to ensure that the password 
+ * confirmation field matches the password field
+ * 
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Alexey Borzov <avb@php.net>
+ * @version     Release: 3.2.16
+ * @since       3.2
+ */
+class HTML_QuickForm_Rule_Compare extends HTML_QuickForm_Rule
+{
+   /**
+    * Possible operators to use
+    * @var array
+    * @access private
+    */
+    var $_operators = array(
+        'eq'  => '===',
+        'neq' => '!==',
+        'gt'  => '>',
+        'gte' => '>=',
+        'lt'  => '<',
+        'lte' => '<=',
+        '=='  => '===',
+        '!='  => '!=='
+    );
+
+
+   /**
+    * Returns the operator to use for comparing the values
+    * 
+    * @access private
+    * @param  string     operator name
+    * @return string     operator to use for validation
+    */
+    function _findOperator($name)
+    {
+        if (empty($name)) {
+            return '===';
+        } elseif (isset($this->_operators[$name])) {
+            return $this->_operators[$name];
+        } elseif (in_array($name, $this->_operators)) {
+            return $name;
+        } else {
+            return '===';
+        }
+    }
+
+
+    function validate($values, $operator = null)
+    {
+        $operator = $this->_findOperator($operator);
+        if ('===' != $operator && '!==' != $operator) {
+            $compareFn = create_function('$a, $b', 'return floatval($a) ' . $operator . ' floatval($b);');
+        } else {
+            $compareFn = create_function('$a, $b', 'return strval($a) ' . $operator . ' strval($b);');
+        }
+        
+        return $compareFn($values[0], $values[1]);
+    }
+
+
+    function getValidationScript($operator = null)
+    {
+        $operator = $this->_findOperator($operator);
+        if ('===' != $operator && '!==' != $operator) {
+            $check = "!(Number({jsVar}[0]) {$operator} Number({jsVar}[1]))";
+        } else {
+            $check = "!(String({jsVar}[0]) {$operator} String({jsVar}[1]))";
+        }
+        return array('', "'' != {jsVar}[0] && {$check}");
+    }
+}
+?>
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Email.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Email.php
new file mode 100644 (file)
index 0000000..d38acd5
--- /dev/null
@@ -0,0 +1,73 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * Email validation rule
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * Abstract base class for QuickForm validation rules 
+ */
+require_once 'HTML/QuickForm/Rule.php';
+
+/**
+ * Email validation rule
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @version     Release: 3.2.16
+ * @since       3.2
+ */
+class HTML_QuickForm_Rule_Email extends HTML_QuickForm_Rule
+{
+    var $regex = '/^((\"[^\"\f\n\r\t\v\b]+\")|([\w\!\#\$\%\&\'\*\+\-\~\/\^\`\|\{\}]+(\.[\w\!\#\$\%\&\'\*\+\-\~\/\^\`\|\{\}]+)*))@((\[(((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9])))\])|(((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9]))\.((25[0-5])|(2[0-4][0-9])|([0-1]?[0-9]?[0-9])))|((([A-Za-z0-9\-])+\.)+[A-Za-z\-]+))$/';
+
+    /**
+     * Validates an email address
+     *
+     * @param     string    $email          Email address
+     * @param     boolean   $checkDomain    True if dns check should be performed
+     * @access    public
+     * @return    boolean   true if email is valid
+     */
+    function validate($email, $checkDomain = false)
+    {
+        // Fix for bug #10799: add 'D' modifier to regex
+        if (preg_match($this->regex . 'D', $email)) {
+            if ($checkDomain && function_exists('checkdnsrr')) {
+                $tokens = explode('@', $email);
+                if (checkdnsrr($tokens[1], 'MX') || checkdnsrr($tokens[1], 'A')) {
+                    return true;
+                }
+                return false;
+            }
+            return true;
+        }
+        return false;
+    } // end func validate
+
+
+    function getValidationScript($options = null)
+    {
+        return array("  var regex = " . $this->regex . ";\n", "{jsVar} != '' && !regex.test({jsVar})");
+    } // end func getValidationScript
+
+} // end class HTML_QuickForm_Rule_Email
+?>
\ No newline at end of file
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Range.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Range.php
new file mode 100644 (file)
index 0000000..14118f5
--- /dev/null
@@ -0,0 +1,75 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * Checks that the length of value is within range
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * Abstract base class for QuickForm validation rules 
+ */
+require_once 'HTML/QuickForm/Rule.php';
+
+/**
+ * Checks that the length of value is within range
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @version     Release: 3.2.16
+ * @since       3.2
+ */
+class HTML_QuickForm_Rule_Range extends HTML_QuickForm_Rule
+{
+    /**
+     * Validates a value using a range comparison
+     *
+     * @param     string    $value      Value to be checked
+     * @param     mixed     $options    Int for length, array for range
+     * @access    public
+     * @return    boolean   true if value is valid
+     */
+    function validate($value, $options = null)
+    {
+        $length = strlen($value);
+        switch ($this->name) {
+            case 'minlength': return ($length >= $options);
+            case 'maxlength': return ($length <= $options);
+            default:          return ($length >= $options[0] && $length <= $options[1]);
+        }
+    } // end func validate
+
+
+    function getValidationScript($options = null)
+    {
+        switch ($this->name) {
+            case 'minlength': 
+                $test = '{jsVar}.length < '.$options;
+                break;
+            case 'maxlength': 
+                $test = '{jsVar}.length > '.$options;
+                break;
+            default: 
+                $test = '({jsVar}.length < '.$options[0].' || {jsVar}.length > '.$options[1].')';
+        }
+        return array('', "{jsVar} != '' && {$test}");
+    } // end func getValidationScript
+
+} // end class HTML_QuickForm_Rule_Range
+?>
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Regex.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Regex.php
new file mode 100644 (file)
index 0000000..2d3d702
--- /dev/null
@@ -0,0 +1,107 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * Validates values using regular expressions
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * Abstract base class for QuickForm validation rules 
+ */
+require_once 'HTML/QuickForm/Rule.php';
+
+/**
+ * Validates values using regular expressions
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @version     Release: 3.2.16
+ * @since       3.2
+ */
+class HTML_QuickForm_Rule_Regex extends HTML_QuickForm_Rule
+{
+    /**
+     * Array of regular expressions
+     *
+     * Array is in the format:
+     * $_data['rulename'] = 'pattern';
+     *
+     * @var     array
+     * @access  private
+     */
+    var $_data = array(
+                    'lettersonly'   => '/^[a-zA-Z]+$/',
+                    'alphanumeric'  => '/^[a-zA-Z0-9]+$/',
+                    'numeric'       => '/(^-?\d\d*\.\d*$)|(^-?\d\d*$)|(^-?\.\d\d*$)/',
+                    'nopunctuation' => '/^[^().\/\*\^\?#!@$%+=,\"\'><~\[\]{}]+$/',
+                    'nonzero'       => '/^-?[1-9][0-9]*/'
+                    );
+
+    /**
+     * Validates a value using a regular expression
+     *
+     * @param     string    $value      Value to be checked
+     * @param     string    $regex      Regular expression
+     * @access    public
+     * @return    boolean   true if value is valid
+     */
+    function validate($value, $regex = null)
+    {
+        // Fix for bug #10799: add 'D' modifier to regex
+        if (isset($this->_data[$this->name])) {
+            if (!preg_match($this->_data[$this->name] . 'D', $value)) {
+                return false;
+            }
+        } else {
+            if (!preg_match($regex . 'D', $value)) {
+                return false;
+            }
+        }
+        return true;
+    } // end func validate
+
+    /**
+     * Adds new regular expressions to the list
+     *
+     * @param     string    $name       Name of rule
+     * @param     string    $pattern    Regular expression pattern
+     * @access    public
+     */
+    function addData($name, $pattern)
+    {
+        $this->_data[$name] = $pattern;
+    } // end func addData
+
+
+    function getValidationScript($options = null)
+    {
+        $regex = isset($this->_data[$this->name]) ? $this->_data[$this->name] : $options;
+
+        // bug #12376, converting unicode escapes and stripping 'u' modifier
+        if ($pos = strpos($regex, 'u', strrpos($regex, '/'))) {
+            $regex = substr($regex, 0, $pos) . substr($regex, $pos + 1);
+            $regex = preg_replace('/(?<!\\\\)(?>\\\\\\\\)*\\\\x{([a-fA-F0-9]+)}/', '\\u$1', $regex);
+        }
+
+        return array("  var regex = " . $regex . ";\n", "{jsVar} != '' && !regex.test({jsVar})");
+    } // end func getValidationScript
+
+} // end class HTML_QuickForm_Rule_Regex
+?>
\ No newline at end of file
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Required.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/Rule/Required.php
new file mode 100644 (file)
index 0000000..26ff62f
--- /dev/null
@@ -0,0 +1,65 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * Required elements validation
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * Abstract base class for QuickForm validation rules 
+ */
+require_once 'HTML/QuickForm/Rule.php';
+
+/**
+ * Required elements validation
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @version     Release: 3.2.16
+ * @since       3.2
+ */
+class HTML_QuickForm_Rule_Required extends HTML_QuickForm_Rule
+{
+    /**
+     * Checks if an element is empty
+     *
+     * @param     string    $value      Value to check
+     * @param     mixed     $options    Not used yet
+     * @access    public
+     * @return    boolean   true if value is not empty
+     */
+    function validate($value, $options = null)
+    {
+        if (is_array($value)) {
+            return (bool) $value;
+        } else if ((string)$value == '') {
+            return false;
+        }
+        return true;
+    } // end func validate
+
+
+    function getValidationScript($options = null)
+    {
+        return array('', "{jsVar} == ''");
+    } // end func getValidationScript
+
+} // end class HTML_QuickForm_Rule_Required
+?>
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/RuleRegistry.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/RuleRegistry.php
new file mode 100644 (file)
index 0000000..3d23716
--- /dev/null
@@ -0,0 +1,349 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * Registers rule objects and uses them for validation
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @author      Alexey Borzov <avb@php.net>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * Registers rule objects and uses them for validation
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @author      Alexey Borzov <avb@php.net>
+ * @version     Release: 3.2.16
+ * @since       3.2
+ */
+class HTML_QuickForm_RuleRegistry
+{
+    /**
+     * Array containing references to used rules
+     * @var     array
+     * @access  private
+     */
+    var $_rules = array();
+
+
+    /**
+     * Returns a singleton of HTML_QuickForm_RuleRegistry
+     *
+     * Usually, only one RuleRegistry object is needed, this is the reason
+     * why it is recommended to use this method to get the validation object. 
+     *
+     * @access    public
+     * @static
+     * @return    HTML_QuickForm_RuleRegistry
+     */
+    function &singleton()
+    {
+        static $obj;
+        if (!isset($obj)) {
+            $obj = new HTML_QuickForm_RuleRegistry();
+        }
+        return $obj;
+    } // end func singleton
+
+    /**
+     * Registers a new validation rule
+     *
+     * In order to use a custom rule in your form, you need to register it
+     * first. For regular expressions, one can directly use the 'regex' type
+     * rule in addRule(), this is faster than registering the rule.
+     *
+     * Functions and methods can be registered. Use the 'function' type.
+     * When registering a method, specify the class name as second parameter.
+     *
+     * You can also register an HTML_QuickForm_Rule subclass with its own
+     * validate() method.
+     *
+     * @param     string    $ruleName   Name of validation rule
+     * @param     string    $type       Either: 'regex', 'function' or null
+     * @param     string    $data1      Name of function, regular expression or
+     *                                  HTML_QuickForm_Rule object class name
+     * @param     string    $data2      Object parent of above function or HTML_QuickForm_Rule file path
+     * @access    public
+     * @return    void
+     */
+    function registerRule($ruleName, $type, $data1, $data2 = null)
+    {
+        $type = strtolower($type);
+        if ($type == 'regex') {
+            // Regular expression
+            $rule =& $this->getRule('regex');
+            $rule->addData($ruleName, $data1);
+            $GLOBALS['_HTML_QuickForm_registered_rules'][$ruleName] = $GLOBALS['_HTML_QuickForm_registered_rules']['regex'];
+
+        } elseif ($type == 'function' || $type == 'callback') {
+            // Callback function
+            $rule =& $this->getRule('callback');
+            $rule->addData($ruleName, $data1, $data2, 'function' == $type);
+            $GLOBALS['_HTML_QuickForm_registered_rules'][$ruleName] = $GLOBALS['_HTML_QuickForm_registered_rules']['callback'];
+
+        } elseif (is_object($data1)) {
+            // An instance of HTML_QuickForm_Rule
+            $this->_rules[strtolower(get_class($data1))] = $data1;
+            $GLOBALS['_HTML_QuickForm_registered_rules'][$ruleName] = array(strtolower(get_class($data1)), null);
+
+        } else {
+            // Rule class name
+            $GLOBALS['_HTML_QuickForm_registered_rules'][$ruleName] = array(strtolower($data1), $data2);
+        }
+    } // end func registerRule
+
+    /**
+     * Returns a reference to the requested rule object
+     *
+     * @param     string   $ruleName        Name of the requested rule
+     * @access    public
+     * @return    HTML_QuickForm_Rule
+     */
+    function &getRule($ruleName)
+    {
+        list($class, $path) = $GLOBALS['_HTML_QuickForm_registered_rules'][$ruleName];
+
+        if (!isset($this->_rules[$class])) {
+            if (!empty($path)) {
+                include_once($path);
+            }
+            $this->_rules[$class] = new $class();
+        }
+        $this->_rules[$class]->setName($ruleName);
+        return $this->_rules[$class];
+    } // end func getRule
+
+    /**
+     * Performs validation on the given values
+     *
+     * @param     string   $ruleName        Name of the rule to be used
+     * @param     mixed    $values          Can be a scalar or an array of values 
+     *                                      to be validated
+     * @param     mixed    $options         Options used by the rule
+     * @param     mixed    $multiple        Whether to validate an array of values altogether
+     * @access    public
+     * @return    mixed    true if no error found, int of valid values (when an array of values is given) or false if error
+     */
+    function validate($ruleName, $values, $options = null, $multiple = false)
+    {
+        $rule =& $this->getRule($ruleName);
+
+        if (is_array($values) && !$multiple) {
+            $result = 0;
+            foreach ($values as $value) {
+                if ($rule->validate($value, $options) === true) {
+                    $result++;
+                }
+            }
+            return ($result == 0) ? false : $result;
+        } else {
+            return $rule->validate($values, $options);
+        }
+    } // end func validate
+
+    /**
+     * Returns the validation test in javascript code
+     *
+     * @param     array|HTML_QuickForm_element  Element(s) the rule applies to
+     * @param     string                        Element name, in case $element is 
+     *                                          not an array
+     * @param     array                         Rule data
+     * @access    public
+     * @return    string    JavaScript for the rule
+     */
+    function getValidationScript(&$element, $elementName, $ruleData)
+    {
+        $reset =  (isset($ruleData['reset'])) ? $ruleData['reset'] : false;
+        $rule  =& $this->getRule($ruleData['type']);
+        if (!is_array($element)) {
+            list($jsValue, $jsReset) = $this->_getJsValue($element, $elementName, $reset, null);
+        } else {
+            $jsValue = "  value = new Array();\n";
+            $jsReset = '';
+            for ($i = 0; $i < count($element); $i++) {
+                list($tmp_value, $tmp_reset) = $this->_getJsValue($element[$i], $element[$i]->getName(), $reset, $i);
+                $jsValue .= "\n" . $tmp_value;
+                $jsReset .= $tmp_reset;
+            }
+        }
+        $jsField = isset($ruleData['group'])? $ruleData['group']: $elementName;
+        list ($jsPrefix, $jsCheck) = $rule->getValidationScript($ruleData['format']);
+        if (!isset($ruleData['howmany'])) {
+            $js = $jsValue . "\n" . $jsPrefix . 
+                  "  if (" . str_replace('{jsVar}', 'value', $jsCheck) . " && !errFlag['{$jsField}']) {\n" .
+                  "    errFlag['{$jsField}'] = true;\n" .
+                  "    _qfMsg = _qfMsg + '\\n - {$ruleData['message']}';\n" .
+                  $jsReset .
+                  "  }\n";
+        } else {
+            $js = $jsValue . "\n" . $jsPrefix . 
+                  "  var res = 0;\n" .
+                  "  for (var i = 0; i < value.length; i++) {\n" .
+                  "    if (!(" . str_replace('{jsVar}', 'value[i]', $jsCheck) . ")) {\n" .
+                  "      res++;\n" .
+                  "    }\n" .
+                  "  }\n" . 
+                  "  if (res < {$ruleData['howmany']} && !errFlag['{$jsField}']) {\n" . 
+                  "    errFlag['{$jsField}'] = true;\n" .
+                  "    _qfMsg = _qfMsg + '\\n - {$ruleData['message']}';\n" .
+                  $jsReset .
+                  "  }\n";
+        }
+        return $js;
+    } // end func getValidationScript
+
+
+   /**
+    * Returns JavaScript to get and to reset the element's value 
+    * 
+    * @access private
+    * @param  HTML_QuickForm_element    element being processed
+    * @param  string                    element's name
+    * @param  bool                      whether to generate JavaScript to reset 
+    *                                   the value
+    * @param  integer                   value's index in the array (only used for
+    *                                   multielement rules)
+    * @return array     first item is value javascript, second is reset
+    */
+    function _getJsValue(&$element, $elementName, $reset = false, $index = null)
+    {
+        $jsIndex = isset($index)? '[' . $index . ']': '';
+        $tmp_reset = $reset? "    var field = frm.elements['$elementName'];\n": '';
+        if (is_a($element, 'html_quickform_group')) {
+            $value = "  _qfGroups['{$elementName}'] = {";
+            $elements =& $element->getElements();
+            for ($i = 0, $count = count($elements); $i < $count; $i++) {
+                $append = ($elements[$i]->getType() == 'select' && $elements[$i]->getMultiple())? '[]': '';
+                $value .= "'" . $element->getElementName($i) . $append . "': true" .
+                          ($i < $count - 1? ', ': '');
+            }
+            $value .=
+                "};\n" .
+                "  value{$jsIndex} = new Array();\n" .
+                "  var valueIdx = 0;\n" .
+                "  for (var i = 0; i < frm.elements.length; i++) {\n" .
+                "    var _element = frm.elements[i];\n" .
+                "    if (_element.name in _qfGroups['{$elementName}']) {\n" . 
+                "      switch (_element.type) {\n" .
+                "        case 'checkbox':\n" .
+                "        case 'radio':\n" .
+                "          if (_element.checked) {\n" .
+                "            value{$jsIndex}[valueIdx++] = _element.value;\n" .
+                "          }\n" .
+                "          break;\n" .
+                "        case 'select-one':\n" .
+                "          if (-1 != _element.selectedIndex) {\n" .
+                "            value{$jsIndex}[valueIdx++] = _element.options[_element.selectedIndex].value;\n" .
+                "          }\n" .
+                "          break;\n" .
+                "        case 'select-multiple':\n" .
+                "          var tmpVal = new Array();\n" .
+                "          var tmpIdx = 0;\n" .
+                "          for (var j = 0; j < _element.options.length; j++) {\n" .
+                "            if (_element.options[j].selected) {\n" .
+                "              tmpVal[tmpIdx++] = _element.options[j].value;\n" .
+                "            }\n" .
+                "          }\n" .
+                "          if (tmpIdx > 0) {\n" .
+                "            value{$jsIndex}[valueIdx++] = tmpVal;\n" .
+                "          }\n" .
+                "          break;\n" .
+                "        default:\n" .
+                "          value{$jsIndex}[valueIdx++] = _element.value;\n" .
+                "      }\n" .
+                "    }\n" .
+                "  }\n";
+            if ($reset) {
+                $tmp_reset =
+                    "    for (var i = 0; i < frm.elements.length; i++) {\n" .
+                    "      var _element = frm.elements[i];\n" .
+                    "      if (_element.name in _qfGroups['{$elementName}']) {\n" . 
+                    "        switch (_element.type) {\n" .
+                    "          case 'checkbox':\n" .
+                    "          case 'radio':\n" .
+                    "            _element.checked = _element.defaultChecked;\n" .
+                    "            break;\n" .
+                    "          case 'select-one':\n" .
+                    "          case 'select-multiple':\n" .
+                    "            for (var j = 0; j < _element.options.length; j++) {\n" .
+                    "              _element.options[j].selected = _element.options[j].defaultSelected;\n" .
+                    "            }\n" .
+                    "            break;\n" .
+                    "          default:\n" .
+                    "            _element.value = _element.defaultValue;\n" .
+                    "        }\n" .
+                    "      }\n" .
+                    "    }\n";
+            }
+
+        } elseif ($element->getType() == 'select') {
+            if ($element->getMultiple()) {
+                $elementName .= '[]';
+                $value =
+                    "  value{$jsIndex} = new Array();\n" .
+                    "  var valueIdx = 0;\n" .
+                    "  for (var i = 0; i < frm.elements['{$elementName}'].options.length; i++) {\n" . 
+                    "    if (frm.elements['{$elementName}'].options[i].selected) {\n" .
+                    "      value{$jsIndex}[valueIdx++] = frm.elements['{$elementName}'].options[i].value;\n" .
+                    "    }\n" .
+                    "  }\n";
+            } else {
+                $value = "  value{$jsIndex} = frm.elements['{$elementName}'].selectedIndex == -1? '': frm.elements['{$elementName}'].options[frm.elements['{$elementName}'].selectedIndex].value;\n";
+            }
+            if ($reset) {
+                $tmp_reset .= 
+                    "    for (var i = 0; i < field.options.length; i++) {\n" .
+                    "      field.options[i].selected = field.options[i].defaultSelected;\n" .
+                    "    }\n";
+            }
+
+        } elseif ($element->getType() == 'checkbox') {
+            if (is_a($element, 'html_quickform_advcheckbox')) {
+                $value = "  value{$jsIndex} = frm.elements['$elementName'][1].checked? frm.elements['$elementName'][1].value: frm.elements['$elementName'][0].value;\n";
+                $tmp_reset .= $reset ? "    field[1].checked = field[1].defaultChecked;\n" : '';
+            } else {
+                $value = "  value{$jsIndex} = frm.elements['$elementName'].checked? '1': '';\n";
+                $tmp_reset .= $reset ? "    field.checked = field.defaultChecked;\n" : '';
+            }
+
+        } elseif ($element->getType() == 'radio') {
+            $value = "  value{$jsIndex} = '';\n" .
+                     // Fix for bug #5644
+                     "  var els = 'length' in frm.elements['$elementName']? frm.elements['$elementName']: [ frm.elements['$elementName'] ];\n" .
+                     "  for (var i = 0; i < els.length; i++) {\n" .
+                     "    if (els[i].checked) {\n" .
+                     "      value{$jsIndex} = els[i].value;\n" .
+                     "    }\n" .
+                     "  }";
+            if ($reset) {
+                $tmp_reset .= "    for (var i = 0; i < field.length; i++) {\n" .
+                              "      field[i].checked = field[i].defaultChecked;\n" .
+                              "    }";
+            }
+
+        } else {
+            $value = "  value{$jsIndex} = frm.elements['$elementName'].value;";
+            $tmp_reset .= ($reset) ? "    field.value = field.defaultValue;\n" : '';
+        }
+        return array($value, $tmp_reset);
+    }
+} // end class HTML_QuickForm_RuleRegistry
+?>
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/advcheckbox.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/advcheckbox.php
new file mode 100644 (file)
index 0000000..6d72be6
--- /dev/null
@@ -0,0 +1,286 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * HTML class for an advanced checkbox type field
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Jason Rust <jrust@php.net>
+ * @author      Alexey Borzov <avb@php.net>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * HTML class for a checkbox type field
+ */
+require_once 'HTML/QuickForm/checkbox.php';
+
+/**
+ * HTML class for an advanced checkbox type field
+ *
+ * Basically this fixes a problem that HTML has had
+ * where checkboxes can only pass a single value (the
+ * value of the checkbox when checked).  A value for when
+ * the checkbox is not checked cannot be passed, and 
+ * furthermore the checkbox variable doesn't even exist if
+ * the checkbox was submitted unchecked.
+ *
+ * It works by prepending a hidden field with the same name and
+ * another "unchecked" value to the checbox. If the checkbox is
+ * checked, PHP overwrites the value of the hidden field with
+ * its value. 
+ * 
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Jason Rust <jrust@php.net>
+ * @author      Alexey Borzov <avb@php.net>
+ * @version     Release: 3.2.16
+ * @since       2.0
+ */
+class HTML_QuickForm_advcheckbox extends HTML_QuickForm_checkbox
+{
+    // {{{ properties
+
+    /**
+     * The values passed by the hidden elment
+     *
+     * @var array
+     * @access private
+     */
+    var $_values = null;
+
+    /**
+     * The default value
+     *
+     * @var boolean
+     * @access private
+     */
+    var $_currentValue = null;
+
+    // }}}
+    // {{{ constructor
+
+    /**
+     * Class constructor
+     * 
+     * @param     string    $elementName    (optional)Input field name attribute
+     * @param     string    $elementLabel   (optional)Input field label 
+     * @param     string    $text           (optional)Text to put after the checkbox
+     * @param     mixed     $attributes     (optional)Either a typical HTML attribute string 
+     *                                      or an associative array
+     * @param     mixed     $values         (optional)Values to pass if checked or not checked 
+     *
+     * @since     1.0
+     * @access    public
+     * @return    void
+     */
+    function HTML_QuickForm_advcheckbox($elementName=null, $elementLabel=null, $text=null, $attributes=null, $values=null)
+    {
+        $this->HTML_QuickForm_checkbox($elementName, $elementLabel, $text, $attributes);
+        $this->setValues($values);
+    } //end constructor
+    
+    // }}}
+    // {{{ getPrivateName()
+
+    /**
+     * Gets the private name for the element
+     *
+     * @param   string  $elementName The element name to make private
+     *
+     * @access public
+     * @return string
+     *
+     * @deprecated          Deprecated since 3.2.6, both generated elements have the same name
+     */
+    function getPrivateName($elementName)
+    {
+        return '__'.$elementName;
+    }
+
+    // }}}
+    // {{{ getOnclickJs()
+
+    /**
+     * Create the javascript for the onclick event which will
+     * set the value of the hidden field
+     *
+     * @param     string    $elementName    The element name
+     *
+     * @access public
+     * @return string
+     *
+     * @deprecated          Deprecated since 3.2.6, this element no longer uses any javascript
+     */
+    function getOnclickJs($elementName)
+    {
+        $onclickJs = 'if (this.checked) { this.form[\''.$elementName.'\'].value=\''.addcslashes($this->_values[1], '\'').'\'; }';
+        $onclickJs .= 'else { this.form[\''.$elementName.'\'].value=\''.addcslashes($this->_values[0], '\'').'\'; }';
+        return $onclickJs;
+    }
+
+    // }}}
+    // {{{ setValues()
+
+    /**
+     * Sets the values used by the hidden element
+     *
+     * @param   mixed   $values The values, either a string or an array
+     *
+     * @access public
+     * @return void
+     */
+    function setValues($values)
+    {
+        if (empty($values)) {
+            // give it default checkbox behavior
+            $this->_values = array('', 1);
+        } elseif (is_scalar($values)) {
+            // if it's string, then assume the value to 
+            // be passed is for when the element is checked
+            $this->_values = array('', $values);
+        } else {
+            $this->_values = $values;
+        }
+        $this->updateAttributes(array('value' => $this->_values[1]));
+        $this->setChecked($this->_currentValue == $this->_values[1]);
+    }
+
+    // }}}
+    // {{{ setValue()
+
+   /**
+    * Sets the element's value
+    * 
+    * @param    mixed   Element's value
+    * @access   public
+    */
+    function setValue($value)
+    {
+        $this->setChecked(isset($this->_values[1]) && $value == $this->_values[1]);
+        $this->_currentValue = $value;
+    }
+
+    // }}}
+    // {{{ getValue()
+
+   /**
+    * Returns the element's value
+    *
+    * @access   public
+    * @return   mixed
+    */
+    function getValue()
+    {
+        if (is_array($this->_values)) {
+            return $this->_values[$this->getChecked()? 1: 0];
+        } else {
+            return null;
+        }
+    }
+
+    // }}}
+    // {{{ toHtml()
+
+    /**
+     * Returns the checkbox element in HTML
+     * and the additional hidden element in HTML
+     * 
+     * @access    public
+     * @return    string
+     */
+    function toHtml()
+    {
+        if ($this->_flagFrozen) {
+            return parent::toHtml();
+        } else {
+            return '<input' . $this->_getAttrString(array(
+                        'type'  => 'hidden', 
+                        'name'  => $this->getName(), 
+                        'value' => $this->_values[0]
+                   )) . ' />' . parent::toHtml();
+            
+        }
+    } //end func toHtml
+    
+    // }}}
+    // {{{ getFrozenHtml()
+
+   /**
+    * Unlike checkbox, this has to append a hidden input in both
+    * checked and non-checked states
+    */
+    function getFrozenHtml()
+    {
+        return ($this->getChecked()? '<tt>[x]</tt>': '<tt>[ ]</tt>') .
+               $this->_getPersistantData();
+    }
+
+    // }}}
+    // {{{ onQuickFormEvent()
+
+    /**
+     * Called by HTML_QuickForm whenever form event is made on this element
+     *
+     * @param     string    $event  Name of event
+     * @param     mixed     $arg    event arguments
+     * @param     object    &$caller calling object
+     * @since     1.0
+     * @access    public
+     * @return    void
+     */
+    function onQuickFormEvent($event, $arg, &$caller)
+    {
+        switch ($event) {
+            case 'updateValue':
+                // constant values override both default and submitted ones
+                // default values are overriden by submitted
+                $value = $this->_findValue($caller->_constantValues);
+                if (null === $value) {
+                    $value = $this->_findValue($caller->_submitValues);
+                    if (null === $value) {
+                        $value = $this->_findValue($caller->_defaultValues);
+                    }
+                }
+                if (null !== $value) {
+                    $this->setValue($value);
+                }
+                break;
+            default:
+                parent::onQuickFormEvent($event, $arg, $caller);
+        }
+        return true;
+    } // end func onQuickFormLoad
+
+    // }}}
+    // {{{ exportValue()
+
+   /**
+    * This element has a value even if it is not checked, thus we override
+    * checkbox's behaviour here
+    */
+    function exportValue(&$submitValues, $assoc = false)
+    {
+        $value = $this->_findValue($submitValues);
+        if (null === $value) {
+            $value = $this->getValue();
+        } elseif (is_array($this->_values) && ($value != $this->_values[0]) && ($value != $this->_values[1])) {
+            $value = null;
+        }
+        return $this->_prepareValue($value, $assoc);
+    }
+    // }}}
+} //end class HTML_QuickForm_advcheckbox
+?>
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/autocomplete.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/autocomplete.php
new file mode 100644 (file)
index 0000000..bb6fe31
--- /dev/null
@@ -0,0 +1,258 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * HTML class for an autocomplete element
+ *
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Matteo Di Giovinazzo <matteodg@infinito.it>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * HTML class for a text field
+ */
+require_once 'HTML/QuickForm/text.php';
+
+/**
+ * HTML class for an autocomplete element
+ *
+ * Creates an HTML input text element that
+ * at every keypressed javascript event checks in an array of options
+ * if there's a match and autocompletes the text in case of match.
+ *
+ * For the JavaScript code thanks to Martin Honnen and Nicholas C. Zakas
+ * See {@link http://www.faqts.com/knowledge_base/view.phtml/aid/13562} and
+ * {@link http://www.sitepoint.com/article/1220}
+ *
+ * Example:
+ * <code>
+ * $autocomplete =& $form->addElement('autocomplete', 'fruit', 'Favourite fruit:');
+ * $options = array("Apple", "Orange", "Pear", "Strawberry");
+ * $autocomplete->setOptions($options);
+ * </code>
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Matteo Di Giovinazzo <matteodg@infinito.it>
+ * @version     Release: 3.2.16
+ * @since       3.2
+ */
+class HTML_QuickForm_autocomplete extends HTML_QuickForm_text
+{
+    // {{{ properties
+
+    /**
+     * Options for the autocomplete input text element
+     *
+     * @var       array
+     * @access    private
+     */
+    var $_options = array();
+
+    /**
+     * "One-time" javascript (containing functions), see bug #4611
+     *
+     * @var     string
+     * @access  private
+     */
+    var $_js = '';
+
+    // }}}
+    // {{{ constructor
+
+    /**
+     * Class constructor
+     *
+     * @param     string    $elementName    (optional)Input field name attribute
+     * @param     string    $elementLabel   (optional)Input field label in form
+     * @param     array     $options        (optional)Autocomplete options
+     * @param     mixed     $attributes     (optional)Either a typical HTML attribute string
+     *                                      or an associative array. Date format is passed along the attributes.
+     * @access    public
+     * @return    void
+     */
+    function HTML_QuickForm_autocomplete($elementName = null, $elementLabel = null, $options = null, $attributes = null)
+    {
+        $this->HTML_QuickForm_text($elementName, $elementLabel, $attributes);
+        $this->_persistantFreeze = true;
+        $this->_type = 'autocomplete';
+        if (isset($options)) {
+            $this->setOptions($options);
+        }
+    } //end constructor
+
+    // }}}
+    // {{{ setOptions()
+
+    /**
+     * Sets the options for the autocomplete input text element
+     *
+     * @param     array    $options    Array of options for the autocomplete input text element
+     * @access    public
+     * @return    void
+     */
+    function setOptions($options)
+    {
+        $this->_options = array_values($options);
+    } // end func setOptions
+
+    // }}}
+    // {{{ toHtml()
+
+    /**
+     * Returns Html for the autocomplete input text element
+     *
+     * @access      public
+     * @return      string
+     */
+    function toHtml()
+    {
+        // prevent problems with grouped elements
+        $arrayName = str_replace(array('[', ']'), array('__', ''), $this->getName()) . '_values';
+
+        $this->updateAttributes(array(
+            'onkeypress' => 'return window.autocomplete(this, event, ' . $arrayName . ');'
+        ));
+        if ($this->_flagFrozen) {
+            $js = '';
+        } else {
+            $js = "<script type=\"text/javascript\">\n//<![CDATA[\n";
+            if (!defined('HTML_QUICKFORM_AUTOCOMPLETE_EXISTS')) {
+                $this->_js .= <<<EOS
+
+/* begin javascript for autocomplete */
+function setSelectionRange(input, selectionStart, selectionEnd) {
+    if (input.setSelectionRange) {
+        input.setSelectionRange(selectionStart, selectionEnd);
+    }
+    else if (input.createTextRange) {
+        var range = input.createTextRange();
+        range.collapse(true);
+        range.moveEnd("character", selectionEnd);
+        range.moveStart("character", selectionStart);
+        range.select();
+    }
+    input.focus();
+}
+
+function setCaretToPosition(input, position) {
+    setSelectionRange(input, position, position);
+}
+
+function replaceSelection (input, replaceString) {
+       var len = replaceString.length;
+    if (input.setSelectionRange) {
+        var selectionStart = input.selectionStart;
+        var selectionEnd = input.selectionEnd;
+
+        input.value = input.value.substring(0, selectionStart) + replaceString + input.value.substring(selectionEnd);
+               input.selectionStart  = selectionStart + len;
+               input.selectionEnd  = selectionStart + len;
+    }
+    else if (document.selection) {
+        var range = document.selection.createRange();
+               var saved_range = range.duplicate();
+
+        if (range.parentElement() == input) {
+            range.text = replaceString;
+                       range.moveEnd("character", saved_range.selectionStart + len);
+                       range.moveStart("character", saved_range.selectionStart + len);
+                       range.select();
+        }
+    }
+    input.focus();
+}
+
+
+function autocompleteMatch (text, values) {
+    for (var i = 0; i < values.length; i++) {
+        if (values[i].toUpperCase().indexOf(text.toUpperCase()) == 0) {
+            return values[i];
+        }
+    }
+
+    return null;
+}
+
+function autocomplete(textbox, event, values) {
+    if (textbox.setSelectionRange || textbox.createTextRange) {
+        switch (event.keyCode) {
+            case 38:    // up arrow
+            case 40:    // down arrow
+            case 37:    // left arrow
+            case 39:    // right arrow
+            case 33:    // page up
+            case 34:    // page down
+            case 36:    // home
+            case 35:    // end
+            case 13:    // enter
+            case 9:     // tab
+            case 27:    // esc
+            case 16:    // shift
+            case 17:    // ctrl
+            case 18:    // alt
+            case 20:    // caps lock
+            case 8:     // backspace
+            case 46:    // delete
+                return true;
+                break;
+
+            default:
+                var c = String.fromCharCode(
+                    (event.charCode == undefined) ? event.keyCode : event.charCode
+                );
+                replaceSelection(textbox, c);
+                sMatch = autocompleteMatch(textbox.value, values);
+                var len = textbox.value.length;
+
+                if (sMatch != null) {
+                    textbox.value = sMatch;
+                    setSelectionRange(textbox, len, textbox.value.length);
+                }
+                return false;
+        }
+    }
+    else {
+        return true;
+    }
+}
+/* end javascript for autocomplete */
+
+EOS;
+                define('HTML_QUICKFORM_AUTOCOMPLETE_EXISTS', true);
+            }
+            $jsEscape = array(
+                "\r"    => '\r',
+                "\n"    => '\n',
+                "\t"    => '\t',
+                "'"     => "\\'",
+                '"'     => '\"',
+                '\\'    => '\\\\'
+            );
+
+            $js .= $this->_js;
+            $js .= 'var ' . $arrayName . " = new Array();\n";
+            for ($i = 0; $i < count($this->_options); $i++) {
+                $js .= $arrayName . '[' . $i . "] = '" . strtr($this->_options[$i], $jsEscape) . "';\n";
+            }
+            $js .= "//]]>\n</script>";
+        }
+        return $js . parent::toHtml();
+    }// end func toHtml
+
+    // }}}
+} // end class HTML_QuickForm_autocomplete
+?>
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/button.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/button.php
new file mode 100644 (file)
index 0000000..e658cd4
--- /dev/null
@@ -0,0 +1,80 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * HTML class for an <input type="button" /> elements
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * Base class for <input /> form elements
+ */
+require_once 'HTML/QuickForm/input.php';
+
+/**
+ * HTML class for an <input type="button" /> elements
+ * 
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @version     Release: 3.2.16
+ * @since       1.0
+ */
+class HTML_QuickForm_button extends HTML_QuickForm_input
+{
+    // {{{ constructor
+
+    /**
+     * Class constructor
+     * 
+     * @param     string    $elementName    (optional)Input field name attribute
+     * @param     string    $value          (optional)Input field value
+     * @param     mixed     $attributes     (optional)Either a typical HTML attribute string 
+     *                                      or an associative array
+     * @since     1.0
+     * @access    public
+     * @return    void
+     */
+    function HTML_QuickForm_button($elementName=null, $value=null, $attributes=null)
+    {
+        HTML_QuickForm_input::HTML_QuickForm_input($elementName, null, $attributes);
+        $this->_persistantFreeze = false;
+        $this->setValue($value);
+        $this->setType('button');
+    } //end constructor
+    
+    // }}}
+    // {{{ freeze()
+
+    /**
+     * Freeze the element so that only its value is returned
+     * 
+     * @access    public
+     * @return    void
+     */
+    function freeze()
+    {
+        return false;
+    } //end func freeze
+
+    // }}}
+} //end class HTML_QuickForm_button
+?>
diff --git a/cookbooks/dmca/files/default/html/HTML/QuickForm/checkbox.php b/cookbooks/dmca/files/default/html/HTML/QuickForm/checkbox.php
new file mode 100644 (file)
index 0000000..0bebe08
--- /dev/null
@@ -0,0 +1,277 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * HTML class for a checkbox type field
+ * 
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.01 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_01.txt If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @author      Alexey Borzov <avb@php.net>
+ * @copyright   2001-2011 The PHP Group
+ * @license     http://www.php.net/license/3_01.txt PHP License 3.01
+ * @version     CVS: $Id$
+ * @link        http://pear.php.net/package/HTML_QuickForm
+ */
+
+/**
+ * Base class for <input /> form elements
+ */
+require_once 'HTML/QuickForm/input.php';
+
+/**
+ * HTML class for a checkbox type field
+ * 
+ * @category    HTML
+ * @package     HTML_QuickForm
+ * @author      Adam Daniel <adaniel1@eesus.jnj.com>
+ * @author      Bertrand Mansion <bmansion@mamasam.com>
+ * @author      Alexey Borzov <avb@php.net>
+ * @version     Release: 3.2.16
+ * @since       1.0
+ */
+class HTML_QuickForm_checkbox extends HTML_QuickForm_input
+{
+    // {{{ properties
+
+    /**
+     * Checkbox display text
+     * @var       string
+     * @since     1.1
+     * @access    private
+     */
+    var $_text = '';
+
+    // }}}
+    // {{{ constructor
+
+    /**
+     * Class constructor
+     * 
+     * @param     string    $elementName    (optional)Input field name attribute
+     * @param     string    $elementLabel   (optional)Input field value
+     * @param     string    $text           (optional)Checkbox display text
+     * @param     mixed     $attributes     (optional)Either a typical HTML attribute string 
+     *                &nb