Component.php 18.2 KB
Newer Older
Qiang Xue committed
1
<?php
w  
Qiang Xue committed
2 3
/**
 * @link http://www.yiiframework.com/
Qiang Xue committed
4
 * @copyright Copyright (c) 2008 Yii Software LLC
w  
Qiang Xue committed
5 6
 * @license http://www.yiiframework.com/license/
 */
Qiang Xue committed
7 8 9

namespace yii\base;

Qiang Xue committed
10 11
use Yii;

w  
Qiang Xue committed
12
/**
Qiang Xue committed
13
 * @include @yii/base/Component.md
14 15 16
 *
 * @property Behavior[] $behaviors List of behaviors attached to this component. This property is read-only.
 *
w  
Qiang Xue committed
17
 * @author Qiang Xue <qiang.xue@gmail.com>
w  
Qiang Xue committed
18
 * @since 2.0
w  
Qiang Xue committed
19
 */
Qiang Xue committed
20
class Component extends Object
Qiang Xue committed
21
{
Qiang Xue committed
22
	/**
Qiang Xue committed
23
	 * @var array the attached event handlers (event name => handlers)
Qiang Xue committed
24
	 */
Qiang Xue committed
25
	private $_events;
Qiang Xue committed
26 27 28
	/**
	 * @var Behavior[] the attached behaviors (behavior name => behavior)
	 */
Qiang Xue committed
29
	private $_behaviors;
Qiang Xue committed
30 31

	/**
w  
Qiang Xue committed
32 33 34 35 36 37 38 39 40
	 * Returns the value of a component property.
	 * This method will check in the following order and act accordingly:
	 *
	 *  - a property defined by a getter: return the getter result
	 *  - a property of a behavior: return the behavior property value
	 *
	 * Do not call this method directly as it is a PHP magic method that
	 * will be implicitly called when executing `$value = $component->property;`.
	 * @param string $name the property name
41
	 * @return mixed the property value or the value of a behavior's property
Qiang Xue committed
42
	 * @throws UnknownPropertyException if the property is not defined
Qiang Xue committed
43
	 * @throws InvalidCallException if the property is write-only.
Qiang Xue committed
44 45 46 47 48
	 * @see __set
	 */
	public function __get($name)
	{
		$getter = 'get' . $name;
49 50
		if (method_exists($this, $getter)) {
			// read property, e.g. getName()
Qiang Xue committed
51
			return $this->$getter();
52 53
		} else {
			// behavior property
Qiang Xue committed
54
			$this->ensureBehaviors();
Qiang Xue committed
55
			foreach ($this->_behaviors as $behavior) {
Qiang Xue committed
56
				if ($behavior->canGetProperty($name)) {
Qiang Xue committed
57
					return $behavior->$name;
Qiang Xue committed
58
				}
Qiang Xue committed
59 60
			}
		}
61 62 63 64 65
		if (method_exists($this, 'set' . $name)) {
			throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
		} else {
			throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
		}
Qiang Xue committed
66 67 68
	}

	/**
69
	 * Sets the value of a component property.
w  
Qiang Xue committed
70 71 72
	 * This method will check in the following order and act accordingly:
	 *
	 *  - a property defined by a setter: set the property value
Qiang Xue committed
73 74
	 *  - an event in the format of "on xyz": attach the handler to the event "xyz"
	 *  - a behavior in the format of "as xyz": attach the behavior named as "xyz"
w  
Qiang Xue committed
75 76 77 78
	 *  - a property of a behavior: set the behavior property value
	 *
	 * Do not call this method directly as it is a PHP magic method that
	 * will be implicitly called when executing `$component->property = $value;`.
Qiang Xue committed
79
	 * @param string $name the property name or the event name
w  
Qiang Xue committed
80
	 * @param mixed $value the property value
81 82
	 * @throws UnknownPropertyException if the property is not defined
	 * @throws InvalidCallException if the property is read-only.
Qiang Xue committed
83 84
	 * @see __get
	 */
Qiang Xue committed
85
	public function __set($name, $value)
Qiang Xue committed
86
	{
Qiang Xue committed
87
		$setter = 'set' . $name;
Qiang Xue committed
88 89
		if (method_exists($this, $setter)) {
			// set property
Qiang Xue committed
90 91
			$this->$setter($value);
			return;
Qiang Xue committed
92 93
		} elseif (strncmp($name, 'on ', 3) === 0) {
			// on event: attach event handler
Qiang Xue committed
94
			$this->on(trim(substr($name, 3)), $value);
Qiang Xue committed
95
			return;
Qiang Xue committed
96 97 98
		} elseif (strncmp($name, 'as ', 3) === 0) {
			// as behavior: attach behavior
			$name = trim(substr($name, 3));
Qiang Xue committed
99
			$this->attachBehavior($name, $value instanceof Behavior ? $value : Yii::createObject($value));
100
			return;
101 102
		} else {
			// behavior property
Qiang Xue committed
103
			$this->ensureBehaviors();
Qiang Xue committed
104
			foreach ($this->_behaviors as $behavior) {
Qiang Xue committed
105
				if ($behavior->canSetProperty($name)) {
Qiang Xue committed
106 107
					$behavior->$name = $value;
					return;
Qiang Xue committed
108
				}
Qiang Xue committed
109 110
			}
		}
Qiang Xue committed
111
		if (method_exists($this, 'get' . $name)) {
Qiang Xue committed
112
			throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
Qiang Xue committed
113
		} else {
Qiang Xue committed
114
			throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
Qiang Xue committed
115
		}
Qiang Xue committed
116 117 118 119
	}

	/**
	 * Checks if a property value is null.
w  
Qiang Xue committed
120 121 122 123 124 125 126
	 * This method will check in the following order and act accordingly:
	 *
	 *  - a property defined by a setter: return whether the property value is null
	 *  - a property of a behavior: return whether the property value is null
	 *
	 * Do not call this method directly as it is a PHP magic method that
	 * will be implicitly called when executing `isset($component->property)`.
Qiang Xue committed
127
	 * @param string $name the property name or the event name
w  
Qiang Xue committed
128
	 * @return boolean whether the named property is null
Qiang Xue committed
129 130 131
	 */
	public function __isset($name)
	{
Qiang Xue committed
132
		$getter = 'get' . $name;
133
		if (method_exists($this, $getter)) {
Qiang Xue committed
134
			return $this->$getter() !== null;
135 136
		} else {
			// behavior property
Qiang Xue committed
137
			$this->ensureBehaviors();
Qiang Xue committed
138
			foreach ($this->_behaviors as $behavior) {
Qiang Xue committed
139
				if ($behavior->canGetProperty($name)) {
Qiang Xue committed
140
					return $behavior->$name !== null;
Qiang Xue committed
141
				}
Qiang Xue committed
142 143 144 145 146 147 148
			}
		}
		return false;
	}

	/**
	 * Sets a component property to be null.
w  
Qiang Xue committed
149 150 151 152 153 154 155 156
	 * This method will check in the following order and act accordingly:
	 *
	 *  - a property defined by a setter: set the property value to be null
	 *  - a property of a behavior: set the property value to be null
	 *
	 * Do not call this method directly as it is a PHP magic method that
	 * will be implicitly called when executing `unset($component->property)`.
	 * @param string $name the property name
157
	 * @throws InvalidCallException if the property is read only.
Qiang Xue committed
158 159 160
	 */
	public function __unset($name)
	{
Qiang Xue committed
161
		$setter = 'set' . $name;
162
		if (method_exists($this, $setter)) {
Qiang Xue committed
163 164
			$this->$setter(null);
			return;
165 166
		} else {
			// behavior property
Qiang Xue committed
167
			$this->ensureBehaviors();
Qiang Xue committed
168
			foreach ($this->_behaviors as $behavior) {
Qiang Xue committed
169
				if ($behavior->canSetProperty($name)) {
Qiang Xue committed
170 171
					$behavior->$name = null;
					return;
Qiang Xue committed
172
				}
Qiang Xue committed
173
			}
Qiang Xue committed
174 175
		}
		if (method_exists($this, 'get' . $name)) {
Qiang Xue committed
176
			throw new InvalidCallException('Unsetting read-only property: ' . get_class($this) . '.' . $name);
w  
Qiang Xue committed
177
		}
Qiang Xue committed
178 179 180 181
	}

	/**
	 * Calls the named method which is not a class method.
182 183
	 *
	 * This method will check if any attached behavior has
w  
Qiang Xue committed
184 185 186 187
	 * the named method and will execute it if available.
	 *
	 * Do not call this method directly as it is a PHP magic method that
	 * will be implicitly called when an unknown method is being invoked.
Qiang Xue committed
188
	 * @param string $name the method name
Qiang Xue committed
189
	 * @param array $params method parameters
Qiang Xue committed
190
	 * @return mixed the method return value
Qiang Xue committed
191
	 * @throws UnknownMethodException when calling unknown method
Qiang Xue committed
192
	 */
Qiang Xue committed
193
	public function __call($name, $params)
Qiang Xue committed
194
	{
Qiang Xue committed
195
		$this->ensureBehaviors();
Qiang Xue committed
196
		foreach ($this->_behaviors as $object) {
197
			if ($object->hasMethod($name)) {
Alexander Makarov committed
198
				return call_user_func_array([$object, $name], $params);
w  
Qiang Xue committed
199
			}
Qiang Xue committed
200
		}
Qiang Xue committed
201

Qiang Xue committed
202
		throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
Qiang Xue committed
203 204
	}

Qiang Xue committed
205 206 207 208 209 210
	/**
	 * This method is called after the object is created by cloning an existing one.
	 * It removes all behaviors because they are attached to the old object.
	 */
	public function __clone()
	{
Qiang Xue committed
211 212
		$this->_events = null;
		$this->_behaviors = null;
Qiang Xue committed
213 214
	}

Qiang Xue committed
215 216 217 218 219 220
	/**
	 * Returns a value indicating whether a property is defined for this component.
	 * A property is defined if:
	 *
	 * - the class has a getter or setter method associated with the specified name
	 *   (in this case, property name is case-insensitive);
crtlib committed
221
	 * - the class has a member variable with the specified name (when `$checkVars` is true);
222
	 * - an attached behavior has a property of the given name (when `$checkBehaviors` is true).
Qiang Xue committed
223 224
	 *
	 * @param string $name the property name
crtlib committed
225
	 * @param boolean $checkVars whether to treat member variables as properties
226
	 * @param boolean $checkBehaviors whether to treat behaviors' properties as properties of this component
Qiang Xue committed
227 228 229 230
	 * @return boolean whether the property is defined
	 * @see canGetProperty
	 * @see canSetProperty
	 */
crtlib committed
231
	public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
Qiang Xue committed
232
	{
crtlib committed
233
		return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
Qiang Xue committed
234 235 236 237 238 239 240 241
	}

	/**
	 * Returns a value indicating whether a property can be read.
	 * A property can be read if:
	 *
	 * - the class has a getter method associated with the specified name
	 *   (in this case, property name is case-insensitive);
crtlib committed
242
	 * - the class has a member variable with the specified name (when `$checkVars` is true);
243
	 * - an attached behavior has a readable property of the given name (when `$checkBehaviors` is true).
Qiang Xue committed
244 245
	 *
	 * @param string $name the property name
crtlib committed
246
	 * @param boolean $checkVars whether to treat member variables as properties
Qiang Xue committed
247
	 * @param boolean $checkBehaviors whether to treat behaviors' properties as properties of this component
Qiang Xue committed
248 249 250
	 * @return boolean whether the property can be read
	 * @see canSetProperty
	 */
crtlib committed
251
	public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
Qiang Xue committed
252
	{
crtlib committed
253
		if (method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name)) {
Qiang Xue committed
254
			return true;
Qiang Xue committed
255
		} elseif ($checkBehaviors) {
Qiang Xue committed
256
			$this->ensureBehaviors();
Qiang Xue committed
257
			foreach ($this->_behaviors as $behavior) {
crtlib committed
258
				if ($behavior->canGetProperty($name, $checkVars)) {
Qiang Xue committed
259 260 261 262
					return true;
				}
			}
		}
263
		return false;
Qiang Xue committed
264 265 266 267 268 269 270 271
	}

	/**
	 * Returns a value indicating whether a property can be set.
	 * A property can be written if:
	 *
	 * - the class has a setter method associated with the specified name
	 *   (in this case, property name is case-insensitive);
crtlib committed
272
	 * - the class has a member variable with the specified name (when `$checkVars` is true);
273
	 * - an attached behavior has a writable property of the given name (when `$checkBehaviors` is true).
Qiang Xue committed
274 275
	 *
	 * @param string $name the property name
crtlib committed
276
	 * @param boolean $checkVars whether to treat member variables as properties
Qiang Xue committed
277
	 * @param boolean $checkBehaviors whether to treat behaviors' properties as properties of this component
Qiang Xue committed
278 279 280
	 * @return boolean whether the property can be written
	 * @see canGetProperty
	 */
crtlib committed
281
	public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
Qiang Xue committed
282
	{
crtlib committed
283
		if (method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name)) {
Qiang Xue committed
284
			return true;
Qiang Xue committed
285
		} elseif ($checkBehaviors) {
Qiang Xue committed
286
			$this->ensureBehaviors();
Qiang Xue committed
287
			foreach ($this->_behaviors as $behavior) {
crtlib committed
288
				if ($behavior->canSetProperty($name, $checkVars)) {
Qiang Xue committed
289 290 291 292
					return true;
				}
			}
		}
293
		return false;
Qiang Xue committed
294 295
	}

296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
	/**
	 * Returns a value indicating whether a method is defined.
	 * A method is defined if:
	 *
	 * - the class has a method with the specified name
	 * - an attached behavior has a method with the given name (when `$checkBehaviors` is true).
	 *
	 * @param string $name the property name
	 * @param boolean $checkBehaviors whether to treat behaviors' methods as methods of this component
	 * @return boolean whether the property is defined
	 */
	public function hasMethod($name, $checkBehaviors = true)
	{
		if (method_exists($this, $name)) {
			return true;
		} elseif ($checkBehaviors) {
			$this->ensureBehaviors();
			foreach ($this->_behaviors as $behavior) {
				if ($behavior->hasMethod($name)) {
					return true;
				}
			}
		}
		return false;
	}

Qiang Xue committed
322 323 324 325 326 327 328 329 330 331
	/**
	 * Returns a list of behaviors that this component should behave as.
	 *
	 * Child classes may override this method to specify the behaviors they want to behave as.
	 *
	 * The return value of this method should be an array of behavior objects or configurations
	 * indexed by behavior names. A behavior configuration can be either a string specifying
	 * the behavior class or an array of the following structure:
	 *
	 * ~~~
Alexander Makarov committed
332
	 * 'behaviorName' => [
Qiang Xue committed
333 334 335
	 *     'class' => 'BehaviorClass',
	 *     'property1' => 'value1',
	 *     'property2' => 'value2',
Alexander Makarov committed
336
	 * ]
Qiang Xue committed
337 338
	 * ~~~
	 *
Qiang Xue committed
339 340 341 342
	 * Note that a behavior class must extend from [[Behavior]]. Behavior names can be strings
	 * or integers. If the former, they uniquely identify the behaviors. If the latter, the corresponding
	 * behaviors are anonymous and their properties and methods will NOT be made available via the component
	 * (however, the behaviors can still respond to the component's events).
Qiang Xue committed
343
	 *
Qiang Xue committed
344
	 * Behaviors declared in this method will be attached to the component automatically (on demand).
Qiang Xue committed
345 346 347 348 349
	 *
	 * @return array the behavior configurations.
	 */
	public function behaviors()
	{
Alexander Makarov committed
350
		return [];
Qiang Xue committed
351 352 353
	}

	/**
Qiang Xue committed
354
	 * Returns a value indicating whether there is any handler attached to the named event.
Qiang Xue committed
355
	 * @param string $name the event name
w  
Qiang Xue committed
356
	 * @return boolean whether there is any handler attached to the event.
Qiang Xue committed
357
	 */
w  
Qiang Xue committed
358
	public function hasEventHandlers($name)
Qiang Xue committed
359
	{
Qiang Xue committed
360
		$this->ensureBehaviors();
Qiang Xue committed
361
		return !empty($this->_events[$name]);
Qiang Xue committed
362 363 364 365 366
	}

	/**
	 * Attaches an event handler to an event.
	 *
w  
Qiang Xue committed
367 368 369
	 * An event handler must be a valid PHP callback. The followings are
	 * some examples:
	 *
w  
Qiang Xue committed
370
	 * ~~~
Qiang Xue committed
371
	 * function ($event) { ... }         // anonymous function
Alexander Makarov committed
372 373 374
	 * [$object, 'handleClick']          // $object->handleClick()
	 * ['Page', 'handleClick']           // Page::handleClick()
	 * 'handleClick'                     // global function handleClick()
w  
Qiang Xue committed
375
	 * ~~~
Qiang Xue committed
376 377 378
	 *
	 * An event handler must be defined with the following signature,
	 *
w  
Qiang Xue committed
379
	 * ~~~
Qiang Xue committed
380
	 * function ($event)
w  
Qiang Xue committed
381
	 * ~~~
Qiang Xue committed
382
	 *
w  
Qiang Xue committed
383
	 * where `$event` is an [[Event]] object which includes parameters associated with the event.
Qiang Xue committed
384 385
	 *
	 * @param string $name the event name
Qiang Xue committed
386 387 388
	 * @param callback $handler the event handler
	 * @param mixed $data the data to be passed to the event handler when the event is triggered.
	 * When the event handler is invoked, this data can be accessed via [[Event::data]].
Qiang Xue committed
389
	 * @see off()
Qiang Xue committed
390
	 */
Qiang Xue committed
391
	public function on($name, $handler, $data = null)
Qiang Xue committed
392
	{
Qiang Xue committed
393
		$this->ensureBehaviors();
Alexander Makarov committed
394
		$this->_events[$name][] = [$handler, $data];
Qiang Xue committed
395 396 397
	}

	/**
Qiang Xue committed
398 399
	 * Detaches an existing event handler from this component.
	 * This method is the opposite of [[on()]].
Qiang Xue committed
400
	 * @param string $name event name
Qiang Xue committed
401 402
	 * @param callback $handler the event handler to be removed.
	 * If it is null, all handlers attached to the named event will be removed.
Qiang Xue committed
403
	 * @return boolean if a handler is found and detached
Qiang Xue committed
404
	 * @see on()
Qiang Xue committed
405
	 */
Qiang Xue committed
406
	public function off($name, $handler = null)
Qiang Xue committed
407
	{
Qiang Xue committed
408 409 410
		$this->ensureBehaviors();
		if (isset($this->_events[$name])) {
			if ($handler === null) {
Alexander Makarov committed
411
				$this->_events[$name] = [];
Qiang Xue committed
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426
			} else {
				$removed = false;
				foreach ($this->_events[$name] as $i => $event) {
					if ($event[0] === $handler) {
						unset($this->_events[$name][$i]);
						$removed = true;
					}
				}
				if ($removed) {
					$this->_events[$name] = array_values($this->_events[$name]);
				}
				return $removed;
			}
		}
		return false;
Qiang Xue committed
427 428 429
	}

	/**
Qiang Xue committed
430
	 * Triggers an event.
Qiang Xue committed
431 432 433
	 * This method represents the happening of an event. It invokes
	 * all attached handlers for the event.
	 * @param string $name the event name
Qiang Xue committed
434
	 * @param Event $event the event parameter. If not set, a default [[Event]] object will be created.
Qiang Xue committed
435
	 */
Qiang Xue committed
436
	public function trigger($name, $event = null)
Qiang Xue committed
437
	{
Qiang Xue committed
438
		$this->ensureBehaviors();
Qiang Xue committed
439
		if (!empty($this->_events[$name])) {
Qiang Xue committed
440
			if ($event === null) {
Qiang Xue committed
441 442 443 444
				$event = new Event;
			}
			if ($event->sender === null) {
				$event->sender = $this;
Qiang Xue committed
445
			}
Qiang Xue committed
446 447
			$event->handled = false;
			$event->name = $name;
Qiang Xue committed
448 449 450
			foreach ($this->_events[$name] as $handler) {
				$event->data = $handler[1];
				call_user_func($handler[0], $event);
w  
Qiang Xue committed
451 452
				// stop further handling if the event is handled
				if ($event instanceof Event && $event->handled) {
Qiang Xue committed
453
					return;
w  
Qiang Xue committed
454 455 456 457 458 459 460
				}
			}
		}
	}

	/**
	 * Returns the named behavior object.
Qiang Xue committed
461
	 * @param string $name the behavior name
w  
Qiang Xue committed
462 463
	 * @return Behavior the behavior object, or null if the behavior does not exist
	 */
Qiang Xue committed
464
	public function getBehavior($name)
w  
Qiang Xue committed
465
	{
Qiang Xue committed
466
		$this->ensureBehaviors();
Qiang Xue committed
467
		return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
Qiang Xue committed
468 469 470 471 472 473 474 475 476
	}

	/**
	 * Returns all behaviors attached to this component.
	 * @return Behavior[] list of behaviors attached to this component
	 */
	public function getBehaviors()
	{
		$this->ensureBehaviors();
Qiang Xue committed
477
		return $this->_behaviors;
w  
Qiang Xue committed
478 479 480 481 482 483
	}

	/**
	 * Attaches a behavior to this component.
	 * This method will create the behavior object based on the given
	 * configuration. After that, the behavior object will be attached to
Qiang Xue committed
484
	 * this component by calling the [[Behavior::attach()]] method.
Qiang Xue committed
485
	 * @param string $name the name of the behavior.
Qiang Xue committed
486
	 * @param string|array|Behavior $behavior the behavior configuration. This can be one of the following:
w  
Qiang Xue committed
487 488 489
	 *
	 *  - a [[Behavior]] object
	 *  - a string specifying the behavior class
Qiang Xue committed
490
	 *  - an object configuration array that will be passed to [[Yii::createObject()]] to create the behavior object.
w  
Qiang Xue committed
491 492 493 494 495 496
	 *
	 * @return Behavior the behavior object
	 * @see detachBehavior
	 */
	public function attachBehavior($name, $behavior)
	{
Qiang Xue committed
497 498
		$this->ensureBehaviors();
		return $this->attachBehaviorInternal($name, $behavior);
w  
Qiang Xue committed
499 500 501 502 503
	}

	/**
	 * Attaches a list of behaviors to the component.
	 * Each behavior is indexed by its name and should be a [[Behavior]] object,
Qiang Xue committed
504
	 * a string specifying the behavior class, or an configuration array for creating the behavior.
w  
Qiang Xue committed
505 506 507 508 509
	 * @param array $behaviors list of behaviors to be attached to the component
	 * @see attachBehavior
	 */
	public function attachBehaviors($behaviors)
	{
Qiang Xue committed
510
		$this->ensureBehaviors();
w  
Qiang Xue committed
511
		foreach ($behaviors as $name => $behavior) {
Qiang Xue committed
512
			$this->attachBehaviorInternal($name, $behavior);
w  
Qiang Xue committed
513 514 515 516 517
		}
	}

	/**
	 * Detaches a behavior from the component.
Qiang Xue committed
518
	 * The behavior's [[Behavior::detach()]] method will be invoked.
w  
Qiang Xue committed
519 520 521 522 523
	 * @param string $name the behavior's name.
	 * @return Behavior the detached behavior. Null if the behavior does not exist.
	 */
	public function detachBehavior($name)
	{
524
		$this->ensureBehaviors();
Qiang Xue committed
525 526 527
		if (isset($this->_behaviors[$name])) {
			$behavior = $this->_behaviors[$name];
			unset($this->_behaviors[$name]);
528
			$behavior->detach();
w  
Qiang Xue committed
529
			return $behavior;
Qiang Xue committed
530 531
		} else {
			return null;
w  
Qiang Xue committed
532 533 534 535 536 537 538 539
		}
	}

	/**
	 * Detaches all behaviors from the component.
	 */
	public function detachBehaviors()
	{
540
		$this->ensureBehaviors();
Qiang Xue committed
541 542
		if ($this->_behaviors !== null) {
			foreach ($this->_behaviors as $name => $behavior) {
w  
Qiang Xue committed
543 544
				$this->detachBehavior($name);
			}
Qiang Xue committed
545
		}
Alexander Makarov committed
546
		$this->_behaviors = [];
Qiang Xue committed
547 548 549 550 551 552 553
	}

	/**
	 * Makes sure that the behaviors declared in [[behaviors()]] are attached to this component.
	 */
	public function ensureBehaviors()
	{
Qiang Xue committed
554
		if ($this->_behaviors === null) {
Alexander Makarov committed
555
			$this->_behaviors = [];
Qiang Xue committed
556
			foreach ($this->behaviors() as $name => $behavior) {
Qiang Xue committed
557
				$this->attachBehaviorInternal($name, $behavior);
Qiang Xue committed
558
			}
w  
Qiang Xue committed
559 560
		}
	}
Qiang Xue committed
561 562 563

	/**
	 * Attaches a behavior to this component.
Qiang Xue committed
564
	 * @param string $name the name of the behavior.
Qiang Xue committed
565 566 567 568 569 570
	 * @param string|array|Behavior $behavior the behavior to be attached
	 * @return Behavior the attached behavior.
	 */
	private function attachBehaviorInternal($name, $behavior)
	{
		if (!($behavior instanceof Behavior)) {
Qiang Xue committed
571
			$behavior = Yii::createObject($behavior);
Qiang Xue committed
572
		}
Qiang Xue committed
573 574
		if (isset($this->_behaviors[$name])) {
			$this->_behaviors[$name]->detach();
Qiang Xue committed
575
		}
Qiang Xue committed
576
		$behavior->attach($this);
Qiang Xue committed
577
		return $this->_behaviors[$name] = $behavior;
Qiang Xue committed
578
	}
Qiang Xue committed
579
}