Class TComponent
TComponent class
TComponent is the base class for all PRADO components. TComponent implements the protocol of defining, using properties, behaviors, and events.
A property is defined by a getter method, and/or a setter method. Properties can be accessed in the way like accessing normal object members. Reading or writing a property will cause the invocation of the corresponding getter or setter method, e.g.,
$a=$this->Text; // equivalent to $a=$this->getText(); $this->Text='abc'; // equivalent to $this->setText('abc');
The signatures of getter and setter methods are as follows,
// getter, defines a readable property 'Text' function getText() { ... } // setter, defines a writable property 'Text', with $value being the value to be set to the property function setText($value) { ... }
Property names are case-insensitive. It is recommended that they are written in the format of concatenated words, with the first letter of each word capitalized (e.g. DisplayMode, ItemStyle).
Javascript Get and Set
Since Prado 3.2 a new class of javascript-friendly properties have been introduced to better deal with potential security problems like cross-site scripting issues. All the data that gets sent clientside inside a javascript block is now encoded by default. Sometimes there's the need to bypass this encoding and be able to send raw javascript code. This new class of javascript-friendly properties are identified by their name starting with 'js' (case insensitive):
// getter, defines a readable property 'Text' function getJsText() { ... } // setter, defines a writable property 'Text', with $value being the value to be set to the property function setJsText(TJavaScriptLiteral $value) { ... }
Js-friendly properties can be accessed using both their Js-less name and their Js-enabled name:
// set some simple text as property value $component->Text = 'text'; // set some javascript code as property value $component->JsText = 'raw javascript';
In the first case, the property value will automatically gets encoded when
sent clientside inside a javascript block. In the second case, the property will
be 'marked' as being a safe javascript statement and will not be encoded when
rendered inside a javascript block. This special handling makes use of the
TJavaScriptLiteral
class.
Events
An event is defined by the presence of a method whose name starts with 'on'.
The event name is the method name and is thus case-insensitive. An event can be
attached with one or several methods (called event handlers). An event can be
raised by calling TComponent::raiseEvent()
method, upon which the attached event
handlers will be invoked automatically in the order they are attached to the
event. Event handlers must have the following signature,
function eventHandlerFuncName($sender,$param) { ... }
where $sender refers to the object who is responsible for the raising of the event, and $param refers to a structure that may contain event-specific information. To raise an event (assuming named as 'Click') of a component, use
$component->raiseEvent('OnClick'); $component->raiseEvent('OnClick', $this, $param);
To attach an event handler to an event, use one of the following ways,
$component->OnClick=$callback; // or $component->OnClick->add($callback); $component->attachEventHandler('OnClick',$callback);
The first two ways make use of the fact that $component->OnClick refers to
the event handler list TPriorityList
for the 'OnClick' event. The
variable $callback contains the definition of the event handler that can be
either a string referring to a global function name, or an array whose first
element refers to an object and second element a method name/path that is
reachable by the object, e.g.
- 'buttonClicked' : buttonClicked($sender,$param);
- array($object,'buttonClicked') : $object->buttonClicked($sender,$param);
- array($object,'MainContent.SubmitButton.buttonClicked') : $object->MainContent->SubmitButton->buttonClicked($sender,$param);
With the addition of behaviors, a more expansive event model is needed. There are two new event types (global and dynamic events) as well as a more comprehensive behavior model that includes class wide behaviors.
A global event is defined by all events whose name starts with 'fx'. The event name is potentially a method name and is thus case-insensitive. All 'fx' events are valid as the whole 'fx' event/method space is global in nature. Any object may patch into any global event by defining that event as a method. Global events have priorities just like 'on' events; so as to be able to order the event execution. Due to the nature of all events which start with 'fx' being valid, in effect, every object has every 'fx' global event. It is simply an issue of tapping into the desired global event.
A global event that starts with 'fx' can be called even if the object does
not implement the method of the global event. A call to a non-existing 'fx'
method will, at minimal, function and return null. If a method argument list has
a first parameter, it will be returned instead of null. This allows filtering
and chaining. 'fx' methods do not automatically install and uninstall. To
install and uninstall an object's global event listeners, call the object's
TComponent::listen()
and TComponent::unlisten()
methods, respectively. An object may
auto-install its global event during TComponent::__construct()
by overriding TComponent::getAutoGlobalListen()
and returning true.
As of PHP version 5.3, nulled objects without code references will still
continue to persist in the global event queue because TComponent::__destruct()
is not
automatically called. In the common __destruct method, if an object is listening
to global events, then TComponent::unlisten()
is called. TComponent::unlisten()
is required
to be manually called before an object is left without references if it is
currently listening to any global events. This includes class wide
behaviors.
An object that contains a method that starts with 'fx' will have those
functions automatically receive those events of the same name after TComponent::listen()
is called on the object.
An object may listen to a global event without defining an 'fx' method of the same name by adding an object method to the global event list. For example
$component->fxGlobalCheck=$callback; // or $component->OnClick->add($callback); $component->attachEventHandler('fxGlobalCheck',array($object, 'someMethod'));
Events between Objects and their behaviors, Dynamic Events
An intra-object/behavior event is defined by methods that start with 'dy'. Just as with 'fx' global events, every object has every dynamic event. Any call to a method that starts with 'dy' will be handled, regardless of whether it is implemented. These events are for communicating with attached behaviors.
Dynamic events can be used in a variety of ways. They can be used to tell behaviors when a non-behavior method is called. Dynamic events could be used as data filters. They could also be used to specify when a piece of code is to be run, eg. should the loop process be performed on a particular piece of data. In this way, some control is handed to the behaviors over the process and/or data.
If there are no handlers for an 'fx' or 'dy' event, it will return the first
parameter of the argument list. If there are no arguments, these events will
return null. If there are handlers an 'fx' method will be called directly within
the object. Global 'fx' events are triggered by calling TComponent::raiseEvent()
. For
dynamic events where there are behaviors that respond to the dynamic events, a
TCallChain
is developed. A call chain allows the behavior dynamic event
implementations to call further implementing behaviors within a chain.
If an object implements IDynamicMethods
, all global and object
dynamic events will be sent to __dycall. In the case of global events,
all global events will trigger this method. In the case of behaviors, all
undefined dynamic events which are called will be passed through to this
method.
Behaviors
There are two types of behaviors. There are individual object behaviors and there are class wide behaviors. Class behaviors depend upon object behaviors.
When a new class implements IBehavior
or IClassBehavior
or
extends TBehavior
or TClassBehavior
, it may be added to an
object by calling the object's TComponent::attachBehavior()
. The behaviors associated
name can then be used to TComponent::enableBehavior()
or TComponent::disableBehavior()
the
specific behavior.
All behaviors may be turned on and off via TComponent::enableBehaviors()
and TComponent::disableBehaviors()
, respectively. To check if behaviors are on or off a call to
TComponent::getBehaviorsEnabled()
will provide the variable.
Attaching and detaching whole sets of behaviors is done using TComponent::attachBehaviors()
and TComponent::detachBehaviors()
. TComponent::clearBehaviors()
removes all
of an object's behaviors.
TComponent::asa()
returns a behavior of a specific name. TComponent::isa()
is the
behavior inclusive function that acts as the PHP operator instanceof. A
behavior could provide the functionality of a specific class thus causing the
host object to act similarly to a completely different class. A behavior would
then implement IInstanceCheck
to provide the identity of the different
class.
Class behaviors are similar to object behaviors except that the class behavior is the implementation for all instances of the class. A class behavior will have the object upon which is being called be prepended to the parameter list. This way the object is known across the class behavior implementation.
Class behaviors are attached using TComponent::attachClassBehavior()
and detached
using TComponent::detachClassBehavior()
. Class behaviors are important in that they
will be applied to all new instances of a particular class. In this way class
behaviors become default behaviors to a new instances of a class in TComponent::__construct()
. Detaching a class behavior will remove the behavior from the
default set of behaviors created for an object when the object is instanced.
Class behaviors are also added to all existing instances via the global 'fx'
event mechanism. When a new class behavior is added, the event TComponent::fxAttachClassBehavior()
is raised and all existing instances that are listening
to this global event (primarily after TComponent::listen()
is called) will have this
new behavior attached. A similar process is used when detaching class behaviors.
Any objects listening to the global 'fx' event TComponent::fxDetachClassBehavior()
will have a class behavior removed.
Dynamic Intra-Object Events
Dynamic events start with 'dy'. This mechanism is used to allow objects to communicate with their behaviors directly. The entire 'dy' event space is valid. All attached, enabled behaviors that implement a dynamic event are called when the host object calls the dynamic event. If there is no implementation or behaviors, this returns null when no parameters are supplied and will return the first parameter when there is at least one parameter in the dynamic event.
null == $this->dyBehaviorEvent(); 5 == $this->dyBehaviorEvent(5); //when no behaviors implement this dynamic event
Dynamic events can be chained together within behaviors to allow for data filtering. Dynamic events are implemented within behaviors by defining the event as a method.
class TObjectBehavior extends TBehavior { public function dyBehaviorEvent($param1, $callchain) { //Do something, eg: $param1 += 13; return $callchain->dyBehaviorEvent($param1); } }
This implementation of a behavior and dynamic event will flow through to the next behavior implementing the dynamic event. The first parameter is always return when it is supplied. Otherwise a dynamic event returns null.
In the case of a class behavior, the object is also prepended to the dynamic event.
class TObjectClassBehavior extends TClassBehavior { public function dyBehaviorEvent($hostobject, $param1, $callchain) { //Do something, eg: $param1 += $hostobject->getNumber(); return $callchain->dyBehaviorEvent($param1); } }
When calling a dynamic event, only the parameters are passed. The host object and the call chain are built into the framework.
Global Event and Dynamic event catching
Given that all global 'fx' events and dynamic 'dy' events are valid and
operational, there is a mechanism for catching events called that are not
implemented (similar to the built-in PHP method TComponent::__call()
). When a dynamic
or global event is called but a behavior does not implement it, yet desires to
know when an undefined dynamic event is run, the behavior implements the
interface IDynamicMethods
and method __dycall.
In the case of dynamic events, __dycall is supplied with the method
name and its parameters. When a global event is raised, via TComponent::raiseEvent()
,
the method is the event name and the parameters are supplied.
When implemented, this catch-all mechanism is called for event global event event when implemented outside of a behavior. Within a behavior, it will also be called when the object to which the behavior is attached calls any unimplemented dynamic event. This is the fall-back mechanism for informing a class and/or behavior of when an global and/or undefined dynamic event is executed.
Direct known subclasses
TActiveRecord, TActiveRecordGateway, TCacheDependency, TCachePageStatePersister, TCachingStatement, TClassBehavior, TClientSideOptions, TComponentReflection, TCompositeLiteral, TDataGatewayCommand, TDataSourceSelectParameters, TDataSourceView, TActiveRecordManager, TDbCommand, TDbCommandBuilder, TDbConnection, TDbDataReader, TDbMetaData, TDbTableColumn, TDbTableInfo, TDbTransaction, TDiscriminator, TDummyDataSource, TApplication, TEventParameter, TFont, THotSpot, THttpCookie, TList, TListItem, TLogger, TMap, TMappedStatement, TMetaTag, TApplicationComponent, TOracleTableInfo, TPageConfiguration, TPagedDataSource, TPageStatePersister, TParameterMap, TParameterProperty, TPreparedStatement, TQueue, Translation, TRepeatInfo, TApplicationConfiguration, TResultMap, TResultProperty, TResultSetListItemParameter, TResultSetMapItemParameter, TSessionPageStatePersister, TSqlCriteria, TSqlMapCacheModel, TSqlMapGateway, TSqlMapManager, TSqlMapObjectCollectionTree, TAuthorizationRule, TSqlMapStatement, TSqlMapTypeHandler, TStack, TStaticSql, TStyle, TSubMap, TTableGateway, TTextWriter, TUri, TUrlMappingPattern, TAutoCompleteTemplate, TUser, TWebControlDecorator, TWizardNavigationTemplate, TWizardSideBarListItemTemplate, TWizardSideBarTemplate, TXmlElement, TBaseActiveControl, TBehaviorIndirect known subclasses
TAccordion, TAccordionView, TActiveControlAdapter, TConditional, TContent, TContentPlaceHolder, TControl, TControlAdapter, TControlCollection, TCustomValidator, TDataBoundControl, TDataGatewayEventParameter, TDataGatewayResultEventParameter, TActiveCustomValidator, TDataGrid, TDataGridColumn, TDataGridColumnCollection, TDataGridCommandEventParameter, TDataGridItem, TDataGridItemCollection, TDataGridItemEventParameter, TDataGridItemRenderer, TDataGridPageChangedEventParameter, TDataGridPager, TActiveCustomValidatorClientSide, TDataGridPagerEventParameter, TDataGridPagerStyle, TDataGridSortCommandEventParameter, TDataList, TDataListCommandEventParameter, TDataListItem, TDataListItemCollection, TDataListItemEventParameter, TDataListItemRenderer, TDataRenderer, TActiveDataGrid, TDataSourceConfig, TDataSourceControl, TDataTypeValidator, TDateFormat, TDatePicker, TDatePickerClientScript, TDbCache, TDbLogRoute, TDbUser, TDbUserManager, TActiveDataGridPager, TDeleteMappedStatement, TDirectoryCacheDependency, TDraggable, TDropContainer, TDropContainerEventParameter, TDropDownList, TDropDownListColumn, TEACache, TEditCommandColumn, TEmailAddressValidator, TActiveDataGridPagerEventParameter, TEmailLogRoute, TEmptyControlCollection, TErrorHandler, TEventTriggeredCallback, TExpression, TFeedService, TFileCacheDependency, TFileLogRoute, TFileUpload, TFirebugLogRoute, TActiveDataList, TFirePhpLogRoute, TFlushOutput, TForm, TGlobalization, TGlobalizationAutoDetect, TGlobalStateCacheDependency, THead, THeader1, THeader2, THeader3, TActiveDatePicker, THeader4, THeader5, THeader6, THiddenField, THotSpotCollection, THtmlArea, THtmlArea4, THtmlElement, THtmlWriter, THttpCookieCollection, TActiveDatePickerClientScript, THttpRequest, THttpResponse, THttpResponseAdapter, THttpSession, THyperLink, THyperLinkColumn, TI18NControl, TImage, TImageButton, TImageClickEventParameter, TActiveDropDownList, TImageMap, TImageMapEventParameter, TInlineFrame, TInPlaceTextBox, TInsertMappedStatement, TItemDataRenderer, TJavascriptLogger, TJsonResponse, TJsonRpcClient, TJsonService, TAccordionViewCollection, TActiveDropDownListColumn, TKeyboard, TLabel, TLinkButton, TListBox, TListControl, TListControlValidator, TListItemCollection, TLiteral, TLiteralColumn, TLogRoute, TActiveEditCommandColumn, TLogRouter, TMarkdown, TMemCache, TMetaTagCollection, TModule, TMssqlCommandBuilder, TMssqlMetaData, TMssqlTableColumn, TMssqlTableInfo, TMultiView, TActiveFileUpload, TMysqlCommandBuilder, TMysqlMetaData, TMysqlTableColumn, TMysqlTableInfo, TNumberFormat, TOracleCommandBuilder, TOracleMetaData, TOracleTableColumn, TOutputCache, TOutputCacheCalculateKeyEventParameter, TActiveHiddenField, TOutputCacheCheckDependencyEventParameter, TOutputCacheTextWriterMulti, TPage, TPagedList, TPagedListFetchDataEventParameter, TPagedListPageChangedEventParameter, TPager, TPagerPageChangedEventParameter, TPageService, TPanel, TActiveHyperLink, TPanelStyle, TParameterModule, TPgsqlCommandBuilder, TPgsqlMetaData, TPgsqlTableColumn, TPgsqlTableInfo, TPlaceHolder, TPolygonHotSpot, TPriorityList, TPriorityMap, TActiveHyperLinkColumn, TRadioButton, TRadioButtonList, TRangeValidator, TRatingList, TReadOnlyDataSource, TReadOnlyDataSourceView, TReCaptcha, TReCaptchaValidator, TRectangleHotSpot, TRegularExpressionValidator, TActiveImage, TRepeater, TRepeaterCommandEventParameter, TRepeaterItem, TRepeaterItemCollection, TRepeaterItemEventParameter, TRepeaterItemRenderer, TRequiredFieldValidator, TRpcApiProvider, TRpcClient, TRpcServer, TActiveImageButton, TRpcService, TSafeHtml, TScaffoldBase, TScaffoldEditView, TScaffoldListView, TScaffoldSearch, TScaffoldView, TSecurityManager, TSelectMappedStatement, TServerValidateEventParameter, TActiveLabel, TService, TShellApplication, TSimpleDynamicSql, TSlider, TSliderClientScript, TSoapServer, TSoapService, TSqliteCache, TSqliteCommandBuilder, TSqliteMetaData, TActiveLinkButton, TSqliteTableColumn, TSqliteTableInfo, TSqlMapConfig, TSqlMapDelete, TSqlMapInsert, TSqlMapPagedList, TSqlMapSelect, TSqlMapSelectKey, TSqlMapUpdate, TStatements, TActiveBoundColumn, TActiveListBox, TStyleSheet, TTable, TTableCell, TTableCellCollection, TTableFooterRow, TTableHeaderCell, TTableHeaderRow, TTableItemStyle, TTableRow, TTableRowCollection, TActiveListControlAdapter, TTableStyle, TTabPanel, TTabView, TTabViewCollection, TTemplate, TTemplateColumn, TTemplateControl, TTemplateControlInheritable, TTemplatedWizardStep, TTemplateManager, TActiveListItemCollection, TTextBox, TTextHighlighter, TTextProcessor, TTheme, TThemeManager, TTimeTriggeredCallback, TTranslate, TTranslateParameter, TTriggeredCallback, TUpdateMappedStatement, TActiveLiteralColumn, TUrlManager, TUrlMapping, TUserManager, TValidationSummary, TValidatorClientSide, TValueTriggeredCallback, TView, TViewCollection, TWebControl, TWebControlAdapter, TActiveMultiView, TWizard, TWizardFinishNavigationTemplate, TWizardNavigationButtonStyle, TWizardNavigationContainer, TWizardNavigationEventParameter, TWizardStartNavigationTemplate, TWizardStep, TWizardStepCollection, TWizardStepNavigationTemplate, TWsatGenerateAR, TActivePageAdapter, TWsatHome, TWsatLayout, TWsatLogin, TWsatScaffolding, TWsatService, TXCache, TXmlDocument, TXmlElementList, TXmlRpcClient, TXmlTransform, TActivePager, TActivePanel, TActiveRadioButton, TActiveRadioButtonList, TActiveButton, TActiveRatingList, TActiveRecordChangeEventParameter, TActiveRecordConfig, TActiveRecordCriteria, TActiveRepeater, TActiveTableCell, TActiveTableCellEventParameter, TActiveTableRow, TActiveTableRowEventParameter, TActiveTemplateColumn, TActiveButtonColumn, TActiveTextBox, TAPCCache, TApplicationStateCacheDependency, TApplicationStatePersister, TAssetManager, TAttributeCollection, TAuthManager, TAuthorizationRuleCollection, TAutoComplete, TAutoCompleteEventParameter, TActiveCheckBox, TBaseActiveCallbackControl, TBaseDataList, TBaseValidator, TBoundColumn, TBroadcastEventParameter, TBrowserLogRoute, TBulletedList, TBulletedListEventParameter, TButton, TButtonColumn, TActiveCheckBoxColumn, TCache, TCacheDependencyList, TCacheHttpSession, TCallback, TCallbackClientScript, TCallbackClientSide, TCallbackErrorHandler, TCallbackEventParameter, TCallbackOptions, TCallbackResponseAdapter, TActiveCheckBoxList, TCallbackResponseWriter, TCallChain, TCaptcha, TCaptchaValidator, TChainedCacheDependency, TCheckBox, TCheckBoxColumn, TCheckBoxList, TChoiceFormat, TCircleHotSpot, TActiveClientScript, TClassBehaviorEventParameter, TClientScript, TClientScriptManager, TClientSideValidationSummaryOptions, TColorPicker, TColorPickerClientSide, TCommandEventParameter, TCompareValidator, TCompleteWizardStep, TCompositeControlCopyright: Copyright © 2005-2014 PradoSoft
License: http://www.pradosoft.com/license/
Author: Qiang Xue <qiang.xue@gmail.com>
Author: Brad Anderson <javalizard@mac.com>
Since: 3.0
Located at TComponent.php
public
|
#
__construct( )
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. |
public
boolean
|
#
getAutoGlobalListen( )
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, |
public
|
|
public
array
|
#
getClassHierarchy( boolean $lowercase = false )
This returns an array of the class name and the names of all its parents. The
base object first, |
public
numeric
|
#
listen( )
This adds an object's fx event handlers into the global broadcaster to listen
into any broadcast global events called through |
public
numeric
|
|
public
boolean
|
|
public
mixed
|
#
__call( string $method, mixed $args )
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 |
public
mixed
|
#
__get( string $name )
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. |
public
|
#
__set( string $name, mixed $value )
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 When behaviors are enabled, this will also set a behaviors properties and events. |
public
|
#
__isset( string $name )
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. |
public
|
#
__unset( string $name )
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. |
public
boolean
|
#
hasProperty( string $name )
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. |
public
boolean
|
#
canGetProperty( string $name )
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. |
public
boolean
|
#
canSetProperty( string $name )
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. |
public
mixed
|
#
getSubProperty( string $path )
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. |
public
|
#
setSubProperty( string $path, mixed $value )
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. |
public
boolean
|
#
hasEvent( string $name )
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. |
public
boolean
|
#
hasEventHandler( string $name )
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. |
public
|
#
getEventHandlers( mixed $name )
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. |
public
|
#
attachEventHandler( string $name, callable $handler, numeric|null $priority = null )
Attaches an event handler to an event. |
public
boolean
|
#
detachEventHandler( string $name, callable $handler, numeric|false|null $priority = false )
Detaches an existing event handler. This method is the opposite of |
public
mixed
|
#
raiseEvent( string $name, mixed $sender,
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 |
public
mixed
|
#
evaluateExpression( string $expression )
Evaluates a PHP expression in the context of this control. |
public
string
|
|
public
|
#
createdOnTemplate(
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 |
public
|
#
addParsedObject( string|
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. |
public
|
#
fxAttachClassBehavior( mixed $sender, mixed $param )
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 |
public
|
#
fxDetachClassBehavior( mixed $sender, mixed $param )
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 |
public static
|
#
attachClassBehavior( string $name, object|string $behavior, string|class $class = null, numeric|null $priority = null )
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. |
public static
|
#
detachClassBehavior( mixed $name, mixed $class = null, mixed $priority = false )
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. |
public
|
|
public
boolean
|
#
isa( class $class )
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. It then checks each Behavior. If a behavior implements
|
public
|
#
attachBehaviors( array $behaviors )
Attaches a list of behaviors to the component. Each behavior is indexed by
its name and should be an instance of |
public
|
#
detachBehaviors( array $behaviors )
Detaches select behaviors from the component. Each behavior is indexed by its
name and should be an instance of |
public
|
|
public
|
#
attachBehavior( string $name, mixed $behavior, mixed $priority = null )
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 |
public
|
#
detachBehavior( string $name, numeric $priority = false )
Detaches a behavior from the component. The behavior's |
public
|
|
public
|
#
disableBehaviors( )
Disables all behaviors attached to this component independent of the behaviors |
public
boolean
|
|
public
|
#
enableBehavior( string $name )
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. |
public
|
#
disableBehavior( string $name )
Disables an attached behavior. This cannot enable or disable whole class behaviors. A behavior is only effective when it is enabled. |
public
|
#
__wakeup( )
Do not call this method. This is a PHP magic method that will be called automatically after any unserialization; it can perform reinitialization tasks on the object. |
public
|
#
__sleep( )
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. |
string |
GLOBAL_RAISE_EVENT_LISTENER |
'fxGlobalListener' |