HTML_QuickForm
[ class tree: HTML_QuickForm ] [ index: HTML_QuickForm ] [ all elements ]

Source for file select.php

Documentation is available at select.php

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

Documentation generated on Sat, 01 Oct 2011 09:00:20 +0000 by phpDocumentor 1.4.3. PEAR Logo Copyright © PHP Group 2004.