1 <?php

     2 /**

     3  * Zend Framework

     4  *

     5  * LICENSE

     6  *

     7  * This source file is subject to the new BSD license that is bundled

     8  * with this package in the file LICENSE.txt.

     9  * It is also available through the world-wide-web at this URL:

    10  * http://framework.zend.com/license/new-bsd

    11  * If you did not receive a copy of the license and are unable to

    12  * obtain it through the world-wide-web, please send an email

    13  * to license@zend.com so we can send you a copy immediately.

    14  *

    15  * @category   Zend

    16  * @package    Zend_Form

    17  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)

    18  * @license    http://framework.zend.com/license/new-bsd     New BSD License

    19  */

    20 

    21 /** @see Zend_Filter */

    22 require_once 'Zend/Filter.php';

    23 

    24 /** @see Zend_Form */

    25 require_once 'Zend/Form.php';

    26 

    27 /** @see Zend_Validate_Interface */

    28 require_once 'Zend/Validate/Interface.php';

    29 

    30 /** @see Zend_Validate_Abstract */

    31 require_once 'Zend/Validate/Abstract.php';

    32 

    33 /**

    34  * Zend_Form_Element

    35  *

    36  * @category   Zend

    37  * @package    Zend_Form

    38  * @subpackage Element

    39  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)

    40  * @license    http://framework.zend.com/license/new-bsd     New BSD License

    41  * @version    $Id: Element.php 22464 2010-06-19 17:31:21Z alab $

    42  */

    43 class Zend_Form_Element implements Zend_Validate_Interface

    44 {

    45     /**

    46      * Element Constants

    47      */

    48     const DECORATOR = 'DECORATOR';

    49     const FILTER    = 'FILTER';

    50     const VALIDATE  = 'VALIDATE';

    51 

    52     /**

    53      * Default view helper to use

    54      * @var string

    55      */

    56     public $helper = 'formText';

    57 

    58     /**

    59      * 'Allow empty' flag

    60      * @var bool

    61      */

    62     protected $_allowEmpty = true;

    63 

    64     /**

    65      * Flag indicating whether or not to insert NotEmpty validator when element is required

    66      * @var bool

    67      */

    68     protected $_autoInsertNotEmptyValidator = true;

    69 

    70     /**

    71      * Array to which element belongs

    72      * @var string

    73      */

    74     protected $_belongsTo;

    75 

    76     /**

    77      * Element decorators

    78      * @var array

    79      */

    80     protected $_decorators = array();

    81 

    82     /**

    83      * Element description

    84      * @var string

    85      */

    86     protected $_description;

    87 

    88     /**

    89      * Should we disable loading the default decorators?

    90      * @var bool

    91      */

    92     protected $_disableLoadDefaultDecorators = false;

    93 

    94     /**

    95      * Custom error messages

    96      * @var array

    97      */

    98     protected $_errorMessages = array();

    99 

   100     /**

   101      * Validation errors

   102      * @var array

   103      */

   104     protected $_errors = array();

   105 

   106     /**

   107      * Separator to use when concatenating aggregate error messages (for

   108      * elements having array values)

   109      * @var string

   110      */

   111     protected $_errorMessageSeparator = '; ';

   112 

   113     /**

   114      * Element filters

   115      * @var array

   116      */

   117     protected $_filters = array();

   118 

   119     /**

   120      * Ignore flag (used when retrieving values at form level)

   121      * @var bool

   122      */

   123     protected $_ignore = false;

   124 

   125     /**

   126      * Does the element represent an array?

   127      * @var bool

   128      */

   129     protected $_isArray = false;

   130 

   131     /**

   132      * Is the error marked as in an invalid state?

   133      * @var bool

   134      */

   135     protected $_isError = false;

   136 

   137     /**

   138      * Has the element been manually marked as invalid?

   139      * @var bool

   140      */

   141     protected $_isErrorForced = false;

   142 

   143     /**

   144      * Element label

   145      * @var string

   146      */

   147     protected $_label;

   148 

   149     /**

   150      * Plugin loaders for filter and validator chains

   151      * @var array

   152      */

   153     protected $_loaders = array();

   154 

   155     /**

   156      * Formatted validation error messages

   157      * @var array

   158      */

   159     protected $_messages = array();

   160 

   161     /**

   162      * Element name

   163      * @var string

   164      */

   165     protected $_name;

   166 

   167     /**

   168      * Order of element

   169      * @var int

   170      */

   171     protected $_order;

   172 

   173     /**

   174      * Required flag

   175      * @var bool

   176      */

   177     protected $_required = false;

   178 

   179     /**

   180      * @var Zend_Translate

   181      */

   182     protected $_translator;

   183 

   184     /**

   185      * Is translation disabled?

   186      * @var bool

   187      */

   188     protected $_translatorDisabled = false;

   189 

   190     /**

   191      * Element type

   192      * @var string

   193      */

   194     protected $_type;

   195 

   196     /**

   197      * Array of initialized validators

   198      * @var array Validators

   199      */

   200     protected $_validators = array();

   201 

   202     /**

   203      * Array of un-initialized validators

   204      * @var array

   205      */

   206     protected $_validatorRules = array();

   207 

   208     /**

   209      * Element value

   210      * @var mixed

   211      */

   212     protected $_value;

   213 

   214     /**

   215      * @var Zend_View_Interface

   216      */

   217     protected $_view;

   218 

   219     /**

   220      * Is a specific decorator being rendered via the magic renderDecorator()?

   221      *

   222      * This is to allow execution of logic inside the render() methods of child

   223      * elements during the magic call while skipping the parent render() method.

   224      *

   225      * @var bool

   226      */

   227     protected $_isPartialRendering = false;

   228 

   229     /**

   230      * Constructor

   231      *

   232      * $spec may be:

   233      * - string: name of element

   234      * - array: options with which to configure element

   235      * - Zend_Config: Zend_Config with options for configuring element

   236      *

   237      * @param  string|array|Zend_Config $spec

   238      * @param  array|Zend_Config $options

   239      * @return void

   240      * @throws Zend_Form_Exception if no element name after initialization

   241      */

   242     public function __construct($spec, $options = null)

   243     {

   244         if (is_string($spec)) {

   245             $this->setName($spec);

   246         } elseif (is_array($spec)) {

   247             $this->setOptions($spec);

   248         } elseif ($spec instanceof Zend_Config) {

   249             $this->setConfig($spec);

   250         }

   251 

   252         if (is_string($spec) && is_array($options)) {

   253             $this->setOptions($options);

   254         } elseif (is_string($spec) && ($options instanceof Zend_Config)) {

   255             $this->setConfig($options);

   256         }

   257 

   258         if (null === $this->getName()) {

   259             require_once 'Zend/Form/Exception.php';

   260             throw new Zend_Form_Exception('Zend_Form_Element requires each element to have a name');

   261         }

   262 

   263         /**

   264          * Extensions

   265          */

   266         $this->init();

   267 

   268         /**

   269          * Register ViewHelper decorator by default

   270          */

   271         $this->loadDefaultDecorators();

   272     }

   273 

   274     /**

   275      * Initialize object; used by extending classes

   276      *

   277      * @return void

   278      */

   279     public function init()

   280     {

   281     }

   282 

   283     /**

   284      * Set flag to disable loading default decorators

   285      *

   286      * @param  bool $flag

   287      * @return Zend_Form_Element

   288      */

   289     public function setDisableLoadDefaultDecorators($flag)

   290     {

   291         $this->_disableLoadDefaultDecorators = (bool) $flag;

   292         return $this;

   293     }

   294 

   295     /**

   296      * Should we load the default decorators?

   297      *

   298      * @return bool

   299      */

   300     public function loadDefaultDecoratorsIsDisabled()

   301     {

   302         return $this->_disableLoadDefaultDecorators;

   303     }

   304 

   305     /**

   306      * Load default decorators

   307      *

   308      * @return Zend_Form_Element

   309      */

   310     public function loadDefaultDecorators()

   311     {

   312         if ($this->loadDefaultDecoratorsIsDisabled()) {

   313             return $this;

   314         }

   315 

   316         $decorators = $this->getDecorators();

   317         if (empty($decorators)) {

   318             $getId = create_function('$decorator',

   319                                      'return $decorator->getElement()->getId()

   320                                              . "-element";');

   321             $this->addDecorator('ViewHelper')

   322                  ->addDecorator('Errors')

   323                  ->addDecorator('Description', array('tag' => 'p', 'class' => 'description'))

   324                  ->addDecorator('HtmlTag', array('tag' => 'dd',

   325                                                  'id'  => array('callback' => $getId)))

   326                  ->addDecorator('Label', array('tag' => 'dt'));

   327         }

   328         return $this;

   329     }

   330 

   331     /**

   332      * Set object state from options array

   333      *

   334      * @param  array $options

   335      * @return Zend_Form_Element

   336      */

   337     public function setOptions(array $options)

   338     {

   339         if (isset($options['prefixPath'])) {

   340             $this->addPrefixPaths($options['prefixPath']);

   341             unset($options['prefixPath']);

   342         }

   343 

   344         if (isset($options['disableTranslator'])) {

   345             $this->setDisableTranslator($options['disableTranslator']);

   346             unset($options['disableTranslator']);

   347         }

   348 

   349         unset($options['options']);

   350         unset($options['config']);

   351 

   352         foreach ($options as $key => $value) {

   353             $method = 'set' . ucfirst($key);

   354 

   355             if (in_array($method, array('setTranslator', 'setPluginLoader', 'setView'))) {

   356                 if (!is_object($value)) {

   357                     continue;

   358                 }

   359             }

   360 

   361             if (method_exists($this, $method)) {

   362                 // Setter exists; use it

   363                 $this->$method($value);

   364             } else {

   365                 // Assume it's metadata

   366                 $this->setAttrib($key, $value);

   367             }

   368         }

   369         return $this;

   370     }

   371 

   372     /**

   373      * Set object state from Zend_Config object

   374      *

   375      * @param  Zend_Config $config

   376      * @return Zend_Form_Element

   377      */

   378     public function setConfig(Zend_Config $config)

   379     {

   380         return $this->setOptions($config->toArray());

   381     }

   382 

   383 

   384     // Localization:

   385 

   386     /**

   387      * Set translator object for localization

   388      *

   389      * @param  Zend_Translate|null $translator

   390      * @return Zend_Form_Element

   391      */

   392     public function setTranslator($translator = null)

   393     {

   394         if (null === $translator) {

   395             $this->_translator = null;

   396         } elseif ($translator instanceof Zend_Translate_Adapter) {

   397             $this->_translator = $translator;

   398         } elseif ($translator instanceof Zend_Translate) {

   399             $this->_translator = $translator->getAdapter();

   400         } else {

   401             require_once 'Zend/Form/Exception.php';

   402             throw new Zend_Form_Exception('Invalid translator specified');

   403         }

   404         return $this;

   405     }

   406 

   407     /**

   408      * Retrieve localization translator object

   409      *

   410      * @return Zend_Translate_Adapter|null

   411      */

   412     public function getTranslator()

   413     {

   414         if ($this->translatorIsDisabled()) {

   415             return null;

   416         }

   417 

   418         if (null === $this->_translator) {

   419             return Zend_Form::getDefaultTranslator();

   420         }

   421         return $this->_translator;

   422     }

   423 

   424     /**

   425      * Does this element have its own specific translator?

   426      *

   427      * @return bool

   428      */

   429     public function hasTranslator()

   430     {

   431         return (bool)$this->_translator;

   432     }

   433 

   434     /**

   435      * Indicate whether or not translation should be disabled

   436      *

   437      * @param  bool $flag

   438      * @return Zend_Form_Element

   439      */

   440     public function setDisableTranslator($flag)

   441     {

   442         $this->_translatorDisabled = (bool) $flag;

   443         return $this;

   444     }

   445 

   446     /**

   447      * Is translation disabled?

   448      *

   449      * @return bool

   450      */

   451     public function translatorIsDisabled()

   452     {

   453         return $this->_translatorDisabled;

   454     }

   455 

   456     // Metadata

   457 

   458     /**

   459      * Filter a name to only allow valid variable characters

   460      *

   461      * @param  string $value

   462      * @param  bool $allowBrackets

   463      * @return string

   464      */

   465     public function filterName($value, $allowBrackets = false)

   466     {

   467         $charset = '^a-zA-Z0-9_\x7f-\xff';

   468         if ($allowBrackets) {

   469             $charset .= '\[\]';

   470         }

   471         return preg_replace('/[' . $charset . ']/', '', (string) $value);

   472     }

   473 

   474     /**

   475      * Set element name

   476      *

   477      * @param  string $name

   478      * @return Zend_Form_Element

   479      */

   480     public function setName($name)

   481     {

   482         $name = $this->filterName($name);

   483         if ('' === $name) {

   484             require_once 'Zend/Form/Exception.php';

   485             throw new Zend_Form_Exception('Invalid name provided; must contain only valid variable characters and be non-empty');

   486         }

   487 

   488         $this->_name = $name;

   489         return $this;

   490     }

   491 

   492     /**

   493      * Return element name

   494      *

   495      * @return string

   496      */

   497     public function getName()

   498     {

   499         return $this->_name;

   500     }

   501 

   502     /**

   503      * Get fully qualified name

   504      *

   505      * Places name as subitem of array and/or appends brackets.

   506      *

   507      * @return string

   508      */

   509     public function getFullyQualifiedName()

   510     {

   511         $name = $this->getName();

   512 

   513         if (null !== ($belongsTo = $this->getBelongsTo())) {

   514             $name = $belongsTo . '[' . $name . ']';

   515         }

   516 

   517         if ($this->isArray()) {

   518             $name .= '[]';

   519         }

   520 

   521         return $name;

   522     }

   523 

   524     /**

   525      * Get element id

   526      *

   527      * @return string

   528      */

   529     public function getId()

   530     {

   531         if (isset($this->id)) {

   532             return $this->id;

   533         }

   534 

   535         $id = $this->getFullyQualifiedName();

   536 

   537         // Bail early if no array notation detected

   538         if (!strstr($id, '[')) {

   539             return $id;

   540         }

   541 

   542         // Strip array notation

   543         if ('[]' == substr($id, -2)) {

   544             $id = substr($id, 0, strlen($id) - 2);

   545         }

   546         $id = str_replace('][', '-', $id);

   547         $id = str_replace(array(']', '['), '-', $id);

   548         $id = trim($id, '-');

   549 

   550         return $id;

   551     }

   552 

   553     /**

   554      * Set element value

   555      *

   556      * @param  mixed $value

   557      * @return Zend_Form_Element

   558      */

   559     public function setValue($value)

   560     {

   561         $this->_value = $value;

   562         return $this;

   563     }

   564 

   565     /**

   566      * Filter a value

   567      *

   568      * @param  string $value

   569      * @param  string $key

   570      * @return void

   571      */

   572     protected function _filterValue(&$value, &$key)

   573     {

   574         foreach ($this->getFilters() as $filter) {

   575             $value = $filter->filter($value);

   576         }

   577     }

   578 

   579     /**

   580      * Retrieve filtered element value

   581      *

   582      * @return mixed

   583      */

   584     public function getValue()

   585     {

   586         $valueFiltered = $this->_value;

   587 

   588         if ($this->isArray() && is_array($valueFiltered)) {

   589             array_walk_recursive($valueFiltered, array($this, '_filterValue'));

   590         } else {

   591             $this->_filterValue($valueFiltered, $valueFiltered);

   592         }

   593 

   594         return $valueFiltered;

   595     }

   596 

   597     /**

   598      * Retrieve unfiltered element value

   599      *

   600      * @return mixed

   601      */

   602     public function getUnfilteredValue()

   603     {

   604         return $this->_value;

   605     }

   606 

   607     /**

   608      * Set element label

   609      *

   610      * @param  string $label

   611      * @return Zend_Form_Element

   612      */

   613     public function setLabel($label)

   614     {

   615         $this->_label = (string) $label;

   616         return $this;

   617     }

   618 

   619     /**

   620      * Retrieve element label

   621      *

   622      * @return string

   623      */

   624     public function getLabel()

   625     {

   626         $translator = $this->getTranslator();

   627         if (null !== $translator) {

   628             return $translator->translate($this->_label);

   629         }

   630 

   631         return $this->_label;

   632     }

   633 

   634     /**

   635      * Set element order

   636      *

   637      * @param  int $order

   638      * @return Zend_Form_Element

   639      */

   640     public function setOrder($order)

   641     {

   642         $this->_order = (int) $order;

   643         return $this;

   644     }

   645 

   646     /**

   647      * Retrieve element order

   648      *

   649      * @return int

   650      */

   651     public function getOrder()

   652     {

   653         return $this->_order;

   654     }

   655 

   656     /**

   657      * Set required flag

   658      *

   659      * @param  bool $flag Default value is true

   660      * @return Zend_Form_Element

   661      */

   662     public function setRequired($flag = true)

   663     {

   664         $this->_required = (bool) $flag;

   665         return $this;

   666     }

   667 

   668     /**

   669      * Is the element required?

   670      *

   671      * @return bool

   672      */

   673     public function isRequired()

   674     {

   675         return $this->_required;

   676     }

   677 

   678     /**

   679      * Set flag indicating whether a NotEmpty validator should be inserted when element is required

   680      *

   681      * @param  bool $flag

   682      * @return Zend_Form_Element

   683      */

   684     public function setAutoInsertNotEmptyValidator($flag)

   685     {

   686         $this->_autoInsertNotEmptyValidator = (bool) $flag;

   687         return $this;

   688     }

   689 

   690     /**

   691      * Get flag indicating whether a NotEmpty validator should be inserted when element is required

   692      *

   693      * @return bool

   694      */

   695     public function autoInsertNotEmptyValidator()

   696     {

   697         return $this->_autoInsertNotEmptyValidator;

   698     }

   699 

   700     /**

   701      * Set element description

   702      *

   703      * @param  string $description

   704      * @return Zend_Form_Element

   705      */

   706     public function setDescription($description)

   707     {

   708         $this->_description = (string) $description;

   709         return $this;

   710     }

   711 

   712     /**

   713      * Retrieve element description

   714      *

   715      * @return string

   716      */

   717     public function getDescription()

   718     {

   719         return $this->_description;

   720     }

   721 

   722     /**

   723      * Set 'allow empty' flag

   724      *

   725      * When the allow empty flag is enabled and the required flag is false, the

   726      * element will validate with empty values.

   727      *

   728      * @param  bool $flag

   729      * @return Zend_Form_Element

   730      */

   731     public function setAllowEmpty($flag)

   732     {

   733         $this->_allowEmpty = (bool) $flag;

   734         return $this;

   735     }

   736 

   737     /**

   738      * Get 'allow empty' flag

   739      *

   740      * @return bool

   741      */

   742     public function getAllowEmpty()

   743     {

   744         return $this->_allowEmpty;

   745     }

   746 

   747     /**

   748      * Set ignore flag (used when retrieving values at form level)

   749      *

   750      * @param  bool $flag

   751      * @return Zend_Form_Element

   752      */

   753     public function setIgnore($flag)

   754     {

   755         $this->_ignore = (bool) $flag;

   756         return $this;

   757     }

   758 

   759     /**

   760      * Get ignore flag (used when retrieving values at form level)

   761      *

   762      * @return bool

   763      */

   764     public function getIgnore()

   765     {

   766         return $this->_ignore;

   767     }

   768 

   769     /**

   770      * Set flag indicating if element represents an array

   771      *

   772      * @param  bool $flag

   773      * @return Zend_Form_Element

   774      */

   775     public function setIsArray($flag)

   776     {

   777         $this->_isArray = (bool) $flag;

   778         return $this;

   779     }

   780 

   781     /**

   782      * Is the element representing an array?

   783      *

   784      * @return bool

   785      */

   786     public function isArray()

   787     {

   788         return $this->_isArray;

   789     }

   790 

   791     /**

   792      * Set array to which element belongs

   793      *

   794      * @param  string $array

   795      * @return Zend_Form_Element

   796      */

   797     public function setBelongsTo($array)

   798     {

   799         $array = $this->filterName($array, true);

   800         if (!empty($array)) {

   801             $this->_belongsTo = $array;

   802         }

   803 

   804         return $this;

   805     }

   806 

   807     /**

   808      * Return array name to which element belongs

   809      *

   810      * @return string

   811      */

   812     public function getBelongsTo()

   813     {

   814         return $this->_belongsTo;

   815     }

   816 

   817     /**

   818      * Return element type

   819      *

   820      * @return string

   821      */

   822     public function getType()

   823     {

   824         if (null === $this->_type) {

   825             $this->_type = get_class($this);

   826         }

   827 

   828         return $this->_type;

   829     }

   830 

   831     /**

   832      * Set element attribute

   833      *

   834      * @param  string $name

   835      * @param  mixed $value

   836      * @return Zend_Form_Element

   837      * @throws Zend_Form_Exception for invalid $name values

   838      */

   839     public function setAttrib($name, $value)

   840     {

   841         $name = (string) $name;

   842         if ('_' == $name[0]) {

   843             require_once 'Zend/Form/Exception.php';

   844             throw new Zend_Form_Exception(sprintf('Invalid attribute "%s"; must not contain a leading underscore', $name));

   845         }

   846 

   847         if (null === $value) {

   848             unset($this->$name);

   849         } else {

   850             $this->$name = $value;

   851         }

   852 

   853         return $this;

   854     }

   855 

   856     /**

   857      * Set multiple attributes at once

   858      *

   859      * @param  array $attribs

   860      * @return Zend_Form_Element

   861      */

   862     public function setAttribs(array $attribs)

   863     {

   864         foreach ($attribs as $key => $value) {

   865             $this->setAttrib($key, $value);

   866         }

   867 

   868         return $this;

   869     }

   870 

   871     /**

   872      * Retrieve element attribute

   873      *

   874      * @param  string $name

   875      * @return string

   876      */

   877     public function getAttrib($name)

   878     {

   879         $name = (string) $name;

   880         if (isset($this->$name)) {

   881             return $this->$name;

   882         }

   883 

   884         return null;

   885     }

   886 

   887     /**

   888      * Return all attributes

   889      *

   890      * @return array

   891      */

   892     public function getAttribs()

   893     {

   894         $attribs = get_object_vars($this);

   895         foreach ($attribs as $key => $value) {

   896             if ('_' == substr($key, 0, 1)) {

   897                 unset($attribs[$key]);

   898             }

   899         }

   900 

   901         return $attribs;

   902     }

   903 

   904     /**

   905      * Overloading: retrieve object property

   906      *

   907      * Prevents access to properties beginning with '_'.

   908      *

   909      * @param  string $key

   910      * @return mixed

   911      */

   912     public function __get($key)

   913     {

   914         if ('_' == $key[0]) {

   915             require_once 'Zend/Form/Exception.php';

   916             throw new Zend_Form_Exception(sprintf('Cannot retrieve value for protected/private property "%s"', $key));

   917         }

   918 

   919         if (!isset($this->$key)) {

   920             return null;

   921         }

   922 

   923         return $this->$key;

   924     }

   925 

   926     /**

   927      * Overloading: set object property

   928      *

   929      * @param  string $key

   930      * @param  mixed $value

   931      * @return voide

   932      */

   933     public function __set($key, $value)

   934     {

   935         $this->setAttrib($key, $value);

   936     }

   937 

   938     /**

   939      * Overloading: allow rendering specific decorators

   940      *

   941      * Call renderDecoratorName() to render a specific decorator.

   942      *

   943      * @param  string $method

   944      * @param  array $args

   945      * @return string

   946      * @throws Zend_Form_Exception for invalid decorator or invalid method call

   947      */

   948     public function __call($method, $args)

   949     {

   950         if ('render' == substr($method, 0, 6)) {

   951             $this->_isPartialRendering = true;

   952             $this->render();

   953             $this->_isPartialRendering = false;

   954             $decoratorName = substr($method, 6);

   955             if (false !== ($decorator = $this->getDecorator($decoratorName))) {

   956                 $decorator->setElement($this);

   957                 $seed = '';

   958                 if (0 < count($args)) {

   959                     $seed = array_shift($args);

   960                 }

   961                 return $decorator->render($seed);

   962             }

   963 

   964             require_once 'Zend/Form/Element/Exception.php';

   965             throw new Zend_Form_Element_Exception(sprintf('Decorator by name %s does not exist', $decoratorName));

   966         }

   967 

   968         require_once 'Zend/Form/Element/Exception.php';

   969         throw new Zend_Form_Element_Exception(sprintf('Method %s does not exist', $method));

   970     }

   971 

   972     // Loaders

   973 

   974     /**

   975      * Set plugin loader to use for validator or filter chain

   976      *

   977      * @param  Zend_Loader_PluginLoader_Interface $loader

   978      * @param  string $type 'decorator', 'filter', or 'validate'

   979      * @return Zend_Form_Element

   980      * @throws Zend_Form_Exception on invalid type

   981      */

   982     public function setPluginLoader(Zend_Loader_PluginLoader_Interface $loader, $type)

   983     {

   984         $type = strtoupper($type);

   985         switch ($type) {

   986             case self::DECORATOR:

   987             case self::FILTER:

   988             case self::VALIDATE:

   989                 $this->_loaders[$type] = $loader;

   990                 return $this;

   991             default:

   992                 require_once 'Zend/Form/Exception.php';

   993                 throw new Zend_Form_Exception(sprintf('Invalid type "%s" provided to setPluginLoader()', $type));

   994         }

   995     }

   996 

   997     /**

   998      * Retrieve plugin loader for validator or filter chain

   999      *

  1000      * Instantiates with default rules if none available for that type. Use

  1001      * 'decorator', 'filter', or 'validate' for $type.

  1002      *

  1003      * @param  string $type

  1004      * @return Zend_Loader_PluginLoader

  1005      * @throws Zend_Loader_Exception on invalid type.

  1006      */

  1007     public function getPluginLoader($type)

  1008     {

  1009         $type = strtoupper($type);

  1010         switch ($type) {

  1011             case self::FILTER:

  1012             case self::VALIDATE:

  1013                 $prefixSegment = ucfirst(strtolower($type));

  1014                 $pathSegment   = $prefixSegment;

  1015             case self::DECORATOR:

  1016                 if (!isset($prefixSegment)) {

  1017                     $prefixSegment = 'Form_Decorator';

  1018                     $pathSegment   = 'Form/Decorator';

  1019                 }

  1020                 if (!isset($this->_loaders[$type])) {

  1021                     require_once 'Zend/Loader/PluginLoader.php';

  1022                     $this->_loaders[$type] = new Zend_Loader_PluginLoader(

  1023                         array('Zend_' . $prefixSegment . '_' => 'Zend/' . $pathSegment . '/')

  1024                     );

  1025                 }

  1026                 return $this->_loaders[$type];

  1027             default:

  1028                 require_once 'Zend/Form/Exception.php';

  1029                 throw new Zend_Form_Exception(sprintf('Invalid type "%s" provided to getPluginLoader()', $type));

  1030         }

  1031     }

  1032 

  1033     /**

  1034      * Add prefix path for plugin loader

  1035      *

  1036      * If no $type specified, assumes it is a base path for both filters and

  1037      * validators, and sets each according to the following rules:

  1038      * - decorators: $prefix = $prefix . '_Decorator'

  1039      * - filters: $prefix = $prefix . '_Filter'

  1040      * - validators: $prefix = $prefix . '_Validate'

  1041      *

  1042      * Otherwise, the path prefix is set on the appropriate plugin loader.

  1043      *

  1044      * @param  string $prefix

  1045      * @param  string $path

  1046      * @param  string $type

  1047      * @return Zend_Form_Element

  1048      * @throws Zend_Form_Exception for invalid type

  1049      */

  1050     public function addPrefixPath($prefix, $path, $type = null)

  1051     {

  1052         $type = strtoupper($type);

  1053         switch ($type) {

  1054             case self::DECORATOR:

  1055             case self::FILTER:

  1056             case self::VALIDATE:

  1057                 $loader = $this->getPluginLoader($type);

  1058                 $loader->addPrefixPath($prefix, $path);

  1059                 return $this;

  1060             case null:

  1061                 $prefix = rtrim($prefix, '_');

  1062                 $path   = rtrim($path, DIRECTORY_SEPARATOR);

  1063                 foreach (array(self::DECORATOR, self::FILTER, self::VALIDATE) as $type) {

  1064                     $cType        = ucfirst(strtolower($type));

  1065                     $pluginPath   = $path . DIRECTORY_SEPARATOR . $cType . DIRECTORY_SEPARATOR;

  1066                     $pluginPrefix = $prefix . '_' . $cType;

  1067                     $loader       = $this->getPluginLoader($type);

  1068                     $loader->addPrefixPath($pluginPrefix, $pluginPath);

  1069                 }

  1070                 return $this;

  1071             default:

  1072                 require_once 'Zend/Form/Exception.php';

  1073                 throw new Zend_Form_Exception(sprintf('Invalid type "%s" provided to getPluginLoader()', $type));

  1074         }

  1075     }

  1076 

  1077     /**

  1078      * Add many prefix paths at once

  1079      *

  1080      * @param  array $spec

  1081      * @return Zend_Form_Element

  1082      */

  1083     public function addPrefixPaths(array $spec)

  1084     {

  1085         if (isset($spec['prefix']) && isset($spec['path'])) {

  1086             return $this->addPrefixPath($spec['prefix'], $spec['path']);

  1087         }

  1088         foreach ($spec as $type => $paths) {

  1089             if (is_numeric($type) && is_array($paths)) {

  1090                 $type = null;

  1091                 if (isset($paths['prefix']) && isset($paths['path'])) {

  1092                     if (isset($paths['type'])) {

  1093                         $type = $paths['type'];

  1094                     }

  1095                     $this->addPrefixPath($paths['prefix'], $paths['path'], $type);

  1096                 }

  1097             } elseif (!is_numeric($type)) {

  1098                 if (!isset($paths['prefix']) || !isset($paths['path'])) {

  1099                     foreach ($paths as $prefix => $spec) {

  1100                         if (is_array($spec)) {

  1101                             foreach ($spec as $path) {

  1102                                 if (!is_string($path)) {

  1103                                     continue;

  1104                                 }

  1105                                 $this->addPrefixPath($prefix, $path, $type);

  1106                             }

  1107                         } elseif (is_string($spec)) {

  1108                             $this->addPrefixPath($prefix, $spec, $type);

  1109                         }

  1110                     }

  1111                 } else {

  1112                     $this->addPrefixPath($paths['prefix'], $paths['path'], $type);

  1113                 }

  1114             }

  1115         }

  1116         return $this;

  1117     }

  1118 

  1119     // Validation

  1120 

  1121     /**

  1122      * Add validator to validation chain

  1123      *

  1124      * Note: will overwrite existing validators if they are of the same class.

  1125      *

  1126      * @param  string|Zend_Validate_Interface $validator

  1127      * @param  bool $breakChainOnFailure

  1128      * @param  array $options

  1129      * @return Zend_Form_Element

  1130      * @throws Zend_Form_Exception if invalid validator type

  1131      */

  1132     public function addValidator($validator, $breakChainOnFailure = false, $options = array())

  1133     {

  1134         if ($validator instanceof Zend_Validate_Interface) {

  1135             $name = get_class($validator);