Packages

  • Nette
    • Application
      • Application\Diagnostics
      • Application\Responses
      • Application\Routers
      • Application\UI
    • Caching
      • Caching\Storages
    • ComponentModel
    • Config
    • Database
      • Database\Diagnostics
      • Database\Drivers
      • Database\Reflection
      • Database\Table
    • DI
    • Diagnostics
    • Forms
      • Forms\Controls
      • Forms\Rendering
    • Http
    • Iterators
    • Latte
      • Latte\Macros
    • Loaders
    • Localization
    • Mail
    • Reflection
    • Security
    • Templating
    • Utils
  • NetteModule
  • None
  • PHP

Classes

  • Button
  • Checkbox
  • HiddenField
  • ImageButton
  • MultiSelectBox
  • RadioList
  • SelectBox
  • SubmitButton
  • TextArea
  • TextBase
  • TextInput
  • UploadControl
  • Overview
  • Package
  • Class
  • Tree
  1: <?php
  2: 
  3: /**
  4:  * This file is part of the Nette Framework (http://nette.org)
  5:  *
  6:  * Copyright (c) 2004, 2011 David Grudl (http://davidgrudl.com)
  7:  *
  8:  * For the full copyright and license information, please view
  9:  * the file license.txt that was distributed with this source code.
 10:  * @package Nette\Forms\Controls
 11:  */
 12: 
 13: 
 14: 
 15: /**
 16:  * Implements the basic functionality common to text input controls.
 17:  *
 18:  * @author     David Grudl
 19:  *
 20:  * @property   string $emptyValue
 21:  * @package Nette\Forms\Controls
 22:  */
 23: abstract class TextBase extends FormControl
 24: {
 25:     /** @var string */
 26:     protected $emptyValue = '';
 27: 
 28:     /** @var array */
 29:     protected $filters = array();
 30: 
 31: 
 32: 
 33:     /**
 34:      * Sets control's value.
 35:      * @param  string
 36:      * @return TextBase  provides a fluent interface
 37:      */
 38:     public function setValue($value)
 39:     {
 40:         $this->value = is_scalar($value) ? (string) $value : '';
 41:         return $this;
 42:     }
 43: 
 44: 
 45: 
 46:     /**
 47:      * Returns control's value.
 48:      * @return string
 49:      */
 50:     public function getValue()
 51:     {
 52:         $value = $this->value;
 53:         foreach ($this->filters as $filter) {
 54:             $value = (string) $filter->invoke($value);
 55:         }
 56:         return $value === $this->translate($this->emptyValue) ? '' : $value;
 57:     }
 58: 
 59: 
 60: 
 61:     /**
 62:      * Sets the special value which is treated as empty string.
 63:      * @param  string
 64:      * @return TextBase  provides a fluent interface
 65:      */
 66:     public function setEmptyValue($value)
 67:     {
 68:         $this->emptyValue = (string) $value;
 69:         return $this;
 70:     }
 71: 
 72: 
 73: 
 74:     /**
 75:      * Returns the special value which is treated as empty string.
 76:      * @return string
 77:      */
 78:     final public function getEmptyValue()
 79:     {
 80:         return $this->emptyValue;
 81:     }
 82: 
 83: 
 84: 
 85:     /**
 86:      * Appends input string filter callback.
 87:      * @param  callback
 88:      * @return TextBase  provides a fluent interface
 89:      */
 90:     public function addFilter($filter)
 91:     {
 92:         $this->filters[] = callback($filter);
 93:         return $this;
 94:     }
 95: 
 96: 
 97: 
 98:     public function getControl()
 99:     {
100:         $control = parent::getControl();
101:         foreach ($this->getRules() as $rule) {
102:             if ($rule->type === Rule::VALIDATOR && !$rule->isNegative
103:                 && ($rule->operation === Form::LENGTH || $rule->operation === Form::MAX_LENGTH)
104:             ) {
105:                 $control->maxlength = is_array($rule->arg) ? $rule->arg[1] : $rule->arg;
106:             }
107:         }
108:         if ($this->emptyValue !== '') {
109:             $control->data('nette-empty-value', $this->translate($this->emptyValue));
110:         }
111:         return $control;
112:     }
113: 
114: 
115: 
116:     public function addRule($operation, $message = NULL, $arg = NULL)
117:     {
118:         if ($operation === Form::FLOAT) {
119:             $this->addFilter(callback(__CLASS__, 'filterFloat'));
120:         }
121:         return parent::addRule($operation, $message, $arg);
122:     }
123: 
124: 
125: 
126:     /**
127:      * Min-length validator: has control's value minimal length?
128:      * @param  TextBase
129:      * @param  int  length
130:      * @return bool
131:      */
132:     public static function validateMinLength(TextBase $control, $length)
133:     {
134:         return Strings::length($control->getValue()) >= $length;
135:     }
136: 
137: 
138: 
139:     /**
140:      * Max-length validator: is control's value length in limit?
141:      * @param  TextBase
142:      * @param  int  length
143:      * @return bool
144:      */
145:     public static function validateMaxLength(TextBase $control, $length)
146:     {
147:         return Strings::length($control->getValue()) <= $length;
148:     }
149: 
150: 
151: 
152:     /**
153:      * Length validator: is control's value length in range?
154:      * @param  TextBase
155:      * @param  array  min and max length pair
156:      * @return bool
157:      */
158:     public static function validateLength(TextBase $control, $range)
159:     {
160:         if (!is_array($range)) {
161:             $range = array($range, $range);
162:         }
163:         $len = Strings::length($control->getValue());
164:         return ($range[0] === NULL || $len >= $range[0]) && ($range[1] === NULL || $len <= $range[1]);
165:     }
166: 
167: 
168: 
169:     /**
170:      * Email validator: is control's value valid email address?
171:      * @param  TextBase
172:      * @return bool
173:      */
174:     public static function validateEmail(TextBase $control)
175:     {
176:         $atom = "[-a-z0-9!#$%&'*+/=?^_`{|}~]"; // RFC 5322 unquoted characters in local-part
177:         $localPart = "(?:\"(?:[ !\\x23-\\x5B\\x5D-\\x7E]*|\\\\[ -~])+\"|$atom+(?:\\.$atom+)*)"; // quoted or unquoted
178:         $chars = "a-z0-9\x80-\xFF"; // superset of IDN
179:         $domain = "[$chars](?:[-$chars]{0,61}[$chars])"; // RFC 1034 one domain component
180:         return (bool) Strings::match($control->getValue(), "(^$localPart@(?:$domain?\\.)+[-$chars]{2,19}\\z)i");
181:     }
182: 
183: 
184: 
185:     /**
186:      * URL validator: is control's value valid URL?
187:      * @param  TextBase
188:      * @return bool
189:      */
190:     public static function validateUrl(TextBase $control)
191:     {
192:         $chars = "a-z0-9\x80-\xFF";
193:         return (bool) Strings::match(
194:             $control->getValue(),
195:             "#^(?:https?://|)(?:[$chars](?:[-$chars]{0,61}[$chars])?\\.)+[-$chars]{2,19}(/\S*)?$#i"
196:         );
197:     }
198: 
199: 
200: 
201:     /** @deprecated */
202:     public static function validateRegexp(TextBase $control, $regexp)
203:     {
204:         return (bool) Strings::match($control->getValue(), $regexp);
205:     }
206: 
207: 
208: 
209:     /**
210:      * Regular expression validator: matches control's value regular expression?
211:      * @param  TextBase
212:      * @param  string
213:      * @return bool
214:      */
215:     public static function validatePattern(TextBase $control, $pattern)
216:     {
217:         return (bool) Strings::match($control->getValue(), "\x01^($pattern)$\x01u");
218:     }
219: 
220: 
221: 
222:     /**
223:      * Integer validator: is a control's value decimal number?
224:      * @param  TextBase
225:      * @return bool
226:      */
227:     public static function validateInteger(TextBase $control)
228:     {
229:         return (bool) Strings::match($control->getValue(), '/^-?[0-9]+$/');
230:     }
231: 
232: 
233: 
234:     /**
235:      * Float validator: is a control's value float number?
236:      * @param  TextBase
237:      * @return bool
238:      */
239:     public static function validateFloat(TextBase $control)
240:     {
241:         return (bool) Strings::match($control->getValue(), '/^-?[0-9]*[.,]?[0-9]+$/');
242:     }
243: 
244: 
245: 
246:     /**
247:      * Rangle validator: is a control's value number in specified range?
248:      * @param  TextBase
249:      * @param  array  min and max value pair
250:      * @return bool
251:      */
252:     public static function validateRange(TextBase $control, $range)
253:     {
254:         return ($range[0] === NULL || $control->getValue() >= $range[0])
255:             && ($range[1] === NULL || $control->getValue() <= $range[1]);
256:     }
257: 
258: 
259: 
260:     /**
261:      * Float string cleanup.
262:      * @param  string
263:      * @return string
264:      */
265:     public static function filterFloat($s)
266:     {
267:         return str_replace(array(' ', ','), array('', '.'), $s);
268:     }
269: 
270: }
271: 
Nette Framework 2.0beta1 (for PHP 5.2) API API documentation generated by ApiGen 2.3.0