cookbooks/dmca/files/default/html/HTML/QuickForm/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$
  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.16
  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 = preg_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)? '&nbsp;': 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 ?>