home *** CD-ROM | disk | FTP | other *** search
/ Cricao de Sites - 650 Layouts Prontos / WebMasters.iso / Servidores / xampp-win32-1.6.7-installer.exe / php / PEAR / HTML / QuickForm / select.php < prev    next >
Encoding:
PHP Script  |  2008-07-02  |  19.0 KB  |  615 lines
  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
  3.  
  4. /**
  5.  * Class to dynamically create an HTML SELECT
  6.  * 
  7.  * PHP versions 4 and 5
  8.  *
  9.  * LICENSE: This source file is subject to version 3.01 of the PHP license
  10.  * that is available through the world-wide-web at the following URI:
  11.  * http://www.php.net/license/3_01.txt If you did not receive a copy of
  12.  * the PHP License and are unable to obtain it through the web, please
  13.  * send a note to license@php.net so we can mail you a copy immediately.
  14.  *
  15.  * @category    HTML
  16.  * @package     HTML_QuickForm
  17.  * @author      Adam Daniel <adaniel1@eesus.jnj.com>
  18.  * @author      Bertrand Mansion <bmansion@mamasam.com>
  19.  * @author      Alexey Borzov <avb@php.net>
  20.  * @copyright   2001-2007 The PHP Group
  21.  * @license     http://www.php.net/license/3_01.txt PHP License 3.01
  22.  * @version     CVS: $Id: select.php,v 1.33 2007/06/03 15:01:00 avb Exp $
  23.  * @link        http://pear.php.net/package/HTML_QuickForm
  24.  */
  25.  
  26. /**
  27.  * Base class for form elements
  28.  */ 
  29. require_once 'HTML/QuickForm/element.php';
  30.  
  31. /**
  32.  * Class to dynamically create an HTML SELECT
  33.  *
  34.  * @category    HTML
  35.  * @package     HTML_QuickForm
  36.  * @author      Adam Daniel <adaniel1@eesus.jnj.com>
  37.  * @author      Bertrand Mansion <bmansion@mamasam.com>
  38.  * @author      Alexey Borzov <avb@php.net>
  39.  * @version     Release: 3.2.10
  40.  * @since       1.0
  41.  */
  42. class HTML_QuickForm_select extends HTML_QuickForm_element {
  43.     
  44.     // {{{ properties
  45.  
  46.     /**
  47.      * Contains the select options
  48.      *
  49.      * @var       array
  50.      * @since     1.0
  51.      * @access    private
  52.      */
  53.     var $_options = array();
  54.     
  55.     /**
  56.      * Default values of the SELECT
  57.      * 
  58.      * @var       string
  59.      * @since     1.0
  60.      * @access    private
  61.      */
  62.     var $_values = null;
  63.  
  64.     // }}}
  65.     // {{{ constructor
  66.         
  67.     /**
  68.      * Class constructor
  69.      * 
  70.      * @param     string    Select name attribute
  71.      * @param     mixed     Label(s) for the select
  72.      * @param     mixed     Data to be used to populate options
  73.      * @param     mixed     Either a typical HTML attribute string or an associative array
  74.      * @since     1.0
  75.      * @access    public
  76.      * @return    void
  77.      */
  78.     function HTML_QuickForm_select($elementName=null, $elementLabel=null, $options=null, $attributes=null)
  79.     {
  80.         HTML_QuickForm_element::HTML_QuickForm_element($elementName, $elementLabel, $attributes);
  81.         $this->_persistantFreeze = true;
  82.         $this->_type = 'select';
  83.         if (isset($options)) {
  84.             $this->load($options);
  85.         }
  86.     } //end constructor
  87.     
  88.     // }}}
  89.     // {{{ apiVersion()
  90.  
  91.     /**
  92.      * Returns the current API version 
  93.      * 
  94.      * @since     1.0
  95.      * @access    public
  96.      * @return    double
  97.      */
  98.     function apiVersion()
  99.     {
  100.         return 2.3;
  101.     } //end func apiVersion
  102.  
  103.     // }}}
  104.     // {{{ setSelected()
  105.  
  106.     /**
  107.      * Sets the default values of the select box
  108.      * 
  109.      * @param     mixed    $values  Array or comma delimited string of selected values
  110.      * @since     1.0
  111.      * @access    public
  112.      * @return    void
  113.      */
  114.     function setSelected($values)
  115.     {
  116.         if (is_string($values) && $this->getMultiple()) {
  117.             $values = split("[ ]?,[ ]?", $values);
  118.         }
  119.         if (is_array($values)) {
  120.             $this->_values = array_values($values);
  121.         } else {
  122.             $this->_values = array($values);
  123.         }
  124.     } //end func setSelected
  125.     
  126.     // }}}
  127.     // {{{ getSelected()
  128.  
  129.     /**
  130.      * Returns an array of the selected values
  131.      * 
  132.      * @since     1.0
  133.      * @access    public
  134.      * @return    array of selected values
  135.      */
  136.     function getSelected()
  137.     {
  138.         return $this->_values;
  139.     } // end func getSelected
  140.  
  141.     // }}}
  142.     // {{{ setName()
  143.  
  144.     /**
  145.      * Sets the input field name
  146.      * 
  147.      * @param     string    $name   Input field name attribute
  148.      * @since     1.0
  149.      * @access    public
  150.      * @return    void
  151.      */
  152.     function setName($name)
  153.     {
  154.         $this->updateAttributes(array('name' => $name));
  155.     } //end func setName
  156.     
  157.     // }}}
  158.     // {{{ getName()
  159.  
  160.     /**
  161.      * Returns the element name
  162.      * 
  163.      * @since     1.0
  164.      * @access    public
  165.      * @return    string
  166.      */
  167.     function getName()
  168.     {
  169.         return $this->getAttribute('name');
  170.     } //end func getName
  171.  
  172.     // }}}
  173.     // {{{ getPrivateName()
  174.  
  175.     /**
  176.      * Returns the element name (possibly with brackets appended)
  177.      * 
  178.      * @since     1.0
  179.      * @access    public
  180.      * @return    string
  181.      */
  182.     function getPrivateName()
  183.     {
  184.         if ($this->getAttribute('multiple')) {
  185.             return $this->getName() . '[]';
  186.         } else {
  187.             return $this->getName();
  188.         }
  189.     } //end func getPrivateName
  190.  
  191.     // }}}
  192.     // {{{ setValue()
  193.  
  194.     /**
  195.      * Sets the value of the form element
  196.      *
  197.      * @param     mixed    $values  Array or comma delimited string of selected values
  198.      * @since     1.0
  199.      * @access    public
  200.      * @return    void
  201.      */
  202.     function setValue($value)
  203.     {
  204.         $this->setSelected($value);
  205.     } // end func setValue
  206.  
  207.     // }}}
  208.     // {{{ getValue()
  209.  
  210.     /**
  211.      * Returns an array of the selected values
  212.      * 
  213.      * @since     1.0
  214.      * @access    public
  215.      * @return    array of selected values
  216.      */
  217.     function getValue()
  218.     {
  219.         return $this->_values;
  220.     } // end func getValue
  221.  
  222.     // }}}
  223.     // {{{ setSize()
  224.  
  225.     /**
  226.      * Sets the select field size, only applies to 'multiple' selects
  227.      * 
  228.      * @param     int    $size  Size of select  field
  229.      * @since     1.0
  230.      * @access    public
  231.      * @return    void
  232.      */
  233.     function setSize($size)
  234.     {
  235.         $this->updateAttributes(array('size' => $size));
  236.     } //end func setSize
  237.     
  238.     // }}}
  239.     // {{{ getSize()
  240.  
  241.     /**
  242.      * Returns the select field size
  243.      * 
  244.      * @since     1.0
  245.      * @access    public
  246.      * @return    int
  247.      */
  248.     function getSize()
  249.     {
  250.         return $this->getAttribute('size');
  251.     } //end func getSize
  252.  
  253.     // }}}
  254.     // {{{ setMultiple()
  255.  
  256.     /**
  257.      * Sets the select mutiple attribute
  258.      * 
  259.      * @param     bool    $multiple  Whether the select supports multi-selections
  260.      * @since     1.2
  261.      * @access    public
  262.      * @return    void
  263.      */
  264.     function setMultiple($multiple)
  265.     {
  266.         if ($multiple) {
  267.             $this->updateAttributes(array('multiple' => 'multiple'));
  268.         } else {
  269.             $this->removeAttribute('multiple');
  270.         }
  271.     } //end func setMultiple
  272.     
  273.     // }}}
  274.     // {{{ getMultiple()
  275.  
  276.     /**
  277.      * Returns the select mutiple attribute
  278.      * 
  279.      * @since     1.2
  280.      * @access    public
  281.      * @return    bool    true if multiple select, false otherwise
  282.      */
  283.     function getMultiple()
  284.     {
  285.         return (bool)$this->getAttribute('multiple');
  286.     } //end func getMultiple
  287.  
  288.     // }}}
  289.     // {{{ addOption()
  290.  
  291.     /**
  292.      * Adds a new OPTION to the SELECT
  293.      *
  294.      * @param     string    $text       Display text for the OPTION
  295.      * @param     string    $value      Value for the OPTION
  296.      * @param     mixed     $attributes Either a typical HTML attribute string 
  297.      *                                  or an associative array
  298.      * @since     1.0
  299.      * @access    public
  300.      * @return    void
  301.      */
  302.     function addOption($text, $value, $attributes=null)
  303.     {
  304.         if (null === $attributes) {
  305.             $attributes = array('value' => (string)$value);
  306.         } else {
  307.             $attributes = $this->_parseAttributes($attributes);
  308.             if (isset($attributes['selected'])) {
  309.                 // the 'selected' attribute will be set in toHtml()
  310.                 $this->_removeAttr('selected', $attributes);
  311.                 if (is_null($this->_values)) {
  312.                     $this->_values = array($value);
  313.                 } elseif (!in_array($value, $this->_values)) {
  314.                     $this->_values[] = $value;
  315.                 }
  316.             }
  317.             $this->_updateAttrArray($attributes, array('value' => (string)$value));
  318.         }
  319.         $this->_options[] = array('text' => $text, 'attr' => $attributes);
  320.     } // end func addOption
  321.     
  322.     // }}}
  323.     // {{{ loadArray()
  324.  
  325.     /**
  326.      * Loads the options from an associative array
  327.      * 
  328.      * @param     array    $arr     Associative array of options
  329.      * @param     mixed    $values  (optional) Array or comma delimited string of selected values
  330.      * @since     1.0
  331.      * @access    public
  332.      * @return    PEAR_Error on error or true
  333.      * @throws    PEAR_Error
  334.      */
  335.     function loadArray($arr, $values=null)
  336.     {
  337.         if (!is_array($arr)) {
  338.             return PEAR::raiseError('Argument 1 of HTML_Select::loadArray is not a valid array');
  339.         }
  340.         if (isset($values)) {
  341.             $this->setSelected($values);
  342.         }
  343.         foreach ($arr as $key => $val) {
  344.             // Warning: new API since release 2.3
  345.             $this->addOption($val, $key);
  346.         }
  347.         return true;
  348.     } // end func loadArray
  349.  
  350.     // }}}
  351.     // {{{ loadDbResult()
  352.  
  353.     /**
  354.      * Loads the options from DB_result object
  355.      * 
  356.      * If no column names are specified the first two columns of the result are
  357.      * used as the text and value columns respectively
  358.      * @param     object    $result     DB_result object 
  359.      * @param     string    $textCol    (optional) Name of column to display as the OPTION text 
  360.      * @param     string    $valueCol   (optional) Name of column to use as the OPTION value 
  361.      * @param     mixed     $values     (optional) Array or comma delimited string of selected values
  362.      * @since     1.0
  363.      * @access    public
  364.      * @return    PEAR_Error on error or true
  365.      * @throws    PEAR_Error
  366.      */
  367.     function loadDbResult(&$result, $textCol=null, $valueCol=null, $values=null)
  368.     {
  369.         if (!is_object($result) || !is_a($result, 'db_result')) {
  370.             return PEAR::raiseError('Argument 1 of HTML_Select::loadDbResult is not a valid DB_result');
  371.         }
  372.         if (isset($values)) {
  373.             $this->setValue($values);
  374.         }
  375.         $fetchMode = ($textCol && $valueCol) ? DB_FETCHMODE_ASSOC : DB_FETCHMODE_ORDERED;
  376.         while (is_array($row = $result->fetchRow($fetchMode)) ) {
  377.             if ($fetchMode == DB_FETCHMODE_ASSOC) {
  378.                 $this->addOption($row[$textCol], $row[$valueCol]);
  379.             } else {
  380.                 $this->addOption($row[0], $row[1]);
  381.             }
  382.         }
  383.         return true;
  384.     } // end func loadDbResult
  385.     
  386.     // }}}
  387.     // {{{ loadQuery()
  388.  
  389.     /**
  390.      * Queries a database and loads the options from the results
  391.      *
  392.      * @param     mixed     $conn       Either an existing DB connection or a valid dsn 
  393.      * @param     string    $sql        SQL query string
  394.      * @param     string    $textCol    (optional) Name of column to display as the OPTION text 
  395.      * @param     string    $valueCol   (optional) Name of column to use as the OPTION value 
  396.      * @param     mixed     $values     (optional) Array or comma delimited string of selected values
  397.      * @since     1.1
  398.      * @access    public
  399.      * @return    void
  400.      * @throws    PEAR_Error
  401.      */
  402.     function loadQuery(&$conn, $sql, $textCol=null, $valueCol=null, $values=null)
  403.     {
  404.         if (is_string($conn)) {
  405.             require_once('DB.php');
  406.             $dbConn = &DB::connect($conn, true);
  407.             if (DB::isError($dbConn)) {
  408.                 return $dbConn;
  409.             }
  410.         } elseif (is_subclass_of($conn, "db_common")) {
  411.             $dbConn = &$conn;
  412.         } else {
  413.             return PEAR::raiseError('Argument 1 of HTML_Select::loadQuery is not a valid type');
  414.         }
  415.         $result = $dbConn->query($sql);
  416.         if (DB::isError($result)) {
  417.             return $result;
  418.         }
  419.         $this->loadDbResult($result, $textCol, $valueCol, $values);
  420.         $result->free();
  421.         if (is_string($conn)) {
  422.             $dbConn->disconnect();
  423.         }
  424.         return true;
  425.     } // end func loadQuery
  426.  
  427.     // }}}
  428.     // {{{ load()
  429.  
  430.     /**
  431.      * Loads options from different types of data sources
  432.      *
  433.      * This method is a simulated overloaded method.  The arguments, other than the
  434.      * first are optional and only mean something depending on the type of the first argument.
  435.      * If the first argument is an array then all arguments are passed in order to loadArray.
  436.      * If the first argument is a db_result then all arguments are passed in order to loadDbResult.
  437.      * If the first argument is a string or a DB connection then all arguments are 
  438.      * passed in order to loadQuery.
  439.      * @param     mixed     $options     Options source currently supports assoc array or DB_result
  440.      * @param     mixed     $param1     (optional) See function detail
  441.      * @param     mixed     $param2     (optional) See function detail
  442.      * @param     mixed     $param3     (optional) See function detail
  443.      * @param     mixed     $param4     (optional) See function detail
  444.      * @since     1.1
  445.      * @access    public
  446.      * @return    PEAR_Error on error or true
  447.      * @throws    PEAR_Error
  448.      */
  449.     function load(&$options, $param1=null, $param2=null, $param3=null, $param4=null)
  450.     {
  451.         switch (true) {
  452.             case is_array($options):
  453.                 return $this->loadArray($options, $param1);
  454.                 break;
  455.             case (is_a($options, 'db_result')):
  456.                 return $this->loadDbResult($options, $param1, $param2, $param3);
  457.                 break;
  458.             case (is_string($options) && !empty($options) || is_subclass_of($options, "db_common")):
  459.                 return $this->loadQuery($options, $param1, $param2, $param3, $param4);
  460.                 break;
  461.         }
  462.     } // end func load
  463.     
  464.     // }}}
  465.     // {{{ toHtml()
  466.  
  467.     /**
  468.      * Returns the SELECT in HTML
  469.      *
  470.      * @since     1.0
  471.      * @access    public
  472.      * @return    string
  473.      */
  474.     function toHtml()
  475.     {
  476.         if ($this->_flagFrozen) {
  477.             return $this->getFrozenHtml();
  478.         } else {
  479.             $tabs    = $this->_getTabs();
  480.             $strHtml = '';
  481.  
  482.             if ($this->getComment() != '') {
  483.                 $strHtml .= $tabs . '<!-- ' . $this->getComment() . " //-->\n";
  484.             }
  485.  
  486.             if (!$this->getMultiple()) {
  487.                 $attrString = $this->_getAttrString($this->_attributes);
  488.             } else {
  489.                 $myName = $this->getName();
  490.                 $this->setName($myName . '[]');
  491.                 $attrString = $this->_getAttrString($this->_attributes);
  492.                 $this->setName($myName);
  493.             }
  494.             $strHtml .= $tabs . '<select' . $attrString . ">\n";
  495.  
  496.             $strValues = is_array($this->_values)? array_map('strval', $this->_values): array();
  497.             foreach ($this->_options as $option) {
  498.                 if (!empty($strValues) && in_array($option['attr']['value'], $strValues, true)) {
  499.                     $option['attr']['selected'] = 'selected';
  500.                 }
  501.                 $strHtml .= $tabs . "\t<option" . $this->_getAttrString($option['attr']) . '>' .
  502.                             $option['text'] . "</option>\n";
  503.             }
  504.  
  505.             return $strHtml . $tabs . '</select>';
  506.         }
  507.     } //end func toHtml
  508.     
  509.     // }}}
  510.     // {{{ getFrozenHtml()
  511.  
  512.     /**
  513.      * Returns the value of field without HTML tags
  514.      * 
  515.      * @since     1.0
  516.      * @access    public
  517.      * @return    string
  518.      */
  519.     function getFrozenHtml()
  520.     {
  521.         $value = array();
  522.         if (is_array($this->_values)) {
  523.             foreach ($this->_values as $key => $val) {
  524.                 for ($i = 0, $optCount = count($this->_options); $i < $optCount; $i++) {
  525.                     if (0 == strcmp($val, $this->_options[$i]['attr']['value'])) {
  526.                         $value[$key] = $this->_options[$i]['text'];
  527.                         break;
  528.                     }
  529.                 }
  530.             }
  531.         }
  532.         $html = empty($value)? ' ': join('<br />', $value);
  533.         if ($this->_persistantFreeze) {
  534.             $name = $this->getPrivateName();
  535.             // Only use id attribute if doing single hidden input
  536.             if (1 == count($value)) {
  537.                 $id     = $this->getAttribute('id');
  538.                 $idAttr = isset($id)? array('id' => $id): array();
  539.             } else {
  540.                 $idAttr = array();
  541.             }
  542.             foreach ($value as $key => $item) {
  543.                 $html .= '<input' . $this->_getAttrString(array(
  544.                              'type'  => 'hidden',
  545.                              'name'  => $name,
  546.                              'value' => $this->_values[$key]
  547.                          ) + $idAttr) . ' />';
  548.             }
  549.         }
  550.         return $html;
  551.     } //end func getFrozenHtml
  552.  
  553.     // }}}
  554.     // {{{ exportValue()
  555.  
  556.    /**
  557.     * We check the options and return only the values that _could_ have been
  558.     * selected. We also return a scalar value if select is not "multiple"
  559.     */
  560.     function exportValue(&$submitValues, $assoc = false)
  561.     {
  562.         $value = $this->_findValue($submitValues);
  563.         if (is_null($value)) {
  564.             $value = $this->getValue();
  565.         } elseif(!is_array($value)) {
  566.             $value = array($value);
  567.         }
  568.         if (is_array($value) && !empty($this->_options)) {
  569.             $cleanValue = null;
  570.             foreach ($value as $v) {
  571.                 for ($i = 0, $optCount = count($this->_options); $i < $optCount; $i++) {
  572.                     if (0 == strcmp($v, $this->_options[$i]['attr']['value'])) {
  573.                         $cleanValue[] = $v;
  574.                         break;
  575.                     }
  576.                 }
  577.             }
  578.         } else {
  579.             $cleanValue = $value;
  580.         }
  581.         if (is_array($cleanValue) && !$this->getMultiple()) {
  582.             return $this->_prepareValue($cleanValue[0], $assoc);
  583.         } else {
  584.             return $this->_prepareValue($cleanValue, $assoc);
  585.         }
  586.     }
  587.     
  588.     // }}}
  589.     // {{{ onQuickFormEvent()
  590.  
  591.     function onQuickFormEvent($event, $arg, &$caller)
  592.     {
  593.         if ('updateValue' == $event) {
  594.             $value = $this->_findValue($caller->_constantValues);
  595.             if (null === $value) {
  596.                 $value = $this->_findValue($caller->_submitValues);
  597.                 // Fix for bug #4465 & #5269
  598.                 // XXX: should we push this to element::onQuickFormEvent()?
  599.                 if (null === $value && (!$caller->isSubmitted() || !$this->getMultiple())) {
  600.                     $value = $this->_findValue($caller->_defaultValues);
  601.                 }
  602.             }
  603.             if (null !== $value) {
  604.                 $this->setValue($value);
  605.             }
  606.             return true;
  607.         } else {
  608.             return parent::onQuickFormEvent($event, $arg, $caller);
  609.         }
  610.     }
  611.  
  612.     // }}}
  613. } //end class HTML_QuickForm_select
  614. ?>
  615.