Attributes

Events

Methods

_addAttrs

Implementation behind the public addAttrs method.
This method is invoked directly by get if it encounters a scenario
in which an attribute's valueFn attempts to obtain the
value an attribute in the same group of attributes, which has not yet
been added (on demand initialization).

Parameters:

cfgsObject

An object with attribute name/configuration pairs.

valuesObject

An object with attribute name/value pairs, defining the initial values to apply.
Values defined in the cfgs argument will be over-written by values in this argument unless defined as read only.

lazyBoolean

Whether or not to delay the intialization of these attributes until the first call to get/set.
Individual attributes can over-ride this behavior by defining a lazyAdd configuration property in their configuration.
See addAttr.

Parameters:

_afterContainerChange

Handles containerChange events. Detaches event handlers from the old
container (if any) and attaches them to the new container.
Right now the container attr is initOnly so this event should only ever
fire the first time the container is created, but in the future (once Y.App
can handle it) we may allow runtime container changes.

_aggregateAttrs

A helper method, used by _initHierarchyData to aggregate
attribute configuration across the instances class hierarchy.
The method will protect the attribute configuration value to protect the statically defined
default value in ATTRS if required (if the value is an object literal, array or the
attribute configuration has cloneDefaultValue set to shallow or deep).

Parameters:

allAttrsArray

An array of ATTRS definitions across classes in the hierarchy
(subclass first, Base last)

_filterAdHocAttrs

Parameters:

allAttrsObject

The set of all attribute configurations for this instance.
Attributes will be removed from this set, if they belong to the filtered class, so
that by the time all classes are processed, allCfgs will be empty.

userValsObject

The config object passed in by the user, from which adhoc attrs are to be filtered.

Returns:

Object:
The set of adhoc attributes passed in, in the form
of an object with attribute name/configuration pairs.

Returns:

_getAttrCfgs

Returns an aggregated set of attribute configurations, by traversing
the class hierarchy.

Returns:

Object:
The hash of attribute configurations, aggregated across classes in the hierarchy
This value is cached the first time the method, or _getClasses, is invoked. Subsequent invocations return
the cached value.

_getAttrInitVal

Returns the initial value of the given attribute from
either the default configuration provided, or the
over-ridden value if it exists in the set of initValues
provided and the attribute is not read-only.

Parameters:

attrString

The name of the attribute

cfgObject

The attribute configuration object

initValuesObject

The object with simple and complex attribute name/value pairs returned from _normAttrVals

Returns:

_getClasses

Returns the class hierarchy for this object, with BaseCore being the last class in the array.

Returns:

Function:
An array of classes (constructor functions), making up the class hierarchy for this object.
This value is cached the first time the method, or _getAttrCfgs, is invoked. Subsequent invocations return the
cached value.

Parameters:

Returns:

_getFullType

Returns the fully qualified type, given a short type string.
That is, returns "foo:bar" when given "bar" if "foo" is the configured prefix.
NOTE: This method, unlike _getType, does no checking of the value passed in, and
is designed to be used with the low level _publish() method, for critical path
implementations which need to fast-track publish for performance reasons.

Parameters:

typeString

The short type to prefix

Returns:

String:
The prefixed type, if a prefix is set, otherwise the type passed in

_getInstanceAttrCfgs

A helper method used to isolate the attrs config for this instance to pass to addAttrs,
from the static cached ATTRS for the class.

Parameters:

allCfgsObject

The set of all attribute configurations for this instance.
Attributes will be removed from this set, if they belong to the filtered class, so
that by the time all classes are processed, allCfgs will be empty.

Returns:

Object:
The set of attributes to be added for this instance, suitable
for passing through to addAttrs.

Parameters:

_initHierarchy

Initializes the class hierarchy for the instance, which includes
initializing attributes for each class defined in the class's
static ATTRS property and
invoking the initializer method on the prototype of each class in the hierarchy.

Returns:

_monitor

This is the entry point for the event monitoring system.
You can monitor 'attach', 'detach', 'fire', and 'publish'.
When configured, these events generate an event. click ->
click_attach, click_detach, click_publish -- these can
be subscribed to like other events to monitor the event
system. Inividual published events can have monitoring
turned on or off (publish can't be turned off before it
it published) by setting the events 'monitor' config.

Parameters:

valueHashObject

An object with attribute name/value pairs

Returns:

Object:
An object literal with 2 properties - "simple" and "complex",
containing simple and complex attribute values respectively keyed
by the top level attribute name, or null, if valueHash is falsey.

Returns:

_publish

The low level event publish implementation. It expects all the massaging to have been done
outside of this method. e.g. the type to fullType conversion. It's designed to be a fast
path publish, which can be used by critical code paths to improve performance.

Parameters:

fullTypeString

The prefixed type of the event to publish.

etOptsObject

The EventTarget specific configuration to mix into the published event.

ceOptsObject

The publish specific configuration to mix into the published event.

Returns:

CustomEvent:
The published event. If called without etOpts or ceOpts, this will
be the default CustomEvent instance, and can be configured independently.

Parameters:

_setTemplate

Initializes the template property of the view. The template is
searched in the template registry and then in the DOM. The id of the
template (both in the registry and in the DOM) is the name of the
view in lowercase with the suffix -ez-template.

A function, which will return the initial value to set on the attribute. This is useful
for cases where the attribute configuration is defined statically, but needs to
reference the host instance ("this") to obtain an initial value. If both the value and valueFn properties are defined,
the value returned by the valueFn has precedence over the value property, unless it returns undefined, in which
case the value property is used.

valueFn can also be set to a string, representing the name of the instance method to be used to retrieve the value.

readOnly <boolean>

Whether or not the attribute is read only. Attributes having readOnly set to true
cannot be modified by invoking the set method.

writeOnce <boolean> or <string>

Whether or not the attribute is "write once". Attributes having writeOnce set to true,
can only have their values set once, be it through the default configuration,
constructor configuration arguments, or by invoking set.

The writeOnce attribute can also be set to the string "initOnly",
in which case the attribute can only be set during initialization
(when used with Base, this means it can only be set during construction)

setter <Function | String>

The setter function used to massage or normalize the value passed to the set method for the attribute.
The value returned by the setter will be the final stored value. Returning
Attribute.INVALID_VALUE, from the setter will prevent
the value from being stored.

setter can also be set to a string, representing the name of the instance method to be used as the setter function.

getter <Function | String>

The getter function used to massage or normalize the value returned by the get method for the attribute.
The value returned by the getter function is the value which will be returned to the user when they
invoke get.

getter can also be set to a string, representing the name of the instance method to be used as the getter function.

validator <Function | String>

The validator function invoked prior to setting the stored value. Returning
false from the validator function will prevent the value from being stored.

validator can also be set to a string, representing the name of the instance method to be used as the validator function.

lazyAdd <boolean>

Whether or not to delay initialization of the attribute until the first call to get/set it.
This flag can be used to over-ride lazy initialization on a per attribute basis, when adding multiple attributes through
the addAttrs method.

The setter, getter and validator are invoked with the value and name passed in as the first and second arguments, and with
the context ("this") set to the host object.

Configuration properties outside of the list mentioned above are considered private properties used internally by attribute,
and are not intended for public use.

Parameters:

nameString

The name of the attribute.

configObject

An object with attribute configuration property/value pairs, specifying the configuration for the attribute.

NOTE: The configuration object is modified when adding an attribute, so if you need
to protect the original values, you will need to merge the object.

lazyBoolean

(optional) Whether or not to add this attribute lazily (on the first call to get/set).

Returns:

addAttrs

NOTE: This method does not isolate the configuration object by merging/cloning.
The caller is responsible for merging/cloning the configuration object if required.

Parameters:

cfgsObject

An object with attribute name/configuration pairs.

valuesObject

An object with attribute name/value pairs, defining the initial values to apply.
Values defined in the cfgs argument will be over-written by values in this argument unless defined as read only.

lazyBoolean

Whether or not to delay the intialization of these attributes until the first call to get/set.
Individual attributes can over-ride this behavior by defining a lazyAdd configuration property in their configuration.
See addAttr.

Returns:

Object:
A reference to the host object.

addTarget

Registers another EventTarget as a bubble target. Bubble order
is determined by the order registered. Multiple targets can
be specified.
Events can only bubble if emitFacade is true.
Included in the event-custom-complex submodule.

Parameters:

after

Subscribe to a custom event hosted by this object. The
supplied callback will execute after any listeners add
via the subscribe method, and after the default function,
if configured for the event, has executed.

Parameters:

typeString

The name of the event

fnFunction

The callback to execute in response to the event

[context]Objectoptional

Override this object in callback

[arg*]Anyoptional

0..n additional arguments to supply to the subscriber

Returns:

EventHandle:
A subscription handle capable of detaching the
subscription

attachEvents

Attaches delegated event handlers to this view's container element. This
method is called internally to subscribe to events configured in the
events attribute when the view is initialized.
You may override this method to customize the event attaching logic.

Parameters:

[events]Objectoptional

Hash of events to attach. See the docs for the
events attribute for details on the format. If not specified, this
view's events property will be used.

before

Executes the callback before a DOM event, custom event
or method. If the first argument is a function, it
is assumed the target is a method. For DOM and custom
events, this is an alias for Y.on.
For DOM and custom events:
type, callback, context, 0-n arguments
For methods:
callback, object (method host), methodName, context, 0-n arguments

Parameters:

Returns:

create

Creates and returns a container node for this view.
By default, the container is created from the HTML template specified in the
containerTemplate property, and is _not_ added to the DOM automatically.
You may override this method to customize how the container node is created
(such as by rendering it from a custom template format). Your method must
return a Y.Node instance.

Returns:

destroy

Destroys this View, detaching any DOM events and optionally also destroying
its container node.
By default, the container node will not be destroyed. Pass an _options_
object with a truthy remove property to destroy the container as well.

Parameters:

[options]Objectoptional

Options.

[remove=false]Booleanoptional

If true, this View's container
will be removed from the DOM and destroyed as well.

detach

Parameters:

Either the handle to the subscriber or the
type of event. If the type
is not specified, it will attempt to remove
the listener from all hosted events.

fnFunction

The subscribed function to unsubscribe, if not
supplied, all subscribers will be removed.

contextObject

The custom object passed to subscribe. This is
optional, but if supplied will be used to
disambiguate multiple listeners that are the same
(e.g., you subscribe many object using a function
that lives on the prototype)

ez-treeview

fire

Fire a custom event by name. The callback functions will be executed
from the context specified when the event was created, and with the
following parameters.
The first argument is the event type, and any additional arguments are
passed to the listeners as parameters. If the first of these is an
object literal, and the event is configured to emit an event facade,
that object is mixed into the event facade and the facade is provided
in place of the original object.
If the custom event object hasn't been created, then the event hasn't
been published and it has no subscribers. For performance sake, we
immediate exit in this case. This means the event won't bubble, so
if the intention is that a bubble target be notified, the event must
be published on this object first.

Parameters:

typeString | Object

The type of the event, or an object that contains
a 'type' property.

argumentsObject

an arbitrary set of parameters to pass to
the handler. If the first of these is an object literal and the event is
configured to emit an event facade, the event facade will replace that
parameter after the properties the object literal contains are copied to
the event facade.

Returns:

Boolean:
True if the whole lifecycle of the event went through,
false if at any point the event propagation was halted.

modifyAttr

Updates the configuration of an attribute which has already been added.

The properties which can be modified through this interface are limited
to the following subset of attributes, which can be safely modified
after a value has already been set on the attribute:

readOnly;

writeOnce;

broadcast; and

getter.

Note: New attributes cannot be added using this interface. New attributes must be
added using {{#crossLink "AttributeCore/addAttr:method"}}addAttr{{/crossLink}}, or an
appropriate manner for a class which utilises Attributes (e.g. the
{{#crossLink "Base/ATTRS:property"}}ATTRS{{/crossLink}} property in
{{#crossLink "Base"}}Base{{/crossLink}}).

Parameters:

nameString

The name of the attribute whose configuration is to be updated.

configObject

An object with configuration property/value pairs, specifying the configuration properties to modify.

on

Subscribe a callback function to a custom event fired by this object or
from an object that bubbles its events to this object.
this.on("change", this._onChange, this);
Callback functions for events published with emitFacade = true will
receive an EventFacade as the first argument (typically named "e").
These callbacks can then call e.preventDefault() to disable the
behavior published to that event's defaultFn. See the EventFacade
API for all available properties and methods. Subscribers to
non-emitFacade events will receive the arguments passed to fire()
after the event name.
To subscribe to multiple events at once, pass an object as the first
argument, where the key:value pairs correspond to the eventName:callback.
this.on({
"attrChange" : this._onAttrChange,
"change" : this._onChange
});
You can also pass an array of event names as the first argument to
subscribe to all listed events with the same callback.
this.on([ "change", "attrChange" ], this._onChange);
Returning false from a callback is supported as an alternative to
calling e.preventDefault(); e.stopPropagation();. However, it is
recommended to use the event methods whenever possible.

Parameters:

typeString

The name of the event

fnFunction

The callback to execute in response to the event

[context]Objectoptional

Override this object in callback

[arg*]Anyoptional

0..n additional arguments to supply to the subscriber

Returns:

EventHandle:
A subscription handle capable of detaching that
subscription

Returns:

parseType

Takes the type parameter passed to 'on' and parses out the
various pieces that could be included in the type. If the
event type is passed without a prefix, it will be expanded
to include the prefix one is supplied or the event target
is configured with a default prefix.

Parameters:

typeString

the type

[pre]Stringoptional

The prefix. Defaults to this._yuievt.config.prefix

Returns:

Array:
an array containing:
* the detach category, if supplied,
* the prefixed event type,
* whether or not this is an after listener,
* the supplied event type

removeTarget

Parameters:

render

Renders this view.
This method is a noop by default. Override it to provide a custom
implementation that renders this view's content and appends it to the
container element. Ideally your render method should also return this as
the end to allow chaining, but that's up to you.
Since there's no default renderer, you're free to render your view however
you see fit, whether that means manipulating the DOM directly, dumping
strings into innerHTML, or using a template language of some kind.
For basic templating needs, Y.Node.create() and Y.Lang.sub() may
suffice, but there are no restrictions on what tools or techniques you can
use to render your view. All you need to do is append something to the
container element at some point, and optionally append the container
to the DOM if it's not there already.

Parameters:

Properties

_allowAdHocAttrs

This tells Y.Base that it should create ad-hoc attributes for config
properties passed to View's constructor. This makes it possible to
instantiate a view and set a bunch of attributes without having to subclass
Y.View and declare all those attributes first.

Default: true

containerTemplate

events

Hash of CSS selectors mapped to events to delegate to elements matching
those selectors.
CSS selectors are relative to the container element. Events are attached
to the container, and delegation is used so that subscribers are only
notified of events that occur on elements inside the container that match
the specified selectors. This allows the container's contents to be re-
rendered as needed without losing event subscriptions.
Event handlers can be specified either as functions or as strings that map
to function names on this view instance or its prototype.
The this object in event handlers will refer to this view instance. If
you'd prefer this to be something else, use Y.bind() to bind a custom
this object.

Default: {}

Example:

var view = new Y.View({
events: {
// Call this.toggle() whenever the element with the id
// "toggle-button" is clicked.
'#toggle-button': {click: 'toggle'},
// Call this.hoverOn() when the mouse moves over any element
// with the "hoverable" class, and this.hoverOff() when the
// mouse moves out of any element with the "hoverable" class.
'.hoverable': {
mouseover: 'hoverOn',
mouseout : 'hoverOff'
}
}
});

template

Template for this view's contents.
This is a convenience property that has no default behavior of its own.
It's only provided as a convention to allow you to store whatever you
consider to be a template, whether that's an HTML string, a Y.Node
instance, a Mustache template, or anything else your little heart
desires.
How this template gets used is entirely up to you and your custom
render() method.

Default: ''

Attributes

container

Container node into which this view's content will be rendered.
The container node serves as the host for all DOM events attached by the
view. Delegation is used to handle events on children of the container,
allowing the container's contents to be re-rendered at any time without
losing event subscriptions.
The default container is a <div> Node, but you can override this in
a subclass, or by passing in a custom container config value at
instantiation time. If you override the default container in a subclass
using ATTRS, you must use the valueFn property. The view's constructor
will ignore any assignments using value.
When container is overridden by a subclass or passed as a config
option at instantiation time, you can provide it as a selector string, a
DOM element, a Y.Node instance, or (if you are subclassing and modifying
the attribute), a valueFn function that returns a Y.Node instance.
The value will be converted into a Y.Node instance if it isn't one
already.
The container is not added to the page automatically. This allows you to
have full control over how and when your view is actually rendered to
the page.