Class \Prado\TComponent

Calls a method.

Do not call this method directly. This is a PHP magic method that we override to allow behaviors, dynamic events (intra-object/behavior events), undefined dynamic and global events, and to allow using the following syntax to call a property setter or getter.

$this->getPropertyName($value); // if there's a $this->getjsPropertyName() method
$this->setPropertyName($value); // if there's a $this->setjsPropertyName() method

Additional object behaviors override class behaviors. dynamic and global events do not fail even if they aren't implemented. Any intra-object/behavior dynamic events that are not implemented by the behavior return the first function paramater or null when no parameters are specified.

This is the magic method that is called when a static function is not found.

It checks the class if it has an ISingleton instance, in which case its behaviors are checked for the static method. This further checks the Class-wide behaviors (added with TComponent::attachClassBehavior) for the static method. When the static method is found (in either the ISingleton behaviors or the class-wide behaviors), the behavior's static method is called and the results returned.

The common __clone magic method from PHP's "clone".

This reattaches the behaviors to the cloned object. IBehavior objects are cloned, IClassBehaviors are not. Clone object events are scrubbed of the old object behaviors' events. To finalize the behaviors, dyClone is raised.

The common __construct.

If desired by the new object, this will auto install and listen to global event functions as defined by the object via 'fx' methods. This also attaches any predefined behaviors. This function installs all class behaviors in a class hierarchy from the deepest subclass through each parent to the top most class, TComponent.

The common __destruct When listening, this unlistens from the global event routines. It also detaches all the behaviors so they can clean up, eg remove handlers.

Prior to PHP 7.4, when listening, unlisten must be manually called for objects to destruct because circular references will prevent the __destruct process.

Returns a property value or an event handler list by property or event name.

Do not call this method. This is a PHP magic method that we override to allow using the following syntax to read a property:

$value = $component->PropertyName;
$value = $component->jsPropertyName; // return JavaScript literal

and to obtain the event handler list for an event,

$eventHandlerList = $component->EventName;

This will also return the global event handler list when specifing an 'fx' event,

$globalEventHandlerList = $component->fxEventName;

When behaviors are enabled, this will return the behavior of a specific name, a property of a behavior, or an object 'on' event defined by the behavior.

Checks if a property value is null, there are no events in the object event list or global event list registered under the name, and, if behaviors are enabled, Do not call this method. This is a PHP magic method that we override to allow using isset() to detect if a component property is set or not.

This also works for global events. When behaviors are enabled, it will check for a behavior of the specified name, and also check the behavior for events and properties.

Sets value of a component property.

Do not call this method. This is a PHP magic method that we override to allow using the following syntax to set a property or attach an event handler.

   $this->PropertyName = $value;
   $this->jsPropertyName = $value; // $value will be treated as a JavaScript literal
   $this->EventName = $handler;
   $this->fxEventName = $handler; //global event listener
   $this->EventName = function($sender, $param) {...};

When behaviors are enabled, this will also set a behaviors properties and events.

Returns an array with the names of all variables of that object that should be serialized.

Do not call this method. This is a PHP magic method that will be called automatically prior to any serialization.

Sets a component property to be null. Clears the object or global events. When enabled, loops through all behaviors and unsets the property or event.

Do not call this method. This is a PHP magic method that we override to allow using unset() to set a component property to be null.

The common __wakeup magic method from PHP's "unserialize".

This reattaches the behaviors to the reconstructed object. Any global class behaviors are used rather than their unserialized copy. Any global behaviors not found in the object will be added. To finalize the behaviors, dyWakeUp is raised. If a TModule needs to add events to an object during unserialization, the module can use a small IClassBehavior [implementing dyWakeUp] (adding the event[s]) attached to the class with attachClassBehavior prior to unserialization.

Processes an object that is created during parsing template.

The object can be either a component or a static text string. This method can be overridden to customize the handling of newly created objects in template. Only framework developers and control developers should use this method.

Behaviors may implement the function:

public function dyAddParsedObject($object, TCallChain $chain) {
     return $chain-> dyAddParsedObject($object);
 }

to be executed when addParsedObject is called. All attached behaviors are notified through dyAddParsedObject.

Returns the named behavior object. If the $behaviorname is not found, but is an existing class or interface, this will return the first instanceof.

The name 'asa' stands for 'as a'.

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 initialized by calling its IBaseBehavior::attach method.

Already attached behaviors may implement the function:

public function dyAttachBehavior($name,$behavior[, ?TCallChain $chain = null]) {
     if ($chain)
         return $chain->dyDetachBehavior($name, $behavior);
 }

to be executed when attachBehavior is called. All attached behaviors are notified through dyAttachBehavior.

Attaches a list of behaviors to the component.

Each behavior is indexed by its name and should be an instance of IBaseBehavior, a string specifying the behavior class, or a TClassBehaviorEventParameter.

This will add a class behavior to all classes instanced (that are listening) and future newly instanced objects.

This registers the behavior for future instances and pushes the changes to all the instances that are listening as well. The universal class behaviors are stored in an inverted stack with the latest class behavior being at the first position in the array. This is done so class behaviors are added last first.

Attaches an event handler to an event.

The handler must be a valid PHP callback, i.e., a string referring to a global function name, or an array containing two elements with the first element being an object and the second element a method name of the object. In Prado, you can also use method path to refer to an event handler. For example, array($object,'Parent.buttonClicked') uses a method path that refers to the method $object->Parent->buttonClicked(...).

The event handler must be of the following signature,

function handlerName($sender, $param) }
function handlerName($sender, $param, $name) }

where $sender represents the object that raises the event, and $param is the event parameter. $name refers to the event name being handled.

This is a convenient method to add an event handler. It is equivalent to getEventHandlers($name)->add($handler). For complete management of event handlers, use getEventHandlers to get the event handler list first, and then do various TWeakCallableCollection operations to append, insert or remove event handlers. You may also do these operations like getting and setting properties, e.g.,

   $component->OnClick[] = array($object,'buttonClicked');
   $component->OnClick->insertAt(0,array($object,'buttonClicked'));
   $component->OnClick[] = function ($sender, $param) { ... };

which are equivalent to the following

   $component->getEventHandlers('OnClick')->add(array($object,'buttonClicked'));
   $component->getEventHandlers('OnClick')->insertAt(0,array($object,'buttonClicked'));

Due to the nature of getEventHandlers, any active behaviors defining new 'on' events, this method will pass through to the behavior transparently.

Calls a method on a component's behaviors. When the method is a dynamic event, it is raised with all the behaviors. When a class implements a dynamic event (eg. for patching), the class can customize raising the dynamic event with the classes behaviors using this method.

Dynamic [dy] and global [fx] events call __dycall when $this implements IDynamicMethods. Finally, this catches all unexecuted Dynamic [dy] and global [fx] events and returns the first $args parameter; acting as a passthrough (filter) of the first $args parameter. In dy/fx methods, there can be no $args parameters, the first parameter used as a pass through filter, or act as a return variable with the first $args parameter being the default return value.

Determines whether a property can be read.

A property can be read if the class has a getter method for the property name. Note, property name is case-insensitive. This also checks for getjs. When enabled, it loops through all active behaviors for the get property when undefined by the object.

Determines whether a property can be set.

A property can be written if the class has a setter method for the property name. Note, property name is case-insensitive. This also checks for setjs. When enabled, it loops through all active behaviors for the set property when undefined by the object.

Detaches all behaviors from the component.

This method is invoked after the component is instantiated by a template.

When this method is invoked, the component's properties have been initialized. The default implementation of this method will invoke the potential parent component's addParsedObject. This method can be overridden.

Behaviors may implement the function:

public function dyCreatedOnTemplate($parent, TCallChain $chain) {
		return $chain->dyCreatedOnTemplate($parent); //example
 }

to be executed when createdOnTemplate is called. All attached behaviors are notified through dyCreatedOnTemplate.

Detaches a behavior from the component.

The behavior's IBaseBehavior::detach method will be invoked.

Behaviors may implement the function:

public function dyDetachBehavior($name, $behavior[, ?TCallChain $chain = null]) {
     if ($chain)
         return $chain->dyDetachBehavior($name, $behavior);
 }

to be executed when detachBehavior is called. All attached behaviors are notified through dyDetachBehavior.

Detaches select behaviors from the component.

Each behavior is indexed by its name and should be an instance of IBaseBehavior, a string specifying the behavior class, or a TClassBehaviorEventParameter.

This will remove a behavior from a class. It unregisters it from future instances and pulls the changes from all the instances that are listening as well.

PHP 5.3 uses Late Static Binding to derive the static class upon which this method is called.

Detaches an existing event handler.

This method is the opposite of attachEventHandler. It will detach any 'on' events defined by an objects active behaviors as well.

Disables an attached behavior. This cannot enable or disable whole class behaviors.

A behavior is only effective when it is enabled.

Behaviors may implement the function:

public function dyDisableBehavior($name, $behavior[, ?TCallChain $chain = null]) {
     if ($chain)
         return $chain->dyDisableBehavior($name, $behavior);
 }

to be executed when disableBehavior is called. All attached behaviors are notified through dyDisableBehavior.

Disables all behaviors attached to this component independent of the behaviors

Behaviors may implement the function:

public function dyDisableBehaviors([?TCallChain $chain = null]) {
     if ($chain)
         return $chain->dyDisableBehaviors();
 }

to be executed when disableBehaviors is called. All attached behaviors are notified through dyDisableBehaviors.

Enables an attached object behavior. This cannot enable or disable whole class behaviors.

A behavior is only effective when it is enabled. A behavior is enabled when first attached.

Behaviors may implement the function:

public function dyEnableBehavior($name, $behavior[, ?TCallChain $chain = null]) {
     if ($chain)
         return $chain->dyEnableBehavior($name, $behavior);
 }

to be executed when enableBehavior is called. All attached behaviors are notified through dyEnableBehavior.

Enables all behaviors attached to this component independent of the behaviors

Behaviors may implement the function:

public function dyEnableBehaviors([?TCallChain $chain = null]) {
     if ($chain)
         return $chain->dyEnableBehaviors();
 }

to be executed when enableBehaviors is called. All attached behaviors are notified through dyEnableBehaviors.

Evaluates a PHP expression in the context of this control.

Behaviors may implement the function:

public function dyEvaluateExpressionFilter($expression, TCallChain $chain) {
		return $chain->dyEvaluateExpressionFilter(str_replace('foo', 'bar', $expression)); //example
}

to be executed when evaluateExpression is called. All attached behaviors are notified through dyEvaluateExpressionFilter. The chaining is important in this function due to the filtering pass-through effect.

Evaluates a list of PHP statements.

Behaviors may implement the function:

public function dyEvaluateStatementsFilter($statements, TCallChain $chain) {
		return $chain->dyEvaluateStatementsFilter(str_replace('foo', 'bar', $statements)); //example
}

to be executed when evaluateStatements is called. All attached behaviors are notified through dyEvaluateStatementsFilter. The chaining is important in this function due to the filtering pass-through effect.

This is the method registered for all instanced objects should a class behavior be added after the class is instanced. Only when the class to which the behavior is being added is in this object's class hierarchy, via {@see getClassHierarchy}, is the behavior added to this instance.

This is the method registered for all instanced objects should a class behavior be removed after the class is instanced. Only when the class to which the behavior is being added is in this object's class hierarchy, via {@see getClassHierarchy}, is the behavior removed from this instance.

Tells TComponent whether or not to automatically listen to global events.

Defaults to false because PHP variable cleanup is affected if this is true. When unsetting a variable that is listening to global events, unlisten must explicitly be called when cleaning variables allocation or else the global event registry will contain references to the old object. This is true for PHP 5.4

Override this method by a subclass to change the setting. When set to true, this will enable __construct to call listen.

Returns all the behaviors attached to the TComponent. IBaseBehavior[s] may be attached but not {@see \Prado\Util\IBaseBehavior::getEnabled Enabled}.

Returns if all the behaviors are turned on or off for the object.

This returns an array of the class name and the names of all its parents. The base object last, {@see \Prado\TComponent}, and the deepest subclass is first.

Returns the list of attached event handlers for an 'on' or 'fx' event. This function also checks through all the behaviors for 'on' event lists when behaviors are enabled.

Gets the state of listening to global events

Evaluates a property path.

A property path is a sequence of property names concatenated by '.' character. For example, 'Parent.Page' refers to the 'Page' property of the component's 'Parent' property value (which should be a component also). When a property is not defined by an object, this also loops through all active behaviors of the object.

Determines whether an event is defined.

An event is defined if the class has a method whose name is the event name prefixed with 'on', 'fx', or 'dy'. Every object responds to every 'fx' and 'dy' event as they are in a universally accepted event space. 'on' event must be declared by the object. When enabled, this will loop through all active behaviors for 'on' events defined by the behavior. Note, event name is case-insensitive.

Checks if an event has any handlers. This function also checks through all the behaviors for 'on' events when behaviors are enabled.

'dy' dynamic events are not handled by this function.

Determines whether a method is defined. When behaviors are enabled, this will loop through all enabled behaviors checking for the method as well.

Nested behaviors within behaviors are not supported but the nested behavior can affect the primary behavior like any behavior affects their owner. Note, method name are case-insensitive.

Determines whether a property is defined.

A property is defined if there is a getter or setter method defined in the class. Note, property names are case-insensitive.

Returns whether or not the object or any of the behaviors are of a particular class.

The name 'isa' stands for 'is a'. This first checks if $this is an instanceof the class. Then it checks if the $class is in the hierarchy, which includes first level traits. It then checks each Behavior. If a behavior implements IInstanceCheck, then the behavior can determine what it is an instanceof. If this behavior function returns true, then this method returns true. If the behavior instance checking function returns false, then no further checking is performed as it is assumed to be correct.

If the behavior instance check function returns nothing or null or the behavior doesn't implement the IInstanceCheck interface, then the default instanceof occurs. The default isa behavior is to check if the behavior is an instanceof the class.

The behavior IInstanceCheck is to allow a behavior to have the host object act as a completely different object.

This adds an object's fx event handlers into the global broadcaster to listen into any broadcast global events called through {@see raiseEvent}

Behaviors may implement the function:

public function dyListen($globalEvents[, ?TCallChain $chain = null]) {
		$this->listen($globalEvents); //eg
     if ($chain)
         $chain->dyUnlisten($globalEvents);
}

to be executed when listen is called. All attached behaviors are notified through dyListen.

Raises an event. This raises both inter-object 'on' events and global 'fx' events.

This method represents the happening of an event and will invoke all attached event handlers for the event in TWeakCallableCollection order. This method does not handle intra-object/behavior dynamic 'dy' events.

There are ways to handle event responses. By default EVENT_RESULT_FILTER, all event responses are stored in an array, filtered for null responses, and returned. If EVENT_RESULT_ALL is specified, all returned results will be stored along with the sender and param in an array

		$result[] = array('sender'=>$sender,'param'=>$param,'response'=>$response);

If EVENT_RESULT_FEED_FORWARD is specified, then each handler result is then fed forward as the parameters for the next event. This allows for events to filter data directly by affecting the event parameters

If a callable function is set in the response type or the post function filter is specified then the result of each called event handler is post processed by the callable function. Used in combination with EVENT_RESULT_FEED_FORWARD, any event (and its result) can be chained.

When raising a global 'fx' event, registered handlers in the global event list for GLOBAL_RAISE_EVENT_LISTENER are always added into the set of event handlers. In this way, these global events are always raised for every global 'fx' event. The registered handlers for global raiseEvent events have priorities. Any registered global raiseEvent event handlers with a priority less than zero are added before the main event handlers being raised and any registered global raiseEvent event handlers with a priority equal or greater than zero are added after the main event handlers being raised. In this way all GLOBAL_RAISE_EVENT_LISTENER handlers are always called for every raised 'fx' event.

Behaviors may implement the following functions with TBehaviors:

public function dyPreRaiseEvent($name, $sender, $param, $responsetype, $postfunction[, TCallChain $chain) {
     ....  //  Your logic
 	return $chain->dyPreRaiseEvent($name, $sender, $param, $responsetype, $postfunction); //eg, the event name may be filtered/changed
 }
public function dyIntraRaiseEventTestHandler($handler, $sender, $param, $name, TCallChain $chain) {
     ....  //  Your logic
 	return $chain->dyIntraRaiseEventTestHandler($handler, $sender, $param, $name); //should this particular handler be executed?  true/false
 }
 public function dyIntraRaiseEventPostHandler($name, $sender, $param, $handler, $response, TCallChain $chain) {
     ....  //  Your logic
	return $chain->dyIntraRaiseEventPostHandler($name, $sender, $param, $handler, $response); //contains the per handler response
 }
 public function dyPostRaiseEvent($responses, $name, $sender, $param,$ responsetype, $postfunction, TCallChain $chain) {
     ....  //  Your logic
	return $chain->dyPostRaiseEvent($responses, $name, $sender, $param,$ responsetype, $postfunction);
 }

to be executed when raiseEvent is called. The 'intra' dynamic events are called per handler in the handler loop. TClassBehaviors prepend the object being raised.

dyPreRaiseEvent has the effect of being able to change the event being raised. This intra object/behavior event returns the name of the desired event to be raised. It will pass through if no dynamic event is specified, or if the original event name is returned. dyIntraRaiseEventTestHandler returns true or false as to whether a specific handler should be called for a specific raised event (and associated event arguments) dyIntraRaiseEventPostHandler does not return anything. This allows behaviors to access the results of an event handler in the per handler loop. dyPostRaiseEvent returns the responses. This allows for any post processing of the event results from the sum of all event handlers

When handling a catch-all __dycall, the method name is the name of the event and the parameters are the sender, the param, and then the name of the event.

In the rare circumstance that the event handlers need to be raised in reverse order, then specifying TEventResults::EVENT_REVERSE can be used to reverse the order of the handlers.

Sets a value to a property path.

A property path is a sequence of property names concatenated by '.' character. For example, 'Parent.Page' refers to the 'Page' property of the component's 'Parent' property value (which should be a component also). When a property is not defined by an object, this also loops through all active behaviors of the object.

this removes an object's fx events from the global broadcaster

Behaviors may implement the function:

public function dyUnlisten($globalEvents[, ?TCallChain $chain = null]) {
		$this->behaviorUnlisten(); //eg
     if ($chain)
         $chain->dyUnlisten($globalEvents);
}

to be executed when listen is called. All attached behaviors are notified through dyUnlisten.

Returns an array with the names of all variables of this object that should NOT be serialized because their value is the default one or useless to be cached for the next page loads.

Reimplement in derived classes to add new variables, but remember to also to call the parent implementation first.

This gets the chain of methods implemented by attached and enabled behaviors.

This method disregards the {behaviorsEnabled

This caches the 'fx' events for classes.

instanceBehavior is an internal method that takes a Behavior Object, a class name, or array of ['class' => 'MyBehavior', 'property1' => 'Value1'...] and creates a Behavior in return. eg.

	$b = $this->instanceBehavior('MyBehavior');
		$b = $this->instanceBehavior(['class' => 'MyBehavior', 'property1' => 'Value1']);
		$b = $this->instanceBehavior(new MyBehavior);

If the behavior is an array, the key IBaseBehavior::CONFIG_KEY is stripped and used to initialize the behavior.

This utility function is a private array filter method. The array values that start with 'fx' are filtered in.