| /branches/livraison_aha/api/pear/HTML/Table.php |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| /branches/livraison_aha/api/pear/HTML/Table.php |
|---|
| New file |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /branches/livraison_aha/api/pear/HTML/Common.php |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| /branches/livraison_aha/api/pear/HTML/Common.php |
|---|
| New file |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /branches/livraison_aha/api/pear/HTML/QuickForm/html.php |
|---|
| New file |
| 0,0 → 1,67 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Author: Alexey Borzov <borz_off@cs.msu.su> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: html.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once 'HTML/QuickForm/static.php'; |
| /** |
| * A pseudo-element used for adding raw HTML to form |
| * |
| * Intended for use with the default renderer only, template-based |
| * ones may (and probably will) completely ignore this |
| * |
| * @author Alexey Borzov <borz_off@cs.msu.su> |
| * @access public |
| */ |
| class HTML_QuickForm_html extends HTML_QuickForm_static |
| { |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @param string $text raw HTML to add |
| * @access public |
| * @return void |
| */ |
| function HTML_QuickForm_html($text = null) |
| { |
| $this->HTML_QuickForm_static(null, null, $text); |
| $this->_type = 'html'; |
| } |
| // }}} |
| // {{{ accept() |
| /** |
| * Accepts a renderer |
| * |
| * @param object An HTML_QuickForm_Renderer object |
| * @access public |
| * @return void |
| */ |
| function accept(&$renderer) |
| { |
| $renderer->renderHtml($this); |
| } // end func accept |
| // }}} |
| } //end class HTML_QuickForm_header |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/Renderer.php |
|---|
| New file |
| 0,0 → 1,150 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Author: Alexey Borzov <borz_off@cs.msu.su> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: Renderer.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| /** |
| * An abstract base class for QuickForm renderers |
| * |
| * The class implements a Visitor design pattern |
| * |
| * @abstract |
| * @author Alexey Borzov <borz_off@cs.msu.su> |
| */ |
| class HTML_QuickForm_Renderer |
| { |
| /** |
| * Constructor |
| * |
| * @access public |
| */ |
| function HTML_QuickForm_Renderer() |
| { |
| } // end constructor |
| /** |
| * Called when visiting a form, before processing any form elements |
| * |
| * @param object An HTML_QuickForm object 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 object An HTML_QuickForm object being visited |
| * @access public |
| * @return void |
| * @abstract |
| */ |
| function finishForm(&$form) |
| { |
| return; |
| } // end func finishForm |
| /** |
| * Called when visiting a header element |
| * |
| * @param object An HTML_QuickForm_header element being visited |
| * @access public |
| * @return void |
| * @abstract |
| */ |
| function renderHeader(&$header) |
| { |
| return; |
| } // end func renderHeader |
| /** |
| * 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 |
| * @abstract |
| */ |
| function renderElement(&$element, $required, $error) |
| { |
| return; |
| } // end func renderElement |
| /** |
| * Called when visiting a hidden element |
| * |
| * @param object An HTML_QuickForm_hidden object being visited |
| * @access public |
| * @return void |
| * @abstract |
| */ |
| function renderHidden(&$element) |
| { |
| return; |
| } // end func renderHidden |
| /** |
| * Called when visiting a raw HTML/text pseudo-element |
| * |
| * Seems that this should not be used when using a template-based renderer |
| * |
| * @param object An HTML_QuickForm_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 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 |
| * @abstract |
| */ |
| function startGroup(&$group, $required, $error) |
| { |
| return; |
| } // 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 |
| * @abstract |
| */ |
| function finishGroup(&$group) |
| { |
| return; |
| } // end func finishGroup |
| } // end class HTML_QuickForm_Renderer |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/Rule.php |
|---|
| New file |
| 0,0 → 1,67 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: Rule.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| 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 |
| * |
| * @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 |
| */ |
| function getValidationScript($options = null) |
| { |
| return array('', ''); |
| } |
| } |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/button.php |
|---|
| New file |
| 0,0 → 1,73 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: button.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once("HTML/QuickForm/input.php"); |
| /** |
| * HTML class for a button type element |
| * |
| * @author Adam Daniel <adaniel1@eesus.jnj.com> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.1 |
| * @since PHP4.04pl1 |
| * @access public |
| */ |
| 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 |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/textarea.php |
|---|
| New file |
| 0,0 → 1,222 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: textarea.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once("HTML/QuickForm/element.php"); |
| /** |
| * HTML class for a textarea type field |
| * |
| * @author Adam Daniel <adaniel1@eesus.jnj.com> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.0 |
| * @since PHP4.04pl1 |
| * @access public |
| */ |
| class HTML_QuickForm_textarea extends HTML_QuickForm_element |
| { |
| // {{{ properties |
| /** |
| * Field value |
| * @var string |
| * @since 1.0 |
| * @access private |
| */ |
| var $_value = null; |
| // }}} |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @param string Input field name attribute |
| * @param mixed Label(s) for a field |
| * @param mixed Either a typical HTML attribute string or an associative array |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function HTML_QuickForm_textarea($elementName=null, $elementLabel=null, $attributes=null) |
| { |
| HTML_QuickForm_element::HTML_QuickForm_element($elementName, $elementLabel, $attributes); |
| $this->_persistantFreeze = true; |
| $this->_type = 'textarea'; |
| } //end constructor |
| // }}} |
| // {{{ setName() |
| /** |
| * Sets the input field name |
| * |
| * @param string $name Input field name attribute |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setName($name) |
| { |
| $this->updateAttributes(array('name'=>$name)); |
| } //end func setName |
| // }}} |
| // {{{ getName() |
| /** |
| * Returns the element name |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function getName() |
| { |
| return $this->getAttribute('name'); |
| } //end func getName |
| // }}} |
| // {{{ setValue() |
| /** |
| * Sets value for textarea element |
| * |
| * @param string $value Value for textarea element |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setValue($value) |
| { |
| $this->_value = $value; |
| } //end func setValue |
| // }}} |
| // {{{ getValue() |
| /** |
| * Returns the value of the form element |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function getValue() |
| { |
| return $this->_value; |
| } // end func getValue |
| // }}} |
| // {{{ setWrap() |
| /** |
| * Sets wrap type for textarea element |
| * |
| * @param string $wrap Wrap type |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setWrap($wrap) |
| { |
| $this->updateAttributes(array('wrap' => $wrap)); |
| } //end func setWrap |
| // }}} |
| // {{{ setRows() |
| /** |
| * Sets height in rows for textarea element |
| * |
| * @param string $rows Height expressed in rows |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setRows($rows) |
| { |
| $this->updateAttributes(array('rows' => $rows)); |
| } //end func setRows |
| // }}} |
| // {{{ setCols() |
| /** |
| * Sets width in cols for textarea element |
| * |
| * @param string $cols Width expressed in cols |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setCols($cols) |
| { |
| $this->updateAttributes(array('cols' => $cols)); |
| } //end func setCols |
| // }}} |
| // {{{ toHtml() |
| /** |
| * Returns the textarea element in HTML |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function toHtml() |
| { |
| if ($this->_flagFrozen) { |
| return $this->getFrozenHtml(); |
| } else { |
| return $this->_getTabs() . |
| '<textarea' . $this->_getAttrString($this->_attributes) . '>' . |
| // because we wrap the form later we don't want the text indented |
| preg_replace("/(\r\n|\n|\r)/", '
', htmlspecialchars($this->_value)) . |
| '</textarea>'; |
| } |
| } //end func toHtml |
| // }}} |
| // {{{ getFrozenHtml() |
| /** |
| * Returns the value of field without HTML tags (in this case, value is changed to a mask) |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function getFrozenHtml() |
| { |
| $value = htmlspecialchars($this->getValue()); |
| if ($this->getAttribute('wrap') == 'off') { |
| $html = $this->_getTabs() . '<pre>' . $value."</pre>\n"; |
| } else { |
| $html = nl2br($value)."\n"; |
| } |
| return $html . $this->_getPersistantData(); |
| } //end func getFrozenHtml |
| // }}} |
| } //end class HTML_QuickForm_textarea |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/date.php |
|---|
| New file |
| 0,0 → 1,484 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP Version 4 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Alexey Borzov <avb@php.net> | |
| // | Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: date.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once 'HTML/QuickForm/group.php'; |
| require_once 'HTML/QuickForm/select.php'; |
| /** |
| * Class for a group of elements used to input dates (and times). |
| * |
| * Inspired by original 'date' element but reimplemented as a subclass |
| * of HTML_QuickForm_group |
| * |
| * @author Alexey Borzov <avb@php.net> |
| * @access public |
| */ |
| class HTML_QuickForm_date extends HTML_QuickForm_group |
| { |
| // {{{ properties |
| /** |
| * Various options to control the element's display. |
| * |
| * Currently known options are |
| * 'language': date language |
| * 'format': Format of the date, based on PHP's date() function. |
| * The following characters are recognised in format string: |
| * D => Short names of days |
| * l => Long names of days |
| * d => Day numbers |
| * M => Short names of months |
| * F => Long names of months |
| * m => Month numbers |
| * Y => Four digit year |
| * y => Two digit year |
| * h => 12 hour format |
| * H => 23 hour format |
| * i => Minutes |
| * s => Seconds |
| * a => am/pm |
| * A => AM/PM |
| * 'minYear': Minimum year in year select |
| * 'maxYear': Maximum year in year select |
| * 'addEmptyOption': Should an empty option be added to the top of |
| * each select box? |
| * 'emptyOptionValue': The value passed by the empty option. |
| * 'emptyOptionText': The text displayed for the empty option. |
| * 'optionIncrement': Step to increase the option values by (works for 'i' and 's') |
| * |
| * @access private |
| * @var array |
| */ |
| var $_options = array( |
| 'language' => 'en', |
| 'format' => 'dMY', |
| 'minYear' => 2001, |
| 'maxYear' => 2010, |
| 'addEmptyOption' => false, |
| 'emptyOptionValue' => '', |
| 'emptyOptionText' => ' ', |
| 'optionIncrement' => array('i' => 1, 's' => 1) |
| ); |
| /** |
| * These complement separators, they are appended to the resultant HTML |
| * @access private |
| * @var array |
| */ |
| var $_wrap = array('', ''); |
| /** |
| * Options in different languages |
| * |
| * Note to potential translators: to avoid encoding problems please send |
| * your translations with "weird" letters encoded as HTML Unicode entities |
| * |
| * @access private |
| * @var array |
| */ |
| var $_locale = array( |
| 'en' => array ( |
| 'weekdays_short'=> array ('Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'), |
| 'weekdays_long' => array ('Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'), |
| 'months_short' => array ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'), |
| 'months_long' => array ('January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December') |
| ), |
| 'de' => array ( |
| 'weekdays_short'=> array ('So', 'Mon', 'Di', 'Mi', 'Do', 'Fr', 'Sa'), |
| 'weekdays_long' => array ('Sonntag', 'Montag', 'Dienstag', 'Mittwoch', 'Donnerstag', 'Freitag', 'Samstag'), |
| 'months_short' => array ('Jan', 'Feb', 'März', 'April', 'Mai', 'Juni', 'Juli', 'Aug', 'Sept', 'Okt', 'Nov', 'Dez'), |
| 'months_long' => array ('Januar', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Dezember') |
| ), |
| 'fr' => array ( |
| 'weekdays_short'=> array ('Dim', 'Lun', 'Mar', 'Mer', 'Jeu', 'Ven', 'Sam'), |
| 'weekdays_long' => array ('Dimanche', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi'), |
| 'months_short' => array ('Jan', 'Fév', 'Mar', 'Avr', 'Mai', 'Juin', 'Juil', 'Août', 'Sep', 'Oct', 'Nov', 'Déc'), |
| 'months_long' => array ('Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet', 'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre') |
| ), |
| 'hu' => array ( |
| 'weekdays_short'=> array ('V', 'H', 'K', 'Sze', 'Cs', 'P', 'Szo'), |
| 'weekdays_long' => array ('vasárnap', 'hétfő', 'kedd', 'szerda', 'csütörtök', 'péntek', 'szombat'), |
| 'months_short' => array ('jan', 'feb', 'márc', 'ápr', 'máj', 'jún', 'júl', 'aug', 'szept', 'okt', 'nov', 'dec'), |
| 'months_long' => array ('január', 'február', 'március', 'április', 'május', 'június', 'július', 'augusztus', 'szeptember', 'október', 'november', 'december') |
| ), |
| 'pl' => array ( |
| 'weekdays_short'=> array ('Nie', 'Pn', 'Wt', 'Śr', 'Czw', 'Pt', 'Sob'), |
| 'weekdays_long' => array ('Niedziela', 'Poniedziałek', 'Wtorek', 'Środa', 'Czwartek', 'Piątek', 'Sobota'), |
| 'months_short' => array ('Sty', 'Lut', 'Mar', 'Kwi', 'Maj', 'Cze', 'Lip', 'Sie', 'Wrz', 'Paź', 'Lis', 'Gru'), |
| 'months_long' => array ('Styczeń', 'Luty', 'Marzec', 'Kwiecień', 'Maj', 'Czerwiec', 'Lipiec', 'Sierpień', 'Wrzesień', 'Październik', 'Listopad', 'Grudzień') |
| ), |
| 'sl' => array ( |
| 'weekdays_short'=> array ('Ned', 'Pon', 'Tor', 'Sre', 'Cet', 'Pet', 'Sob'), |
| 'weekdays_long' => array ('Nedelja', 'Ponedeljek', 'Torek', 'Sreda', 'Cetrtek', 'Petek', 'Sobota'), |
| 'months_short' => array ('Jan', 'Feb', 'Mar', 'Apr', 'Maj', 'Jun', 'Jul', 'Avg', 'Sep', 'Okt', 'Nov', 'Dec'), |
| 'months_long' => array ('Januar', 'Februar', 'Marec', 'April', 'Maj', 'Junij', 'Julij', 'Avgust', 'September', 'Oktober', 'November', 'December') |
| ), |
| 'ru' => array ( |
| 'weekdays_short'=> array ('Вс', 'Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб'), |
| 'weekdays_long' => array ('Воскресенье', 'Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота'), |
| 'months_short' => array ('Янв', 'Фев', 'Мар', 'Апр', 'Май', 'Июн', 'Июл', 'Авг', 'Сен', 'Окт', 'Ноя', 'Дек'), |
| 'months_long' => array ('Январь', 'Февраль', 'Март', 'Апрель', 'Май', 'Июнь', 'Июль', 'Август', 'Сентябрь', 'Октябрь', 'Ноябрь', 'Декабрь') |
| ), |
| 'es' => array ( |
| 'weekdays_short'=> array ('Dom', 'Lun', 'Mar', 'Mié', 'Jue', 'Vie', 'Sáb'), |
| 'weekdays_long' => array ('Domingo', 'Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado'), |
| 'months_short' => array ('Ene', 'Feb', 'Mar', 'Abr', 'May', 'Jun', 'Jul', 'Ago', 'Sep', 'Oct', 'Nov', 'Dic'), |
| 'months_long' => array ('Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre') |
| ), |
| 'da' => array ( |
| 'weekdays_short'=> array ('Søn', 'Man', 'Tir', 'Ons', 'Tor', 'Fre', 'Lør'), |
| 'weekdays_long' => array ('Søndag', 'Mandag', 'Tirsdag', 'Onsdag', 'Torsdag', 'Fredag', 'Lørdag'), |
| 'months_short' => array ('Jan', 'Feb', 'Mar', 'Apr', 'Maj', 'Jun', 'Jul', 'Aug', 'Sep', 'Okt', 'Nov', 'Dec'), |
| 'months_long' => array ('Januar', 'Februar', 'Marts', 'April', 'Maj', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'December') |
| ), |
| 'is' => array ( |
| 'weekdays_short'=> array ('Sun', 'Mán', 'Þri', 'Mið', 'Fim', 'Fös', 'Lau'), |
| 'weekdays_long' => array ('Sunnudagur', 'Mánudagur', 'Þriðjudagur', 'Miðvikudagur', 'Fimmtudagur', 'Föstudagur', 'Laugardagur'), |
| 'months_short' => array ('Jan', 'Feb', 'Mar', 'Apr', 'Maí', 'Jún', 'Júl', 'Ágú', 'Sep', 'Okt', 'Nóv', 'Des'), |
| 'months_long' => array ('Janúar', 'Febrúar', 'Mars', 'Apríl', 'Maí', 'Júní', 'Júlí', 'Ágúst', 'September', 'Október', 'Nóvember', 'Desember') |
| ), |
| 'it' => array ( |
| 'weekdays_short'=> array ('Dom', 'Lun', 'Mar', 'Mer', 'Gio', 'Ven', 'Sab'), |
| 'weekdays_long' => array ('Domenica', 'Lunedì', 'Martedì', 'Mercoledì', 'Giovedì', 'Venerdì', 'Sabato'), |
| 'months_short' => array ('Gen', 'Feb', 'Mar', 'Apr', 'Mag', 'Giu', 'Lug', 'Ago', 'Set', 'Ott', 'Nov', 'Dic'), |
| 'months_long' => array ('Gennaio', 'Febbraio', 'Marzo', 'Aprile', 'Maggio', 'Giugno', 'Luglio', 'Agosto', 'Settembre', 'Ottobre', 'Novembre', 'Dicembre') |
| ), |
| 'sk' => array ( |
| 'weekdays_short'=> array ('Ned', 'Pon', 'Uto', 'Str', 'Štv', 'Pia', 'Sob'), |
| 'weekdays_long' => array ('Nedeža', 'Pondelok', 'Utorok', 'Streda', 'Štvrtok', 'Piatok', 'Sobota'), |
| 'months_short' => array ('Jan', 'Feb', 'Mar', 'Apr', 'Máj', 'Jún', 'Júl', 'Aug', 'Sep', 'Okt', 'Nov', 'Dec'), |
| 'months_long' => array ('Január', 'Február', 'Marec', 'Apríl', 'Máj', 'Jún', 'Júl', 'August', 'September', 'Október', 'November', 'December') |
| ), |
| 'cs' => array ( |
| 'weekdays_short'=> array ('Ne', 'Po', 'Út', 'St', 'Čt', 'Pá', 'So'), |
| 'weekdays_long' => array ('Neděle', 'Pondělí', 'Úterý', 'Středa', 'Čtvrtek', 'Pátek', 'Sobota'), |
| 'months_short' => array ('Led', 'Úno', 'Bře', 'Dub', 'Kvě', 'Čen', 'Čec', 'Srp', 'Zář', 'Říj', 'Lis', 'Pro'), |
| 'months_long' => array ('Leden', 'Únor', 'Březen', 'Duben', 'Květen', 'Červen', 'Červenec', 'Srpen', 'Září', 'Říjen', 'Listopad', 'Prosinec') |
| ), |
| 'hy' => array ( |
| 'weekdays_short'=> array ('Կրկ', 'Երկ', 'Երք', 'Չրք', 'Հնգ', 'Ուր', 'Շբթ'), |
| 'weekdays_long' => array ('Կիրակի', 'Երկուշաբթի', 'Երեքշաբթի', 'Չորեքշաբթի', 'Հինգշաբթի', 'Ուրբաթ', 'Շաբաթ'), |
| 'months_short' => array ('Հնվ', 'Փտր', 'Մրտ', 'Ապր', 'Մյս', 'Հնս', 'Հլս', 'Օգս', 'Սպտ', 'Հկտ', 'Նյմ', 'Դկտ'), |
| 'months_long' => array ('Հունվար', 'Փետրվար', 'Մարտ', 'Ապրիլ', 'Մայիս', 'Հունիս', 'Հուլիս', 'Օգոստոս', 'Սեպտեմբեր', 'Հոկտեմբեր', 'Նոյեմբեր', 'Դեկտեմբեր') |
| ), |
| 'nl' => array ( |
| 'weekdays_short'=> array ('Zo', 'Ma', 'Di', 'Wo', 'Do', 'Vr', 'Za'), |
| 'weekdays_long' => array ('Zondag', 'Maandag', 'Dinsdag', 'Woensdag', 'Donderdag', 'Vrijdag', 'Zaterdag'), |
| 'months_short' => array ('Jan', 'Feb', 'Mar', 'Apr', 'Mei', 'Jun', 'Jul', 'Aug', 'Sep', 'Okt', 'Nov', 'Dec'), |
| 'months_long' => array ('Januari', 'Februari', 'Maart', 'April', 'Mei', 'Juni', 'Juli', 'Augustus', 'September', 'Oktober', 'November', 'December') |
| ), |
| 'et' => array ( |
| 'weekdays_short'=> array ('P', 'E', 'T', 'K', 'N', 'R', 'L'), |
| 'weekdays_long' => array ('Pühapäev', 'Esmaspäev', 'Teisipäev', 'Kolmapäev', 'Neljapäev', 'Reede', 'Laupäev'), |
| 'months_short' => array ('Jaan', 'Veebr', 'Märts', 'Aprill', 'Mai', 'Juuni', 'Juuli', 'Aug', 'Sept', 'Okt', 'Nov', 'Dets'), |
| 'months_long' => array ('Jaanuar', 'Veebruar', 'Märts', 'Aprill', 'Mai', 'Juuni', 'Juuli', 'August', 'September', 'Oktoober', 'November', 'Detsember') |
| ), |
| 'tr' => array ( |
| 'weekdays_short'=> array ('Paz', 'Pzt', 'Sal', 'Çar', 'Per', 'Cum', 'Cts'), |
| 'weekdays_long' => array ('Pazar', 'Pazartesi', 'Salı', 'Çarşamba', 'Perşembe', 'Cuma', 'Cumartesi'), |
| 'months_short' => array ('Ock', 'Şbt', 'Mrt', 'Nsn', 'Mys', 'Hzrn', 'Tmmz', 'Ağst', 'Eyl', 'Ekm', 'Ksm', 'Arlk'), |
| 'months_long' => array ('Ocak', 'Şubat', 'Mart', 'Nisan', 'Mayıs', 'Haziran', 'Temmuz', 'Ağustos', 'Eylül', 'Ekim', 'Kasım', 'Aralık') |
| ), |
| 'no' => array ( |
| 'weekdays_short'=> array ('Søn', 'Man', 'Tir', 'Ons', 'Tor', 'Fre', 'Lør'), |
| 'weekdays_long' => array ('Søndag', 'Mandag', 'Tirsdag', 'Onsdag', 'Torsdag', 'Fredag', 'Lørdag'), |
| 'months_short' => array ('Jan', 'Feb', 'Mar', 'Apr', 'Mai', 'Jun', 'Jul', 'Aug', 'Sep', 'Okt', 'Nov', 'Des'), |
| 'months_long' => array ('Januar', 'Februar', 'Mars', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Desember') |
| ), |
| 'eo' => array ( |
| 'weekdays_short'=> array ('Dim', 'Lun', 'Mar', 'Mer', 'Ĵaŭ', 'Ven', 'Sab'), |
| 'weekdays_long' => array ('Dimanĉo', 'Lundo', 'Mardo', 'Merkredo', 'Ĵaŭdo', 'Vendredo', 'Sabato'), |
| 'months_short' => array ('Jan', 'Feb', 'Mar', 'Apr', 'Maj', 'Jun', 'Jul', 'Aŭg', 'Sep', 'Okt', 'Nov', 'Dec'), |
| 'months_long' => array ('Januaro', 'Februaro', 'Marto', 'Aprilo', 'Majo', 'Junio', 'Julio', 'Aŭgusto', 'Septembro', 'Oktobro', 'Novembro', 'Decembro') |
| ), |
| 'ua' => array ( |
| 'weekdays_short'=> array('Ндл', 'Пнд', 'Втр', 'Срд', 'Чтв', 'Птн', 'Сбт'), |
| 'weekdays_long' => array('Неділя', 'Понеділок', 'Вівторок', 'Середа', 'Четвер', 'П\'ятниця', 'Субота'), |
| 'months_short' => array('Січ', 'Лют', 'Бер', 'Кві', 'Тра', 'Чер', 'Лип', 'Сер', 'Вер', 'Жов', 'Лис', 'Гру'), |
| 'months_long' => array('Січень', 'Лютий', 'Березень', 'Квітень', 'Травень', 'Червень', 'Липень', 'Серпень', 'Вересень', 'Жовтень', 'Листопад', 'Грудень') |
| ), |
| 'ro' => array ( |
| 'weekdays_short'=> array ('Dum', 'Lun', 'Mar', 'Mie', 'Joi', 'Vin', 'Sam'), |
| 'weekdays_long' => array ('Duminica', 'Luni', 'Marti', 'Miercuri', 'Joi', 'Vineri', 'Sambata'), |
| 'months_short' => array ('Ian', 'Feb', 'Mar', 'Apr', 'Mai', 'Iun', 'Iul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'), |
| 'months_long' => array ('Ianuarie', 'Februarie', 'Martie', 'Aprilie', 'Mai', 'Iunie', 'Iulie', 'August', 'Septembrie', 'Octombrie', 'Noiembrie', 'Decembrie') |
| ), |
| 'he' => array ( |
| 'weekdays_short'=> array ('ראשון', 'שני', 'שלישי', 'רביעי', 'חמישי', 'שישי', 'שבת'), |
| 'weekdays_long' => array ('יום ראשון', 'יום שני', 'יום שלישי', 'יום רביעי', 'יום חמישי', 'יום שישי', 'שבת'), |
| 'months_short' => array ('ינואר', 'פברואר', 'מרץ', 'אפריל', 'מאי', 'יוני', 'יולי', 'אוגוסט', 'ספטמבר', 'אוקטובר', 'נובמבר', 'דצמבר'), |
| 'months_long' => array ('ינואר', 'פברואר', 'מרץ', 'אפריל', 'מאי', 'יוני', 'יולי', 'אוגוסט', 'ספטמבר', 'אוקטובר', 'נובמבר', 'דצמבר') |
| ), |
| 'sv' => array ( |
| 'weekdays_short'=> array ('Sön', 'Mån', 'Tis', 'Ons', 'Tor', 'Fre', 'Lör'), |
| 'weekdays_long' => array ('Söndag', 'Måndag', 'Tisdag', 'Onsdag', 'Torsdag', 'Fredag', 'Lördag'), |
| 'months_short' => array ('Jan', 'Feb', 'Mar', 'Apr', 'Maj', 'Jun', 'Jul', 'Aug', 'Sep', 'Okt', 'Nov', 'Dec'), |
| 'months_long' => array ('Januari', 'Februari', 'Mars', 'April', 'Maj', 'Juni', 'Juli', 'Augusti', 'September', 'Oktober', 'November', 'December') |
| ), |
| 'pt' => array ( |
| 'weekdays_short'=> array ('Dom', 'Seg', 'Ter', 'Qua', 'Qui', 'Sex', 'Sáb'), |
| 'weekdays_long' => array ('Domingo', 'Segunda-feira', 'Terça-feira', 'Quarta-feira', 'Quinta-feira', 'Sexta-feira', 'Sábado'), |
| 'months_short' => array ('Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out', 'Nov', 'Dez'), |
| 'months_long' => array ('Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho', 'Julho', 'Agosto', 'Setembro', 'Outubro', 'Novembro', 'Dezembro') |
| ) |
| ); |
| // }}} |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @access public |
| * @param string Element's name |
| * @param mixed Label(s) for an element |
| * @param array Options to control the element's display |
| * @param mixed Either a typical HTML attribute string or an associative array |
| */ |
| function HTML_QuickForm_date($elementName = null, $elementLabel = null, $options = array(), $attributes = null) |
| { |
| $this->HTML_QuickForm_element($elementName, $elementLabel, $attributes); |
| $this->_persistantFreeze = true; |
| $this->_appendName = true; |
| $this->_type = 'date'; |
| // set the options, do not bother setting bogus ones |
| if (is_array($options)) { |
| foreach ($options as $name => $value) { |
| if ('language' == $name) { |
| $this->_options['language'] = isset($this->_locale[$value])? $value: 'en'; |
| } elseif (isset($this->_options[$name])) { |
| if (is_array($value)) { |
| $this->_options[$name] = @array_merge($this->_options[$name], $value); |
| } else { |
| $this->_options[$name] = $value; |
| } |
| } |
| } |
| } |
| } |
| // }}} |
| // {{{ _createElements() |
| function _createElements() |
| { |
| $this->_separator = $this->_elements = array(); |
| $separator = ''; |
| $locale =& $this->_locale[$this->_options['language']]; |
| $backslash = false; |
| for ($i = 0, $length = strlen($this->_options['format']); $i < $length; $i++) { |
| $sign = $this->_options['format']{$i}; |
| if ($backslash) { |
| $backslash = false; |
| $separator .= $sign; |
| } else { |
| $loadSelect = true; |
| switch ($sign) { |
| case 'D': |
| // Sunday is 0 like with 'w' in date() |
| $options = $locale['weekdays_short']; |
| break; |
| case 'l': |
| $options = $locale['weekdays_long']; |
| break; |
| case 'd': |
| $options = $this->_createOptionList(1, 31); |
| break; |
| case 'M': |
| $options = $locale['months_short']; |
| array_unshift($options , ''); |
| unset($options[0]); |
| break; |
| case 'm': |
| $options = $this->_createOptionList(1, 12); |
| break; |
| case 'F': |
| $options = $locale['months_long']; |
| array_unshift($options , ''); |
| unset($options[0]); |
| break; |
| case 'Y': |
| $options = $this->_createOptionList( |
| $this->_options['minYear'], |
| $this->_options['maxYear'], |
| $this->_options['minYear'] > $this->_options['maxYear']? -1: 1 |
| ); |
| break; |
| case 'y': |
| $options = $this->_createOptionList( |
| $this->_options['minYear'], |
| $this->_options['maxYear'], |
| $this->_options['minYear'] > $this->_options['maxYear']? -1: 1 |
| ); |
| array_walk($options, create_function('&$v,$k','$v = substr($v,-2);')); |
| break; |
| case 'h': |
| $options = $this->_createOptionList(1, 12); |
| break; |
| case 'g': |
| $options = $this->_createOptionList(1, 12); |
| array_walk($options, create_function('&$v,$k', '$v = intval($v);')); |
| break; |
| case 'H': |
| $options = $this->_createOptionList(0, 23); |
| break; |
| case 'i': |
| $options = $this->_createOptionList(0, 59, $this->_options['optionIncrement']['i']); |
| break; |
| case 's': |
| $options = $this->_createOptionList(0, 59, $this->_options['optionIncrement']['s']); |
| break; |
| case 'a': |
| $options = array('am' => 'am', 'pm' => 'pm'); |
| break; |
| case 'A': |
| $options = array('AM' => 'AM', 'PM' => 'PM'); |
| break; |
| case 'W': |
| $options = $this->_createOptionList(1, 53); |
| break; |
| case '\\': |
| $backslash = true; |
| $loadSelect = false; |
| break; |
| default: |
| $separator .= (' ' == $sign? ' ': $sign); |
| $loadSelect = false; |
| } |
| if ($loadSelect) { |
| if (0 < count($this->_elements)) { |
| $this->_separator[] = $separator; |
| } else { |
| $this->_wrap[0] = $separator; |
| } |
| $separator = ''; |
| // Should we add an empty option to the top of the select? |
| if (!is_array($this->_options['addEmptyOption']) && $this->_options['addEmptyOption'] || |
| is_array($this->_options['addEmptyOption']) && !empty($this->_options['addEmptyOption'][$sign])) { |
| // Using '+' array operator to preserve the keys |
| if (is_array($this->_options['emptyOptionText']) && !empty($this->_options['emptyOptionText'][$sign])) { |
| $options = array($this->_options['emptyOptionValue'] => $this->_options['emptyOptionText'][$sign]) + $options; |
| } else { |
| $options = array($this->_options['emptyOptionValue'] => $this->_options['emptyOptionText']) + $options; |
| } |
| } |
| $this->_elements[] =& new HTML_QuickForm_select($sign, null, $options, $this->getAttributes()); |
| } |
| } |
| } |
| $this->_wrap[1] = $separator . ($backslash? '\\': ''); |
| } |
| // }}} |
| // {{{ _createOptionList() |
| /** |
| * Creates an option list containing the numbers from the start number to the end, inclusive |
| * |
| * @param int The start number |
| * @param int The end number |
| * @param int Increment by this value |
| * @access private |
| * @return array An array of numeric options. |
| */ |
| function _createOptionList($start, $end, $step = 1) |
| { |
| for ($i = $start, $options = array(); $start > $end? $i >= $end: $i <= $end; $i += $step) { |
| $options[$i] = sprintf('%02d', $i); |
| } |
| return $options; |
| } |
| // }}} |
| // {{{ setValue() |
| function setValue($value) |
| { |
| if (empty($value)) { |
| $value = array(); |
| } elseif (is_scalar($value)) { |
| if (!is_numeric($value)) { |
| $value = strtotime($value); |
| } |
| // might be a unix epoch, then we fill all possible values |
| $arr = explode('-', date('w-d-n-Y-h-H-i-s-a-A-W', (int)$value)); |
| $value = array( |
| 'D' => $arr[0], |
| 'l' => $arr[0], |
| 'd' => $arr[1], |
| 'M' => $arr[2], |
| 'm' => $arr[2], |
| 'F' => $arr[2], |
| 'Y' => $arr[3], |
| 'y' => $arr[3], |
| 'h' => $arr[4], |
| 'g' => $arr[4], |
| 'H' => $arr[5], |
| 'i' => $arr[6], |
| 's' => $arr[7], |
| 'a' => $arr[8], |
| 'A' => $arr[9], |
| 'W' => $arr[10] |
| ); |
| } |
| parent::setValue($value); |
| } |
| // }}} |
| // {{{ toHtml() |
| function toHtml() |
| { |
| include_once('HTML/QuickForm/Renderer/Default.php'); |
| $renderer =& new HTML_QuickForm_Renderer_Default(); |
| $renderer->setElementTemplate('{element}'); |
| parent::accept($renderer); |
| return $this->_wrap[0] . $renderer->toHtml() . $this->_wrap[1]; |
| } |
| // }}} |
| // {{{ accept() |
| function accept(&$renderer, $required = false, $error = null) |
| { |
| $renderer->renderElement($this, $required, $error); |
| } |
| // }}} |
| // {{{ onQuickFormEvent() |
| function onQuickFormEvent($event, $arg, &$caller) |
| { |
| if ('updateValue' == $event) { |
| // we need to call setValue(), 'cause the default/constant value |
| // may be in fact a timestamp, not an array |
| return HTML_QuickForm_element::onQuickFormEvent($event, $arg, $caller); |
| } else { |
| return parent::onQuickFormEvent($event, $arg, $caller); |
| } |
| } |
| // }}} |
| } |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/select.php |
|---|
| New file |
| 0,0 → 1,604 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: select.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once('HTML/QuickForm/element.php'); |
| /** |
| * Class to dynamically create an HTML SELECT |
| * |
| * @author Adam Daniel <adaniel1@eesus.jnj.com> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.0 |
| * @since PHP4.04pl1 |
| * @access public |
| */ |
| class HTML_QuickForm_select extends HTML_QuickForm_element { |
| // {{{ properties |
| /** |
| * Contains the select options |
| * |
| * @var array |
| * @since 1.0 |
| * @access private |
| */ |
| var $_options = array(); |
| /** |
| * Default values of the SELECT |
| * |
| * @var string |
| * @since 1.0 |
| * @access private |
| */ |
| var $_values = null; |
| // }}} |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @param string Select name attribute |
| * @param mixed Label(s) for the select |
| * @param mixed Data to be used to populate options |
| * @param mixed Either a typical HTML attribute string or an associative array |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function HTML_QuickForm_select($elementName=null, $elementLabel=null, $options=null, $attributes=null) |
| { |
| HTML_QuickForm_element::HTML_QuickForm_element($elementName, $elementLabel, $attributes); |
| $this->_persistantFreeze = true; |
| $this->_type = 'select'; |
| if (isset($options)) { |
| $this->load($options); |
| } |
| } //end constructor |
| // }}} |
| // {{{ apiVersion() |
| /** |
| * Returns the current API version |
| * |
| * @since 1.0 |
| * @access public |
| * @return double |
| */ |
| function apiVersion() |
| { |
| return 2.3; |
| } //end func apiVersion |
| // }}} |
| // {{{ setSelected() |
| /** |
| * Sets the default values of the select box |
| * |
| * @param mixed $values Array or comma delimited string of selected values |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setSelected($values) |
| { |
| if (is_string($values) && $this->getMultiple()) { |
| $values = split("[ ]?,[ ]?", $values); |
| } |
| if (is_array($values)) { |
| $this->_values = array_values($values); |
| } else { |
| $this->_values = array($values); |
| } |
| } //end func setSelected |
| // }}} |
| // {{{ getSelected() |
| /** |
| * Returns an array of the selected values |
| * |
| * @since 1.0 |
| * @access public |
| * @return array of selected values |
| */ |
| function getSelected() |
| { |
| return $this->_values; |
| } // end func getSelected |
| // }}} |
| // {{{ setName() |
| /** |
| * Sets the input field name |
| * |
| * @param string $name Input field name attribute |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setName($name) |
| { |
| $this->updateAttributes(array('name' => $name)); |
| } //end func setName |
| // }}} |
| // {{{ getName() |
| /** |
| * Returns the element name |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function getName() |
| { |
| return $this->getAttribute('name'); |
| } //end func getName |
| // }}} |
| // {{{ getPrivateName() |
| /** |
| * Returns the element name (possibly with brackets appended) |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function getPrivateName() |
| { |
| if ($this->getAttribute('multiple')) { |
| return $this->getName() . '[]'; |
| } else { |
| return $this->getName(); |
| } |
| } //end func getPrivateName |
| // }}} |
| // {{{ setValue() |
| /** |
| * Sets the value of the form element |
| * |
| * @param mixed $values Array or comma delimited string of selected values |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setValue($value) |
| { |
| $this->setSelected($value); |
| } // end func setValue |
| // }}} |
| // {{{ getValue() |
| /** |
| * Returns an array of the selected values |
| * |
| * @since 1.0 |
| * @access public |
| * @return array of selected values |
| */ |
| function getValue() |
| { |
| return $this->_values; |
| } // end func getValue |
| // }}} |
| // {{{ setSize() |
| /** |
| * Sets the select field size, only applies to 'multiple' selects |
| * |
| * @param int $size Size of select field |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setSize($size) |
| { |
| $this->updateAttributes(array('size' => $size)); |
| } //end func setSize |
| // }}} |
| // {{{ getSize() |
| /** |
| * Returns the select field size |
| * |
| * @since 1.0 |
| * @access public |
| * @return int |
| */ |
| function getSize() |
| { |
| return $this->getAttribute('size'); |
| } //end func getSize |
| // }}} |
| // {{{ setMultiple() |
| /** |
| * Sets the select mutiple attribute |
| * |
| * @param bool $multiple Whether the select supports multi-selections |
| * @since 1.2 |
| * @access public |
| * @return void |
| */ |
| function setMultiple($multiple) |
| { |
| if ($multiple) { |
| $this->updateAttributes(array('multiple' => 'multiple')); |
| } else { |
| $this->removeAttribute('multiple'); |
| } |
| } //end func setMultiple |
| // }}} |
| // {{{ getMultiple() |
| /** |
| * Returns the select mutiple attribute |
| * |
| * @since 1.2 |
| * @access public |
| * @return bool true if multiple select, false otherwise |
| */ |
| function getMultiple() |
| { |
| return (bool)$this->getAttribute('multiple'); |
| } //end func getMultiple |
| // }}} |
| // {{{ addOption() |
| /** |
| * Adds a new OPTION to the SELECT |
| * |
| * @param string $text Display text for the OPTION |
| * @param string $value Value for the OPTION |
| * @param mixed $attributes Either a typical HTML attribute string |
| * or an associative array |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function addOption($text, $value, $attributes=null) |
| { |
| if (null === $attributes) { |
| $attributes = array('value' => $value); |
| } else { |
| $attributes = $this->_parseAttributes($attributes); |
| if (isset($attributes['selected'])) { |
| // the 'selected' attribute will be set in toHtml() |
| $this->_removeAttr('selected', $attributes); |
| if (is_null($this->_values)) { |
| $this->_values = array($value); |
| } elseif (!in_array($value, $this->_values)) { |
| $this->_values[] = $value; |
| } |
| } |
| $this->_updateAttrArray($attributes, array('value' => $value)); |
| } |
| $this->_options[] = array('text' => $text, 'attr' => $attributes); |
| } // end func addOption |
| // }}} |
| // {{{ loadArray() |
| /** |
| * Loads the options from an associative array |
| * |
| * @param array $arr Associative array of options |
| * @param mixed $values (optional) Array or comma delimited string of selected values |
| * @since 1.0 |
| * @access public |
| * @return PEAR_Error on error or true |
| * @throws PEAR_Error |
| */ |
| function loadArray($arr, $values=null) |
| { |
| if (!is_array($arr)) { |
| return PEAR::raiseError('Argument 1 of HTML_Select::loadArray is not a valid array'); |
| } |
| if (isset($values)) { |
| $this->setSelected($values); |
| } |
| foreach ($arr as $key => $val) { |
| // Warning: new API since release 2.3 |
| $this->addOption($val, $key); |
| } |
| return true; |
| } // end func loadArray |
| // }}} |
| // {{{ loadDbResult() |
| /** |
| * Loads the options from DB_result object |
| * |
| * If no column names are specified the first two columns of the result are |
| * used as the text and value columns respectively |
| * @param object $result DB_result object |
| * @param string $textCol (optional) Name of column to display as the OPTION text |
| * @param string $valueCol (optional) Name of column to use as the OPTION value |
| * @param mixed $values (optional) Array or comma delimited string of selected values |
| * @since 1.0 |
| * @access public |
| * @return PEAR_Error on error or true |
| * @throws PEAR_Error |
| */ |
| function loadDbResult(&$result, $textCol=null, $valueCol=null, $values=null) |
| { |
| if (!is_object($result) || !is_a($result, 'db_result')) { |
| return PEAR::raiseError('Argument 1 of HTML_Select::loadDbResult is not a valid DB_result'); |
| } |
| if (isset($values)) { |
| $this->setValue($values); |
| } |
| $fetchMode = ($textCol && $valueCol) ? DB_FETCHMODE_ASSOC : DB_FETCHMODE_DEFAULT; |
| while (is_array($row = $result->fetchRow($fetchMode)) ) { |
| if ($fetchMode == DB_FETCHMODE_ASSOC) { |
| $this->addOption($row[$textCol], $row[$valueCol]); |
| } else { |
| $this->addOption($row[0], $row[1]); |
| } |
| } |
| return true; |
| } // end func loadDbResult |
| // }}} |
| // {{{ loadQuery() |
| /** |
| * Queries a database and loads the options from the results |
| * |
| * @param mixed $conn Either an existing DB connection or a valid dsn |
| * @param string $sql SQL query string |
| * @param string $textCol (optional) Name of column to display as the OPTION text |
| * @param string $valueCol (optional) Name of column to use as the OPTION value |
| * @param mixed $values (optional) Array or comma delimited string of selected values |
| * @since 1.1 |
| * @access public |
| * @return void |
| * @throws PEAR_Error |
| */ |
| function loadQuery(&$conn, $sql, $textCol=null, $valueCol=null, $values=null) |
| { |
| if (is_string($conn)) { |
| require_once('DB.php'); |
| $dbConn = &DB::connect($conn, true); |
| if (DB::isError($dbConn)) { |
| return $dbConn; |
| } |
| } elseif (is_subclass_of($conn, "db_common")) { |
| $dbConn = &$conn; |
| } else { |
| return PEAR::raiseError('Argument 1 of HTML_Select::loadQuery is not a valid type'); |
| } |
| $result = $dbConn->query($sql); |
| if (DB::isError($result)) { |
| return $result; |
| } |
| $this->loadDbResult($result, $textCol, $valueCol, $values); |
| $result->free(); |
| if (is_string($conn)) { |
| $dbConn->disconnect(); |
| } |
| return true; |
| } // end func loadQuery |
| // }}} |
| // {{{ load() |
| /** |
| * Loads options from different types of data sources |
| * |
| * This method is a simulated overloaded method. The arguments, other than the |
| * first are optional and only mean something depending on the type of the first argument. |
| * If the first argument is an array then all arguments are passed in order to loadArray. |
| * If the first argument is a db_result then all arguments are passed in order to loadDbResult. |
| * If the first argument is a string or a DB connection then all arguments are |
| * passed in order to loadQuery. |
| * @param mixed $options Options source currently supports assoc array or DB_result |
| * @param mixed $param1 (optional) See function detail |
| * @param mixed $param2 (optional) See function detail |
| * @param mixed $param3 (optional) See function detail |
| * @param mixed $param4 (optional) See function detail |
| * @since 1.1 |
| * @access public |
| * @return PEAR_Error on error or true |
| * @throws PEAR_Error |
| */ |
| function load(&$options, $param1=null, $param2=null, $param3=null, $param4=null) |
| { |
| switch (true) { |
| case is_array($options): |
| return $this->loadArray($options, $param1); |
| break; |
| case (is_a($options, 'db_result')): |
| return $this->loadDbResult($options, $param1, $param2, $param3); |
| break; |
| case (is_string($options) && !empty($options) ): |
| return $this->loadQuery($options, $param1, $param2, $param3, $param4); |
| break; |
| } |
| } // end func load |
| // }}} |
| // {{{ toHtml() |
| /** |
| * Returns the SELECT in HTML |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function toHtml() |
| { |
| if ($this->_flagFrozen) { |
| return $this->getFrozenHtml(); |
| } else { |
| $tabs = $this->_getTabs(); |
| $strHtml = ''; |
| if ($this->getComment() != '') { |
| $strHtml .= $tabs . '<!-- ' . $this->getComment() . " //-->\n"; |
| } |
| if (!$this->getMultiple()) { |
| $attrString = $this->_getAttrString($this->_attributes); |
| } else { |
| $myName = $this->getName(); |
| $this->setName($myName . '[]'); |
| $attrString = $this->_getAttrString($this->_attributes); |
| $this->setName($myName); |
| } |
| $strHtml .= $tabs . '<select' . $attrString . ">\n"; |
| foreach ($this->_options as $option) { |
| if (is_array($this->_values) && in_array((string)$option['attr']['value'], $this->_values)) { |
| $this->_updateAttrArray($option['attr'], array('selected' => 'selected')); |
| } |
| $strHtml .= $tabs . "\t<option" . $this->_getAttrString($option['attr']) . '>' . |
| $option['text'] . "</option>\n"; |
| } |
| return $strHtml . $tabs . '</select>'; |
| } |
| } //end func toHtml |
| // }}} |
| // {{{ getFrozenHtml() |
| /** |
| * Returns the value of field without HTML tags |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function getFrozenHtml() |
| { |
| $value = array(); |
| if (is_array($this->_values)) { |
| foreach ($this->_values as $key => $val) { |
| for ($i = 0, $optCount = count($this->_options); $i < $optCount; $i++) { |
| if ((string)$val == (string)$this->_options[$i]['attr']['value']) { |
| $value[$key] = $this->_options[$i]['text']; |
| break; |
| } |
| } |
| } |
| } |
| $html = empty($value)? ' ': join('<br />', $value); |
| if ($this->_persistantFreeze) { |
| $name = $this->getPrivateName(); |
| // Only use id attribute if doing single hidden input |
| if (1 == count($value)) { |
| $id = $this->getAttribute('id'); |
| $idAttr = isset($id)? array('id' => $id): array(); |
| } else { |
| $idAttr = array(); |
| } |
| foreach ($value as $key => $item) { |
| $html .= '<input' . $this->_getAttrString(array( |
| 'type' => 'hidden', |
| 'name' => $name, |
| 'value' => $this->_values[$key] |
| ) + $idAttr) . ' />'; |
| } |
| } |
| return $html; |
| } //end func getFrozenHtml |
| // }}} |
| // {{{ exportValue() |
| /** |
| * We check the options and return only the values that _could_ have been |
| * selected. We also return a scalar value if select is not "multiple" |
| */ |
| function exportValue(&$submitValues, $assoc = false) |
| { |
| $value = $this->_findValue($submitValues); |
| if (is_null($value)) { |
| $value = $this->getValue(); |
| } elseif(!is_array($value)) { |
| $value = array($value); |
| } |
| if (is_array($value) && !empty($this->_options)) { |
| $cleanValue = null; |
| foreach ($value as $v) { |
| for ($i = 0, $optCount = count($this->_options); $i < $optCount; $i++) { |
| if ($v == $this->_options[$i]['attr']['value']) { |
| $cleanValue[] = $v; |
| break; |
| } |
| } |
| } |
| } else { |
| $cleanValue = $value; |
| } |
| if (is_array($cleanValue) && !$this->getMultiple()) { |
| return $this->_prepareValue($cleanValue[0], $assoc); |
| } else { |
| return $this->_prepareValue($cleanValue, $assoc); |
| } |
| } |
| // }}} |
| // {{{ onQuickFormEvent() |
| function onQuickFormEvent($event, $arg, &$caller) |
| { |
| if ('updateValue' == $event) { |
| $value = $this->_findValue($caller->_constantValues); |
| if (null === $value) { |
| $value = $this->_findValue($caller->_submitValues); |
| // Fix for bug #4465 |
| // XXX: should we push this to element::onQuickFormEvent()? |
| if (null === $value && !$caller->isSubmitted()) { |
| $value = $this->_findValue($caller->_defaultValues); |
| } |
| } |
| if (null !== $value) { |
| $this->setValue($value); |
| } |
| return true; |
| } else { |
| return parent::onQuickFormEvent($event, $arg, $caller); |
| } |
| } |
| // }}} |
| } //end class HTML_QuickForm_select |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/file.php |
|---|
| New file |
| 0,0 → 1,346 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: file.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once("HTML/QuickForm/input.php"); |
| // register file-related rules |
| if (class_exists('HTML_QuickForm')) { |
| HTML_QuickForm::registerRule('uploadedfile', 'callback', '_ruleIsUploadedFile', 'HTML_QuickForm_file'); |
| HTML_QuickForm::registerRule('maxfilesize', 'callback', '_ruleCheckMaxFileSize', 'HTML_QuickForm_file'); |
| HTML_QuickForm::registerRule('mimetype', 'callback', '_ruleCheckMimeType', 'HTML_QuickForm_file'); |
| HTML_QuickForm::registerRule('filename', 'callback', '_ruleCheckFileName', 'HTML_QuickForm_file'); |
| } |
| /** |
| * HTML class for a file type element |
| * |
| * @author Adam Daniel <adaniel1@eesus.jnj.com> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.0 |
| * @since PHP4.04pl1 |
| * @access public |
| */ |
| class HTML_QuickForm_file extends HTML_QuickForm_input |
| { |
| // {{{ properties |
| /** |
| * Uploaded file data, from $_FILES |
| * @var array |
| */ |
| var $_value = null; |
| // }}} |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @param string Input field name attribute |
| * @param string Input field label |
| * @param mixed (optional)Either a typical HTML attribute string |
| * or an associative array |
| * @since 1.0 |
| * @access public |
| */ |
| function HTML_QuickForm_file($elementName=null, $elementLabel=null, $attributes=null) |
| { |
| HTML_QuickForm_input::HTML_QuickForm_input($elementName, $elementLabel, $attributes); |
| $this->setType('file'); |
| } //end constructor |
| // }}} |
| // {{{ setSize() |
| /** |
| * Sets size of file element |
| * |
| * @param int Size of file element |
| * @since 1.0 |
| * @access public |
| */ |
| function setSize($size) |
| { |
| $this->updateAttributes(array('size' => $size)); |
| } //end func setSize |
| // }}} |
| // {{{ getSize() |
| /** |
| * Returns size of file element |
| * |
| * @since 1.0 |
| * @access public |
| * @return int |
| */ |
| function getSize() |
| { |
| return $this->getAttribute('size'); |
| } //end func getSize |
| // }}} |
| // {{{ freeze() |
| /** |
| * Freeze the element so that only its value is returned |
| * |
| * @access public |
| * @return bool |
| */ |
| function freeze() |
| { |
| return false; |
| } //end func freeze |
| // }}} |
| // {{{ setValue() |
| /** |
| * Sets value for file element. |
| * |
| * Actually this does nothing. The function is defined here to override |
| * HTML_Quickform_input's behaviour of setting the 'value' attribute. As |
| * no sane user-agent uses <input type="file">'s value for anything |
| * (because of security implications) we implement file's value as a |
| * read-only property with a special meaning. |
| * |
| * @param mixed Value for file element |
| * @since 3.0 |
| * @access public |
| */ |
| function setValue($value) |
| { |
| return null; |
| } //end func setValue |
| // }}} |
| // {{{ getValue() |
| /** |
| * Returns information about the uploaded file |
| * |
| * @since 3.0 |
| * @access public |
| * @return array |
| */ |
| function getValue() |
| { |
| return $this->_value; |
| } // end func getValue |
| // }}} |
| // {{{ onQuickFormEvent() |
| /** |
| * Called by HTML_QuickForm whenever form event is made on this element |
| * |
| * @param string Name of event |
| * @param mixed event arguments |
| * @param object calling object |
| * @since 1.0 |
| * @access public |
| * @return bool |
| */ |
| function onQuickFormEvent($event, $arg, &$caller) |
| { |
| switch ($event) { |
| case 'updateValue': |
| if ($caller->getAttribute('method') == 'get') { |
| return PEAR::raiseError('Cannot add a file upload field to a GET method form'); |
| } |
| $this->_value = $this->_findValue(); |
| $caller->updateAttributes(array('enctype' => 'multipart/form-data')); |
| $caller->setMaxFileSize(); |
| break; |
| case 'addElement': |
| $this->onQuickFormEvent('createElement', $arg, $caller); |
| return $this->onQuickFormEvent('updateValue', null, $caller); |
| break; |
| case 'createElement': |
| $className = get_class($this); |
| $this->$className($arg[0], $arg[1], $arg[2]); |
| break; |
| } |
| return true; |
| } // end func onQuickFormEvent |
| // }}} |
| // {{{ moveUploadedFile() |
| /** |
| * Moves an uploaded file into the destination |
| * |
| * @param string Destination directory path |
| * @param string New file name |
| * @access public |
| */ |
| function moveUploadedFile($dest, $fileName = '') |
| { |
| if ($dest != '' && substr($dest, -1) != '/') { |
| $dest .= '/'; |
| } |
| $fileName = ($fileName != '') ? $fileName : basename($this->_value['name']); |
| if (move_uploaded_file($this->_value['tmp_name'], $dest . $fileName)) { |
| return true; |
| } else { |
| return false; |
| } |
| } // end func moveUploadedFile |
| // }}} |
| // {{{ isUploadedFile() |
| /** |
| * Checks if the element contains an uploaded file |
| * |
| * @access public |
| * @return bool true if file has been uploaded, false otherwise |
| */ |
| function isUploadedFile() |
| { |
| return $this->_ruleIsUploadedFile($this->_value); |
| } // end func isUploadedFile |
| // }}} |
| // {{{ _ruleIsUploadedFile() |
| /** |
| * Checks if the given element contains an uploaded file |
| * |
| * @param array Uploaded file info (from $_FILES) |
| * @access private |
| * @return bool true if file has been uploaded, false otherwise |
| */ |
| function _ruleIsUploadedFile($elementValue) |
| { |
| if ((isset($elementValue['error']) && $elementValue['error'] == 0) || |
| (!empty($elementValue['tmp_name']) && $elementValue['tmp_name'] != 'none')) { |
| return is_uploaded_file($elementValue['tmp_name']); |
| } else { |
| return false; |
| } |
| } // end func _ruleIsUploadedFile |
| // }}} |
| // {{{ _ruleCheckMaxFileSize() |
| /** |
| * Checks that the file does not exceed the max file size |
| * |
| * @param array Uploaded file info (from $_FILES) |
| * @param int Max file size |
| * @access private |
| * @return bool true if filesize is lower than maxsize, false otherwise |
| */ |
| function _ruleCheckMaxFileSize($elementValue, $maxSize) |
| { |
| if (!empty($elementValue['error']) && |
| (UPLOAD_ERR_FORM_SIZE == $elementValue['error'] || UPLOAD_ERR_INI_SIZE == $elementValue['error'])) { |
| return false; |
| } |
| if (!HTML_QuickForm_file::_ruleIsUploadedFile($elementValue)) { |
| return true; |
| } |
| return ($maxSize >= @filesize($elementValue['tmp_name'])); |
| } // end func _ruleCheckMaxFileSize |
| // }}} |
| // {{{ _ruleCheckMimeType() |
| /** |
| * Checks if the given element contains an uploaded file of the right mime type |
| * |
| * @param array Uploaded file info (from $_FILES) |
| * @param mixed Mime Type (can be an array of allowed types) |
| * @access private |
| * @return bool true if mimetype is correct, false otherwise |
| */ |
| function _ruleCheckMimeType($elementValue, $mimeType) |
| { |
| if (!HTML_QuickForm_file::_ruleIsUploadedFile($elementValue)) { |
| return true; |
| } |
| if (is_array($mimeType)) { |
| return in_array($elementValue['type'], $mimeType); |
| } |
| return $elementValue['type'] == $mimeType; |
| } // end func _ruleCheckMimeType |
| // }}} |
| // {{{ _ruleCheckFileName() |
| /** |
| * Checks if the given element contains an uploaded file of the filename regex |
| * |
| * @param array Uploaded file info (from $_FILES) |
| * @param string Regular expression |
| * @access private |
| * @return bool true if name matches regex, false otherwise |
| */ |
| function _ruleCheckFileName($elementValue, $regex) |
| { |
| if (!HTML_QuickForm_file::_ruleIsUploadedFile($elementValue)) { |
| return true; |
| } |
| return preg_match($regex, $elementValue['name']); |
| } // end func _ruleCheckFileName |
| // }}} |
| // {{{ _findValue() |
| /** |
| * Tries to find the element value from the values array |
| * |
| * Needs to be redefined here as $_FILES is populated differently from |
| * other arrays when element name is of the form foo[bar] |
| * |
| * @access private |
| * @return mixed |
| */ |
| function _findValue() |
| { |
| if (empty($_FILES)) { |
| return null; |
| } |
| $elementName = $this->getName(); |
| if (isset($_FILES[$elementName])) { |
| return $_FILES[$elementName]; |
| } elseif (false !== ($pos = strpos($elementName, '['))) { |
| $base = substr($elementName, 0, $pos); |
| $idx = "['" . str_replace(array(']', '['), array('', "']['"), substr($elementName, $pos + 1, -1)) . "']"; |
| $props = array('name', 'type', 'size', 'tmp_name', 'error'); |
| $code = "if (!isset(\$_FILES['{$base}']['name']{$idx})) {\n" . |
| " return null;\n" . |
| "} else {\n" . |
| " \$value = array();\n"; |
| foreach ($props as $prop) { |
| $code .= " \$value['{$prop}'] = \$_FILES['{$base}']['{$prop}']{$idx};\n"; |
| } |
| return eval($code . " return \$value;\n}\n"); |
| } else { |
| return null; |
| } |
| } |
| // }}} |
| } // end class HTML_QuickForm_file |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/Renderer/Default.php |
|---|
| New file |
| 0,0 → 1,474 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Alexey Borzov <borz_off@cs.msu.su> | |
| // | Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: Default.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once('HTML/QuickForm/Renderer.php'); |
| /** |
| * A concrete renderer for HTML_QuickForm, |
| * based on QuickForm 2.x built-in one |
| * |
| * @access public |
| */ |
| 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 object An HTML_QuickForm 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 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) { |
| $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 object An HTML_QuickForm_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 -->(\s|\S)*<!-- END required -->([ \t\n\r]*)?/i", '', $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 -->(\s|\S)*<!-- END error -->([ \t\n\r]*)?/i", '', $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*/i', '', $html); |
| } |
| return $html; |
| } // end func _prepareTemplate |
| /** |
| * 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) |
| { |
| 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 -->(\s|\S)*<!-- END required -->([ \t\n\r]*)?/i", '', $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 object An HTML_QuickForm_hidden object 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 object An 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 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) |
| { |
| $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 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 = ' '; |
| } |
| $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 |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/Renderer/ITStatic.php |
|---|
| New file |
| 0,0 → 1,490 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Author: Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: ITStatic.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| 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. |
| * |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @access public |
| */ |
| class HTML_QuickForm_Renderer_ITStatic extends HTML_QuickForm_Renderer |
| { |
| /** |
| * 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 object An HTML_Template_IT or other compatible 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 object An HTML_QuickForm 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 object An HTML_QuickForm 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 object An HTML_QuickForm_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 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) |
| { |
| $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 object An HTML_QuickForm_hidden object 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 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) |
| { |
| $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 object An HTML_QuickForm_group object 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 |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/Renderer/Object.php |
|---|
| New file |
| 0,0 → 1,432 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Author: Ron McClain <ron@humaniq.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: Object.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| 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 |
| * |
| * @access public |
| */ |
| class HTML_QuickForm_Renderer_Object extends HTML_QuickForm_Renderer |
| { |
| /** |
| * The object being generated |
| * @var object $_obj |
| */ |
| 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 collecthidden 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 type 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 element object An HTML_QuickForm_element object |
| * @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 elObj object 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. |
| * {form.outputJavaScript():h} |
| * {form.outputHeader():h} |
| * <table> |
| * <tr> |
| * <td>{form.name.label:h}</td><td>{form.name.html:h}</td> |
| * </tr> |
| * </table> |
| * </form> |
| */ |
| 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 <form> header |
| * {form.outputHeader():h} |
| * @return string <form attributes> |
| */ |
| 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. |
| */ |
| 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 |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/Renderer/Array.php |
|---|
| New file |
| 0,0 → 1,319 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Alexey Borzov <borz_off@cs.msu.su> | |
| // | Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // | Thomas Schulz <ths@4bconsult.de> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: Array.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once 'HTML/QuickForm/Renderer.php'; |
| /** |
| * A concrete renderer for HTML_QuickForm, makes an array of form contents |
| * |
| * Based on old toArray() code. |
| * |
| * The form array structure is the following: |
| * 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 |
| * ) |
| * ) |
| * ) |
| * ); |
| * |
| * where element_i is an array of the form: |
| * 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 |
| * ) |
| * ); |
| * |
| * @access public |
| */ |
| class HTML_QuickForm_Renderer_Array extends HTML_QuickForm_Renderer |
| { |
| /** |
| * 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 object An HTML_QuickForm_element object |
| * @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; |
| } |
| } |
| } |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/Renderer/ArraySmarty.php |
|---|
| New file |
| 0,0 → 1,376 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Alexey Borzov <borz_off@cs.msu.su> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // | Thomas Schulz <ths@4bconsult.de> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: ArraySmarty.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once 'HTML/QuickForm/Renderer/Array.php'; |
| /** |
| * A static renderer for HTML_QuickForm, makes an array of form content |
| * useful for an Smarty template |
| * |
| * Based on old toArray() code and ITStatic renderer. |
| * |
| * The form array structure is the following: |
| * 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 |
| * |
| * // where an element array has the form: |
| * ( |
| * [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 |
| * ) |
| * ) |
| * |
| * @access public |
| */ |
| class HTML_QuickForm_Renderer_ArraySmarty extends HTML_QuickForm_Renderer_Array |
| { |
| /** |
| * 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 object 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" |
| * @access public |
| */ |
| function HTML_QuickForm_Renderer_ArraySmarty(&$tpl, $staticLabels = false) |
| { |
| $this->HTML_QuickForm_Renderer_Array(true, $staticLabels); |
| $this->_tpl =& $tpl; |
| } // end constructor |
| /** |
| * Called when visiting a header element |
| * |
| * @param object An HTML_QuickForm_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 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) |
| { |
| 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 object An HTML_QuickForm_element object |
| * @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) { |
| 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 = '[\'' . $matches[1] . '\']' . $sKeysSub; |
| } else { |
| $sKeys = '[\'' . $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 = '[\'' . $ret['name'] . '\']'; |
| } |
| // for radios: add extra key from value |
| if ('radio' == $ret['type'] and substr($sKeys, -2) != '[]') { |
| $sKeys .= '[\'' . $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 |
| } |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/Renderer/ObjectFlexy.php |
|---|
| New file |
| 0,0 → 1,261 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Author: Ron McClain <ron@humaniq.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: ObjectFlexy.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| 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: |
| * $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"); |
| * |
| * Based on the code for HTML_QuickForm_Renderer_ArraySmarty |
| * |
| * @see QuickFormFlexyObject |
| * @access public |
| */ |
| class HTML_QuickForm_Renderer_ObjectFlexy extends HTML_QuickForm_Renderer_Object |
| { |
| /** |
| * 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 $flexy object HTML_Template_Flexy instance |
| * @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 element object An HTML_QuickForm_element object |
| * @param required bool Whether an element is required |
| * @param error 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 = '->{\'' . $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 = '->{\'' . $ret->name . '\'}'; |
| } |
| // for radios: add extra key from value |
| if ('radio' == $ret->type && '[]' != substr($keys, -2)) { |
| $keys .= '->{\'' . $ret->value . '\'}'; |
| } |
| $ret->keys = $keys; |
| $this->_elementIdx++; |
| return $ret; |
| } |
| /** |
| * Stores an object representation of an element in the |
| * QuickformFormObject instance |
| * |
| * @access private |
| * @param elObj object 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. |
| * {if:error} |
| * <font color="red" size="1">{error:h}</font><br /> |
| * {end:} |
| * {html:h} |
| * |
| * @access public |
| * @param template 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. |
| * {if:required} |
| * <font color="orange" size="1">*</font> |
| * {end:} |
| * {label:h} |
| * |
| * @access public |
| * @param template 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 |
| */ |
| class QuickformFlexyForm extends QuickformForm |
| { |
| } |
| /** |
| * Adds nothing to QuickformElement, left for backwards compatibility |
| */ |
| class QuickformFlexyElement extends QuickformElement |
| { |
| } |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/Renderer/ITDynamic.php |
|---|
| New file |
| 0,0 → 1,287 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Author: Alexey Borzov <borz_off@cs.msu.su> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: ITDynamic.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| 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. |
| * |
| * @author Alexey Borzov <borz_off@cs.msu.su> |
| * @access public |
| */ |
| class HTML_QuickForm_Renderer_ITDynamic extends HTML_QuickForm_Renderer |
| { |
| /** |
| * A template class (HTML_Template_ITX or HTML_Template_Sigma) instance |
| * @var object |
| */ |
| 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 object An HTML_Template_ITX/HTML_Template_Sigma 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)? ' ': $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 object An HTML_QuickForm_element object |
| * @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; |
| } |
| } |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/Renderer/QuickHtml.php |
|---|
| New file |
| 0,0 → 1,203 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Jason Rust <jrust@rustyparts.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: QuickHtml.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| 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 |
| * |
| * @access public |
| * @package QuickForm |
| */ |
| 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 |
| */ |
| 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 object An HTML_QuickForm_element object |
| * @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 object An HTML_QuickForm_hidden object 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 object An HTML_QuickForm_group object 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 |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/advcheckbox.php |
|---|
| New file |
| 0,0 → 1,283 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: advcheckbox.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| 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 creating a hidden field with the passed-in name |
| * and creating the checkbox with no name, but with a javascript |
| * onclick which sets the value of the hidden field. |
| * |
| * @author Jason Rust <jrust@php.net> |
| * @since 2.0 |
| * @access public |
| */ |
| 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 pribate name for the element |
| * |
| * @param string $elementName The element name to make private |
| * |
| * @access public |
| * @return string |
| */ |
| 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 |
| */ |
| 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->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 { |
| $oldName = $this->getName(); |
| $oldJs = $this->getAttribute('onclick'); |
| $this->updateAttributes(array( |
| 'name' => $this->getPrivateName($oldName), |
| 'onclick' => $this->getOnclickJs($oldName) . ' ' . $oldJs |
| )); |
| $html = parent::toHtml() . '<input' . |
| $this->_getAttrString(array( |
| 'type' => 'hidden', |
| 'name' => $oldName, |
| 'value' => $this->getValue() |
| )) . ' />'; |
| // revert the name and JS, in case this method will be called once more |
| $this->updateAttributes(array( |
| 'name' => $oldName, |
| 'onclick' => $oldJs |
| )); |
| return $html; |
| } |
| } //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) |
| { |
| $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 |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/Rule/Callback.php |
|---|
| New file |
| 0,0 → 1,113 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: Callback.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once('HTML/QuickForm/Rule.php'); |
| /** |
| * Validates values using callback functions or methods |
| * @version 1.0 |
| */ |
| 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 |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/Rule/Range.php |
|---|
| New file |
| 0,0 → 1,64 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: Range.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once('HTML/QuickForm/Rule.php'); |
| /** |
| * Validates values using range comparison |
| * @version 1.0 |
| */ |
| 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) |
| { |
| $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 |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/Rule/Required.php |
|---|
| New file |
| 0,0 → 1,52 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: Required.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once('HTML/QuickForm/Rule.php'); |
| /** |
| * Required elements validation |
| * @version 1.0 |
| */ |
| 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 ((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 |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/Rule/Compare.php |
|---|
| New file |
| 0,0 → 1,95 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Author: Alexey Borzov <avb@php.net> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: Compare.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| 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 |
| * |
| * @access public |
| * @package HTML_QuickForm |
| * @version $Revision: 1.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 $a ' . $operator . ' $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 = "!({jsVar}[0] {$operator} {jsVar}[1])"; |
| } |
| return array('', "'' != {jsVar}[0] && {$check}"); |
| } |
| } |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/Rule/Email.php |
|---|
| New file |
| 0,0 → 1,61 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: Email.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once('HTML/QuickForm/Rule.php'); |
| /** |
| * Email validation rule |
| * @version 1.0 |
| */ |
| 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) |
| { |
| if (preg_match($this->regex, $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 |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/Rule/Regex.php |
|---|
| New file |
| 0,0 → 1,89 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: Regex.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once('HTML/QuickForm/Rule.php'); |
| /** |
| * Validates values using regular expressions |
| * @version 1.0 |
| */ |
| 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) |
| { |
| if (isset($this->_data[$this->name])) { |
| if (!preg_match($this->_data[$this->name], $value)) { |
| return false; |
| } |
| } else { |
| if (!preg_match($regex, $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; |
| return array(" var regex = " . $regex . ";\n", "{jsVar} != '' && !regex.test({jsVar})"); |
| } // end func getValidationScript |
| } // end class HTML_QuickForm_Rule_Regex |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/image.php |
|---|
| New file |
| 0,0 → 1,119 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: image.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once("HTML/QuickForm/input.php"); |
| /** |
| * HTML class for a image type element |
| * |
| * @author Adam Daniel <adaniel1@eesus.jnj.com> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.0 |
| * @since PHP4.04pl1 |
| * @access public |
| */ |
| class HTML_QuickForm_image extends HTML_QuickForm_input |
| { |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @param string $elementName (optional)Element name attribute |
| * @param string $src (optional)Image source |
| * @param mixed $attributes (optional)Either a typical HTML attribute string |
| * or an associative array |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function HTML_QuickForm_image($elementName=null, $src='', $attributes=null) |
| { |
| HTML_QuickForm_input::HTML_QuickForm_input($elementName, null, $attributes); |
| $this->setType('image'); |
| $this->setSource($src); |
| } // end class constructor |
| // }}} |
| // {{{ setSource() |
| /** |
| * Sets source for image element |
| * |
| * @param string $src source for image element |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setSource($src) |
| { |
| $this->updateAttributes(array('src' => $src)); |
| } // end func setSource |
| // }}} |
| // {{{ setBorder() |
| /** |
| * Sets border size for image element |
| * |
| * @param string $border border for image element |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setBorder($border) |
| { |
| $this->updateAttributes(array('border' => $border)); |
| } // end func setBorder |
| // }}} |
| // {{{ setAlign() |
| /** |
| * Sets alignment for image element |
| * |
| * @param string $align alignment for image element |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setAlign($align) |
| { |
| $this->updateAttributes(array('align' => $align)); |
| } // end func setAlign |
| // }}} |
| // {{{ 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_image |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/reset.php |
|---|
| New file |
| 0,0 → 1,72 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: reset.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once("HTML/QuickForm/input.php"); |
| /** |
| * HTML class for a reset type element |
| * |
| * @author Adam Daniel <adaniel1@eesus.jnj.com> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.1 |
| * @since PHP4.04pl1 |
| * @access public |
| */ |
| class HTML_QuickForm_reset 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_reset($elementName=null, $value=null, $attributes=null) |
| { |
| HTML_QuickForm_input::HTML_QuickForm_input($elementName, null, $attributes); |
| $this->setValue($value); |
| $this->setType('reset'); |
| } //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_reset |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/text.php |
|---|
| New file |
| 0,0 → 1,91 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: text.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once("HTML/QuickForm/input.php"); |
| /** |
| * HTML class for a text field |
| * |
| * @author Adam Daniel <adaniel1@eesus.jnj.com> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.0 |
| * @since PHP4.04pl1 |
| * @access public |
| */ |
| class HTML_QuickForm_text extends HTML_QuickForm_input |
| { |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @param string $elementName (optional)Input field name attribute |
| * @param string $elementLabel (optional)Input field label |
| * @param mixed $attributes (optional)Either a typical HTML attribute string |
| * or an associative array |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function HTML_QuickForm_text($elementName=null, $elementLabel=null, $attributes=null) |
| { |
| HTML_QuickForm_input::HTML_QuickForm_input($elementName, $elementLabel, $attributes); |
| $this->_persistantFreeze = true; |
| $this->setType('text'); |
| } //end constructor |
| // }}} |
| // {{{ setSize() |
| /** |
| * Sets size of text field |
| * |
| * @param string $size Size of text field |
| * @since 1.3 |
| * @access public |
| * @return void |
| */ |
| function setSize($size) |
| { |
| $this->updateAttributes(array('size'=>$size)); |
| } //end func setSize |
| // }}} |
| // {{{ setMaxlength() |
| /** |
| * Sets maxlength of text field |
| * |
| * @param string $maxlength Maximum length of text field |
| * @since 1.3 |
| * @access public |
| * @return void |
| */ |
| function setMaxlength($maxlength) |
| { |
| $this->updateAttributes(array('maxlength'=>$maxlength)); |
| } //end func setMaxlength |
| // }}} |
| } //end class HTML_QuickForm_text |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/checkbox.php |
|---|
| New file |
| 0,0 → 1,268 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: checkbox.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once("HTML/QuickForm/input.php"); |
| /** |
| * HTML class for a checkbox type field |
| * |
| * @author Adam Daniel <adaniel1@eesus.jnj.com> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.1 |
| * @since PHP4.04pl1 |
| * @access public |
| */ |
| 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 |
| * or an associative array |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function HTML_QuickForm_checkbox($elementName=null, $elementLabel=null, $text='', $attributes=null) |
| { |
| HTML_QuickForm_input::HTML_QuickForm_input($elementName, $elementLabel, $attributes); |
| $this->_persistantFreeze = true; |
| $this->_text = $text; |
| $this->setType('checkbox'); |
| $this->updateAttributes(array('value'=>1)); |
| $this->_generateId(); |
| } //end constructor |
| // }}} |
| // {{{ setChecked() |
| /** |
| * Sets whether a checkbox is checked |
| * |
| * @param bool $checked Whether the field is checked or not |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setChecked($checked) |
| { |
| if (!$checked) { |
| $this->removeAttribute('checked'); |
| } else { |
| $this->updateAttributes(array('checked'=>'checked')); |
| } |
| } //end func setChecked |
| // }}} |
| // {{{ getChecked() |
| /** |
| * Returns whether a checkbox is checked |
| * |
| * @since 1.0 |
| * @access public |
| * @return bool |
| */ |
| function getChecked() |
| { |
| return (bool)$this->getAttribute('checked'); |
| } //end func getChecked |
| // }}} |
| // {{{ toHtml() |
| /** |
| * Returns the checkbox element in HTML |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function toHtml() |
| { |
| if (0 == strlen($this->_text)) { |
| $label = ''; |
| } elseif ($this->_flagFrozen) { |
| $label = $this->_text; |
| } else { |
| $label = '<label for="' . $this->getAttribute('id') . '">' . $this->_text . '</label>'; |
| } |
| return HTML_QuickForm_input::toHtml() . $label; |
| } //end func toHtml |
| // }}} |
| // {{{ getFrozenHtml() |
| /** |
| * Returns the value of field without HTML tags |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function getFrozenHtml() |
| { |
| if ($this->getChecked()) { |
| return '<tt>[x]</tt>' . |
| $this->_getPersistantData(); |
| } else { |
| return '<tt>[ ]</tt>'; |
| } |
| } //end func getFrozenHtml |
| // }}} |
| // {{{ setText() |
| /** |
| * Sets the checkbox text |
| * |
| * @param string $text |
| * @since 1.1 |
| * @access public |
| * @return void |
| */ |
| function setText($text) |
| { |
| $this->_text = $text; |
| } //end func setText |
| // }}} |
| // {{{ getText() |
| /** |
| * Returns the checkbox text |
| * |
| * @since 1.1 |
| * @access public |
| * @return string |
| */ |
| function getText() |
| { |
| return $this->_text; |
| } //end func getText |
| // }}} |
| // {{{ setValue() |
| /** |
| * Sets the value of the form element |
| * |
| * @param string $value Default value of the form element |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setValue($value) |
| { |
| return $this->setChecked($value); |
| } // end func setValue |
| // }}} |
| // {{{ getValue() |
| /** |
| * Returns the value of the form element |
| * |
| * @since 1.0 |
| * @access public |
| * @return bool |
| */ |
| function getValue() |
| { |
| return $this->getChecked(); |
| } // end func getValue |
| // }}} |
| // {{{ 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) { |
| // if no boxes were checked, then there is no value in the array |
| // yet we don't want to display default value in this case |
| if ($caller->isSubmitted()) { |
| $value = $this->_findValue($caller->_submitValues); |
| } else { |
| $value = $this->_findValue($caller->_defaultValues); |
| } |
| } |
| if (null !== $value) { |
| $this->setChecked($value); |
| } |
| break; |
| case 'setGroupValue': |
| $this->setChecked($arg); |
| break; |
| default: |
| parent::onQuickFormEvent($event, $arg, $caller); |
| } |
| return true; |
| } // end func onQuickFormEvent |
| // }}} |
| // {{{ exportValue() |
| /** |
| * Return true if the checkbox is checked, null if it is not checked (getValue() returns false) |
| */ |
| function exportValue(&$submitValues, $assoc = false) |
| { |
| $value = $this->_findValue($submitValues); |
| if (null === $value) { |
| $value = $this->getChecked()? true: null; |
| } |
| return $this->_prepareValue($value, $assoc); |
| } |
| // }}} |
| } //end class HTML_QuickForm_checkbox |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/hierselect.php |
|---|
| New file |
| 0,0 → 1,565 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2004 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Herim Vasquez <vasquezh@iro.umontreal.ca> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // | Alexey Borzov <avb@php.net> |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: hierselect.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once('HTML/QuickForm/group.php'); |
| require_once('HTML/QuickForm/select.php'); |
| /** |
| * Class to dynamically create two or more HTML Select elements |
| * The first select changes the content of the second select and so on. |
| * This element is considered as a group. Selects will be named |
| * groupName[0], groupName[1], groupName[2]... |
| * |
| * @author Herim Vasquez <vasquezh@iro.umontreal.ca> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.0 |
| * @since PHP4.04pl1 |
| * @access public |
| */ |
| class HTML_QuickForm_hierselect extends HTML_QuickForm_group |
| { |
| // {{{ properties |
| /** |
| * Options for all the select elements |
| * |
| * Format is a bit more complex as we need to know which options |
| * are related to the ones in the previous select: |
| * |
| * Ex: |
| * // first select |
| * $select1[0] = 'Pop'; |
| * $select1[1] = 'Classical'; |
| * $select1[2] = 'Funeral doom'; |
| * |
| * // second select |
| * $select2[0][0] = 'Red Hot Chil Peppers'; |
| * $select2[0][1] = 'The Pixies'; |
| * $select2[1][0] = 'Wagner'; |
| * $select2[1][1] = 'Strauss'; |
| * $select2[2][0] = 'Pantheist'; |
| * $select2[2][1] = 'Skepticism'; |
| * |
| * // If only need two selects |
| * // - and using the depracated functions |
| * $sel =& $form->addElement('hierselect', 'cds', 'Choose CD:'); |
| * $sel->setMainOptions($select1); |
| * $sel->setSecOptions($select2); |
| * |
| * // - and using the new setOptions function |
| * $sel =& $form->addElement('hierselect', 'cds', 'Choose CD:'); |
| * $sel->setOptions(array($select1, $select2)); |
| * |
| * // If you have a third select with prices for the cds |
| * $select3[0][0][0] = '15.00$'; |
| * $select3[0][0][1] = '17.00$'; |
| * etc |
| * |
| * // You can now use |
| * $sel =& $form->addElement('hierselect', 'cds', 'Choose CD:'); |
| * $sel->setOptions(array($select1, $select2, $select3)); |
| * |
| * @var array |
| * @access private |
| */ |
| var $_options = array(); |
| /** |
| * Number of select elements on this group |
| * |
| * @var int |
| * @access private |
| */ |
| var $_nbElements = 0; |
| /** |
| * The javascript used to set and change the options |
| * |
| * @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 mixed $attributes (optional)Either a typical HTML attribute string |
| * or an associative array. Date format is passed along the attributes. |
| * @param mixed $separator (optional)Use a string for one separator, |
| * use an array to alternate the separators. |
| * @access public |
| * @return void |
| */ |
| function HTML_QuickForm_hierselect($elementName=null, $elementLabel=null, $attributes=null, $separator=null) |
| { |
| $this->HTML_QuickForm_element($elementName, $elementLabel, $attributes); |
| $this->_persistantFreeze = true; |
| if (isset($separator)) { |
| $this->_separator = $separator; |
| } |
| $this->_type = 'hierselect'; |
| $this->_appendName = true; |
| } //end constructor |
| // }}} |
| // {{{ setOptions() |
| /** |
| * Initialize the array structure containing the options for each select element. |
| * Call the functions that actually do the magic. |
| * |
| * @param array $options Array of options defining each element |
| * |
| * @access public |
| * @return void |
| */ |
| function setOptions($options) |
| { |
| $this->_options = $options; |
| if (empty($this->_elements)) { |
| $this->_nbElements = count($this->_options); |
| $this->_createElements(); |
| } else { |
| // setDefaults has probably been called before this function |
| // check if all elements have been created |
| $totalNbElements = count($this->_options); |
| for ($i = $this->_nbElements; $i < $totalNbElements; $i ++) { |
| $this->_elements[] =& new HTML_QuickForm_select($i, null, array(), $this->getAttributes()); |
| $this->_nbElements++; |
| } |
| } |
| $this->_setOptions(); |
| } // end func setMainOptions |
| // }}} |
| // {{{ setMainOptions() |
| /** |
| * Sets the options for the first select element. Deprecated. setOptions() should be used. |
| * |
| * @param array $array Options for the first select element |
| * |
| * @access public |
| * @return void |
| */ |
| function setMainOptions($array) |
| { |
| $this->_options[0] = $array; |
| if (empty($this->_elements)) { |
| $this->_nbElements = 2; |
| $this->_createElements(); |
| } |
| } // end func setMainOptions |
| // }}} |
| // {{{ setSecOptions() |
| /** |
| * Sets the options for the second select element. Deprecated. setOptions() should be used. |
| * The main _options array is initialized and the _setOptions function is called. |
| * |
| * @param array $array Options for the second select element |
| * |
| * @access public |
| * @return void |
| */ |
| function setSecOptions($array) |
| { |
| $this->_options[1] = $array; |
| if (empty($this->_elements)) { |
| $this->_nbElements = 2; |
| $this->_createElements(); |
| } else { |
| // setDefaults has probably been called before this function |
| // check if all elements have been created |
| $totalNbElements = 2; |
| for ($i = $this->_nbElements; $i < $totalNbElements; $i ++) { |
| $this->_elements[] =& new HTML_QuickForm_select($i, null, array(), $this->getAttributes()); |
| $this->_nbElements++; |
| } |
| } |
| $this->_setOptions(); |
| } // end func setSecOptions |
| // }}} |
| // {{{ _setOptions() |
| /** |
| * Sets the options for each select element |
| * |
| * @access private |
| * @return void |
| */ |
| function _setOptions() |
| { |
| $toLoad = ''; |
| foreach (array_keys($this->_elements) AS $key) { |
| $array = eval("return isset(\$this->_options[{$key}]{$toLoad})? \$this->_options[{$key}]{$toLoad}: null;"); |
| if (is_array($array)) { |
| $select =& $this->_elements[$key]; |
| $select->_options = array(); |
| $select->loadArray($array); |
| $value = is_array($v = $select->getValue()) ? $v[0] : key($array); |
| $toLoad .= '[\'' . str_replace(array('\\', '\''), array('\\\\', '\\\''), $value) . '\']'; |
| } |
| } |
| } // end func _setOptions |
| // }}} |
| // {{{ setValue() |
| /** |
| * Sets values for group's elements |
| * |
| * @param array $value An array of 2 or more values, for the first, |
| * the second, the third etc. select |
| * |
| * @access public |
| * @return void |
| */ |
| function setValue($value) |
| { |
| $this->_nbElements = count($value); |
| parent::setValue($value); |
| $this->_setOptions(); |
| } // end func setValue |
| // }}} |
| // {{{ _createElements() |
| /** |
| * Creates all the elements for the group |
| * |
| * @access private |
| * @return void |
| */ |
| function _createElements() |
| { |
| for ($i = 0; $i < $this->_nbElements; $i++) { |
| $this->_elements[] =& new HTML_QuickForm_select($i, null, array(), $this->getAttributes()); |
| } |
| } // end func _createElements |
| // }}} |
| // {{{ toHtml() |
| function toHtml() |
| { |
| $this->_js = ''; |
| if (!$this->_flagFrozen) { |
| // set the onchange attribute for each element except last |
| $keys = array_keys($this->_elements); |
| $onChange = array(); |
| for ($i = 0; $i < count($keys) - 1; $i++) { |
| $select =& $this->_elements[$keys[$i]]; |
| $onChange[$i] = $select->getAttribute('onchange'); |
| $select->updateAttributes( |
| array('onchange' => '_hs_swapOptions(this.form, \'' . $this->_escapeString($this->getName()) . '\', ' . $keys[$i] . ');' . $onChange[$i]) |
| ); |
| } |
| // create the js function to call |
| if (!defined('HTML_QUICKFORM_HIERSELECT_EXISTS')) { |
| $this->_js .= <<<JAVASCRIPT |
| function _hs_findOptions(ary, keys) |
| { |
| var key = keys.shift(); |
| if (!key in ary) { |
| return {}; |
| } else if (0 == keys.length) { |
| return ary[key]; |
| } else { |
| return _hs_findOptions(ary[key], keys); |
| } |
| } |
| function _hs_findSelect(form, groupName, selectIndex) |
| { |
| if (groupName+'['+ selectIndex +']' in form) { |
| return form[groupName+'['+ selectIndex +']']; |
| } else { |
| return form[groupName+'['+ selectIndex +'][]']; |
| } |
| } |
| function _hs_replaceOptions(ctl, optionList) |
| { |
| var j = 0; |
| ctl.options.length = 0; |
| for (i in optionList) { |
| ctl.options[j++] = new Option(optionList[i], i, false, false); |
| } |
| } |
| function _hs_setValue(ctl, value) |
| { |
| var testValue = {}; |
| if (value instanceof Array) { |
| for (var i = 0; i < value.length; i++) { |
| testValue[value[i]] = true; |
| } |
| } else { |
| testValue[value] = true; |
| } |
| for (var i = 0; i < ctl.options.length; i++) { |
| if (ctl.options[i].value in testValue) { |
| ctl.options[i].selected = true; |
| } |
| } |
| } |
| function _hs_swapOptions(form, groupName, selectIndex) |
| { |
| var hsValue = []; |
| for (var i = 0; i <= selectIndex; i++) { |
| hsValue[i] = _hs_findSelect(form, groupName, i).value; |
| } |
| _hs_replaceOptions(_hs_findSelect(form, groupName, selectIndex + 1), |
| _hs_findOptions(_hs_options[groupName][selectIndex], hsValue)); |
| if (selectIndex + 1 < _hs_options[groupName].length) { |
| _hs_swapOptions(form, groupName, selectIndex + 1); |
| } |
| } |
| function _hs_onReset(form, groupNames) |
| { |
| for (var i = 0; i < groupNames.length; i++) { |
| try { |
| for (var j = 0; j <= _hs_options[groupNames[i]].length; j++) { |
| _hs_setValue(_hs_findSelect(form, groupNames[i], j), _hs_defaults[groupNames[i]][j]); |
| if (j < _hs_options[groupNames[i]].length) { |
| _hs_replaceOptions(_hs_findSelect(form, groupNames[i], j + 1), |
| _hs_findOptions(_hs_options[groupNames[i]][j], _hs_defaults[groupNames[i]].slice(0, j + 1))); |
| } |
| } |
| } catch (e) { |
| if (!(e instanceof TypeError)) { |
| throw e; |
| } |
| } |
| } |
| } |
| function _hs_setupOnReset(form, groupNames) |
| { |
| setTimeout(function() { _hs_onReset(form, groupNames); }, 25); |
| } |
| function _hs_onReload() |
| { |
| var ctl; |
| for (var i = 0; i < document.forms.length; i++) { |
| for (var j in _hs_defaults) { |
| if (ctl = _hs_findSelect(document.forms[i], j, 0)) { |
| for (var k = 0; k < _hs_defaults[j].length; k++) { |
| _hs_setValue(_hs_findSelect(document.forms[i], j, k), _hs_defaults[j][k]); |
| } |
| } |
| } |
| } |
| if (_hs_prevOnload) { |
| _hs_prevOnload(); |
| } |
| } |
| var _hs_prevOnload = null; |
| if (window.onload) { |
| _hs_prevOnload = window.onload; |
| } |
| window.onload = _hs_onReload; |
| var _hs_options = {}; |
| var _hs_defaults = {}; |
| JAVASCRIPT; |
| define('HTML_QUICKFORM_HIERSELECT_EXISTS', true); |
| } |
| // option lists |
| $jsParts = array(); |
| for ($i = 1; $i < $this->_nbElements; $i++) { |
| $jsParts[] = $this->_convertArrayToJavascript($this->_options[$i]); |
| } |
| $this->_js .= "\n_hs_options['" . $this->_escapeString($this->getName()) . "'] = [\n" . |
| implode(",\n", $jsParts) . |
| "\n];\n"; |
| // default value; if we don't actually have any values yet just use |
| // the first option (for single selects) or empty array (for multiple) |
| $values = array(); |
| foreach (array_keys($this->_elements) as $key) { |
| if (is_array($v = $this->_elements[$key]->getValue())) { |
| $values[] = count($v) > 1? $v: $v[0]; |
| } else { |
| // XXX: accessing the supposedly private _options array |
| $values[] = $this->_elements[$key]->getMultiple() || empty($this->_elements[$key]->_options[0])? |
| array(): |
| $this->_elements[$key]->_options[0]['attr']['value']; |
| } |
| } |
| $this->_js .= "_hs_defaults['" . $this->_escapeString($this->getName()) . "'] = " . |
| $this->_convertArrayToJavascript($values, false) . ";\n"; |
| } |
| include_once('HTML/QuickForm/Renderer/Default.php'); |
| $renderer =& new HTML_QuickForm_Renderer_Default(); |
| $renderer->setElementTemplate('{element}'); |
| parent::accept($renderer); |
| if (!empty($onChange)) { |
| $keys = array_keys($this->_elements); |
| for ($i = 0; $i < count($keys) - 1; $i++) { |
| $this->_elements[$keys[$i]]->updateAttributes(array('onchange' => $onChange[$i])); |
| } |
| } |
| return (empty($this->_js)? '': "<script type=\"text/javascript\">\n//<![CDATA[\n" . $this->_js . "//]]>\n</script>") . |
| $renderer->toHtml(); |
| } // end func toHtml |
| // }}} |
| // {{{ accept() |
| function accept(&$renderer, $required = false, $error = null) |
| { |
| $renderer->renderElement($this, $required, $error); |
| } // end func accept |
| // }}} |
| // {{{ onQuickFormEvent() |
| function onQuickFormEvent($event, $arg, &$caller) |
| { |
| if ('updateValue' == $event) { |
| // we need to call setValue() so that the secondary option |
| // matches the main option |
| return HTML_QuickForm_element::onQuickFormEvent($event, $arg, $caller); |
| } else { |
| $ret = parent::onQuickFormEvent($event, $arg, $caller); |
| // add onreset handler to form to properly reset hierselect (see bug #2970) |
| if ('addElement' == $event) { |
| $onReset = $caller->getAttribute('onreset'); |
| if (strlen($onReset)) { |
| if (strpos($onReset, '_hs_setupOnReset')) { |
| $caller->updateAttributes(array('onreset' => str_replace('_hs_setupOnReset(this, [', "_hs_setupOnReset(this, ['" . $this->_escapeString($this->getName()) . "', ", $onReset))); |
| } else { |
| $caller->updateAttributes(array('onreset' => "var temp = function() { {$onReset} } ; if (!temp()) { return false; } ; if (typeof _hs_setupOnReset != 'undefined') { return _hs_setupOnReset(this, ['" . $this->_escapeString($this->getName()) . "']); } ")); |
| } |
| } else { |
| $caller->updateAttributes(array('onreset' => "if (typeof _hs_setupOnReset != 'undefined') { return _hs_setupOnReset(this, ['" . $this->_escapeString($this->getName()) . "']); } ")); |
| } |
| } |
| return $ret; |
| } |
| } // end func onQuickFormEvent |
| // }}} |
| // {{{ _convertArrayToJavascript() |
| /** |
| * Converts PHP array to its Javascript analog |
| * |
| * @access private |
| * @param array PHP array to convert |
| * @param bool Generate Javascript object literal (default, works like PHP's associative array) or array literal |
| * @return string Javascript representation of the value |
| */ |
| function _convertArrayToJavascript($array, $assoc = true) |
| { |
| if (!is_array($array)) { |
| return $this->_convertScalarToJavascript($array); |
| } else { |
| $items = array(); |
| foreach ($array as $key => $val) { |
| $item = $assoc? "'" . $this->_escapeString($key) . "': ": ''; |
| if (is_array($val)) { |
| $item .= $this->_convertArrayToJavascript($val, $assoc); |
| } else { |
| $item .= $this->_convertScalarToJavascript($val); |
| } |
| $items[] = $item; |
| } |
| } |
| $js = implode(', ', $items); |
| return $assoc? '{ ' . $js . ' }': '[' . $js . ']'; |
| } |
| // }}} |
| // {{{ _convertScalarToJavascript() |
| /** |
| * Converts PHP's scalar value to its Javascript analog |
| * |
| * @access private |
| * @param mixed PHP value to convert |
| * @return string Javascript representation of the value |
| */ |
| function _convertScalarToJavascript($val) |
| { |
| if (is_bool($val)) { |
| return $val ? 'true' : 'false'; |
| } elseif (is_int($val) || is_double($val)) { |
| return $val; |
| } elseif (is_string($val)) { |
| return "'" . $this->_escapeString($val) . "'"; |
| } elseif (is_null($val)) { |
| return 'null'; |
| } else { |
| // don't bother |
| return '{}'; |
| } |
| } |
| // }}} |
| // {{{ _escapeString() |
| /** |
| * Quotes the string so that it can be used in Javascript string constants |
| * |
| * @access private |
| * @param string |
| * @return string |
| */ |
| function _escapeString($str) |
| { |
| return strtr($str,array( |
| "\r" => '\r', |
| "\n" => '\n', |
| "\t" => '\t', |
| "'" => "\\'", |
| '"' => '\"', |
| '\\' => '\\\\' |
| )); |
| } |
| // }}} |
| } // end class HTML_QuickForm_hierselect |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/static.php |
|---|
| New file |
| 0,0 → 1,193 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: static.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once("HTML/QuickForm/element.php"); |
| /** |
| * HTML class for static data |
| * |
| * @author Wojciech Gdela <eltehaem@poczta.onet.pl> |
| * @access public |
| */ |
| class HTML_QuickForm_static extends HTML_QuickForm_element { |
| // {{{ properties |
| /** |
| * Display text |
| * @var string |
| * @access private |
| */ |
| var $_text = null; |
| // }}} |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @param string $elementLabel (optional)Label |
| * @param string $text (optional)Display text |
| * @access public |
| * @return void |
| */ |
| function HTML_QuickForm_static($elementName=null, $elementLabel=null, $text=null) |
| { |
| HTML_QuickForm_element::HTML_QuickForm_element($elementName, $elementLabel); |
| $this->_persistantFreeze = false; |
| $this->_type = 'static'; |
| $this->_text = $text; |
| } //end constructor |
| // }}} |
| // {{{ setName() |
| /** |
| * Sets the element name |
| * |
| * @param string $name Element name |
| * @access public |
| * @return void |
| */ |
| function setName($name) |
| { |
| $this->updateAttributes(array('name'=>$name)); |
| } //end func setName |
| // }}} |
| // {{{ getName() |
| /** |
| * Returns the element name |
| * |
| * @access public |
| * @return string |
| */ |
| function getName() |
| { |
| return $this->getAttribute('name'); |
| } //end func getName |
| // }}} |
| // {{{ setText() |
| /** |
| * Sets the text |
| * |
| * @param string $text |
| * @access public |
| * @return void |
| */ |
| function setText($text) |
| { |
| $this->_text = $text; |
| } // end func setText |
| // }}} |
| // {{{ setValue() |
| /** |
| * Sets the text (uses the standard setValue call to emulate a form element. |
| * |
| * @param string $text |
| * @access public |
| * @return void |
| */ |
| function setValue($text) |
| { |
| $this->setText($text); |
| } // end func setValue |
| // }}} |
| // {{{ toHtml() |
| /** |
| * Returns the static text element in HTML |
| * |
| * @access public |
| * @return string |
| */ |
| function toHtml() |
| { |
| return $this->_getTabs() . $this->_text; |
| } //end func toHtml |
| // }}} |
| // {{{ getFrozenHtml() |
| /** |
| * Returns the value of field without HTML tags |
| * |
| * @access public |
| * @return string |
| */ |
| function getFrozenHtml() |
| { |
| return $this->toHtml(); |
| } //end func getFrozenHtml |
| // }}} |
| // {{{ 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 |
| * @throws |
| */ |
| function onQuickFormEvent($event, $arg, &$caller) |
| { |
| switch ($event) { |
| case 'updateValue': |
| // do NOT use submitted values for static elements |
| $value = $this->_findValue($caller->_constantValues); |
| 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 onQuickFormEvent |
| // }}} |
| // {{{ exportValue() |
| /** |
| * We override this here because we don't want any values from static elements |
| */ |
| function exportValue(&$submitValues, $assoc = false) |
| { |
| return null; |
| } |
| // }}} |
| } //end class HTML_QuickForm_static |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/header.php |
|---|
| New file |
| 0,0 → 1,65 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Author: Alexey Borzov <borz_off@cs.msu.su> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: header.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once 'HTML/QuickForm/static.php'; |
| /** |
| * A pseudo-element used for adding headers to form |
| * |
| * @author Alexey Borzov <borz_off@cs.msu.su> |
| * @access public |
| */ |
| class HTML_QuickForm_header extends HTML_QuickForm_static |
| { |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @param string $elementName Header name |
| * @param string $text Header text |
| * @access public |
| * @return void |
| */ |
| function HTML_QuickForm_header($elementName = null, $text = null) |
| { |
| $this->HTML_QuickForm_static($elementName, null, $text); |
| $this->_type = 'header'; |
| } |
| // }}} |
| // {{{ accept() |
| /** |
| * Accepts a renderer |
| * |
| * @param object An HTML_QuickForm_Renderer object |
| * @access public |
| * @return void |
| */ |
| function accept(&$renderer) |
| { |
| $renderer->renderHeader($this); |
| } // end func accept |
| // }}} |
| } //end class HTML_QuickForm_header |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/element.php |
|---|
| New file |
| 0,0 → 1,479 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: element.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once('HTML/Common.php'); |
| /** |
| * Base class for form elements |
| * |
| * @author Adam Daniel <adaniel1@eesus.jnj.com> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.3 |
| * @since PHP4.04pl1 |
| * @access public |
| * @abstract |
| */ |
| class HTML_QuickForm_element extends HTML_Common |
| { |
| // {{{ properties |
| /** |
| * Label of the field |
| * @var string |
| * @since 1.3 |
| * @access private |
| */ |
| var $_label = ''; |
| /** |
| * Form element type |
| * @var string |
| * @since 1.0 |
| * @access private |
| */ |
| var $_type = ''; |
| /** |
| * Flag to tell if element is frozen |
| * @var boolean |
| * @since 1.0 |
| * @access private |
| */ |
| var $_flagFrozen = false; |
| /** |
| * Does the element support persistant data when frozen |
| * @var boolean |
| * @since 1.3 |
| * @access private |
| */ |
| var $_persistantFreeze = false; |
| // }}} |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @param string Name of the element |
| * @param mixed Label(s) for the element |
| * @param mixed Associative array of tag attributes or HTML attributes name="value" pairs |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function HTML_QuickForm_element($elementName=null, $elementLabel=null, $attributes=null) |
| { |
| HTML_Common::HTML_Common($attributes); |
| if (isset($elementName)) { |
| $this->setName($elementName); |
| } |
| if (isset($elementLabel)) { |
| $this->setLabel($elementLabel); |
| } |
| } //end constructor |
| // }}} |
| // {{{ apiVersion() |
| /** |
| * Returns the current API version |
| * |
| * @since 1.0 |
| * @access public |
| * @return float |
| */ |
| function apiVersion() |
| { |
| return 2.0; |
| } // end func apiVersion |
| // }}} |
| // {{{ getType() |
| /** |
| * Returns element type |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function getType() |
| { |
| return $this->_type; |
| } // end func getType |
| // }}} |
| // {{{ setName() |
| /** |
| * Sets the input field name |
| * |
| * @param string $name Input field name attribute |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setName($name) |
| { |
| // interface method |
| } //end func setName |
| // }}} |
| // {{{ getName() |
| /** |
| * Returns the element name |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function getName() |
| { |
| // interface method |
| } //end func getName |
| // }}} |
| // {{{ setValue() |
| /** |
| * Sets the value of the form element |
| * |
| * @param string $value Default value of the form element |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setValue($value) |
| { |
| // interface |
| } // end func setValue |
| // }}} |
| // {{{ getValue() |
| /** |
| * Returns the value of the form element |
| * |
| * @since 1.0 |
| * @access public |
| * @return mixed |
| */ |
| function getValue() |
| { |
| // interface |
| return null; |
| } // end func getValue |
| // }}} |
| // {{{ freeze() |
| /** |
| * Freeze the element so that only its value is returned |
| * |
| * @access public |
| * @return void |
| */ |
| function freeze() |
| { |
| $this->_flagFrozen = true; |
| } //end func freeze |
| // }}} |
| // {{{ unfreeze() |
| /** |
| * Unfreezes the element so that it becomes editable |
| * |
| * @access public |
| * @return void |
| * @since 3.2.4 |
| */ |
| function unfreeze() |
| { |
| $this->_flagFrozen = false; |
| } |
| // }}} |
| // {{{ getFrozenHtml() |
| /** |
| * Returns the value of field without HTML tags |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function getFrozenHtml() |
| { |
| $value = $this->getValue(); |
| return ('' != $value? htmlspecialchars($value): ' ') . |
| $this->_getPersistantData(); |
| } //end func getFrozenHtml |
| // }}} |
| // {{{ _getPersistantData() |
| /** |
| * Used by getFrozenHtml() to pass the element's value if _persistantFreeze is on |
| * |
| * @access private |
| * @return string |
| */ |
| function _getPersistantData() |
| { |
| if (!$this->_persistantFreeze) { |
| return ''; |
| } else { |
| $id = $this->getAttribute('id'); |
| return '<input' . $this->_getAttrString(array( |
| 'type' => 'hidden', |
| 'name' => $this->getName(), |
| 'value' => $this->getValue() |
| ) + (isset($id)? array('id' => $id): array())) . ' />'; |
| } |
| } |
| // }}} |
| // {{{ isFrozen() |
| /** |
| * Returns whether or not the element is frozen |
| * |
| * @since 1.3 |
| * @access public |
| * @return bool |
| */ |
| function isFrozen() |
| { |
| return $this->_flagFrozen; |
| } // end func isFrozen |
| // }}} |
| // {{{ setPersistantFreeze() |
| /** |
| * Sets wether an element value should be kept in an hidden field |
| * when the element is frozen or not |
| * |
| * @param bool $persistant True if persistant value |
| * @since 2.0 |
| * @access public |
| * @return void |
| */ |
| function setPersistantFreeze($persistant=false) |
| { |
| $this->_persistantFreeze = $persistant; |
| } //end func setPersistantFreeze |
| // }}} |
| // {{{ setLabel() |
| /** |
| * Sets display text for the element |
| * |
| * @param string $label Display text for the element |
| * @since 1.3 |
| * @access public |
| * @return void |
| */ |
| function setLabel($label) |
| { |
| $this->_label = $label; |
| } //end func setLabel |
| // }}} |
| // {{{ getLabel() |
| /** |
| * Returns display text for the element |
| * |
| * @since 1.3 |
| * @access public |
| * @return string |
| */ |
| function getLabel() |
| { |
| return $this->_label; |
| } //end func getLabel |
| // }}} |
| // {{{ _findValue() |
| /** |
| * Tries to find the element value from the values array |
| * |
| * @since 2.7 |
| * @access private |
| * @return mixed |
| */ |
| function _findValue(&$values) |
| { |
| if (empty($values)) { |
| return null; |
| } |
| $elementName = $this->getName(); |
| if (isset($values[$elementName])) { |
| return $values[$elementName]; |
| } elseif (strpos($elementName, '[')) { |
| $myVar = "['" . str_replace(array(']', '['), array('', "']['"), $elementName) . "']"; |
| return eval("return (isset(\$values$myVar)) ? \$values$myVar : null;"); |
| } else { |
| return null; |
| } |
| } //end func _findValue |
| // }}} |
| // {{{ 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 'createElement': |
| $className = get_class($this); |
| $this->$className($arg[0], $arg[1], $arg[2], $arg[3], $arg[4]); |
| break; |
| case 'addElement': |
| $this->onQuickFormEvent('createElement', $arg, $caller); |
| $this->onQuickFormEvent('updateValue', null, $caller); |
| break; |
| 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; |
| case 'setGroupValue': |
| $this->setValue($arg); |
| } |
| return true; |
| } // end func onQuickFormEvent |
| // }}} |
| // {{{ accept() |
| /** |
| * Accepts a renderer |
| * |
| * @param object An HTML_QuickForm_Renderer object |
| * @param bool Whether an element is required |
| * @param string An error message associated with an element |
| * @access public |
| * @return void |
| */ |
| function accept(&$renderer, $required=false, $error=null) |
| { |
| $renderer->renderElement($this, $required, $error); |
| } // end func accept |
| // }}} |
| // {{{ _generateId() |
| /** |
| * Automatically generates and assigns an 'id' attribute for the element. |
| * |
| * Currently used to ensure that labels work on radio buttons and |
| * checkboxes. Per idea of Alexander Radivanovich. |
| * |
| * @access private |
| * @return void |
| */ |
| function _generateId() |
| { |
| static $idx = 1; |
| if (!$this->getAttribute('id')) { |
| $this->updateAttributes(array('id' => 'qf_' . substr(md5(microtime() . $idx++), 0, 6))); |
| } |
| } // end func _generateId |
| // }}} |
| // {{{ exportValue() |
| /** |
| * Returns a 'safe' element's value |
| * |
| * @param array array of submitted values to search |
| * @param bool whether to return the value as associative array |
| * @access public |
| * @return mixed |
| */ |
| function exportValue(&$submitValues, $assoc = false) |
| { |
| $value = $this->_findValue($submitValues); |
| if (null === $value) { |
| $value = $this->getValue(); |
| } |
| return $this->_prepareValue($value, $assoc); |
| } |
| // }}} |
| // {{{ _prepareValue() |
| /** |
| * Used by exportValue() to prepare the value for returning |
| * |
| * @param mixed the value found in exportValue() |
| * @param bool whether to return the value as associative array |
| * @access private |
| * @return mixed |
| */ |
| function _prepareValue($value, $assoc) |
| { |
| if (null === $value) { |
| return null; |
| } elseif (!$assoc) { |
| return $value; |
| } else { |
| $name = $this->getName(); |
| if (!strpos($name, '[')) { |
| return array($name => $value); |
| } else { |
| $valueAry = array(); |
| $myIndex = "['" . str_replace(array(']', '['), array('', "']['"), $name) . "']"; |
| eval("\$valueAry$myIndex = \$value;"); |
| return $valueAry; |
| } |
| } |
| } |
| // }}} |
| } // end class HTML_QuickForm_element |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/hiddenselect.php |
|---|
| New file |
| 0,0 → 1,107 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: hiddenselect.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once('HTML/QuickForm/select.php'); |
| /** |
| * This class takes the same arguments as a select element, but instead |
| * of creating a select ring it creates hidden elements for all values |
| * already selected with setDefault or setConstant. This is useful if |
| * you have a select ring that you don't want visible, but you need all |
| * selected values to be passed. |
| * |
| * @author Isaac Shepard <ishepard@bsiweb.com> |
| * |
| * @version 1.0 |
| * @since 2.1 |
| * @access public |
| */ |
| class HTML_QuickForm_hiddenselect extends HTML_QuickForm_select |
| { |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @param string Select name attribute |
| * @param mixed Label(s) for the select (not used) |
| * @param mixed Data to be used to populate options |
| * @param mixed Either a typical HTML attribute string or an associative array (not used) |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function HTML_QuickForm_hiddenselect($elementName=null, $elementLabel=null, $options=null, $attributes=null) |
| { |
| HTML_QuickForm_element::HTML_QuickForm_element($elementName, $elementLabel, $attributes); |
| $this->_persistantFreeze = true; |
| $this->_type = 'hiddenselect'; |
| if (isset($options)) { |
| $this->load($options); |
| } |
| } //end constructor |
| // }}} |
| // {{{ toHtml() |
| /** |
| * Returns the SELECT in HTML |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| * @throws |
| */ |
| function toHtml() |
| { |
| $tabs = $this->_getTabs(); |
| $name = $this->getPrivateName(); |
| $strHtml = ''; |
| foreach ($this->_values as $key => $val) { |
| for ($i = 0, $optCount = count($this->_options); $i < $optCount; $i++) { |
| if ($val == $this->_options[$i]['attr']['value']) { |
| $strHtml .= $tabs . '<input' . $this->_getAttrString(array( |
| 'type' => 'hidden', |
| 'name' => $name, |
| 'value' => $val |
| )) . " />\n" ; |
| } |
| } |
| } |
| return $strHtml; |
| } //end func toHtml |
| // }}} |
| // {{{ accept() |
| /** |
| * This is essentially a hidden element and should be rendered as one |
| */ |
| function accept(&$renderer) |
| { |
| $renderer->renderHidden($this); |
| } |
| // }}} |
| } //end class HTML_QuickForm_hiddenselect |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/hidden.php |
|---|
| New file |
| 0,0 → 1,87 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: hidden.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once("HTML/QuickForm/input.php"); |
| /** |
| * HTML class for a hidden type element |
| * |
| * @author Adam Daniel <adaniel1@eesus.jnj.com> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.0 |
| * @since PHP4.04pl1 |
| * @access public |
| */ |
| class HTML_QuickForm_hidden 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_hidden($elementName=null, $value='', $attributes=null) |
| { |
| HTML_QuickForm_input::HTML_QuickForm_input($elementName, null, $attributes); |
| $this->setType('hidden'); |
| $this->setValue($value); |
| } //end constructor |
| // }}} |
| // {{{ freeze() |
| /** |
| * Freeze the element so that only its value is returned |
| * |
| * @access public |
| * @return void |
| */ |
| function freeze() |
| { |
| return false; |
| } //end func freeze |
| // }}} |
| // {{{ accept() |
| /** |
| * Accepts a renderer |
| * |
| * @param object An HTML_QuickForm_Renderer object |
| * @access public |
| * @return void |
| */ |
| function accept(&$renderer) |
| { |
| $renderer->renderHidden($this); |
| } // end func accept |
| // }}} |
| } //end class HTML_QuickForm_hidden |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/group.php |
|---|
| New file |
| 0,0 → 1,579 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: group.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once("HTML/QuickForm/element.php"); |
| /** |
| * HTML class for a form element group |
| * |
| * @author Adam Daniel <adaniel1@eesus.jnj.com> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.0 |
| * @since PHP4.04pl1 |
| * @access public |
| */ |
| class HTML_QuickForm_group extends HTML_QuickForm_element |
| { |
| // {{{ properties |
| /** |
| * Name of the element |
| * @var string |
| * @since 1.0 |
| * @access private |
| */ |
| var $_name = ''; |
| /** |
| * Array of grouped elements |
| * @var array |
| * @since 1.0 |
| * @access private |
| */ |
| var $_elements = array(); |
| /** |
| * String to separate elements |
| * @var mixed |
| * @since 2.5 |
| * @access private |
| */ |
| var $_separator = null; |
| /** |
| * Required elements in this group |
| * @var array |
| * @since 2.5 |
| * @access private |
| */ |
| var $_required = array(); |
| /** |
| * Whether to change elements' names to $groupName[$elementName] or leave them as is |
| * @var bool |
| * @since 3.0 |
| * @access private |
| */ |
| var $_appendName = true; |
| // }}} |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @param string $elementName (optional)Group name |
| * @param array $elementLabel (optional)Group label |
| * @param array $elements (optional)Group elements |
| * @param mixed $separator (optional)Use a string for one separator, |
| * use an array to alternate the separators. |
| * @param bool $appendName (optional)whether to change elements' names to |
| * the form $groupName[$elementName] or leave |
| * them as is. |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function HTML_QuickForm_group($elementName=null, $elementLabel=null, $elements=null, $separator=null, $appendName = true) |
| { |
| $this->HTML_QuickForm_element($elementName, $elementLabel); |
| $this->_type = 'group'; |
| if (isset($elements) && is_array($elements)) { |
| $this->setElements($elements); |
| } |
| if (isset($separator)) { |
| $this->_separator = $separator; |
| } |
| if (isset($appendName)) { |
| $this->_appendName = $appendName; |
| } |
| } //end constructor |
| // }}} |
| // {{{ setName() |
| /** |
| * Sets the group name |
| * |
| * @param string $name Group name |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setName($name) |
| { |
| $this->_name = $name; |
| } //end func setName |
| // }}} |
| // {{{ getName() |
| /** |
| * Returns the group name |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function getName() |
| { |
| return $this->_name; |
| } //end func getName |
| // }}} |
| // {{{ setValue() |
| /** |
| * Sets values for group's elements |
| * |
| * @param mixed Values for group's elements |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setValue($value) |
| { |
| $this->_createElementsIfNotExist(); |
| foreach (array_keys($this->_elements) as $key) { |
| if (!$this->_appendName) { |
| $v = $this->_elements[$key]->_findValue($value); |
| if (null !== $v) { |
| $this->_elements[$key]->onQuickFormEvent('setGroupValue', $v, $this); |
| } |
| } else { |
| $elementName = $this->_elements[$key]->getName(); |
| $index = strlen($elementName) ? $elementName : $key; |
| if (is_array($value)) { |
| if (isset($value[$index])) { |
| $this->_elements[$key]->onQuickFormEvent('setGroupValue', $value[$index], $this); |
| } |
| } elseif (isset($value)) { |
| $this->_elements[$key]->onQuickFormEvent('setGroupValue', $value, $this); |
| } |
| } |
| } |
| } //end func setValue |
| // }}} |
| // {{{ getValue() |
| /** |
| * Returns the value of the group |
| * |
| * @since 1.0 |
| * @access public |
| * @return mixed |
| */ |
| function getValue() |
| { |
| $value = null; |
| foreach (array_keys($this->_elements) as $key) { |
| $element =& $this->_elements[$key]; |
| switch ($element->getType()) { |
| case 'radio': |
| $v = $element->getChecked()? $element->getValue(): null; |
| break; |
| case 'checkbox': |
| $v = $element->getChecked()? true: null; |
| break; |
| default: |
| $v = $element->getValue(); |
| } |
| if (null !== $v) { |
| $elementName = $element->getName(); |
| if (is_null($elementName)) { |
| $value = $v; |
| } else { |
| if (!is_array($value)) { |
| $value = is_null($value)? array(): array($value); |
| } |
| if ('' === $elementName) { |
| $value[] = $v; |
| } else { |
| $value[$elementName] = $v; |
| } |
| } |
| } |
| } |
| return $value; |
| } // end func getValue |
| // }}} |
| // {{{ setElements() |
| /** |
| * Sets the grouped elements |
| * |
| * @param array $elements Array of elements |
| * @since 1.1 |
| * @access public |
| * @return void |
| */ |
| function setElements($elements) |
| { |
| $this->_elements = array_values($elements); |
| if ($this->_flagFrozen) { |
| $this->freeze(); |
| } |
| } // end func setElements |
| // }}} |
| // {{{ getElements() |
| /** |
| * Gets the grouped elements |
| * |
| * @since 2.4 |
| * @access public |
| * @return array |
| */ |
| function &getElements() |
| { |
| $this->_createElementsIfNotExist(); |
| return $this->_elements; |
| } // end func getElements |
| // }}} |
| // {{{ getGroupType() |
| /** |
| * Gets the group type based on its elements |
| * Will return 'mixed' if elements contained in the group |
| * are of different types. |
| * |
| * @access public |
| * @return string group elements type |
| */ |
| function getGroupType() |
| { |
| $this->_createElementsIfNotExist(); |
| $prevType = ''; |
| foreach (array_keys($this->_elements) as $key) { |
| $type = $this->_elements[$key]->getType(); |
| if ($type != $prevType && $prevType != '') { |
| return 'mixed'; |
| } |
| $prevType = $type; |
| } |
| return $type; |
| } // end func getGroupType |
| // }}} |
| // {{{ toHtml() |
| /** |
| * Returns Html for the group |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function toHtml() |
| { |
| include_once('HTML/QuickForm/Renderer/Default.php'); |
| $renderer =& new HTML_QuickForm_Renderer_Default(); |
| $renderer->setElementTemplate('{element}'); |
| $this->accept($renderer); |
| return $renderer->toHtml(); |
| } //end func toHtml |
| // }}} |
| // {{{ getElementName() |
| /** |
| * Returns the element name inside the group such as found in the html form |
| * |
| * @param mixed $index Element name or element index in the group |
| * @since 3.0 |
| * @access public |
| * @return mixed string with element name, false if not found |
| */ |
| function getElementName($index) |
| { |
| $this->_createElementsIfNotExist(); |
| $elementName = false; |
| if (is_int($index) && isset($this->_elements[$index])) { |
| $elementName = $this->_elements[$index]->getName(); |
| if (isset($elementName) && $elementName == '') { |
| $elementName = $index; |
| } |
| if ($this->_appendName) { |
| if (is_null($elementName)) { |
| $elementName = $this->getName(); |
| } else { |
| $elementName = $this->getName().'['.$elementName.']'; |
| } |
| } |
| } elseif (is_string($index)) { |
| foreach (array_keys($this->_elements) as $key) { |
| $elementName = $this->_elements[$key]->getName(); |
| if ($index == $elementName) { |
| if ($this->_appendName) { |
| $elementName = $this->getName().'['.$elementName.']'; |
| } |
| break; |
| } elseif ($this->_appendName && $this->getName().'['.$elementName.']' == $index) { |
| break; |
| } |
| } |
| } |
| return $elementName; |
| } //end func getElementName |
| // }}} |
| // {{{ getFrozenHtml() |
| /** |
| * Returns the value of field without HTML tags |
| * |
| * @since 1.3 |
| * @access public |
| * @return string |
| */ |
| function getFrozenHtml() |
| { |
| $flags = array(); |
| $this->_createElementsIfNotExist(); |
| foreach (array_keys($this->_elements) as $key) { |
| if (false === ($flags[$key] = $this->_elements[$key]->isFrozen())) { |
| $this->_elements[$key]->freeze(); |
| } |
| } |
| $html = $this->toHtml(); |
| foreach (array_keys($this->_elements) as $key) { |
| if (!$flags[$key]) { |
| $this->_elements[$key]->unfreeze(); |
| } |
| } |
| return $html; |
| } //end func getFrozenHtml |
| // }}} |
| // {{{ 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': |
| $this->_createElementsIfNotExist(); |
| foreach (array_keys($this->_elements) as $key) { |
| if ($this->_appendName) { |
| $elementName = $this->_elements[$key]->getName(); |
| if (is_null($elementName)) { |
| $this->_elements[$key]->setName($this->getName()); |
| } elseif ('' === $elementName) { |
| $this->_elements[$key]->setName($this->getName() . '[' . $key . ']'); |
| } else { |
| $this->_elements[$key]->setName($this->getName() . '[' . $elementName . ']'); |
| } |
| } |
| $this->_elements[$key]->onQuickFormEvent('updateValue', $arg, $caller); |
| if ($this->_appendName) { |
| $this->_elements[$key]->setName($elementName); |
| } |
| } |
| break; |
| default: |
| parent::onQuickFormEvent($event, $arg, $caller); |
| } |
| return true; |
| } // end func onQuickFormEvent |
| // }}} |
| // {{{ accept() |
| /** |
| * Accepts a renderer |
| * |
| * @param object An HTML_QuickForm_Renderer object |
| * @param bool Whether a group is required |
| * @param string An error message associated with a group |
| * @access public |
| * @return void |
| */ |
| function accept(&$renderer, $required = false, $error = null) |
| { |
| $this->_createElementsIfNotExist(); |
| $renderer->startGroup($this, $required, $error); |
| $name = $this->getName(); |
| foreach (array_keys($this->_elements) as $key) { |
| $element =& $this->_elements[$key]; |
| if ($this->_appendName) { |
| $elementName = $element->getName(); |
| if (isset($elementName)) { |
| $element->setName($name . '['. (strlen($elementName)? $elementName: $key) .']'); |
| } else { |
| $element->setName($name); |
| } |
| } |
| $required = !$element->isFrozen() && in_array($element->getName(), $this->_required); |
| $element->accept($renderer, $required); |
| // restore the element's name |
| if ($this->_appendName) { |
| $element->setName($elementName); |
| } |
| } |
| $renderer->finishGroup($this); |
| } // end func accept |
| // }}} |
| // {{{ exportValue() |
| /** |
| * As usual, to get the group's value we access its elements and call |
| * their exportValue() methods |
| */ |
| function exportValue(&$submitValues, $assoc = false) |
| { |
| $value = null; |
| foreach (array_keys($this->_elements) as $key) { |
| $elementName = $this->_elements[$key]->getName(); |
| if ($this->_appendName) { |
| if (is_null($elementName)) { |
| $this->_elements[$key]->setName($this->getName()); |
| } elseif ('' === $elementName) { |
| $this->_elements[$key]->setName($this->getName() . '[' . $key . ']'); |
| } else { |
| $this->_elements[$key]->setName($this->getName() . '[' . $elementName . ']'); |
| } |
| } |
| $v = $this->_elements[$key]->exportValue($submitValues, $assoc); |
| if ($this->_appendName) { |
| $this->_elements[$key]->setName($elementName); |
| } |
| if (null !== $v) { |
| // Make $value an array, we will use it like one |
| if (null === $value) { |
| $value = array(); |
| } |
| if ($assoc) { |
| // just like HTML_QuickForm::exportValues() |
| $value = HTML_QuickForm::arrayMerge($value, $v); |
| } else { |
| // just like getValue(), but should work OK every time here |
| if (is_null($elementName)) { |
| $value = $v; |
| } elseif ('' === $elementName) { |
| $value[] = $v; |
| } else { |
| $value[$elementName] = $v; |
| } |
| } |
| } |
| } |
| // do not pass the value through _prepareValue, we took care of this already |
| return $value; |
| } |
| // }}} |
| // {{{ _createElements() |
| /** |
| * Creates the group's elements. |
| * |
| * This should be overriden by child classes that need to create their |
| * elements. The method will be called automatically when needed, calling |
| * it from the constructor is discouraged as the constructor is usually |
| * called _twice_ on element creation, first time with _no_ parameters. |
| * |
| * @access private |
| * @abstract |
| */ |
| function _createElements() |
| { |
| // abstract |
| } |
| // }}} |
| // {{{ _createElementsIfNotExist() |
| /** |
| * A wrapper around _createElements() |
| * |
| * This method calls _createElements() if the group's _elements array |
| * is empty. It also performs some updates, e.g. freezes the created |
| * elements if the group is already frozen. |
| * |
| * @access private |
| */ |
| function _createElementsIfNotExist() |
| { |
| if (empty($this->_elements)) { |
| $this->_createElements(); |
| if ($this->_flagFrozen) { |
| $this->freeze(); |
| } |
| } |
| } |
| // }}} |
| // {{{ freeze() |
| function freeze() |
| { |
| parent::freeze(); |
| foreach (array_keys($this->_elements) as $key) { |
| $this->_elements[$key]->freeze(); |
| } |
| } |
| // }}} |
| // {{{ unfreeze() |
| function unfreeze() |
| { |
| parent::unfreeze(); |
| foreach (array_keys($this->_elements) as $key) { |
| $this->_elements[$key]->unfreeze(); |
| } |
| } |
| // }}} |
| // {{{ setPersistantFreeze() |
| function setPersistantFreeze($persistant = false) |
| { |
| parent::setPersistantFreeze($persistant); |
| foreach (array_keys($this->_elements) as $key) { |
| $this->_elements[$key]->setPersistantFreeze($persistant); |
| } |
| } |
| // }}} |
| } //end class HTML_QuickForm_group |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/link.php |
|---|
| New file |
| 0,0 → 1,192 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| require_once 'HTML/QuickForm/static.php'; |
| /** |
| * HTML class for a link type field |
| * |
| * @author Adam Daniel <adaniel1@eesus.jnj.com> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.0 |
| * @since PHP4.04pl1 |
| * @access public |
| */ |
| class HTML_QuickForm_link extends HTML_QuickForm_static |
| { |
| // {{{ properties |
| /** |
| * Link display text |
| * @var string |
| * @since 1.0 |
| * @access private |
| */ |
| var $_text = ""; |
| // }}} |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @param string $elementLabel (optional)Link label |
| * @param string $href (optional)Link href |
| * @param string $text (optional)Link display text |
| * @param mixed $attributes (optional)Either a typical HTML attribute string |
| * or an associative array |
| * @since 1.0 |
| * @access public |
| * @return void |
| * @throws |
| */ |
| function HTML_QuickForm_link($elementName=null, $elementLabel=null, $href=null, $text=null, $attributes=null) |
| { |
| HTML_QuickForm_element::HTML_QuickForm_element($elementName, $elementLabel, $attributes); |
| $this->_persistantFreeze = false; |
| $this->_type = 'link'; |
| $this->setHref($href); |
| $this->_text = $text; |
| } //end constructor |
| // }}} |
| // {{{ setName() |
| /** |
| * Sets the input field name |
| * |
| * @param string $name Input field name attribute |
| * @since 1.0 |
| * @access public |
| * @return void |
| * @throws |
| */ |
| function setName($name) |
| { |
| $this->updateAttributes(array('name'=>$name)); |
| } //end func setName |
| // }}} |
| // {{{ getName() |
| /** |
| * Returns the element name |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| * @throws |
| */ |
| function getName() |
| { |
| return $this->getAttribute('name'); |
| } //end func getName |
| // }}} |
| // {{{ setValue() |
| /** |
| * Sets value for textarea element |
| * |
| * @param string $value Value for password element |
| * @since 1.0 |
| * @access public |
| * @return void |
| * @throws |
| */ |
| function setValue($value) |
| { |
| return; |
| } //end func setValue |
| // }}} |
| // {{{ getValue() |
| /** |
| * Returns the value of the form element |
| * |
| * @since 1.0 |
| * @access public |
| * @return void |
| * @throws |
| */ |
| function getValue() |
| { |
| return; |
| } // end func getValue |
| // }}} |
| // {{{ setHref() |
| /** |
| * Sets the links href |
| * |
| * @param string $href |
| * @since 1.0 |
| * @access public |
| * @return void |
| * @throws |
| */ |
| function setHref($href) |
| { |
| $this->updateAttributes(array('href'=>$href)); |
| } // end func setHref |
| // }}} |
| // {{{ toHtml() |
| /** |
| * Returns the textarea element in HTML |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| * @throws |
| */ |
| function toHtml() |
| { |
| $tabs = $this->_getTabs(); |
| $html = "$tabs<a".$this->_getAttrString($this->_attributes).">"; |
| $html .= $this->_text; |
| $html .= "</a>"; |
| return $html; |
| } //end func toHtml |
| // }}} |
| // {{{ getFrozenHtml() |
| /** |
| * Returns the value of field without HTML tags (in this case, value is changed to a mask) |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| * @throws |
| */ |
| function getFrozenHtml() |
| { |
| return; |
| } //end func getFrozenHtml |
| // }}} |
| } //end class HTML_QuickForm_textarea |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/radio.php |
|---|
| New file |
| 0,0 → 1,244 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: radio.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once('HTML/QuickForm/input.php'); |
| /** |
| * HTML class for a radio type element |
| * |
| * @author Adam Daniel <adaniel1@eesus.jnj.com> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.1 |
| * @since PHP4.04pl1 |
| * @access public |
| */ |
| class HTML_QuickForm_radio extends HTML_QuickForm_input |
| { |
| // {{{ properties |
| /** |
| * Radio display text |
| * @var string |
| * @since 1.1 |
| * @access private |
| */ |
| var $_text = ''; |
| // }}} |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @param string Input field name attribute |
| * @param mixed Label(s) for a field |
| * @param string Text to display near the radio |
| * @param string Input field value |
| * @param mixed Either a typical HTML attribute string or an associative array |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function HTML_QuickForm_radio($elementName=null, $elementLabel=null, $text=null, $value=null, $attributes=null) |
| { |
| $this->HTML_QuickForm_element($elementName, $elementLabel, $attributes); |
| if (isset($value)) { |
| $this->setValue($value); |
| } |
| $this->_persistantFreeze = true; |
| $this->setType('radio'); |
| $this->_text = $text; |
| $this->_generateId(); |
| } //end constructor |
| // }}} |
| // {{{ setChecked() |
| /** |
| * Sets whether radio button is checked |
| * |
| * @param bool $checked Whether the field is checked or not |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setChecked($checked) |
| { |
| if (!$checked) { |
| $this->removeAttribute('checked'); |
| } else { |
| $this->updateAttributes(array('checked'=>'checked')); |
| } |
| } //end func setChecked |
| // }}} |
| // {{{ getChecked() |
| /** |
| * Returns whether radio button is checked |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function getChecked() |
| { |
| return $this->getAttribute('checked'); |
| } //end func getChecked |
| // }}} |
| // {{{ toHtml() |
| /** |
| * Returns the radio element in HTML |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function toHtml() |
| { |
| if (0 == strlen($this->_text)) { |
| $label = ''; |
| } elseif ($this->_flagFrozen) { |
| $label = $this->_text; |
| } else { |
| $label = '<label for="' . $this->getAttribute('id') . '">' . $this->_text . '</label>'; |
| } |
| return HTML_QuickForm_input::toHtml() . $label; |
| } //end func toHtml |
| // }}} |
| // {{{ getFrozenHtml() |
| /** |
| * Returns the value of field without HTML tags |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function getFrozenHtml() |
| { |
| if ($this->getChecked()) { |
| return '<tt>(x)</tt>' . |
| $this->_getPersistantData(); |
| } else { |
| return '<tt>( )</tt>'; |
| } |
| } //end func getFrozenHtml |
| // }}} |
| // {{{ setText() |
| /** |
| * Sets the radio text |
| * |
| * @param string $text Text to display near the radio button |
| * @since 1.1 |
| * @access public |
| * @return void |
| */ |
| function setText($text) |
| { |
| $this->_text = $text; |
| } //end func setText |
| // }}} |
| // {{{ getText() |
| /** |
| * Returns the radio text |
| * |
| * @since 1.1 |
| * @access public |
| * @return string |
| */ |
| function getText() |
| { |
| return $this->_text; |
| } //end func getText |
| // }}} |
| // {{{ 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 ($value == $this->getValue()) { |
| $this->setChecked(true); |
| } else { |
| $this->setChecked(false); |
| } |
| break; |
| case 'setGroupValue': |
| if ($arg == $this->getValue()) { |
| $this->setChecked(true); |
| } else { |
| $this->setChecked(false); |
| } |
| break; |
| default: |
| parent::onQuickFormEvent($event, $arg, $caller); |
| } |
| return true; |
| } // end func onQuickFormLoad |
| // }}} |
| // {{{ exportValue() |
| /** |
| * Returns the value attribute if the radio is checked, null if it is not |
| */ |
| function exportValue(&$submitValues, $assoc = false) |
| { |
| $value = $this->_findValue($submitValues); |
| if (null === $value) { |
| $value = $this->getChecked()? $this->getValue(): null; |
| } elseif ($value != $this->getValue()) { |
| $value = null; |
| } |
| return $this->_prepareValue($value, $assoc); |
| } |
| // }}} |
| } //end class HTML_QuickForm_radio |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/input.php |
|---|
| New file |
| 0,0 → 1,202 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: input.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once("HTML/QuickForm/element.php"); |
| /** |
| * Base class for input form elements |
| * |
| * @author Adam Daniel <adaniel1@eesus.jnj.com> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.0 |
| * @since PHP4.04pl1 |
| * @access public |
| * @abstract |
| */ |
| class HTML_QuickForm_input extends HTML_QuickForm_element |
| { |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @param string Input field name attribute |
| * @param mixed Label(s) for the input field |
| * @param mixed Either a typical HTML attribute string or an associative array |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function HTML_QuickForm_input($elementName=null, $elementLabel=null, $attributes=null) |
| { |
| $this->HTML_QuickForm_element($elementName, $elementLabel, $attributes); |
| } //end constructor |
| // }}} |
| // {{{ setType() |
| /** |
| * Sets the element type |
| * |
| * @param string $type Element type |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setType($type) |
| { |
| $this->_type = $type; |
| $this->updateAttributes(array('type'=>$type)); |
| } // end func setType |
| // }}} |
| // {{{ setName() |
| /** |
| * Sets the input field name |
| * |
| * @param string $name Input field name attribute |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setName($name) |
| { |
| $this->updateAttributes(array('name'=>$name)); |
| } //end func setName |
| // }}} |
| // {{{ getName() |
| /** |
| * Returns the element name |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function getName() |
| { |
| return $this->getAttribute('name'); |
| } //end func getName |
| // }}} |
| // {{{ setValue() |
| /** |
| * Sets the value of the form element |
| * |
| * @param string $value Default value of the form element |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setValue($value) |
| { |
| $this->updateAttributes(array('value'=>$value)); |
| } // end func setValue |
| // }}} |
| // {{{ getValue() |
| /** |
| * Returns the value of the form element |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function getValue() |
| { |
| return $this->getAttribute('value'); |
| } // end func getValue |
| // }}} |
| // {{{ toHtml() |
| /** |
| * Returns the input field in HTML |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| */ |
| function toHtml() |
| { |
| if ($this->_flagFrozen) { |
| return $this->getFrozenHtml(); |
| } else { |
| return $this->_getTabs() . '<input' . $this->_getAttrString($this->_attributes) . ' />'; |
| } |
| } //end func toHtml |
| // }}} |
| // {{{ 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 |
| * @throws |
| */ |
| function onQuickFormEvent($event, $arg, &$caller) |
| { |
| // do not use submit values for button-type elements |
| $type = $this->getType(); |
| if (('updateValue' != $event) || |
| ('submit' != $type && 'reset' != $type && 'image' != $type && 'button' != $type)) { |
| parent::onQuickFormEvent($event, $arg, $caller); |
| } else { |
| $value = $this->_findValue($caller->_constantValues); |
| if (null === $value) { |
| $value = $this->_findValue($caller->_defaultValues); |
| } |
| if (null !== $value) { |
| $this->setValue($value); |
| } |
| } |
| return true; |
| } // end func onQuickFormEvent |
| // }}} |
| // {{{ exportValue() |
| /** |
| * We don't need values from button-type elements (except submit) and files |
| */ |
| function exportValue(&$submitValues, $assoc = false) |
| { |
| $type = $this->getType(); |
| if ('reset' == $type || 'image' == $type || 'button' == $type || 'file' == $type) { |
| return null; |
| } else { |
| return parent::exportValue($submitValues, $assoc); |
| } |
| } |
| // }}} |
| } // end class HTML_QuickForm_element |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/RuleRegistry.php |
|---|
| New file |
| 0,0 → 1,333 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Alexey Borzov <borz_off@cs.msu.su> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: RuleRegistry.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| /** |
| * Registers rule objects and uses them for validation |
| * |
| */ |
| 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 object Reference to the HTML_QuickForm_RuleRegistry singleton |
| */ |
| 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 object |
| */ |
| 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 mixed Element(s) the rule applies to |
| * @param string Element name, in case $element is not 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 object 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' && !is_a($element, 'html_quickform_advcheckbox')) { |
| $value = " if (frm.elements['$elementName'].checked) {\n" . |
| " value{$jsIndex} = '1';\n" . |
| " } else {\n" . |
| " value{$jsIndex} = '';\n" . |
| " }"; |
| $tmp_reset .= ($reset) ? " field.checked = field.defaultChecked;\n" : ''; |
| } elseif ($element->getType() == 'radio') { |
| $value = " value{$jsIndex} = '';\n" . |
| " for (var i = 0; i < frm.elements['$elementName'].length; i++) {\n" . |
| " if (frm.elements['$elementName'][i].checked) {\n" . |
| " value{$jsIndex} = frm.elements['$elementName'][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 |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/autocomplete.php |
|---|
| New file |
| 0,0 → 1,249 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP Version 4 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Author: Matteo Di Giovinazzo <matteodg@infinito.it> | |
| // | | |
| // | For the JavaScript code thanks to Martin Honnen and | |
| // | Nicholas C. Zakas | |
| // | See: | |
| // | http://www.faqts.com/knowledge_base/view.phtml/aid/13562 | |
| // | and | |
| // | http://www.sitepoint.com/article/1220 | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: autocomplete.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once("HTML/QuickForm/text.php"); |
| /** |
| * Class to dynamically create an HTML input text element that |
| * at every keypressed javascript event, check in an array of options |
| * if there's a match and autocomplete the text in case of match. |
| * |
| * Ex: |
| * $autocomplete =& $form->addElement('autocomplete', 'fruit', 'Favourite fruit:'); |
| * $options = array("Apple", "Orange", "Pear", "Strawberry"); |
| * $autocomplete->setOptions($options); |
| * |
| * @author Matteo Di Giovinazzo <matteodg@infinito.it> |
| */ |
| 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 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 |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/password.php |
|---|
| New file |
| 0,0 → 1,108 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: password.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once("HTML/QuickForm/input.php"); |
| /** |
| * HTML class for a password type field |
| * |
| * @author Adam Daniel <adaniel1@eesus.jnj.com> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.1 |
| * @since PHP4.04pl1 |
| * @access public |
| */ |
| class HTML_QuickForm_password extends HTML_QuickForm_input |
| { |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @param string $elementName (optional)Input field name attribute |
| * @param string $elementLabel (optional)Input field label |
| * @param mixed $attributes (optional)Either a typical HTML attribute string |
| * or an associative array |
| * @since 1.0 |
| * @access public |
| * @return void |
| * @throws |
| */ |
| function HTML_QuickForm_password($elementName=null, $elementLabel=null, $attributes=null) |
| { |
| HTML_QuickForm_input::HTML_QuickForm_input($elementName, $elementLabel, $attributes); |
| $this->setType('password'); |
| } //end constructor |
| // }}} |
| // {{{ setSize() |
| /** |
| * Sets size of password element |
| * |
| * @param string $size Size of password field |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setSize($size) |
| { |
| $this->updateAttributes(array('size'=>$size)); |
| } //end func setSize |
| // }}} |
| // {{{ setMaxlength() |
| /** |
| * Sets maxlength of password element |
| * |
| * @param string $maxlength Maximum length of password field |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function setMaxlength($maxlength) |
| { |
| $this->updateAttributes(array('maxlength'=>$maxlength)); |
| } //end func setMaxlength |
| // }}} |
| // {{{ getFrozenHtml() |
| /** |
| * Returns the value of field without HTML tags (in this case, value is changed to a mask) |
| * |
| * @since 1.0 |
| * @access public |
| * @return string |
| * @throws |
| */ |
| function getFrozenHtml() |
| { |
| $value = $this->getValue(); |
| return ('' != $value? '**********': ' ') . |
| $this->_getPersistantData(); |
| } //end func getFrozenHtml |
| // }}} |
| } //end class HTML_QuickForm_password |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/xbutton.php |
|---|
| New file |
| 0,0 → 1,145 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP Version 4 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2003 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Alexey Borzov <avb@php.net> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: xbutton.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once 'HTML/QuickForm/element.php'; |
| /** |
| * Class for HTML 4.0 <button> element |
| * |
| * @author Alexey Borzov <avb@php.net> |
| * @since 3.2.3 |
| * @access public |
| */ |
| class HTML_QuickForm_xbutton extends HTML_QuickForm_element |
| { |
| /** |
| * Contents of the <button> tag |
| * @var string |
| * @access private |
| */ |
| var $_content; |
| /** |
| * Class constructor |
| * |
| * @param string Button name |
| * @param string Button content (HTML to add between <button></button> tags) |
| * @param mixed Either a typical HTML attribute string or an associative array |
| * @access public |
| */ |
| function HTML_QuickForm_xbutton($elementName = null, $elementContent = null, $attributes = null) |
| { |
| $this->HTML_QuickForm_element($elementName, null, $attributes); |
| $this->setContent($elementContent); |
| $this->setPersistantFreeze(false); |
| $this->_type = 'xbutton'; |
| } |
| function toHtml() |
| { |
| return '<button' . $this->getAttributes(true) . '>' . $this->_content . '</button>'; |
| } |
| function getFrozenHtml() |
| { |
| return $this->toHtml(); |
| } |
| function freeze() |
| { |
| return false; |
| } |
| function setName($name) |
| { |
| $this->updateAttributes(array( |
| 'name' => $name |
| )); |
| } |
| function getName() |
| { |
| return $this->getAttribute('name'); |
| } |
| function setValue($value) |
| { |
| $this->updateAttributes(array( |
| 'value' => $value |
| )); |
| } |
| function getValue() |
| { |
| return $this->getAttribute('value'); |
| } |
| /** |
| * Sets the contents of the button element |
| * |
| * @param string Button content (HTML to add between <button></button> tags) |
| */ |
| function setContent($content) |
| { |
| $this->_content = $content; |
| } |
| function onQuickFormEvent($event, $arg, &$caller) |
| { |
| if ('updateValue' != $event) { |
| return parent::onQuickFormEvent($event, $arg, $caller); |
| } else { |
| $value = $this->_findValue($caller->_constantValues); |
| if (null === $value) { |
| $value = $this->_findValue($caller->_defaultValues); |
| } |
| if (null !== $value) { |
| $this->setValue($value); |
| } |
| } |
| return true; |
| } |
| /** |
| * Returns a 'safe' element's value |
| * |
| * The value is only returned if the button's type is "submit" and if this |
| * particlular button was clicked |
| */ |
| function exportValue(&$submitValues, $assoc = false) |
| { |
| if ('submit' == $this->getAttribute('type')) { |
| return $this->_prepareValue($this->_findValue($submitValues), $assoc); |
| } else { |
| return null; |
| } |
| } |
| } |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm/submit.php |
|---|
| New file |
| 0,0 → 1,82 |
| <?php |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +----------------------------------------------------------------------+ |
| // | PHP version 4.0 | |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to version 2.0 of the PHP license, | |
| // | that is bundled with this package in the file LICENSE, and is | |
| // | available at through the world-wide-web at | |
| // | http://www.php.net/license/2_02.txt. | |
| // | If you did not receive a copy of the PHP license and are unable to | |
| // | obtain it through the world-wide-web, please send a note to | |
| // | license@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Authors: Adam Daniel <adaniel1@eesus.jnj.com> | |
| // | Bertrand Mansion <bmansion@mamasam.com> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id: submit.php,v 1.2 2005-09-20 17:01:22 ddelon Exp $ |
| require_once("HTML/QuickForm/input.php"); |
| /** |
| * HTML class for a submit type element |
| * |
| * @author Adam Daniel <adaniel1@eesus.jnj.com> |
| * @author Bertrand Mansion <bmansion@mamasam.com> |
| * @version 1.0 |
| * @since PHP4.04pl1 |
| * @access public |
| */ |
| class HTML_QuickForm_submit extends HTML_QuickForm_input |
| { |
| // {{{ constructor |
| /** |
| * Class constructor |
| * |
| * @param string Input field name attribute |
| * @param string Input field value |
| * @param mixed Either a typical HTML attribute string or an associative array |
| * @since 1.0 |
| * @access public |
| * @return void |
| */ |
| function HTML_QuickForm_submit($elementName=null, $value=null, $attributes=null) |
| { |
| HTML_QuickForm_input::HTML_QuickForm_input($elementName, null, $attributes); |
| $this->setValue($value); |
| $this->setType('submit'); |
| } //end constructor |
| // }}} |
| // {{{ freeze() |
| /** |
| * Freeze the element so that only its value is returned |
| * |
| * @access public |
| * @return void |
| */ |
| function freeze() |
| { |
| return false; |
| } //end func freeze |
| // }}} |
| // {{{ exportValue() |
| /** |
| * Only return the value if it is found within $submitValues (i.e. if |
| * this particular submit button was clicked) |
| */ |
| function exportValue(&$submitValues, $assoc = false) |
| { |
| return $this->_prepareValue($this->_findValue($submitValues), $assoc); |
| } |
| // }}} |
| } //end class HTML_QuickForm_submit |
| ?> |
| /branches/livraison_aha/api/pear/HTML/QuickForm.php |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| /branches/livraison_aha/api/pear/HTML/QuickForm.php |
|---|
| New file |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /branches/livraison_aha/api/pear/HTML/Template/ITX.php |
|---|
| New file |
| 0,0 → 1,809 |
| <?php |
| // |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2005 Ulf Wendel, Pierre-Alain Joye | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to the New BSD license, That is bundled | |
| // | with this package in the file LICENSE, and is available through | |
| // | the world-wide-web at | |
| // | http://www.opensource.org/licenses/bsd-license.php | |
| // | If you did not receive a copy of the new BSD license and are unable | |
| // | to obtain it through the world-wide-web, please send a note to | |
| // | pajoye@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Author: Ulf Wendel <ulf.wendel@phpdoc.de> | |
| // | Pierre-Alain Joye <pajoye@php.net> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id$ |
| // |
| require_once 'HTML/Template/IT.php'; |
| require_once 'HTML/Template/IT_Error.php'; |
| /** |
| * Integrated Template Extension - ITX |
| * |
| * With this class you get the full power of the phplib template class. |
| * You may have one file with blocks in it but you have as well one main file |
| * and multiple files one for each block. This is quite usefull when you have |
| * user configurable websites. Using blocks not in the main template allows |
| * you to modify some parts of your layout easily. |
| * |
| * Note that you can replace an existing block and add new blocks at runtime. |
| * Adding new blocks means changing a variable placeholder to a block. |
| * |
| * @author Ulf Wendel <uw@netuse.de> |
| * @access public |
| * @version $Id$ |
| * @package IT[X] |
| */ |
| class HTML_Template_ITX extends HTML_Template_IT |
| { |
| /** |
| * Array with all warnings. |
| * @var array |
| * @access public |
| * @see $printWarning, $haltOnWarning, warning() |
| */ |
| var $warn = array(); |
| /** |
| * Print warnings? |
| * @var array |
| * @access public |
| * @see $haltOnWarning, $warn, warning() |
| */ |
| var $printWarning = false; |
| /** |
| * Call die() on warning? |
| * @var boolean |
| * @access public |
| * @see $warn, $printWarning, warning() |
| */ |
| var $haltOnWarning = false; |
| /** |
| * RegExp used to test for a valid blockname. |
| * @var string |
| */ |
| var $checkblocknameRegExp = ''; |
| /** |
| * Functionnameprefix used when searching function calls in the template. |
| * @var string |
| */ |
| var $functionPrefix = 'func_'; |
| /** |
| * Functionname RegExp. |
| * @var string |
| */ |
| var $functionnameRegExp = '[_a-zA-Z]+[A-Za-z_0-9]*'; |
| /** |
| * RegExp used to grep function calls in the template. |
| * |
| * The variable gets set by the constructor. |
| * |
| * @var string |
| * @see HTML_Template_IT() |
| */ |
| var $functionRegExp = ''; |
| /** |
| * List of functions found in the template. |
| * |
| * @var array |
| */ |
| var $functions = array(); |
| /** |
| * List of callback functions specified by the user. |
| * |
| * @var array |
| */ |
| var $callback = array(); |
| /** |
| * Builds some complex regexps and calls the constructor |
| * of the parent class. |
| * |
| * Make sure that you call this constructor if you derive your own |
| * template class from this one. |
| * |
| * @see HTML_Template_IT() |
| */ |
| function HTML_Template_ITX($root = '') |
| { |
| $this->checkblocknameRegExp = '@' . $this->blocknameRegExp . '@'; |
| $this->functionRegExp = '@' . $this->functionPrefix . '(' . |
| $this->functionnameRegExp . ')\s*\(@sm'; |
| $this->HTML_Template_IT($root); |
| } // end func constructor |
| function init() |
| { |
| $this->free(); |
| $this->buildFunctionlist(); |
| $this->findBlocks($this->template); |
| // we don't need it any more |
| $this->template = ''; |
| $this->buildBlockvariablelist(); |
| } // end func init |
| /** |
| * Replaces an existing block with new content. |
| * |
| * This function will replace a block of the template and all blocks |
| * contained in the replaced block and add a new block insted, means |
| * you can dynamically change your template. |
| * |
| * Note that changing the template structure violates one of the IT[X] |
| * development goals. I've tried to write a simple to use template engine |
| * supporting blocks. In contrast to other systems IT[X] analyses the way |
| * you've nested blocks and knows which block belongs into another block. |
| * The nesting information helps to make the API short and simple. Replacing |
| * blocks does not only mean that IT[X] has to update the nesting |
| * information (relatively time consumpting task) but you have to make sure |
| * that you do not get confused due to the template change itself. |
| * |
| * @param string Blockname |
| * @param string Blockcontent |
| * @param boolean true if the new block inherits the content |
| * of the old block |
| * @return boolean |
| * @throws IT_Error |
| * @see replaceBlockfile(), addBlock(), addBlockfile() |
| * @access public |
| */ |
| function replaceBlock($block, $template, $keep_content = false) |
| { |
| if (!isset($this->blocklist[$block])) { |
| return new IT_Error( |
| "The block "."'$block'". |
| " does not exist in the template and thus it can't be replaced.", |
| __FILE__, __LINE__ |
| ); |
| } |
| if ($template == '') { |
| return new IT_Error('No block content given.', __FILE__, __LINE__); |
| } |
| if ($keep_content) { |
| $blockdata = $this->blockdata[$block]; |
| } |
| // remove all kinds of links to the block / data of the block |
| $this->removeBlockData($block); |
| $template = "<!-- BEGIN $block -->" . $template . "<!-- END $block -->"; |
| $parents = $this->blockparents[$block]; |
| $this->findBlocks($template); |
| $this->blockparents[$block] = $parents; |
| // KLUDGE: rebuild the list for all block - could be done faster |
| $this->buildBlockvariablelist(); |
| if ($keep_content) { |
| $this->blockdata[$block] = $blockdata; |
| } |
| // old TODO - I'm not sure if we need this |
| // update caches |
| return true; |
| } // end func replaceBlock |
| /** |
| * Replaces an existing block with new content from a file. |
| * |
| * @brother replaceBlock() |
| * @param string Blockname |
| * @param string Name of the file that contains the blockcontent |
| * @param boolean true if the new block inherits the content of the old block |
| */ |
| function replaceBlockfile($block, $filename, $keep_content = false) |
| { |
| return $this->replaceBlock($block, $this->getFile($filename), $keep_content); |
| } // end func replaceBlockfile |
| /** |
| * Adds a block to the template changing a variable placeholder |
| * to a block placeholder. |
| * |
| * Add means "replace a variable placeholder by a new block". |
| * This is different to PHPLibs templates. The function loads a |
| * block, creates a handle for it and assigns it to a certain |
| * variable placeholder. To to the same with PHPLibs templates you would |
| * call set_file() to create the handle and parse() to assign the |
| * parsed block to a variable. By this PHPLibs templates assume |
| * that you tend to assign a block to more than one one placeholder. |
| * To assign a parsed block to more than only the placeholder you specify |
| * in this function you have to use a combination of getBlock() |
| * and setVariable(). |
| * |
| * As no updates to cached data is necessary addBlock() and addBlockfile() |
| * are rather "cheap" meaning quick operations. |
| * |
| * The block content must not start with <!-- BEGIN blockname --> |
| * and end with <!-- END blockname --> this would cause overhead and |
| * produce an error. |
| * |
| * @param string Name of the variable placeholder, the name must be unique |
| * within the template. |
| * @param string Name of the block to be added |
| * @param string Content of the block |
| * @return boolean |
| * @throws IT_Error |
| * @see addBlockfile() |
| * @access public |
| */ |
| function addBlock($placeholder, $blockname, $template) |
| { |
| // Don't trust any user even if it's a programmer or yourself... |
| if ($placeholder == '') { |
| return new IT_Error('No variable placeholder given.', |
| __FILE__, __LINE__ |
| ); |
| } elseif ($blockname == '' || |
| !preg_match($this->checkblocknameRegExp, $blockname) |
| ) { |
| return new IT_Error("No or invalid blockname '$blockname' given.", |
| __FILE__, __LINE__ |
| ); |
| } elseif ($template == '') { |
| return new IT_Error('No block content given.', __FILE__, __LINE__); |
| } elseif (isset($this->blocklist[$blockname])) { |
| return new IT_Error('The block already exists.', |
| __FILE__, __LINE__ |
| ); |
| } |
| // find out where to insert the new block |
| $parents = $this->findPlaceholderBlocks($placeholder); |
| if (count($parents) == 0) { |
| return new IT_Error( |
| "The variable placeholder". |
| " '$placeholder' was not found in the template.", |
| __FILE__, __LINE__ |
| ); |
| } elseif (count($parents) > 1) { |
| reset($parents); |
| while (list($k, $parent) = each($parents)) { |
| $msg .= "$parent, "; |
| } |
| $msg = substr($parent, -2); |
| return new IT_Error("The variable placeholder "."'$placeholder'". |
| " must be unique, found in multiple blocks '$msg'.", |
| __FILE__, __LINE__ |
| ); |
| } |
| $template = "<!-- BEGIN $blockname -->" . $template . "<!-- END $blockname -->"; |
| $this->findBlocks($template); |
| if ($this->flagBlocktrouble) { |
| return false; // findBlocks() already throws an exception |
| } |
| $this->blockinner[$parents[0]][] = $blockname; |
| $this->blocklist[$parents[0]] = preg_replace( |
| '@' . $this->openingDelimiter . $placeholder . |
| $this->closingDelimiter . '@', |
| $this->openingDelimiter . '__' . $blockname . '__' . |
| $this->closingDelimiter, |
| $this->blocklist[$parents[0]] |
| ); |
| $this->deleteFromBlockvariablelist($parents[0], $placeholder); |
| $this->updateBlockvariablelist($blockname); |
| /* |
| // check if any inner blocks were found |
| if(is_array($this->blockinner[$blockname]) and count($this->blockinner[$blockname]) > 0) { |
| // loop through inner blocks, registering the variable placeholders in each |
| foreach($this->blockinner[$blockname] as $childBlock) { |
| $this->updateBlockvariablelist($childBlock); |
| } |
| } |
| */ |
| return true; |
| } // end func addBlock |
| /** |
| * Adds a block taken from a file to the template changing a variable |
| * placeholder to a block placeholder. |
| * |
| * @param string Name of the variable placeholder to be converted |
| * @param string Name of the block to be added |
| * @param string File that contains the block |
| * @brother addBlock() |
| */ |
| function addBlockfile($placeholder, $blockname, $filename) |
| { |
| return $this->addBlock($placeholder, $blockname, $this->getFile($filename)); |
| } // end func addBlockfile |
| /** |
| * Returns the name of the (first) block that contains |
| * the specified placeholder. |
| * |
| * @param string Name of the placeholder you're searching |
| * @param string Name of the block to scan. If left out (default) |
| * all blocks are scanned. |
| * @return string Name of the (first) block that contains |
| * the specified placeholder. |
| * If the placeholder was not found or an error occured |
| * an empty string is returned. |
| * @throws IT_Error |
| * @access public |
| */ |
| function placeholderExists($placeholder, $block = '') |
| { |
| if ($placeholder == '') { |
| new IT_Error('No placeholder name given.', __FILE__, __LINE__); |
| return ''; |
| } |
| if ($block != '' && !isset($this->blocklist[$block])) { |
| new IT_Error("Unknown block '$block'.", __FILE__, __LINE__); |
| return ''; |
| } |
| // name of the block where the given placeholder was found |
| $found = ''; |
| if ($block != '') { |
| if (is_array($variables = $this->blockvariables[$block])) { |
| // search the value in the list of blockvariables |
| reset($variables); |
| while (list($k, $variable) = each($variables)) { |
| if ($k == $placeholder) { |
| $found = $block; |
| break; |
| } |
| } |
| } |
| } else { |
| // search all blocks and return the name of the first block that |
| // contains the placeholder |
| reset($this->blockvariables); |
| while (list($blockname, $variables) = each($this->blockvariables)){ |
| if (is_array($variables) && isset($variables[$placeholder])) { |
| $found = $blockname; |
| break; |
| } |
| } |
| } |
| return $found; |
| } // end func placeholderExists |
| /** |
| * Checks the list of function calls in the template and |
| * calls their callback function. |
| * |
| * @access public |
| */ |
| function performCallback() |
| { |
| reset($this->functions); |
| while (list($func_id, $function) = each($this->functions)) { |
| if (isset($this->callback[$function['name']])) { |
| if ($this->callback[$function['name']]['object'] != '') { |
| $this->variableCache['__function' . $func_id . '__'] = |
| call_user_func( |
| array( |
| &$GLOBALS[$this->callback[$function['name']]['object']], |
| $this->callback[$function['name']]['function']), |
| $function['args'] |
| ); |
| } else { |
| $this->variableCache['__function' . $func_id . '__'] = |
| call_user_func( |
| $this->callback[$function['name']]['function'], |
| $function['args'] |
| ); |
| } |
| } |
| } |
| } // end func performCallback |
| /** |
| * Returns a list of all function calls in the current template. |
| * |
| * @return array |
| * @access public |
| */ |
| function getFunctioncalls() |
| { |
| return $this->functions; |
| } // end func getFunctioncalls |
| /** |
| * Replaces a function call with the given replacement. |
| * |
| * @param int Function ID |
| * @param string Replacement |
| * @deprec |
| */ |
| function setFunctioncontent($functionID, $replacement) |
| { |
| $this->variableCache['__function' . $functionID . '__'] = $replacement; |
| } // end func setFunctioncontent |
| /** |
| * Sets a callback function. |
| * |
| * IT[X] templates (note the X) can contain simple function calls. |
| * "function call" means that the editor of the template can add |
| * special placeholder to the template like 'func_h1("embedded in h1")'. |
| * IT[X] will grab this function calls and allow you to define a callback |
| * function for them. |
| * |
| * This is an absolutely evil feature. If your application makes heavy |
| * use of such callbacks and you're even implementing if-then etc. on |
| * the level of a template engine you're reiventing the wheel... - that's |
| * actually how PHP came into life. Anyway, sometimes it's handy. |
| * |
| * Consider also using XML/XSLT or native PHP. And please do not push |
| * IT[X] any further into this direction of adding logics to the template |
| * engine. |
| * |
| * For those of you ready for the X in IT[X]: |
| * |
| * <?php |
| * ... |
| * function h_one($args) { |
| * return sprintf('<h1>%s</h1>', $args[0]); |
| * } |
| * |
| * ... |
| * $itx = new HTML_Template_ITX( ... ); |
| * ... |
| * $itx->setCallbackFunction('h1', 'h_one'); |
| * $itx->performCallback(); |
| * ?> |
| * |
| * template: |
| * func_h1('H1 Headline'); |
| * |
| * @param string Function name in the template |
| * @param string Name of the callback function |
| * @param string Name of the callback object |
| * @return boolean False on failure. |
| * @throws IT_Error |
| * @access public |
| */ |
| function |
| setCallbackFunction($tplfunction, $callbackfunction, $callbackobject = '') |
| { |
| if ($tplfunction == '' || $callbackfunction == '') { |
| return new IT_Error( |
| "No template function "."('$tplfunction')". |
| " and/or no callback function ('$callback') given.", |
| __FILE__, __LINE__ |
| ); |
| } |
| $this->callback[$tplfunction] = array( |
| 'function' => $callbackfunction, |
| 'object' => $callbackobject |
| ); |
| return true; |
| } // end func setCallbackFunction |
| /** |
| * Sets the Callback function lookup table |
| * |
| * @param array function table |
| * array[templatefunction] = |
| * array( |
| * "function" => userfunction, |
| * "object" => userobject |
| * ) |
| * @access public |
| */ |
| function setCallbackFuntiontable($functions) |
| { |
| $this->callback = $functions; |
| } // end func setCallbackFunctiontable |
| /** |
| * Recursively removes all data assiciated with a block, including all inner blocks |
| * |
| * @param string block to be removed |
| */ |
| function removeBlockData($block) |
| { |
| if (isset($this->blockinner[$block])) { |
| foreach ($this->blockinner[$block] as $k => $inner) { |
| $this->removeBlockData($inner); |
| } |
| unset($this->blockinner[$block]); |
| } |
| unset($this->blocklist[$block]); |
| unset($this->blockdata[$block]); |
| unset($this->blockvariables[$block]); |
| unset($this->touchedBlocks[$block]); |
| } // end func removeBlockinner |
| /** |
| * Returns a list of blocknames in the template. |
| * |
| * @return array [blockname => blockname] |
| * @access public |
| * @see blockExists() |
| */ |
| function getBlocklist() |
| { |
| $blocklist = array(); |
| foreach ($this->blocklist as $block => $content) { |
| $blocklist[$block] = $block; |
| } |
| return $blocklist; |
| } // end func getBlocklist |
| /** |
| * Checks wheter a block exists. |
| * |
| * @param string |
| * @return boolean |
| * @access public |
| * @see getBlocklist() |
| */ |
| function blockExists($blockname) |
| { |
| return isset($this->blocklist[$blockname]); |
| } // end func blockExists |
| /** |
| * Returns a list of variables of a block. |
| * |
| * @param string Blockname |
| * @return array [varname => varname] |
| * @access public |
| * @see BlockvariableExists() |
| */ |
| function getBlockvariables($block) |
| { |
| if (!isset($this->blockvariables[$block])) { |
| return array(); |
| } |
| $variables = array(); |
| foreach ($this->blockvariables[$block] as $variable => $v) { |
| $variables[$variable] = $variable; |
| } |
| return $variables; |
| } // end func getBlockvariables |
| /** |
| * Checks wheter a block variable exists. |
| * |
| * @param string Blockname |
| * @param string Variablename |
| * @return boolean |
| * @access public |
| * @see getBlockvariables() |
| */ |
| function BlockvariableExists($block, $variable) |
| { |
| return isset($this->blockvariables[$block][$variable]); |
| } // end func BlockvariableExists |
| /** |
| * Builds a functionlist from the template. |
| */ |
| function buildFunctionlist() |
| { |
| $this->functions = array(); |
| $template = $this->template; |
| $num = 0; |
| while (preg_match($this->functionRegExp, $template, $regs)) { |
| $pos = strpos($template, $regs[0]); |
| $template = substr($template, $pos + strlen($regs[0])); |
| $head = $this->getValue($template, ')'); |
| $args = array(); |
| $search = $regs[0] . $head . ')'; |
| $replace = $this->openingDelimiter . |
| '__function' . $num . '__' . |
| $this->closingDelimiter; |
| $this->template = str_replace($search, $replace, $this->template); |
| $template = str_replace($search, $replace, $template); |
| while ($head != '' && $args2 = $this->getValue($head, ',')) { |
| $arg2 = trim($args2); |
| $args[] = ('"' == $arg2{0} || "'" == $arg2{0}) ? |
| substr($arg2, 1, -1) : $arg2; |
| if ($arg2 == $head) { |
| break; |
| } |
| $head = substr($head, strlen($arg2) + 1); |
| } |
| $this->functions[$num++] = array( |
| 'name' => $regs[1], |
| 'args' => $args |
| ); |
| } |
| } // end func buildFunctionlist |
| function getValue($code, $delimiter) { |
| if ($code == '') { |
| return ''; |
| } |
| if (!is_array($delimiter)) { |
| $delimiter = array( $delimiter => true ); |
| } |
| $len = strlen($code); |
| $enclosed = false; |
| $enclosed_by = ''; |
| if (isset($delimiter[$code[0]])) { |
| $i = 1; |
| } else { |
| for ($i = 0; $i < $len; ++$i) { |
| $char = $code[$i]; |
| if ( |
| ($char == '"' || $char = "'") && |
| ($char == $enclosed_by || '' == $enclosed_by) && |
| (0 == $i || ($i > 0 && '\\' != $code[$i - 1])) |
| ) { |
| if (!$enclosed) { |
| $enclosed_by = $char; |
| } else { |
| $enclosed_by = ""; |
| } |
| $enclosed = !$enclosed; |
| } |
| if (!$enclosed && isset($delimiter[$char])) { |
| break; |
| } |
| } |
| } |
| return substr($code, 0, $i); |
| } // end func getValue |
| /** |
| * Deletes one or many variables from the block variable list. |
| * |
| * @param string Blockname |
| * @param mixed Name of one variable or array of variables |
| * ( array ( name => true ) ) to be stripped. |
| */ |
| function deleteFromBlockvariablelist($block, $variables) |
| { |
| if (!is_array($variables)) { |
| $variables = array($variables => true); |
| } |
| reset($this->blockvariables[$block]); |
| while (list($varname, $val) = each($this->blockvariables[$block])) { |
| if (isset($variables[$varname])) { |
| unset($this->blockvariables[$block][$varname]); |
| } |
| } |
| } // end deleteFromBlockvariablelist |
| /** |
| * Updates the variable list of a block. |
| * |
| * @param string Blockname |
| */ |
| function updateBlockvariablelist($block) |
| { |
| preg_match_all( $this->variablesRegExp, |
| $this->blocklist[$block], $regs |
| ); |
| if (count($regs[1]) != 0) { |
| foreach ($regs[1] as $k => $var) { |
| $this->blockvariables[$block][$var] = true; |
| } |
| } else { |
| $this->blockvariables[$block] = array(); |
| } |
| // check if any inner blocks were found |
| if (isset($this->blockinner[$block]) && |
| is_array($this->blockinner[$block]) && |
| count($this->blockinner[$block]) > 0 |
| ) { |
| /* |
| * loop through inner blocks, registering the variable |
| * placeholders in each |
| */ |
| foreach ($this->blockinner[$block] as $childBlock) { |
| $this->updateBlockvariablelist($childBlock); |
| } |
| } |
| } // end func updateBlockvariablelist |
| /** |
| * Returns an array of blocknames where the given variable |
| * placeholder is used. |
| * |
| * @param string Variable placeholder |
| * @return array $parents parents[0..n] = blockname |
| */ |
| function findPlaceholderBlocks($variable) |
| { |
| $parents = array(); |
| reset($this->blocklist); |
| while (list($blockname, $content) = each($this->blocklist)) { |
| reset($this->blockvariables[$blockname]); |
| while ( |
| list($varname, $val) = each($this->blockvariables[$blockname])) |
| { |
| if ($variable == $varname) { |
| $parents[] = $blockname; |
| } |
| } |
| } |
| return $parents; |
| } // end func findPlaceholderBlocks |
| /** |
| * Handles warnings, saves them to $warn and prints them or |
| * calls die() depending on the flags |
| * |
| * @param string Warning |
| * @param string File where the warning occured |
| * @param int Linenumber where the warning occured |
| * @see $warn, $printWarning, $haltOnWarning |
| */ |
| function warning($message, $file = '', $line = 0) |
| { |
| $message = sprintf( |
| 'HTML_Template_ITX Warning: %s [File: %s, Line: %d]', |
| $message, |
| $file, |
| $line |
| ); |
| $this->warn[] = $message; |
| if ($this->printWarning) { |
| print $message; |
| } |
| if ($this->haltOnWarning) { |
| die($message); |
| } |
| } // end func warning |
| } // end class HTML_Template_ITX |
| ?> |
| /branches/livraison_aha/api/pear/HTML/Template/IT_Error.php |
|---|
| New file |
| 0,0 → 1,51 |
| <?php |
| // |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2005 Ulf Wendel, Pierre-Alain Joye | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to the New BSD license, That is bundled | |
| // | with this package in the file LICENSE, and is available through | |
| // | the world-wide-web at | |
| // | http://www.opensource.org/licenses/bsd-license.php | |
| // | If you did not receive a copy of the new BSD license and are unable | |
| // | to obtain it through the world-wide-web, please send a note to | |
| // | pajoye@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Author: Ulf Wendel <ulf.wendel@phpdoc.de> | |
| // | Pierre-Alain Joye <pajoye@php.net> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id$ |
| require_once "PEAR.php"; |
| /** |
| * IT[X] Error class |
| * |
| * @package IT[X] |
| */ |
| class IT_Error extends PEAR_Error { |
| /** |
| * Prefix of all error messages. |
| * |
| * @var string |
| */ |
| var $error_message_prefix = "IntegratedTemplate Error: "; |
| /** |
| * Creates an cache error object. |
| * |
| * @param string error message |
| * @param string file where the error occured |
| * @param string linenumber where the error occured |
| */ |
| function IT_Error($msg, $file = __FILE__, $line = __LINE__) { |
| $this->PEAR_Error(sprintf("%s [%s on line %d].", $msg, $file, $line)); |
| } // end func IT_Error |
| } // end class IT_Error |
| ?> |
| /branches/livraison_aha/api/pear/HTML/Template/IT.php |
|---|
| New file |
| 0,0 → 1,990 |
| <?php |
| // |
| // +----------------------------------------------------------------------+ |
| // | Copyright (c) 1997-2005 Ulf Wendel, Pierre-Alain Joye | |
| // +----------------------------------------------------------------------+ |
| // | This source file is subject to the New BSD license, That is bundled | |
| // | with this package in the file LICENSE, and is available through | |
| // | the world-wide-web at | |
| // | http://www.opensource.org/licenses/bsd-license.php | |
| // | If you did not receive a copy of the new BSDlicense and are unable | |
| // | to obtain it through the world-wide-web, please send a note to | |
| // | pajoye@php.net so we can mail you a copy immediately. | |
| // +----------------------------------------------------------------------+ |
| // | Author: Ulf Wendel <ulf.wendel@phpdoc.de> | |
| // | Pierre-Alain Joye <pajoye@php.net> | |
| // +----------------------------------------------------------------------+ |
| // |
| // $Id$ |
| // |
| require_once 'PEAR.php'; |
| define('IT_OK', 1); |
| define('IT_ERROR', -1); |
| define('IT_TPL_NOT_FOUND', -2); |
| define('IT_BLOCK_NOT_FOUND', -3); |
| define('IT_BLOCK_DUPLICATE', -4); |
| define('IT_UNKNOWN_OPTION', -6); |
| /** |
| * Integrated Template - IT |
| * |
| * Well there's not much to say about it. I needed a template class that |
| * supports a single template file with multiple (nested) blocks inside and |
| * a simple block API. |
| * |
| * The Isotemplate API is somewhat tricky for a beginner although it is the best |
| * one you can build. template::parse() [phplib template = Isotemplate] requests |
| * you to name a source and a target where the current block gets parsed into. |
| * Source and target can be block names or even handler names. This API gives you |
| * a maximum of fexibility but you always have to know what you do which is |
| * quite unusual for php skripter like me. |
| * |
| * I noticed that I do not any control on which block gets parsed into which one. |
| * If all blocks are within one file, the script knows how they are nested and in |
| * which way you have to parse them. IT knows that inner1 is a child of block2, there's |
| * no need to tell him about this. |
| * |
| * <table border> |
| * <tr> |
| * <td colspan=2> |
| * __global__ |
| * <p> |
| * (hidden and automatically added) |
| * </td> |
| * </tr> |
| * <tr> |
| * <td>block1</td> |
| * <td> |
| * <table border> |
| * <tr> |
| * <td colspan=2>block2</td> |
| * </tr> |
| * <tr> |
| * <td>inner1</td> |
| * <td>inner2</td> |
| * </tr> |
| * </table> |
| * </td> |
| * </tr> |
| * </table> |
| * |
| * To add content to block1 you simply type: |
| * <code>$tpl->setCurrentBlock("block1");</code> |
| * and repeat this as often as needed: |
| * <code> |
| * $tpl->setVariable(...); |
| * $tpl->parseCurrentBlock(); |
| * </code> |
| * |
| * To add content to block2 you would type something like: |
| * <code> |
| * $tpl->setCurrentBlock("inner1"); |
| * $tpl->setVariable(...); |
| * $tpl->parseCurrentBlock(); |
| * |
| * $tpl->setVariable(...); |
| * $tpl->parseCurrentBlock(); |
| * |
| * $tpl->parse("block1"); |
| * </code> |
| * |
| * This will result in one repition of block1 which contains two repitions |
| * of inner1. inner2 will be removed if $removeEmptyBlock is set to true which is the default. |
| * |
| * Usage: |
| * <code> |
| * $tpl = new HTML_Template_IT( [string filerootdir] ); |
| * |
| * // load a template or set it with setTemplate() |
| * $tpl->loadTemplatefile( string filename [, boolean removeUnknownVariables, boolean removeEmptyBlocks] ) |
| * |
| * // set "global" Variables meaning variables not beeing within a (inner) block |
| * $tpl->setVariable( string variablename, mixed value ); |
| * |
| * // like with the Isotemplates there's a second way to use setVariable() |
| * $tpl->setVariable( array ( string varname => mixed value ) ); |
| * |
| * // Let's use any block, even a deeply nested one |
| * $tpl->setCurrentBlock( string blockname ); |
| * |
| * // repeat this as often as you need it. |
| * $tpl->setVariable( array ( string varname => mixed value ) ); |
| * $tpl->parseCurrentBlock(); |
| * |
| * // get the parsed template or print it: $tpl->show() |
| * $tpl->get(); |
| * </code> |
| * |
| * @author Ulf Wendel <uw@netuse.de> |
| * @version $Id$ |
| * @access public |
| * @package HTML_Template_IT |
| */ |
| class HTML_Template_IT |
| { |
| /** |
| * Contains the error objects |
| * @var array |
| * @access public |
| * @see halt(), $printError, $haltOnError |
| */ |
| var $err = array(); |
| /** |
| * Clear cache on get()? |
| * @var boolean |
| */ |
| var $clearCache = false; |
| /** |
| * First character of a variable placeholder ( _{_VARIABLE} ). |
| * @var string |
| * @access public |
| * @see $closingDelimiter, $blocknameRegExp, $variablenameRegExp |
| */ |
| var $openingDelimiter = '{'; |
| /** |
| * Last character of a variable placeholder ( {VARIABLE_}_ ). |
| * @var string |
| * @access public |
| * @see $openingDelimiter, $blocknameRegExp, $variablenameRegExp |
| */ |
| var $closingDelimiter = '}'; |
| /** |
| * RegExp matching a block in the template. |
| * Per default "sm" is used as the regexp modifier, "i" is missing. |
| * That means a case sensitive search is done. |
| * @var string |
| * @access public |
| * @see $variablenameRegExp, $openingDelimiter, $closingDelimiter |
| */ |
| var $blocknameRegExp = '[0-9A-Za-z_-]+'; |
| /** |
| * RegExp matching a variable placeholder in the template. |
| * Per default "sm" is used as the regexp modifier, "i" is missing. |
| * That means a case sensitive search is done. |
| * @var string |
| * @access public |
| * @see $blocknameRegExp, $openingDelimiter, $closingDelimiter |
| */ |
| var $variablenameRegExp = '[0-9A-Za-z_-]+'; |
| /** |
| * RegExp used to find variable placeholder, filled by the constructor. |
| * @var string Looks somewhat like @(delimiter varname delimiter)@ |
| * @access public |
| * @see IntegratedTemplate() |
| */ |
| var $variablesRegExp = ''; |
| /** |
| * RegExp used to strip unused variable placeholder. |
| * @brother $variablesRegExp |
| */ |
| var $removeVariablesRegExp = ''; |
| /** |
| * Controls the handling of unknown variables, default is remove. |
| * @var boolean |
| * @access public |
| */ |
| var $removeUnknownVariables = true; |
| /** |
| * Controls the handling of empty blocks, default is remove. |
| * @var boolean |
| * @access public |
| */ |
| var $removeEmptyBlocks = true; |
| /** |
| * RegExp used to find blocks an their content, filled by the constructor. |
| * @var string |
| * @see IntegratedTemplate() |
| */ |
| var $blockRegExp = ''; |
| /** |
| * Name of the current block. |
| * @var string |
| */ |
| var $currentBlock = '__global__'; |
| /** |
| * Content of the template. |
| * @var string |
| */ |
| var $template = ''; |
| /** |
| * Array of all blocks and their content. |
| * |
| * @var array |
| * @see findBlocks() |
| */ |
| var $blocklist = array(); |
| /** |
| * Array with the parsed content of a block. |
| * |
| * @var array |
| */ |
| var $blockdata = array(); |
| /** |
| * Array of variables in a block. |
| * @var array |
| */ |
| var $blockvariables = array(); |
| /** |
| * Array of inner blocks of a block. |
| * @var array |
| */ |
| var $blockinner = array(); |
| /** |
| * List of blocks to preverse even if they are "empty". |
| * |
| * This is something special. Sometimes you have blocks that |
| * should be preserved although they are empty (no placeholder replaced). |
| * Think of a shopping basket. If it's empty you have to drop a message to |
| * the user. If it's filled you have to show the contents of |
| * the shopping baseket. Now where do you place the message that the basket |
| * is empty? It's no good idea to place it in you applications as customers |
| * tend to like unecessary minor text changes. Having another template file |
| * for an empty basket means that it's very likely that one fine day |
| * the filled and empty basket templates have different layout. I decided |
| * to introduce blocks that to not contain any placeholder but only |
| * text such as the message "Your shopping basked is empty". |
| * |
| * Now if there is no replacement done in such a block the block will |
| * be recognized as "empty" and by default ($removeEmptyBlocks = true) be |
| * stripped off. To avoid thisyou can now call touchBlock() to avoid this. |
| * |
| * The array $touchedBlocks stores a list of touched block which must not |
| * be removed even if they are empty. |
| * |
| * @var array $touchedBlocks |
| * @see touchBlock(), $removeEmptyBlocks |
| */ |
| var $touchedBlocks = array(); |
| /** |
| * List of blocks which should not be shown even if not "empty" |
| * @var array $_hiddenBlocks |
| * @see hideBlock(), $removeEmptyBlocks |
| */ |
| var $_hiddenBlocks = array(); |
| /** |
| * Variable cache. |
| * |
| * Variables get cached before any replacement is done. |
| * Advantage: empty blocks can be removed automatically. |
| * Disadvantage: might take some more memory |
| * |
| * @var array |
| * @see setVariable(), $clearCacheOnParse |
| */ |
| var $variableCache = array(); |
| /** |
| * Clear the variable cache on parse? |
| * |
| * If you're not an expert just leave the default false. |
| * True reduces memory consumption somewhat if you tend to |
| * add lots of values for unknown placeholder. |
| * |
| * @var boolean |
| */ |
| var $clearCacheOnParse = false; |
| /** |
| * Root directory for all file operations. |
| * The string gets prefixed to all filenames given. |
| * @var string |
| * @see HTML_Template_IT(), setRoot() |
| */ |
| var $fileRoot = ''; |
| /** |
| * Internal flag indicating that a blockname was used multiple times. |
| * @var boolean |
| */ |
| var $flagBlocktrouble = false; |
| /** |
| * Flag indicating that the global block was parsed. |
| * @var boolean |
| */ |
| var $flagGlobalParsed = false; |
| /** |
| * EXPERIMENTAL! FIXME! |
| * Flag indication that a template gets cached. |
| * |
| * Complex templates require some times to be preparsed |
| * before the replacement can take place. Often I use |
| * one template file over and over again but I don't know |
| * before that I will use the same template file again. |
| * Now IT could notice this and skip the preparse. |
| * |
| * @var boolean |
| */ |
| var $flagCacheTemplatefile = true; |
| /** |
| * EXPERIMENTAL! FIXME! |
| */ |
| var $lastTemplatefile = ''; |
| /** |
| * $_options['preserve_data'] Whether to substitute variables and remove |
| * empty placeholders in data passed through setVariable |
| * (see also bugs #20199, #21951). |
| * $_options['use_preg'] Whether to use preg_replace instead of |
| * str_replace in parse() |
| * (this is a backwards compatibility feature, see also bugs #21951, #20392) |
| */ |
| var $_options = array( |
| 'preserve_data' => false, |
| 'use_preg' => true |
| ); |
| /** |
| * Builds some complex regular expressions and optinally sets the |
| * file root directory. |
| * |
| * Make sure that you call this constructor if you derive your template |
| * class from this one. |
| * |
| * @param string File root directory, prefix for all filenames |
| * given to the object. |
| * @see setRoot() |
| */ |
| function HTML_Template_IT($root = '', $options = null) |
| { |
| if (!is_null($options)) { |
| $this->setOptions($options); |
| } |
| $this->variablesRegExp = '@' . $this->openingDelimiter . |
| '(' . $this->variablenameRegExp . ')' . |
| $this->closingDelimiter . '@sm'; |
| $this->removeVariablesRegExp = '@' . $this->openingDelimiter . |
| "\s*(" . $this->variablenameRegExp . |
| ")\s*" . $this->closingDelimiter .'@sm'; |
| $this->blockRegExp = '@<!--\s+BEGIN\s+(' . $this->blocknameRegExp . |
| ')\s+-->(.*)<!--\s+END\s+\1\s+-->@sm'; |
| $this->setRoot($root); |
| } // end constructor |
| /** |
| * Sets the option for the template class |
| * |
| * @access public |
| * @param string option name |
| * @param mixed option value |
| * @return mixed IT_OK on success, error object on failure |
| */ |
| function setOption($option, $value) |
| { |
| if (array_key_exists($option, $this->_options)) { |
| $this->_options[$option] = $value; |
| return IT_OK; |
| } |
| return PEAR::raiseError( |
| $this->errorMessage(IT_UNKNOWN_OPTION) . ": '{$option}'", |
| IT_UNKNOWN_OPTION |
| ); |
| } |
| /** |
| * Sets the options for the template class |
| * |
| * @access public |
| * @param string options array of options |
| * default value: |
| * 'preserve_data' => false, |
| * 'use_preg' => true |
| * @param mixed option value |
| * @return mixed IT_OK on success, error object on failure |
| * @see $options |
| */ |
| function setOptions($options) |
| { |
| if (is_array($options)) { |
| foreach ($options as $option => $value) { |
| $error = $this->setOption($option, $value); |
| if (PEAR::isError($error)) { |
| return $error; |
| } |
| } |
| } |
| return IT_OK; |
| } |
| /** |
| * Print a certain block with all replacements done. |
| * @brother get() |
| */ |
| function show($block = '__global__') |
| { |
| print $this->get($block); |
| } // end func show |
| /** |
| * Returns a block with all replacements done. |
| * |
| * @param string name of the block |
| * @return string |
| * @throws PEAR_Error |
| * @access public |
| * @see show() |
| */ |
| function get($block = '__global__') |
| { |
| if ($block == '__global__' && !$this->flagGlobalParsed) { |
| $this->parse('__global__'); |
| } |
| if (!isset($this->blocklist[$block])) { |
| $this->err[] = PEAR::raiseError( |
| $this->errorMessage(IT_BLOCK_NOT_FOUND) . |
| '"' . $block . "'", |
| IT_BLOCK_NOT_FOUND |
| ); |
| return ''; |
| } |
| if (isset($this->blockdata[$block])) { |
| $ret = $this->blockdata[$block]; |
| if ($this->clearCache) { |
| unset($this->blockdata[$block]); |
| } |
| if ($this->_options['preserve_data']) { |
| $ret = str_replace( |
| $this->openingDelimiter . |
| '%preserved%' . $this->closingDelimiter, |
| $this->openingDelimiter, |
| $ret |
| ); |
| } |
| return $ret; |
| } |
| return ''; |
| } // end func get() |
| /** |
| * Parses the given block. |
| * |
| * @param string name of the block to be parsed |
| * @access public |
| * @see parseCurrentBlock() |
| * @throws PEAR_Error |
| */ |
| function parse($block = '__global__', $flag_recursion = false) |
| { |
| static $regs, $values; |
| if (!isset($this->blocklist[$block])) { |
| return PEAR::raiseError( |
| $this->errorMessage( IT_BLOCK_NOT_FOUND ) . '"' . $block . "'", |
| IT_BLOCK_NOT_FOUND |
| ); |
| } |
| if ($block == '__global__') { |
| $this->flagGlobalParsed = true; |
| } |
| if (!$flag_recursion) { |
| $regs = array(); |
| $values = array(); |
| } |
| $outer = $this->blocklist[$block]; |
| $empty = true; |
| if ($this->clearCacheOnParse) { |
| foreach ($this->variableCache as $name => $value) { |
| $regs[] = $this->openingDelimiter . |
| $name . $this->closingDelimiter; |
| $values[] = $value; |
| $empty = false; |
| } |
| $this->variableCache = array(); |
| } else { |
| foreach ($this->blockvariables[$block] as $allowedvar => $v) { |
| if (isset($this->variableCache[$allowedvar])) { |
| $regs[] = $this->openingDelimiter . |
| $allowedvar . $this->closingDelimiter; |
| $values[] = $this->variableCache[$allowedvar]; |
| unset($this->variableCache[$allowedvar]); |
| $empty = false; |
| } |
| } |
| } |
| if (isset($this->blockinner[$block])) { |
| foreach ($this->blockinner[$block] as $k => $innerblock) { |
| $this->parse($innerblock, true); |
| if ($this->blockdata[$innerblock] != '') { |
| $empty = false; |
| } |
| $placeholder = $this->openingDelimiter . "__" . |
| $innerblock . "__" . $this->closingDelimiter; |
| $outer = str_replace( |
| $placeholder, |
| $this->blockdata[$innerblock], $outer |
| ); |
| $this->blockdata[$innerblock] = ""; |
| } |
| } |
| if (!$flag_recursion && 0 != count($values)) { |
| if ($this->_options['use_preg']) { |
| $regs = array_map(array( |
| &$this, '_addPregDelimiters'), |
| $regs |
| ); |
| $funcReplace = 'preg_replace'; |
| } else { |
| $funcReplace = 'str_replace'; |
| } |
| if ($this->_options['preserve_data']) { |
| $values = array_map( |
| array(&$this, '_preserveOpeningDelimiter'), $values |
| ); |
| } |
| $outer = $funcReplace($regs, $values, $outer); |
| if ($this->removeUnknownVariables) { |
| $outer = preg_replace($this->removeVariablesRegExp, "", $outer); |
| } |
| } |
| if ($empty) { |
| if (!$this->removeEmptyBlocks) { |
| $this->blockdata[$block ].= $outer; |
| } else { |
| if (isset($this->touchedBlocks[$block])) { |
| $this->blockdata[$block] .= $outer; |
| unset($this->touchedBlocks[$block]); |
| } |
| } |
| } else { |
| $this->blockdata[$block] .= $outer; |
| } |
| return $empty; |
| } // end func parse |
| /** |
| * Parses the current block |
| * @see parse(), setCurrentBlock(), $currentBlock |
| * @access public |
| */ |
| function parseCurrentBlock() |
| { |
| return $this->parse($this->currentBlock); |
| } // end func parseCurrentBlock |
| /** |
| * Sets a variable value. |
| * |
| * The function can be used eighter like setVariable( "varname", "value") |
| * or with one array $variables["varname"] = "value" |
| * given setVariable($variables) quite like phplib templates set_var(). |
| * |
| * @param mixed string with the variable name or an array |
| * %variables["varname"] = "value" |
| * @param string value of the variable or empty if $variable |
| * is an array. |
| * @param string prefix for variable names |
| * @access public |
| */ |
| function setVariable($variable, $value = '') |
| { |
| if (is_array($variable)) { |
| $this->variableCache = array_merge( |
| $this->variableCache, $variable |
| ); |
| } else { |
| $this->variableCache[$variable] = $value; |
| } |
| } // end func setVariable |
| /** |
| * Sets the name of the current block that is the block where variables |
| * are added. |
| * |
| * @param string name of the block |
| * @return boolean false on failure, otherwise true |
| * @throws PEAR_Error |
| * @access public |
| */ |
| function setCurrentBlock($block = '__global__') |
| { |
| if (!isset($this->blocklist[$block])) { |
| return PEAR::raiseError( |
| $this->errorMessage( IT_BLOCK_NOT_FOUND ) . |
| '"' . $block . "'", IT_BLOCK_NOT_FOUND |
| ); |
| } |
| $this->currentBlock = $block; |
| return true; |
| } // end func setCurrentBlock |
| /** |
| * Preserves an empty block even if removeEmptyBlocks is true. |
| * |
| * @param string name of the block |
| * @return boolean false on false, otherwise true |
| * @throws PEAR_Error |
| * @access public |
| * @see $removeEmptyBlocks |
| */ |
| function touchBlock($block) |
| { |
| if (!isset($this->blocklist[$block])) { |
| return PEAR::raiseError( |
| $this->errorMessage(IT_BLOCK_NOT_FOUND) . |
| '"' . $block . "'", IT_BLOCK_NOT_FOUND); |
| } |
| $this->touchedBlocks[$block] = true; |
| return true; |
| } // end func touchBlock |
| /** |
| * Clears all datafields of the object and rebuild the internal blocklist |
| * |
| * LoadTemplatefile() and setTemplate() automatically call this function |
| * when a new template is given. Don't use this function |
| * unless you know what you're doing. |
| * |
| * @access public |
| * @see free() |
| */ |
| function init() |
| { |
| $this->free(); |
| $this->findBlocks($this->template); |
| // we don't need it any more |
| $this->template = ''; |
| $this->buildBlockvariablelist(); |
| } // end func init |
| /** |
| * Clears all datafields of the object. |
| * |
| * Don't use this function unless you know what you're doing. |
| * |
| * @access public |
| * @see init() |
| */ |
| function free() |
| { |
| $this->err = array(); |
| $this->currentBlock = '__global__'; |
| $this->variableCache = array(); |
| $this->blocklookup = array(); |
| $this->touchedBlocks = array(); |
| $this->flagBlocktrouble = false; |
| $this->flagGlobalParsed = false; |
| } // end func free |
| /** |
| * Sets the template. |
| * |
| * You can eighter load a template file from disk with |
| * LoadTemplatefile() or set the template manually using this function. |
| * |
| * @param string template content |
| * @param boolean remove unknown/unused variables? |
| * @param boolean remove empty blocks? |
| * @see LoadTemplatefile(), $template |
| * @access public |
| */ |
| function setTemplate( $template, $removeUnknownVariables = true, |
| $removeEmptyBlocks = true) |
| { |
| $this->removeUnknownVariables = $removeUnknownVariables; |
| $this->removeEmptyBlocks = $removeEmptyBlocks; |
| if ($template == '' && $this->flagCacheTemplatefile) { |
| $this->variableCache = array(); |
| $this->blockdata = array(); |
| $this->touchedBlocks = array(); |
| $this->currentBlock = '__global__'; |
| } else { |
| $this->template = '<!-- BEGIN __global__ -->' . $template . |
| '<!-- END __global__ -->'; |
| $this->init(); |
| } |
| if ($this->flagBlocktrouble) { |
| return false; |
| } |
| return true; |
| } // end func setTemplate |
| /** |
| * Reads a template file from the disk. |
| * |
| * @param string name of the template file |
| * @param bool how to handle unknown variables. |
| * @param bool how to handle empty blocks. |
| * @access public |
| * @return boolean false on failure, otherwise true |
| * @see $template, setTemplate(), $removeUnknownVariables, |
| * $removeEmptyBlocks |
| */ |
| function loadTemplatefile( $filename, |
| $removeUnknownVariables = true, |
| $removeEmptyBlocks = true ) |
| { |
| $template = ''; |
| if (!$this->flagCacheTemplatefile || |
| $this->lastTemplatefile != $filename |
| ) { |
| $template = $this->getFile($filename); |
| } |
| $this->lastTemplatefile = $filename; |
| return $template != '' ? |
| $this->setTemplate( |
| $template,$removeUnknownVariables, $removeEmptyBlocks |
| ) : false; |
| } // end func LoadTemplatefile |
| /** |
| * Sets the file root. The file root gets prefixed to all filenames passed |
| * to the object. |
| * |
| * Make sure that you override this function when using the class |
| * on windows. |
| * |
| * @param string |
| * @see IntegratedTemplate() |
| * @access public |
| */ |
| function setRoot($root) |
| { |
| if ($root != '' && substr($root, -1) != '/') { |
| $root .= '/'; |
| } |
| $this->fileRoot = $root; |
| } // end func setRoot |
| /** |
| * Build a list of all variables within of a block |
| */ |
| function buildBlockvariablelist() |
| { |
| foreach ($this->blocklist as $name => $content) { |
| preg_match_all($this->variablesRegExp, $content, $regs); |
| if (count($regs[1]) != 0) { |
| foreach ($regs[1] as $k => $var) { |
| $this->blockvariables[$name][$var] = true; |
| } |
| } else { |
| $this->blockvariables[$name] = array(); |
| } |
| } |
| } // end func buildBlockvariablelist |
| /** |
| * Returns a list of all global variables |
| */ |
| function getGlobalvariables() |
| { |
| $regs = array(); |
| $values = array(); |
| foreach ($this->blockvariables['__global__'] as $allowedvar => $v) { |
| if (isset($this->variableCache[$allowedvar])) { |
| $regs[] = '@' . $this->openingDelimiter . |
| $allowedvar . $this->closingDelimiter . '@'; |
| $values[] = $this->variableCache[$allowedvar]; |
| unset($this->variableCache[$allowedvar]); |
| } |
| } |
| return array($regs, $values); |
| } // end func getGlobalvariables |
| /** |
| * Recusively builds a list of all blocks within the template. |
| * |
| * @param string string that gets scanned |
| * @see $blocklist |
| */ |
| function findBlocks($string) |
| { |
| $blocklist = array(); |
| if (preg_match_all($this->blockRegExp, $string, $regs, PREG_SET_ORDER)) { |
| foreach ($regs as $k => $match) { |
| $blockname = $match[1]; |
| $blockcontent = $match[2]; |
| if (isset($this->blocklist[$blockname])) { |
| $this->err[] = PEAR::raiseError( |
| $this->errorMessage( |
| IT_BLOCK_DUPLICATE, $blockname), |
| IT_BLOCK_DUPLICATE |
| ); |
| $this->flagBlocktrouble = true; |
| } |
| $this->blocklist[$blockname] = $blockcontent; |
| $this->blockdata[$blockname] = ""; |
| $blocklist[] = $blockname; |
| $inner = $this->findBlocks($blockcontent); |
| foreach ($inner as $k => $name) { |
| $pattern = sprintf( |
| '@<!--\s+BEGIN\s+%s\s+-->(.*)<!--\s+END\s+%s\s+-->@sm', |
| $name, |
| $name |
| ); |
| $this->blocklist[$blockname] = preg_replace( |
| $pattern, |
| $this->openingDelimiter . |
| '__' . $name . '__' . |
| $this->closingDelimiter, |
| $this->blocklist[$blockname] |
| ); |
| $this->blockinner[$blockname][] = $name; |
| $this->blockparents[$name] = $blockname; |
| } |
| } |
| } |
| return $blocklist; |
| } // end func findBlocks |
| /** |
| * Reads a file from disk and returns its content. |
| * @param string Filename |
| * @return string Filecontent |
| */ |
| function getFile($filename) |
| { |
| if ($filename{0} == '/' && substr($this->fileRoot, -1) == '/') { |
| $filename = substr($filename, 1); |
| } |
| $filename = $this->fileRoot . $filename; |
| if (!($fh = @fopen($filename, 'r'))) { |
| $this->err[] = PEAR::raiseError( |
| $this->errorMessage(IT_TPL_NOT_FOUND) . |
| ': "' .$filename .'"', |
| IT_TPL_NOT_FOUND |
| ); |
| return ""; |
| } |
| $content = fread($fh, filesize($filename)); |
| fclose($fh); |
| return preg_replace( |
| "#<!-- INCLUDE (.*) -->#ime", "\$this->getFile('\\1')", $content |
| ); |
| } // end func getFile |
| /** |
| * Adds delimiters to a string, so it can be used as a pattern |
| * in preg_* functions |
| * |
| * @param string |
| * @return string |
| */ |
| function _addPregDelimiters($str) |
| { |
| return '@' . $str . '@'; |
| } |
| /** |
| * Replaces an opening delimiter by a special string |
| * |
| * @param string |
| * @return string |
| */ |
| function _preserveOpeningDelimiter($str) |
| { |
| return (false === strpos($str, $this->openingDelimiter))? |
| $str: |
| str_replace( |
| $this->openingDelimiter, |
| $this->openingDelimiter . |
| '%preserved%' . $this->closingDelimiter, |
| $str |
| ); |
| } |
| /** |
| * Return a textual error message for a IT error code |
| * |
| * @param integer $value error code |
| * |
| * @return string error message, or false if the error code was |
| * not recognized |
| */ |
| function errorMessage($value, $blockname = '') |
| { |
| static $errorMessages; |
| if (!isset($errorMessages)) { |
| $errorMessages = array( |
| IT_OK => '', |
| IT_ERROR => 'unknown error', |
| IT_TPL_NOT_FOUND => 'Cannot read the template file', |
| IT_BLOCK_NOT_FOUND => 'Cannot find this block', |
| IT_BLOCK_DUPLICATE => 'The name of a block must be'. |
| ' uniquewithin a template.'. |
| ' Found "' . $blockname . '" twice.'. |
| 'Unpredictable results '. |
| 'may appear.', |
| IT_UNKNOWN_OPTION => 'Unknown option' |
| ); |
| } |
| if (PEAR::isError($value)) { |
| $value = $value->getCode(); |
| } |
| return isset($errorMessages[$value]) ? |
| $errorMessages[$value] : $errorMessages[IT_ERROR]; |
| } |
| } // end class IntegratedTemplate |
| ?> |